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

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

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

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

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

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

When I provide the same abort criteria that everyone can see
is obviously correct they lie about it.

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

Op 27.mrt.2024 om 20:04 schreef olcott:
> 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)
That is a premature conclusion when A is not specified. It holds if A
does not halt. If A returns, then B will halt (unless aborted).
So, the problem of not halting is not in B but in the unspecified A. If
A halts, B will halt. If A does not halt, B will not halt.
Even a beginner will see it.

> Line 03: simulated B(B) invokes simulated A(B,B) that simulates B(B)
but not completely, because A aborts the simulation and halts, which
makes that B halts too (unless aborted).

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

Except if A aborts and halts, because then also B halts (unless aborted).

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

It would be correct if A would not halt. Only in that case B would not
halt and an abort is needed. But not halting and aborting is not
possible for the same A, so A is wrong, because it aborts prematurely.

On 3/27/2024 2:57 PM, Fred. Zwarts wrote:
> Op 27.mrt.2024 om 20:04 schreef olcott:
>> 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)
> That is a premature conclusion when A is not specified.

*simulating abort decider* A(D,D)
*simulating abort decider* A(D,D)
*simulating abort decider* A(D,D)
*simulating abort decider* A(D,D)

> It holds if A
> does not halt. If A returns, then B will halt (unless aborted).

If you honestly don't see that no A can possible return to
any simulated B then you lied about your programming skill.
Otherwise you can see this and are lying about it.

> So, the problem of not halting is not in B but in the unspecified A. If
> A halts, B will halt. If A does not halt, B will not halt.
> Even a beginner will see it.
>
>> Line 03: simulated B(B) invokes simulated A(B,B) that simulates B(B)
> but not completely, because A aborts the simulation and halts, which
> makes that B halts too (unless aborted).
>
>> *Simulation invariant*
>> B correctly simulated by A cannot possibly reach past its own line 03.
>
> Except if A aborts and halts, because then also B halts (unless aborted).
>

For every A that simulates B whether any A ever aborts this
simulation or not the simulated B cannot possibly reach its
own line 04 and halt.

You either are lying about this or
lying about your programming skill or
are lying about which B you are referring to.

>>
>> The whole class of every A(B,B) that simulates its input
>> is divided into two sub-classes:
>> (a) A(B,B) that DOES NOT abort its simulation is incorrect
>>      (ABOUT THIS ABORT DECISION)
>>      because it would never halt and all deciders must always halt.
>>
>> (b) A(B,N) that DOES abort its simulation is correct
>>      (ABOUT THIS ABORT DECISION)
>>      because it would halt and all deciders must always halt.
>
> It would be correct if A would not halt. Only in that case B would not
> halt and an abort is needed. But not halting and aborting is not
> possible for the same A, so A is wrong, because it aborts prematurely.
>
>
>

--
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/27/24 4:10 PM, olcott wrote:
> On 3/27/2024 2:57 PM, Fred. Zwarts wrote:
>> Op 27.mrt.2024 om 20:04 schreef olcott:
>>> 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)
>> That is a premature conclusion when A is not specified.
>
> *simulating abort decider* A(D,D)
> *simulating abort decider* A(D,D)
> *simulating abort decider* A(D,D)
> *simulating abort decider* A(D,D)

Which just shows your ignorance as that doesn't define what A actually
is, or needs to do.

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

>
>> It holds if A does not halt. If A returns, then B will halt (unless
>> aborted).
>
> If you honestly don't see that no A can possible return to
> any simulated B then you lied about your programming skill.
> Otherwise you can see this and are lying about it.

It may not be able to simulate a B to the point of seeing an A return to
it, but that doesn't mean that the actual behavior of B doesn't have
that happen.

REALITY is the actual behavior of B.

"FANTASY" is what A sees in its simulation and then extrapolating
without reason.

REALITY is what matters, not the lies of FANTASY.

>
>> So, the problem of not halting is not in B but in the unspecified A.
>> If A halts, B will halt. If A does not halt, B will not halt.
>> Even a beginner will see it.
>>
>>> Line 03: simulated B(B) invokes simulated A(B,B) that simulates B(B)
>> but not completely, because A aborts the simulation and halts, which
>> makes that B halts too (unless aborted).
>>
>>> *Simulation invariant*
>>> B correctly simulated by A cannot possibly reach past its own line 03.
>>
>> Except if A aborts and halts, because then also B halts (unless aborted).
>>
>
> For every A that simulates B whether any A ever aborts this
> simulation or not the simulated B cannot possibly reach its
> own line 04 and halt.

But the ACTUAL B does, which is what matters.

>
> You either are lying about this or
> lying about your programming skill or
> are lying about which B you are referring to.

No, you are lying abort how your idea have ANY connection to actual reality.

>
>>>
>>> The whole class of every A(B,B) that simulates its input
>>> is divided into two sub-classes:
>>> (a) A(B,B) that DOES NOT abort its simulation is incorrect
>>>      (ABOUT THIS ABORT DECISION)
>>>      because it would never halt and all deciders must always halt.
>>>
>>> (b) A(B,N) that DOES abort its simulation is correct
>>>      (ABOUT THIS ABORT DECISION)
>>>      because it would halt and all deciders must always halt.
>>
>> It would be correct if A would not halt. Only in that case B would not
>> halt and an abort is needed. But not halting and aborting is not
>> possible for the same A, so A is wrong, because it aborts prematurely.
>>
>>
>>
>

On 3/27/2024 7:48 PM, Richard Damon wrote:
> On 3/27/24 4:10 PM, olcott wrote:
>> On 3/27/2024 2:57 PM, Fred. Zwarts wrote:
>>> Op 27.mrt.2024 om 20:04 schreef olcott:
>>>> 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)
>>> That is a premature conclusion when A is not specified.
>>
>> *simulating abort decider* A(D,D)
>> *simulating abort decider* A(D,D)
>> *simulating abort decider* A(D,D)
>> *simulating abort decider* A(D,D)
>
> Which just shows your ignorance as that doesn't define what A actually
> is, or needs to do.
>
> You are just demonstrating that you don't know what you are talking about.
>
>>
>>> It holds if A does not halt. If A returns, then B will halt (unless
>>> aborted).
>>
>> If you honestly don't see that no A can possible return to
>> any simulated B then you lied about your programming skill.
>> Otherwise you can see this and are lying about it.
>
> It may not be able to simulate a B to the point of seeing an A return to
> it,

*That is the behavior that an abort decider must report on*
*That is the behavior that an abort decider must report on*
*That is the behavior that an abort decider must report on*

It is not possible to CORRECTLY simulate a B to the point of seeing
an A return to it because A calls B in recursive simulation.

--
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/27/24 9:10 PM, olcott wrote:
> On 3/27/2024 7:48 PM, Richard Damon wrote:
>> On 3/27/24 4:10 PM, olcott wrote:
>>> On 3/27/2024 2:57 PM, Fred. Zwarts wrote:
>>>> Op 27.mrt.2024 om 20:04 schreef olcott:
>>>>> 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)
>>>> That is a premature conclusion when A is not specified.
>>>
>>> *simulating abort decider* A(D,D)
>>> *simulating abort decider* A(D,D)
>>> *simulating abort decider* A(D,D)
>>> *simulating abort decider* A(D,D)
>>
>> Which just shows your ignorance as that doesn't define what A actually
>> is, or needs to do.
>>
>> You are just demonstrating that you don't know what you are talking
>> about.
>>
>>>
>>>> It holds if A does not halt. If A returns, then B will halt (unless
>>>> aborted).
>>>
>>> If you honestly don't see that no A can possible return to
>>> any simulated B then you lied about your programming skill.
>>> Otherwise you can see this and are lying about it.
>>
>> It may not be able to simulate a B to the point of seeing an A return
>> to it,
>
> *That is the behavior that an abort decider must report on*
> *That is the behavior that an abort decider must report on*
> *That is the behavior that an abort decider must report on*
>
> It is not possible to CORRECTLY simulate a B to the point of seeing
> an A return to it because A calls B in recursive simulation.
>

Nope, it IS possible to simulate any B to the point of seeing A return,
if A does return, which means it has decided to abort its simulation
(and thus did so incorrectly).

It just isn't possible for the A that B calls to do that.

It IS possible for some other A to do that, but then we need to give
them different names, as we have two different "A"s in the same program
address space, so we need to quallify the name.

Your problem seems to be that you just don't know the language of
Computation Theory well enough to know how to properly describe thinks,
and what you need to do in order to try to do so.

The biggest problem seems to be that you don't understand that a program
is ONE SPECIFIC SET OF CODE, that FULL describes the steps the program
will take. And THAT is the soert of thng that it talks about.

Your "B" as you try to define it, just isn't something in the domain of
Computation Theory, as its behavior changes based on something different
than it, so asking what "it" does is an improper question.

Thats like asking how much will a box weigh when you fill it, but leave
what you will fill it undefined. It could be feathers, or it could be
lead, these give different answers.

On 3/27/2024 8:39 PM, Richard Damon wrote:
> On 3/27/24 9:10 PM, olcott wrote:
>> On 3/27/2024 7:48 PM, Richard Damon wrote:
>>> On 3/27/24 4:10 PM, olcott wrote:
>>>> On 3/27/2024 2:57 PM, Fred. Zwarts wrote:
>>>>> Op 27.mrt.2024 om 20:04 schreef olcott:
>>>>>> 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)
>>>>> That is a premature conclusion when A is not specified.
>>>>
>>>> *simulating abort decider* A(D,D)
>>>> *simulating abort decider* A(D,D)
>>>> *simulating abort decider* A(D,D)
>>>> *simulating abort decider* A(D,D)
>>>
>>> Which just shows your ignorance as that doesn't define what A
>>> actually is, or needs to do.
>>>
>>> You are just demonstrating that you don't know what you are talking
>>> about.
>>>
>>>>
>>>>> It holds if A does not halt. If A returns, then B will halt (unless
>>>>> aborted).
>>>>
>>>> If you honestly don't see that no A can possible return to
>>>> any simulated B then you lied about your programming skill.
>>>> Otherwise you can see this and are lying about it.
>>>
>>> It may not be able to simulate a B to the point of seeing an A return
>>> to it,
>>
>> *That is the behavior that an abort decider must report on*
>> *That is the behavior that an abort decider must report on*
>> *That is the behavior that an abort decider must report on*
>>
>> It is not possible to CORRECTLY simulate a B to the point of seeing
>> an A return to it because A calls B in recursive simulation.
>>
>
> Nope, it IS possible to simulate any B to the point of seeing A return,

It is impossible for A(B,B) to simulate its input such that any
A ever returns to any B simulated by A because B calls A in recursive
simulation.

--
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/27/24 10:13 PM, olcott wrote:
> On 3/27/2024 8:39 PM, Richard Damon wrote:
>> On 3/27/24 9:10 PM, olcott wrote:
>>> On 3/27/2024 7:48 PM, Richard Damon wrote:
>>>> On 3/27/24 4:10 PM, olcott wrote:
>>>>> On 3/27/2024 2:57 PM, Fred. Zwarts wrote:
>>>>>> Op 27.mrt.2024 om 20:04 schreef olcott:
>>>>>>> 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)
>>>>>> That is a premature conclusion when A is not specified.
>>>>>
>>>>> *simulating abort decider* A(D,D)
>>>>> *simulating abort decider* A(D,D)
>>>>> *simulating abort decider* A(D,D)
>>>>> *simulating abort decider* A(D,D)
>>>>
>>>> Which just shows your ignorance as that doesn't define what A
>>>> actually is, or needs to do.
>>>>
>>>> You are just demonstrating that you don't know what you are talking
>>>> about.
>>>>
>>>>>
>>>>>> It holds if A does not halt. If A returns, then B will halt
>>>>>> (unless aborted).
>>>>>
>>>>> If you honestly don't see that no A can possible return to
>>>>> any simulated B then you lied about your programming skill.
>>>>> Otherwise you can see this and are lying about it.
>>>>
>>>> It may not be able to simulate a B to the point of seeing an A
>>>> return to it,
>>>
>>> *That is the behavior that an abort decider must report on*
>>> *That is the behavior that an abort decider must report on*
>>> *That is the behavior that an abort decider must report on*
>>>
>>> It is not possible to CORRECTLY simulate a B to the point of seeing
>>> an A return to it because A calls B in recursive simulation.
>>>
>>
>> Nope, it IS possible to simulate any B to the point of seeing A return,
>
> It is impossible for A(B,B) to simulate its input such that any
> A ever returns to any B simulated by A because B calls A in recursive
> simulation.
>

And if the "Definition" of the answer is based on it "Correctly
Simulating its input", which it can not do, then you have a problem with
your definitions.

Your problem is you keep on forgetting that at any given time and
example, A is a SPECIFIC program, with SPECIFIC behavior and it will
either simulate and not abort and not answer, or abort and not show what
its input does.

We can use ANOTHER simulator (perhaps a different version of A, and give
it THIS B, connect with that original A, and not itself) to see the
right answer.

If you can't do that, then you Computation system is just too weak to be
of any interest.

Yes, you may be able to establish what you want to establish, but only
by admittng that you system is FAR from being "Turing Complete", and
thus not any where NEAR being a usable replacement for the actual
Computation Theory and its Halting Question.

On 3/27/2024 9:43 PM, Richard Damon wrote:
> On 3/27/24 10:13 PM, olcott wrote:
>> On 3/27/2024 8:39 PM, Richard Damon wrote:
>>> On 3/27/24 9:10 PM, olcott wrote:
>>>> On 3/27/2024 7:48 PM, Richard Damon wrote:
>>>>> On 3/27/24 4:10 PM, olcott wrote:
>>>>>> On 3/27/2024 2:57 PM, Fred. Zwarts wrote:
>>>>>>> Op 27.mrt.2024 om 20:04 schreef olcott:
>>>>>>>> 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)
>>>>>>> That is a premature conclusion when A is not specified.
>>>>>>
>>>>>> *simulating abort decider* A(D,D)
>>>>>> *simulating abort decider* A(D,D)
>>>>>> *simulating abort decider* A(D,D)
>>>>>> *simulating abort decider* A(D,D)
>>>>>
>>>>> Which just shows your ignorance as that doesn't define what A
>>>>> actually is, or needs to do.
>>>>>
>>>>> You are just demonstrating that you don't know what you are talking
>>>>> about.
>>>>>
>>>>>>
>>>>>>> It holds if A does not halt. If A returns, then B will halt
>>>>>>> (unless aborted).
>>>>>>
>>>>>> If you honestly don't see that no A can possible return to
>>>>>> any simulated B then you lied about your programming skill.
>>>>>> Otherwise you can see this and are lying about it.
>>>>>
>>>>> It may not be able to simulate a B to the point of seeing an A
>>>>> return to it,
>>>>
>>>> *That is the behavior that an abort decider must report on*
>>>> *That is the behavior that an abort decider must report on*
>>>> *That is the behavior that an abort decider must report on*
>>>>
>>>> It is not possible to CORRECTLY simulate a B to the point of seeing
>>>> an A return to it because A calls B in recursive simulation.
>>>>
>>>
>>> Nope, it IS possible to simulate any B to the point of seeing A return,
>>
>> It is impossible for A(B,B) to simulate its input such that any
>> A ever returns to any B simulated by A because B calls A in recursive
>> simulation.
>>
>
> And if the "Definition" of the answer is based on it "Correctly
> Simulating its input", which it can not do, then you have a problem with
> your definitions.
>

Every A(B,B) simulates its input until it sees the same thing
that you an I have seen for two years.

> Your problem is you keep on forgetting that at any given time and
> example, A is a SPECIFIC program, with SPECIFIC behavior and it will
> either simulate and not abort and not answer, or abort and not show what
> its input does.

I never forget that.
I KNOW THAT IRRELEVANT DIFFERENCES ARE IRRELEVANT
I KNOW THAT IRRELEVANT DIFFERENCES ARE IRRELEVANT
I KNOW THAT IRRELEVANT DIFFERENCES ARE IRRELEVANT

>
> We can use ANOTHER simulator (perhaps a different version of A, and give
> it THIS B, connect with that original A, and not itself) to see the
> right answer.
>

Every H(D,D) that simulates its input and does not abort
that simulation is wrong.

Every H(D,D) that simulates its input and does abort
that simulation is correct about this abort decision.

> If you can't do that, then you Computation system is just too weak to be
> of any interest.
>
> Yes, you may be able to establish what you want to establish, but only
> by admittng that you system is FAR from being "Turing Complete", and

The same thing works for the Linz H but all the time that
you ridiculously persistently deny easily verified facts
I cannot trust you with that additional complexity.

You must totally accept that H(D,D) is a correct abort decider
for its input before we can move on.

> thus not any where NEAR being a usable replacement for the actual
> Computation Theory and its Halting Question.

--
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/27/24 11:09 PM, olcott wrote:
> On 3/27/2024 9:43 PM, Richard Damon wrote:
>> On 3/27/24 10:13 PM, olcott wrote:
>>> On 3/27/2024 8:39 PM, Richard Damon wrote:
>>>> On 3/27/24 9:10 PM, olcott wrote:
>>>>> On 3/27/2024 7:48 PM, Richard Damon wrote:
>>>>>> On 3/27/24 4:10 PM, olcott wrote:
>>>>>>> On 3/27/2024 2:57 PM, Fred. Zwarts wrote:
>>>>>>>> Op 27.mrt.2024 om 20:04 schreef olcott:
>>>>>>>>> 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)
>>>>>>>> That is a premature conclusion when A is not specified.
>>>>>>>
>>>>>>> *simulating abort decider* A(D,D)
>>>>>>> *simulating abort decider* A(D,D)
>>>>>>> *simulating abort decider* A(D,D)
>>>>>>> *simulating abort decider* A(D,D)
>>>>>>
>>>>>> Which just shows your ignorance as that doesn't define what A
>>>>>> actually is, or needs to do.
>>>>>>
>>>>>> You are just demonstrating that you don't know what you are
>>>>>> talking about.
>>>>>>
>>>>>>>
>>>>>>>> It holds if A does not halt. If A returns, then B will halt
>>>>>>>> (unless aborted).
>>>>>>>
>>>>>>> If you honestly don't see that no A can possible return to
>>>>>>> any simulated B then you lied about your programming skill.
>>>>>>> Otherwise you can see this and are lying about it.
>>>>>>
>>>>>> It may not be able to simulate a B to the point of seeing an A
>>>>>> return to it,
>>>>>
>>>>> *That is the behavior that an abort decider must report on*
>>>>> *That is the behavior that an abort decider must report on*
>>>>> *That is the behavior that an abort decider must report on*
>>>>>
>>>>> It is not possible to CORRECTLY simulate a B to the point of seeing
>>>>> an A return to it because A calls B in recursive simulation.
>>>>>
>>>>
>>>> Nope, it IS possible to simulate any B to the point of seeing A return,
>>>
>>> It is impossible for A(B,B) to simulate its input such that any
>>> A ever returns to any B simulated by A because B calls A in recursive
>>> simulation.
>>>
>>
>> And if the "Definition" of the answer is based on it "Correctly
>> Simulating its input", which it can not do, then you have a problem
>> with your definitions.
>>
>
> Every A(B,B) simulates its input until it sees the same thing
> that you an I have seen for two years.

Which is an INCORECT condition for aborting, as it matches some machines
that do not need there simulation to be aborted.

>
>> Your problem is you keep on forgetting that at any given time and
>> example, A is a SPECIFIC program, with SPECIFIC behavior and it will
>> either simulate and not abort and not answer, or abort and not show
>> what its input does.
>
> I never forget that.
> I KNOW THAT IRRELEVANT DIFFERENCES ARE IRRELEVANT
> I KNOW THAT IRRELEVANT DIFFERENCES ARE IRRELEVANT
> I KNOW THAT IRRELEVANT DIFFERENCES ARE IRRELEVANT

But you seem to think that some RELEVERNT differences are IRrelevant,
showing you are just stupid.

If it makes a difference to the answer, it is relevent.

>
>>
>> We can use ANOTHER simulator (perhaps a different version of A, and
>> give it THIS B, connect with that original A, and not itself) to see
>> the right answer.
>>
>
> Every H(D,D) that simulates its input and does not abort
> that simulation is wrong.
>
> Every H(D,D) that simulates its input and does abort
> that simulation is correct about this abort decision.

Nope.

Just more of your LIES.

>
>> If you can't do that, then you Computation system is just too weak to
>> be of any interest.
>>
>> Yes, you may be able to establish what you want to establish, but only
>> by admittng that you system is FAR from being "Turing Complete", and
>
> The same thing works for the Linz H but all the time that
> you ridiculously persistently deny easily verified facts
> I cannot trust you with that additional complexity.

Nope, just more of your lies.

You have so seered you concience you can not tell what is actually true
anymore.

>
> You must totally accept that H(D,D) is a correct abort decider
> for its input before we can move on.

SO, I guess we can't move on, as I can not accept an incorrect decider
to be a correct one.

*I* value what is true.

>
>> thus not any where NEAR being a usable replacement for the actual
>> Computation Theory and its Halting Question.
>

On 3/27/2024 10:25 PM, Richard Damon wrote:
> On 3/27/24 11:09 PM, olcott wrote:
>> On 3/27/2024 9:43 PM, Richard Damon wrote:
>>> On 3/27/24 10:13 PM, olcott wrote:
>>>> On 3/27/2024 8:39 PM, Richard Damon wrote:
>>>>> On 3/27/24 9:10 PM, olcott wrote:
>>>>>> On 3/27/2024 7:48 PM, Richard Damon wrote:
>>>>>>> On 3/27/24 4:10 PM, olcott wrote:
>>>>>>>> On 3/27/2024 2:57 PM, Fred. Zwarts wrote:
>>>>>>>>> Op 27.mrt.2024 om 20:04 schreef olcott:
>>>>>>>>>> 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)
>>>>>>>>> That is a premature conclusion when A is not specified.
>>>>>>>>
>>>>>>>> *simulating abort decider* A(D,D)
>>>>>>>> *simulating abort decider* A(D,D)
>>>>>>>> *simulating abort decider* A(D,D)
>>>>>>>> *simulating abort decider* A(D,D)
>>>>>>>
>>>>>>> Which just shows your ignorance as that doesn't define what A
>>>>>>> actually is, or needs to do.
>>>>>>>
>>>>>>> You are just demonstrating that you don't know what you are
>>>>>>> talking about.
>>>>>>>
>>>>>>>>
>>>>>>>>> It holds if A does not halt. If A returns, then B will halt
>>>>>>>>> (unless aborted).
>>>>>>>>
>>>>>>>> If you honestly don't see that no A can possible return to
>>>>>>>> any simulated B then you lied about your programming skill.
>>>>>>>> Otherwise you can see this and are lying about it.
>>>>>>>
>>>>>>> It may not be able to simulate a B to the point of seeing an A
>>>>>>> return to it,
>>>>>>
>>>>>> *That is the behavior that an abort decider must report on*
>>>>>> *That is the behavior that an abort decider must report on*
>>>>>> *That is the behavior that an abort decider must report on*
>>>>>>
>>>>>> It is not possible to CORRECTLY simulate a B to the point of seeing
>>>>>> an A return to it because A calls B in recursive simulation.
>>>>>>
>>>>>
>>>>> Nope, it IS possible to simulate any B to the point of seeing A
>>>>> return,
>>>>
>>>> It is impossible for A(B,B) to simulate its input such that any
>>>> A ever returns to any B simulated by A because B calls A in recursive
>>>> simulation.
>>>>
>>>
>>> And if the "Definition" of the answer is based on it "Correctly
>>> Simulating its input", which it can not do, then you have a problem
>>> with your definitions.
>>>
>>
>> Every A(B,B) simulates its input until it sees the same thing
>> that you an I have seen for two years.
>
> Which is an INCORECT condition for aborting, as it matches some machines
> that do not need there simulation to be aborted.
>
>>
>>> Your problem is you keep on forgetting that at any given time and
>>> example, A is a SPECIFIC program, with SPECIFIC behavior and it will
>>> either simulate and not abort and not answer, or abort and not show
>>> what its input does.
>>
>> I never forget that.
>> I KNOW THAT IRRELEVANT DIFFERENCES ARE IRRELEVANT
>> I KNOW THAT IRRELEVANT DIFFERENCES ARE IRRELEVANT
>> I KNOW THAT IRRELEVANT DIFFERENCES ARE IRRELEVANT
>
> But you seem to think that some RELEVERNT differences are IRrelevant,
> showing you are just stupid.
>
> If it makes a difference to the answer, it is relevent.
>
>>
>>>
>>> We can use ANOTHER simulator (perhaps a different version of A, and
>>> give it THIS B, connect with that original A, and not itself) to see
>>> the right answer.
>>>
>>
>> Every H(D,D) that simulates its input and does not abort
>> that simulation is wrong.
>>
>> Every H(D,D) that simulates its input and does abort
>> that simulation is correct about this abort decision.
>
> Nope.
>
> Just more of your LIES.
>

Yet you cannot point out any mistake because you are lying about there
being any mistake. Every time you try to explain your reasoning about
this it always comes down to this:

*Every H(D,D) that needs to abort its input never needed to abort*
*its input because some other H somewhere else that did not abort*
*its input already aborted its input that it never aborted*

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

On 2024-03-27 19:04:13 +0000, olcott said:

> 01 void B(ptr x) // ptr is pointer to void function
> 02 {
> 03 A(x, x);
> 04 return;
> 05 }
> 06
> 07 void main()
> 08 {
> 09 A(B,B);
> 10 }
>
> *Execution Trace*
> Line 09: main() invokes A(B,B);
>
> *keeps repeating* (unless aborted)
> Line 03: simulated B(B) invokes simulated A(B,B) that simulates B(B)
>
> *Simulation invariant*
> B correctly simulated by A cannot possibly reach past its own line 03.
>
> The whole class of every A(B,B) that simulates its input
> is divided into two sub-classes:
> (a) A(B,B) that DOES NOT abort its simulation is incorrect
> (ABOUT THIS ABORT DECISION)
> because it would never halt and all deciders must always halt.
>
> (b) A(B,N) that DOES abort its simulation is correct
> (ABOUT THIS ABORT DECISION)
> because it would halt and all deciders must always halt.
>
> When I provide the same abort criteria that everyone can see
> is obviously correct they lie about it.

You cannot prove anything about an abort decider before you
define what "abort decider" means. You cannot define what
"abort decider" means before you learn how to define.

There is no reason to refute anything as long as you have not
arrempted to prove.

--
Mikko

On 3/27/24 11:32 PM, olcott wrote:
> On 3/27/2024 10:25 PM, Richard Damon wrote:
>> On 3/27/24 11:09 PM, olcott wrote:
>>> On 3/27/2024 9:43 PM, Richard Damon wrote:
>>>> On 3/27/24 10:13 PM, olcott wrote:
>>>>> On 3/27/2024 8:39 PM, Richard Damon wrote:
>>>>>> On 3/27/24 9:10 PM, olcott wrote:
>>>>>>> On 3/27/2024 7:48 PM, Richard Damon wrote:
>>>>>>>> On 3/27/24 4:10 PM, olcott wrote:
>>>>>>>>> On 3/27/2024 2:57 PM, Fred. Zwarts wrote:
>>>>>>>>>> Op 27.mrt.2024 om 20:04 schreef olcott:
>>>>>>>>>>> 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)
>>>>>>>>>> That is a premature conclusion when A is not specified.
>>>>>>>>>
>>>>>>>>> *simulating abort decider* A(D,D)
>>>>>>>>> *simulating abort decider* A(D,D)
>>>>>>>>> *simulating abort decider* A(D,D)
>>>>>>>>> *simulating abort decider* A(D,D)
>>>>>>>>
>>>>>>>> Which just shows your ignorance as that doesn't define what A
>>>>>>>> actually is, or needs to do.
>>>>>>>>
>>>>>>>> You are just demonstrating that you don't know what you are
>>>>>>>> talking about.
>>>>>>>>
>>>>>>>>>
>>>>>>>>>> It holds if A does not halt. If A returns, then B will halt
>>>>>>>>>> (unless aborted).
>>>>>>>>>
>>>>>>>>> If you honestly don't see that no A can possible return to
>>>>>>>>> any simulated B then you lied about your programming skill.
>>>>>>>>> Otherwise you can see this and are lying about it.
>>>>>>>>
>>>>>>>> It may not be able to simulate a B to the point of seeing an A
>>>>>>>> return to it,
>>>>>>>
>>>>>>> *That is the behavior that an abort decider must report on*
>>>>>>> *That is the behavior that an abort decider must report on*
>>>>>>> *That is the behavior that an abort decider must report on*
>>>>>>>
>>>>>>> It is not possible to CORRECTLY simulate a B to the point of seeing
>>>>>>> an A return to it because A calls B in recursive simulation.
>>>>>>>
>>>>>>
>>>>>> Nope, it IS possible to simulate any B to the point of seeing A
>>>>>> return,
>>>>>
>>>>> It is impossible for A(B,B) to simulate its input such that any
>>>>> A ever returns to any B simulated by A because B calls A in recursive
>>>>> simulation.
>>>>>
>>>>
>>>> And if the "Definition" of the answer is based on it "Correctly
>>>> Simulating its input", which it can not do, then you have a problem
>>>> with your definitions.
>>>>
>>>
>>> Every A(B,B) simulates its input until it sees the same thing
>>> that you an I have seen for two years.
>>
>> Which is an INCORECT condition for aborting, as it matches some
>> machines that do not need there simulation to be aborted.
>>
>>>
>>>> Your problem is you keep on forgetting that at any given time and
>>>> example, A is a SPECIFIC program, with SPECIFIC behavior and it will
>>>> either simulate and not abort and not answer, or abort and not show
>>>> what its input does.
>>>
>>> I never forget that.
>>> I KNOW THAT IRRELEVANT DIFFERENCES ARE IRRELEVANT
>>> I KNOW THAT IRRELEVANT DIFFERENCES ARE IRRELEVANT
>>> I KNOW THAT IRRELEVANT DIFFERENCES ARE IRRELEVANT
>>
>> But you seem to think that some RELEVERNT differences are IRrelevant,
>> showing you are just stupid.
>>
>> If it makes a difference to the answer, it is relevent.
>>
>>>
>>>>
>>>> We can use ANOTHER simulator (perhaps a different version of A, and
>>>> give it THIS B, connect with that original A, and not itself) to see
>>>> the right answer.
>>>>
>>>
>>> Every H(D,D) that simulates its input and does not abort
>>> that simulation is wrong.
>>>
>>> Every H(D,D) that simulates its input and does abort
>>> that simulation is correct about this abort decision.
>>
>> Nope.
>>
>> Just more of your LIES.
>>
>
> Yet you cannot point out any mistake because you are lying about there
> being any mistake. Every time you try to explain your reasoning about
> this it always comes down to this:
>
> *Every H(D,D) that needs to abort its input never needed to abort*
> *its input because some other H somewhere else that did not abort*
> *its input already aborted its input that it never aborted*
>

Nope, the fact that you can't even summarize what I said, just shows it
is beyound your ability to comprehend.

You look at the workd through Olcott glasses, and only see what you want.

This makes you blind to the truth, and the truth will crush you.

I have explained why you are wrong already elsewhere, and don't need to
repeat it.

On 3/28/2024 7:01 AM, Richard Damon wrote:
> On 3/27/24 11:32 PM, olcott wrote:
>> On 3/27/2024 10:25 PM, Richard Damon wrote:
>>> On 3/27/24 11:09 PM, olcott wrote:
>>>> On 3/27/2024 9:43 PM, Richard Damon wrote:
>>>>> On 3/27/24 10:13 PM, olcott wrote:
>>>>>> On 3/27/2024 8:39 PM, Richard Damon wrote:
>>>>>>> On 3/27/24 9:10 PM, olcott wrote:
>>>>>>>> On 3/27/2024 7:48 PM, Richard Damon wrote:
>>>>>>>>> On 3/27/24 4:10 PM, olcott wrote:
>>>>>>>>>> On 3/27/2024 2:57 PM, Fred. Zwarts wrote:
>>>>>>>>>>> Op 27.mrt.2024 om 20:04 schreef olcott:
>>>>>>>>>>>> 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)
>>>>>>>>>>> That is a premature conclusion when A is not specified.
>>>>>>>>>>
>>>>>>>>>> *simulating abort decider* A(D,D)
>>>>>>>>>> *simulating abort decider* A(D,D)
>>>>>>>>>> *simulating abort decider* A(D,D)
>>>>>>>>>> *simulating abort decider* A(D,D)
>>>>>>>>>
>>>>>>>>> Which just shows your ignorance as that doesn't define what A
>>>>>>>>> actually is, or needs to do.
>>>>>>>>>
>>>>>>>>> You are just demonstrating that you don't know what you are
>>>>>>>>> talking about.
>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>>> It holds if A does not halt. If A returns, then B will halt
>>>>>>>>>>> (unless aborted).
>>>>>>>>>>
>>>>>>>>>> If you honestly don't see that no A can possible return to
>>>>>>>>>> any simulated B then you lied about your programming skill.
>>>>>>>>>> Otherwise you can see this and are lying about it.
>>>>>>>>>
>>>>>>>>> It may not be able to simulate a B to the point of seeing an A
>>>>>>>>> return to it,
>>>>>>>>
>>>>>>>> *That is the behavior that an abort decider must report on*
>>>>>>>> *That is the behavior that an abort decider must report on*
>>>>>>>> *That is the behavior that an abort decider must report on*
>>>>>>>>
>>>>>>>> It is not possible to CORRECTLY simulate a B to the point of seeing
>>>>>>>> an A return to it because A calls B in recursive simulation.
>>>>>>>>
>>>>>>>
>>>>>>> Nope, it IS possible to simulate any B to the point of seeing A
>>>>>>> return,
>>>>>>
>>>>>> It is impossible for A(B,B) to simulate its input such that any
>>>>>> A ever returns to any B simulated by A because B calls A in recursive
>>>>>> simulation.
>>>>>>
>>>>>
>>>>> And if the "Definition" of the answer is based on it "Correctly
>>>>> Simulating its input", which it can not do, then you have a problem
>>>>> with your definitions.
>>>>>
>>>>
>>>> Every A(B,B) simulates its input until it sees the same thing
>>>> that you an I have seen for two years.
>>>
>>> Which is an INCORECT condition for aborting, as it matches some
>>> machines that do not need there simulation to be aborted.
>>>
>>>>
>>>>> Your problem is you keep on forgetting that at any given time and
>>>>> example, A is a SPECIFIC program, with SPECIFIC behavior and it
>>>>> will either simulate and not abort and not answer, or abort and not
>>>>> show what its input does.
>>>>
>>>> I never forget that.
>>>> I KNOW THAT IRRELEVANT DIFFERENCES ARE IRRELEVANT
>>>> I KNOW THAT IRRELEVANT DIFFERENCES ARE IRRELEVANT
>>>> I KNOW THAT IRRELEVANT DIFFERENCES ARE IRRELEVANT
>>>
>>> But you seem to think that some RELEVERNT differences are IRrelevant,
>>> showing you are just stupid.
>>>
>>> If it makes a difference to the answer, it is relevent.
>>>
>>>>
>>>>>
>>>>> We can use ANOTHER simulator (perhaps a different version of A, and
>>>>> give it THIS B, connect with that original A, and not itself) to
>>>>> see the right answer.
>>>>>
>>>>
>>>> Every H(D,D) that simulates its input and does not abort
>>>> that simulation is wrong.
>>>>
>>>> Every H(D,D) that simulates its input and does abort
>>>> that simulation is correct about this abort decision.
>>>
>>> Nope.
>>>
>>> Just more of your LIES.
>>>
>>
>> Yet you cannot point out any mistake because you are lying about there
>> being any mistake. Every time you try to explain your reasoning about
>> this it always comes down to this:
>>
>> *Every H(D,D) that needs to abort its input never needed to abort*
>> *its input because some other H somewhere else that did not abort*
>> *its input already aborted its input that it never aborted*
>>
>
> Nope, the fact that you can't even summarize what I said, just shows it
> is beyound your ability to comprehend.
>
> You look at the workd through Olcott glasses, and only see what you want.
>
> This makes you blind to the truth, and the truth will crush you.
>
> I have explained why you are wrong already elsewhere, and don't need to
> repeat it.

Yes you are great at dogmatically saying that I am wrong.
What you are terrible at is showing any mistake because there are
no mistakes.

This is the machine code of D that every H examines.
83c4088945fc837dfc007402ebfe8b45fc8be55dc3
This finite string of bytes never changes.

You keep insisting that necessarily irrelevant differences
between H/D pairs that have nothing to do with the abort
decision make a significant difference in the abort decision.

You already know that these irrelevant differences don't
make any semantic difference in the abort decision because:

*Every H(D,D) that simulates its input and aborts is equivalent*
and
*Every H(D,D) that simulates its input and does not abort is equivalent*

Why lie? (that could count Revelations 21:8 against you).
Is playing trollish head games worth eternity in the lake
which burneth with fire and brimstone?

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

Op 28.mrt.2024 om 15:49 schreef olcott:
> On 3/28/2024 7:01 AM, Richard Damon wrote:
>> On 3/27/24 11:32 PM, olcott wrote:
>>> On 3/27/2024 10:25 PM, Richard Damon wrote:
>>>> On 3/27/24 11:09 PM, olcott wrote:
>>>>> On 3/27/2024 9:43 PM, Richard Damon wrote:
>>>>>> On 3/27/24 10:13 PM, olcott wrote:
>>>>>>> On 3/27/2024 8:39 PM, Richard Damon wrote:
>>>>>>>> On 3/27/24 9:10 PM, olcott wrote:
>>>>>>>>> On 3/27/2024 7:48 PM, Richard Damon wrote:
>>>>>>>>>> On 3/27/24 4:10 PM, olcott wrote:
>>>>>>>>>>> On 3/27/2024 2:57 PM, Fred. Zwarts wrote:
>>>>>>>>>>>> Op 27.mrt.2024 om 20:04 schreef olcott:
>>>>>>>>>>>>> 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)
>>>>>>>>>>>> That is a premature conclusion when A is not specified.
>>>>>>>>>>>
>>>>>>>>>>> *simulating abort decider* A(D,D)
>>>>>>>>>>> *simulating abort decider* A(D,D)
>>>>>>>>>>> *simulating abort decider* A(D,D)
>>>>>>>>>>> *simulating abort decider* A(D,D)
>>>>>>>>>>
>>>>>>>>>> Which just shows your ignorance as that doesn't define what A
>>>>>>>>>> actually is, or needs to do.
>>>>>>>>>>
>>>>>>>>>> You are just demonstrating that you don't know what you are
>>>>>>>>>> talking about.
>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>>> It holds if A does not halt. If A returns, then B will halt
>>>>>>>>>>>> (unless aborted).
>>>>>>>>>>>
>>>>>>>>>>> If you honestly don't see that no A can possible return to
>>>>>>>>>>> any simulated B then you lied about your programming skill.
>>>>>>>>>>> Otherwise you can see this and are lying about it.
>>>>>>>>>>
>>>>>>>>>> It may not be able to simulate a B to the point of seeing an A
>>>>>>>>>> return to it,
>>>>>>>>>
>>>>>>>>> *That is the behavior that an abort decider must report on*
>>>>>>>>> *That is the behavior that an abort decider must report on*
>>>>>>>>> *That is the behavior that an abort decider must report on*
>>>>>>>>>
>>>>>>>>> It is not possible to CORRECTLY simulate a B to the point of
>>>>>>>>> seeing
>>>>>>>>> an A return to it because A calls B in recursive simulation.
>>>>>>>>>
>>>>>>>>
>>>>>>>> Nope, it IS possible to simulate any B to the point of seeing A
>>>>>>>> return,
>>>>>>>
>>>>>>> It is impossible for A(B,B) to simulate its input such that any
>>>>>>> A ever returns to any B simulated by A because B calls A in
>>>>>>> recursive
>>>>>>> simulation.
>>>>>>>
>>>>>>
>>>>>> And if the "Definition" of the answer is based on it "Correctly
>>>>>> Simulating its input", which it can not do, then you have a
>>>>>> problem with your definitions.
>>>>>>
>>>>>
>>>>> Every A(B,B) simulates its input until it sees the same thing
>>>>> that you an I have seen for two years.
>>>>
>>>> Which is an INCORECT condition for aborting, as it matches some
>>>> machines that do not need there simulation to be aborted.
>>>>
>>>>>
>>>>>> Your problem is you keep on forgetting that at any given time and
>>>>>> example, A is a SPECIFIC program, with SPECIFIC behavior and it
>>>>>> will either simulate and not abort and not answer, or abort and
>>>>>> not show what its input does.
>>>>>
>>>>> I never forget that.
>>>>> I KNOW THAT IRRELEVANT DIFFERENCES ARE IRRELEVANT
>>>>> I KNOW THAT IRRELEVANT DIFFERENCES ARE IRRELEVANT
>>>>> I KNOW THAT IRRELEVANT DIFFERENCES ARE IRRELEVANT
>>>>
>>>> But you seem to think that some RELEVERNT differences are
>>>> IRrelevant, showing you are just stupid.
>>>>
>>>> If it makes a difference to the answer, it is relevent.
>>>>
>>>>>
>>>>>>
>>>>>> We can use ANOTHER simulator (perhaps a different version of A,
>>>>>> and give it THIS B, connect with that original A, and not itself)
>>>>>> to see the right answer.
>>>>>>
>>>>>
>>>>> Every H(D,D) that simulates its input and does not abort
>>>>> that simulation is wrong.
>>>>>
>>>>> Every H(D,D) that simulates its input and does abort
>>>>> that simulation is correct about this abort decision.
>>>>
>>>> Nope.
>>>>
>>>> Just more of your LIES.
>>>>
>>>
>>> Yet you cannot point out any mistake because you are lying about there
>>> being any mistake. Every time you try to explain your reasoning about
>>> this it always comes down to this:
>>>
>>> *Every H(D,D) that needs to abort its input never needed to abort*
>>> *its input because some other H somewhere else that did not abort*
>>> *its input already aborted its input that it never aborted*
>>>
>>
>> Nope, the fact that you can't even summarize what I said, just shows
>> it is beyound your ability to comprehend.
>>
>> You look at the workd through Olcott glasses, and only see what you want.
>>
>> This makes you blind to the truth, and the truth will crush you.
>>
>> I have explained why you are wrong already elsewhere, and don't need
>> to repeat it.
>
> Yes you are great at dogmatically saying that I am wrong.
> What you are terrible at is showing any mistake because there are
> no mistakes.
>
> This is the machine code of D that every H examines.
> 83c4088945fc837dfc007402ebfe8b45fc8be55dc3
> This finite string of bytes never changes.
>

This string is incomplete. There is a call to an undefined function in
it. Therefore, it is not a program, so no decision can be given for it.
A decision can be made only, if the code of the missing function is
added as well. This will make the string longer. But only then we know
the D for which a decision is required. So, olcott should give the
string of (not an incomplete program, but of) the complete program, that
includes the H.
It is very cheating to place all the different H functions at the same
address and pretend that we are still speaking of the same program.
Therefore, we need a string that describes the full program including H.

On 3/28/2024 2:09 PM, Fred. Zwarts wrote:
> Op 28.mrt.2024 om 15:49 schreef olcott:
>> On 3/28/2024 7:01 AM, Richard Damon wrote:
>>> On 3/27/24 11:32 PM, olcott wrote:
>>>> On 3/27/2024 10:25 PM, Richard Damon wrote:
>>>>> On 3/27/24 11:09 PM, olcott wrote:
>>>>>> On 3/27/2024 9:43 PM, Richard Damon wrote:
>>>>>>> On 3/27/24 10:13 PM, olcott wrote:
>>>>>>>> On 3/27/2024 8:39 PM, Richard Damon wrote:
>>>>>>>>> On 3/27/24 9:10 PM, olcott wrote:
>>>>>>>>>> On 3/27/2024 7:48 PM, Richard Damon wrote:
>>>>>>>>>>> On 3/27/24 4:10 PM, olcott wrote:
>>>>>>>>>>>> On 3/27/2024 2:57 PM, Fred. Zwarts wrote:
>>>>>>>>>>>>> Op 27.mrt.2024 om 20:04 schreef olcott:
>>>>>>>>>>>>>> 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)
>>>>>>>>>>>>> That is a premature conclusion when A is not specified.
>>>>>>>>>>>>
>>>>>>>>>>>> *simulating abort decider* A(D,D)
>>>>>>>>>>>> *simulating abort decider* A(D,D)
>>>>>>>>>>>> *simulating abort decider* A(D,D)
>>>>>>>>>>>> *simulating abort decider* A(D,D)
>>>>>>>>>>>
>>>>>>>>>>> Which just shows your ignorance as that doesn't define what A
>>>>>>>>>>> actually is, or needs to do.
>>>>>>>>>>>
>>>>>>>>>>> You are just demonstrating that you don't know what you are
>>>>>>>>>>> talking about.
>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>>> It holds if A does not halt. If A returns, then B will halt
>>>>>>>>>>>>> (unless aborted).
>>>>>>>>>>>>
>>>>>>>>>>>> If you honestly don't see that no A can possible return to
>>>>>>>>>>>> any simulated B then you lied about your programming skill.
>>>>>>>>>>>> Otherwise you can see this and are lying about it.
>>>>>>>>>>>
>>>>>>>>>>> It may not be able to simulate a B to the point of seeing an
>>>>>>>>>>> A return to it,
>>>>>>>>>>
>>>>>>>>>> *That is the behavior that an abort decider must report on*
>>>>>>>>>> *That is the behavior that an abort decider must report on*
>>>>>>>>>> *That is the behavior that an abort decider must report on*
>>>>>>>>>>
>>>>>>>>>> It is not possible to CORRECTLY simulate a B to the point of
>>>>>>>>>> seeing
>>>>>>>>>> an A return to it because A calls B in recursive simulation.
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> Nope, it IS possible to simulate any B to the point of seeing A
>>>>>>>>> return,
>>>>>>>>
>>>>>>>> It is impossible for A(B,B) to simulate its input such that any
>>>>>>>> A ever returns to any B simulated by A because B calls A in
>>>>>>>> recursive
>>>>>>>> simulation.
>>>>>>>>
>>>>>>>
>>>>>>> And if the "Definition" of the answer is based on it "Correctly
>>>>>>> Simulating its input", which it can not do, then you have a
>>>>>>> problem with your definitions.
>>>>>>>
>>>>>>
>>>>>> Every A(B,B) simulates its input until it sees the same thing
>>>>>> that you an I have seen for two years.
>>>>>
>>>>> Which is an INCORECT condition for aborting, as it matches some
>>>>> machines that do not need there simulation to be aborted.
>>>>>
>>>>>>
>>>>>>> Your problem is you keep on forgetting that at any given time and
>>>>>>> example, A is a SPECIFIC program, with SPECIFIC behavior and it
>>>>>>> will either simulate and not abort and not answer, or abort and
>>>>>>> not show what its input does.
>>>>>>
>>>>>> I never forget that.
>>>>>> I KNOW THAT IRRELEVANT DIFFERENCES ARE IRRELEVANT
>>>>>> I KNOW THAT IRRELEVANT DIFFERENCES ARE IRRELEVANT
>>>>>> I KNOW THAT IRRELEVANT DIFFERENCES ARE IRRELEVANT
>>>>>
>>>>> But you seem to think that some RELEVERNT differences are
>>>>> IRrelevant, showing you are just stupid.
>>>>>
>>>>> If it makes a difference to the answer, it is relevent.
>>>>>
>>>>>>
>>>>>>>
>>>>>>> We can use ANOTHER simulator (perhaps a different version of A,
>>>>>>> and give it THIS B, connect with that original A, and not itself)
>>>>>>> to see the right answer.
>>>>>>>
>>>>>>
>>>>>> Every H(D,D) that simulates its input and does not abort
>>>>>> that simulation is wrong.
>>>>>>
>>>>>> Every H(D,D) that simulates its input and does abort
>>>>>> that simulation is correct about this abort decision.
>>>>>
>>>>> Nope.
>>>>>
>>>>> Just more of your LIES.
>>>>>
>>>>
>>>> Yet you cannot point out any mistake because you are lying about there
>>>> being any mistake. Every time you try to explain your reasoning about
>>>> this it always comes down to this:
>>>>
>>>> *Every H(D,D) that needs to abort its input never needed to abort*
>>>> *its input because some other H somewhere else that did not abort*
>>>> *its input already aborted its input that it never aborted*
>>>>
>>>
>>> Nope, the fact that you can't even summarize what I said, just shows
>>> it is beyound your ability to comprehend.
>>>
>>> You look at the workd through Olcott glasses, and only see what you
>>> want.
>>>
>>> This makes you blind to the truth, and the truth will crush you.
>>>
>>> I have explained why you are wrong already elsewhere, and don't need
>>> to repeat it.
>>
>> Yes you are great at dogmatically saying that I am wrong.
>> What you are terrible at is showing any mistake because there are
>> no mistakes.
>>
>> This is the machine code of D that every H examines.
>> 83c4088945fc837dfc007402ebfe8b45fc8be55dc3
>> This finite string of bytes never changes.
>>
>
> This string is incomplete. There is a call to an undefined function in
> it. Therefore, it is not a program, so no decision can be given for it.
> A decision can be made only, if the code of the missing function is
> added as well. This will make the string longer. But only then we know
> the D for which a decision is required. So, olcott should give the
> string of (not an incomplete program, but of) the complete program, that
> includes the H.
> It is very cheating to place all the different H functions at the same
> address and pretend that we are still speaking of the same program.
> Therefore, we need a string that describes the full program including H.
>

Op 28.mrt.2024 om 20:20 schreef olcott:
> On 3/28/2024 2:09 PM, Fred. Zwarts wrote:
>> Op 28.mrt.2024 om 15:49 schreef olcott:
>>> On 3/28/2024 7:01 AM, Richard Damon wrote:
>>>> On 3/27/24 11:32 PM, olcott wrote:
>>>>> On 3/27/2024 10:25 PM, Richard Damon wrote:
>>>>>> On 3/27/24 11:09 PM, olcott wrote:
>>>>>>> On 3/27/2024 9:43 PM, Richard Damon wrote:
>>>>>>>> On 3/27/24 10:13 PM, olcott wrote:
>>>>>>>>> On 3/27/2024 8:39 PM, Richard Damon wrote:
>>>>>>>>>> On 3/27/24 9:10 PM, olcott wrote:
>>>>>>>>>>> On 3/27/2024 7:48 PM, Richard Damon wrote:
>>>>>>>>>>>> On 3/27/24 4:10 PM, olcott wrote:
>>>>>>>>>>>>> On 3/27/2024 2:57 PM, Fred. Zwarts wrote:
>>>>>>>>>>>>>> Op 27.mrt.2024 om 20:04 schreef olcott:
>>>>>>>>>>>>>>> 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)
>>>>>>>>>>>>>> That is a premature conclusion when A is not specified.
>>>>>>>>>>>>>
>>>>>>>>>>>>> *simulating abort decider* A(D,D)
>>>>>>>>>>>>> *simulating abort decider* A(D,D)
>>>>>>>>>>>>> *simulating abort decider* A(D,D)
>>>>>>>>>>>>> *simulating abort decider* A(D,D)
>>>>>>>>>>>>
>>>>>>>>>>>> Which just shows your ignorance as that doesn't define what
>>>>>>>>>>>> A actually is, or needs to do.
>>>>>>>>>>>>
>>>>>>>>>>>> You are just demonstrating that you don't know what you are
>>>>>>>>>>>> talking about.
>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>>> It holds if A does not halt. If A returns, then B will
>>>>>>>>>>>>>> halt (unless aborted).
>>>>>>>>>>>>>
>>>>>>>>>>>>> If you honestly don't see that no A can possible return to
>>>>>>>>>>>>> any simulated B then you lied about your programming skill.
>>>>>>>>>>>>> Otherwise you can see this and are lying about it.
>>>>>>>>>>>>
>>>>>>>>>>>> It may not be able to simulate a B to the point of seeing an
>>>>>>>>>>>> A return to it,
>>>>>>>>>>>
>>>>>>>>>>> *That is the behavior that an abort decider must report on*
>>>>>>>>>>> *That is the behavior that an abort decider must report on*
>>>>>>>>>>> *That is the behavior that an abort decider must report on*
>>>>>>>>>>>
>>>>>>>>>>> It is not possible to CORRECTLY simulate a B to the point of
>>>>>>>>>>> seeing
>>>>>>>>>>> an A return to it because A calls B in recursive simulation.
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> Nope, it IS possible to simulate any B to the point of seeing
>>>>>>>>>> A return,
>>>>>>>>>
>>>>>>>>> It is impossible for A(B,B) to simulate its input such that any
>>>>>>>>> A ever returns to any B simulated by A because B calls A in
>>>>>>>>> recursive
>>>>>>>>> simulation.
>>>>>>>>>
>>>>>>>>
>>>>>>>> And if the "Definition" of the answer is based on it "Correctly
>>>>>>>> Simulating its input", which it can not do, then you have a
>>>>>>>> problem with your definitions.
>>>>>>>>
>>>>>>>
>>>>>>> Every A(B,B) simulates its input until it sees the same thing
>>>>>>> that you an I have seen for two years.
>>>>>>
>>>>>> Which is an INCORECT condition for aborting, as it matches some
>>>>>> machines that do not need there simulation to be aborted.
>>>>>>
>>>>>>>
>>>>>>>> Your problem is you keep on forgetting that at any given time
>>>>>>>> and example, A is a SPECIFIC program, with SPECIFIC behavior and
>>>>>>>> it will either simulate and not abort and not answer, or abort
>>>>>>>> and not show what its input does.
>>>>>>>
>>>>>>> I never forget that.
>>>>>>> I KNOW THAT IRRELEVANT DIFFERENCES ARE IRRELEVANT
>>>>>>> I KNOW THAT IRRELEVANT DIFFERENCES ARE IRRELEVANT
>>>>>>> I KNOW THAT IRRELEVANT DIFFERENCES ARE IRRELEVANT
>>>>>>
>>>>>> But you seem to think that some RELEVERNT differences are
>>>>>> IRrelevant, showing you are just stupid.
>>>>>>
>>>>>> If it makes a difference to the answer, it is relevent.
>>>>>>
>>>>>>>
>>>>>>>>
>>>>>>>> We can use ANOTHER simulator (perhaps a different version of A,
>>>>>>>> and give it THIS B, connect with that original A, and not
>>>>>>>> itself) to see the right answer.
>>>>>>>>
>>>>>>>
>>>>>>> Every H(D,D) that simulates its input and does not abort
>>>>>>> that simulation is wrong.
>>>>>>>
>>>>>>> Every H(D,D) that simulates its input and does abort
>>>>>>> that simulation is correct about this abort decision.
>>>>>>
>>>>>> Nope.
>>>>>>
>>>>>> Just more of your LIES.
>>>>>>
>>>>>
>>>>> Yet you cannot point out any mistake because you are lying about there
>>>>> being any mistake. Every time you try to explain your reasoning about
>>>>> this it always comes down to this:
>>>>>
>>>>> *Every H(D,D) that needs to abort its input never needed to abort*
>>>>> *its input because some other H somewhere else that did not abort*
>>>>> *its input already aborted its input that it never aborted*
>>>>>
>>>>
>>>> Nope, the fact that you can't even summarize what I said, just shows
>>>> it is beyound your ability to comprehend.
>>>>
>>>> You look at the workd through Olcott glasses, and only see what you
>>>> want.
>>>>
>>>> This makes you blind to the truth, and the truth will crush you.
>>>>
>>>> I have explained why you are wrong already elsewhere, and don't need
>>>> to repeat it.
>>>
>>> Yes you are great at dogmatically saying that I am wrong.
>>> What you are terrible at is showing any mistake because there are
>>> no mistakes.
>>>
>>> This is the machine code of D that every H examines.
>>> 83c4088945fc837dfc007402ebfe8b45fc8be55dc3
>>> This finite string of bytes never changes.
>>>
>>
>> This string is incomplete. There is a call to an undefined function in
>> it. Therefore, it is not a program, so no decision can be given for
>> it. A decision can be made only, if the code of the missing function
>> is added as well. This will make the string longer. But only then we
>> know the D for which a decision is required. So, olcott should give
>> the string of (not an incomplete program, but of) the complete
>> program, that includes the H.
>> It is very cheating to place all the different H functions at the same
>> address and pretend that we are still speaking of the same program.
>> Therefore, we need a string that describes the full program including H.
>>
>
> 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 }
>
> The question has always been:
> Of every element of the infinite set of H/D pairs where H simulates
> the above input can any implementation of the above H(D,D) ever stop
> running without aborting its simulation of D?
>
>
>

On 3/28/2024 2:34 PM, Fred. Zwarts wrote:
> Op 28.mrt.2024 om 20:20 schreef olcott:
>> On 3/28/2024 2:09 PM, Fred. Zwarts wrote:
>>> Op 28.mrt.2024 om 15:49 schreef olcott:
>>>> On 3/28/2024 7:01 AM, Richard Damon wrote:
>>>>> On 3/27/24 11:32 PM, olcott wrote:
>>>>>> On 3/27/2024 10:25 PM, Richard Damon wrote:
>>>>>>> On 3/27/24 11:09 PM, olcott wrote:
>>>>>>>> On 3/27/2024 9:43 PM, Richard Damon wrote:
>>>>>>>>> On 3/27/24 10:13 PM, olcott wrote:
>>>>>>>>>> On 3/27/2024 8:39 PM, Richard Damon wrote:
>>>>>>>>>>> On 3/27/24 9:10 PM, olcott wrote:
>>>>>>>>>>>> On 3/27/2024 7:48 PM, Richard Damon wrote:
>>>>>>>>>>>>> On 3/27/24 4:10 PM, olcott wrote:
>>>>>>>>>>>>>> On 3/27/2024 2:57 PM, Fred. Zwarts wrote:
>>>>>>>>>>>>>>> Op 27.mrt.2024 om 20:04 schreef olcott:
>>>>>>>>>>>>>>>> 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)
>>>>>>>>>>>>>>> That is a premature conclusion when A is not specified.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> *simulating abort decider* A(D,D)
>>>>>>>>>>>>>> *simulating abort decider* A(D,D)
>>>>>>>>>>>>>> *simulating abort decider* A(D,D)
>>>>>>>>>>>>>> *simulating abort decider* A(D,D)
>>>>>>>>>>>>>
>>>>>>>>>>>>> Which just shows your ignorance as that doesn't define what
>>>>>>>>>>>>> A actually is, or needs to do.
>>>>>>>>>>>>>
>>>>>>>>>>>>> You are just demonstrating that you don't know what you are
>>>>>>>>>>>>> talking about.
>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> It holds if A does not halt. If A returns, then B will
>>>>>>>>>>>>>>> halt (unless aborted).
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> If you honestly don't see that no A can possible return to
>>>>>>>>>>>>>> any simulated B then you lied about your programming skill.
>>>>>>>>>>>>>> Otherwise you can see this and are lying about it.
>>>>>>>>>>>>>
>>>>>>>>>>>>> It may not be able to simulate a B to the point of seeing
>>>>>>>>>>>>> an A return to it,
>>>>>>>>>>>>
>>>>>>>>>>>> *That is the behavior that an abort decider must report on*
>>>>>>>>>>>> *That is the behavior that an abort decider must report on*
>>>>>>>>>>>> *That is the behavior that an abort decider must report on*
>>>>>>>>>>>>
>>>>>>>>>>>> It is not possible to CORRECTLY simulate a B to the point of
>>>>>>>>>>>> seeing
>>>>>>>>>>>> an A return to it because A calls B in recursive simulation.
>>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> Nope, it IS possible to simulate any B to the point of seeing
>>>>>>>>>>> A return,
>>>>>>>>>>
>>>>>>>>>> It is impossible for A(B,B) to simulate its input such that any
>>>>>>>>>> A ever returns to any B simulated by A because B calls A in
>>>>>>>>>> recursive
>>>>>>>>>> simulation.
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> And if the "Definition" of the answer is based on it "Correctly
>>>>>>>>> Simulating its input", which it can not do, then you have a
>>>>>>>>> problem with your definitions.
>>>>>>>>>
>>>>>>>>
>>>>>>>> Every A(B,B) simulates its input until it sees the same thing
>>>>>>>> that you an I have seen for two years.
>>>>>>>
>>>>>>> Which is an INCORECT condition for aborting, as it matches some
>>>>>>> machines that do not need there simulation to be aborted.
>>>>>>>
>>>>>>>>
>>>>>>>>> Your problem is you keep on forgetting that at any given time
>>>>>>>>> and example, A is a SPECIFIC program, with SPECIFIC behavior
>>>>>>>>> and it will either simulate and not abort and not answer, or
>>>>>>>>> abort and not show what its input does.
>>>>>>>>
>>>>>>>> I never forget that.
>>>>>>>> I KNOW THAT IRRELEVANT DIFFERENCES ARE IRRELEVANT
>>>>>>>> I KNOW THAT IRRELEVANT DIFFERENCES ARE IRRELEVANT
>>>>>>>> I KNOW THAT IRRELEVANT DIFFERENCES ARE IRRELEVANT
>>>>>>>
>>>>>>> But you seem to think that some RELEVERNT differences are
>>>>>>> IRrelevant, showing you are just stupid.
>>>>>>>
>>>>>>> If it makes a difference to the answer, it is relevent.
>>>>>>>
>>>>>>>>
>>>>>>>>>
>>>>>>>>> We can use ANOTHER simulator (perhaps a different version of A,
>>>>>>>>> and give it THIS B, connect with that original A, and not
>>>>>>>>> itself) to see the right answer.
>>>>>>>>>
>>>>>>>>
>>>>>>>> Every H(D,D) that simulates its input and does not abort
>>>>>>>> that simulation is wrong.
>>>>>>>>
>>>>>>>> Every H(D,D) that simulates its input and does abort
>>>>>>>> that simulation is correct about this abort decision.
>>>>>>>
>>>>>>> Nope.
>>>>>>>
>>>>>>> Just more of your LIES.
>>>>>>>
>>>>>>
>>>>>> Yet you cannot point out any mistake because you are lying about
>>>>>> there
>>>>>> being any mistake. Every time you try to explain your reasoning about
>>>>>> this it always comes down to this:
>>>>>>
>>>>>> *Every H(D,D) that needs to abort its input never needed to abort*
>>>>>> *its input because some other H somewhere else that did not abort*
>>>>>> *its input already aborted its input that it never aborted*
>>>>>>
>>>>>
>>>>> Nope, the fact that you can't even summarize what I said, just
>>>>> shows it is beyound your ability to comprehend.
>>>>>
>>>>> You look at the workd through Olcott glasses, and only see what you
>>>>> want.
>>>>>
>>>>> This makes you blind to the truth, and the truth will crush you.
>>>>>
>>>>> I have explained why you are wrong already elsewhere, and don't
>>>>> need to repeat it.
>>>>
>>>> Yes you are great at dogmatically saying that I am wrong.
>>>> What you are terrible at is showing any mistake because there are
>>>> no mistakes.
>>>>
>>>> This is the machine code of D that every H examines.
>>>> 83c4088945fc837dfc007402ebfe8b45fc8be55dc3
>>>> This finite string of bytes never changes.
>>>>
>>>
>>> This string is incomplete. There is a call to an undefined function
>>> in it. Therefore, it is not a program, so no decision can be given
>>> for it. A decision can be made only, if the code of the missing
>>> function is added as well. This will make the string longer. But only
>>> then we know the D for which a decision is required. So, olcott
>>> should give the string of (not an incomplete program, but of) the
>>> complete program, that includes the H.
>>> It is very cheating to place all the different H functions at the
>>> same address and pretend that we are still speaking of the same program.
>>> Therefore, we need a string that describes the full program including H.
>>>
>>
>> 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 }
>>
>> The question has always been:
>> Of every element of the infinite set of H/D pairs where H simulates
>> the above input can any implementation of the above H(D,D) ever stop
>> running without aborting its simulation of D?
>>
>>
>>
>
> This is not the answer to the question, but a side track with another
> question.

On 3/28/24 10:49 AM, olcott wrote:
> On 3/28/2024 7:01 AM, Richard Damon wrote:
>> On 3/27/24 11:32 PM, olcott wrote:
>>> On 3/27/2024 10:25 PM, Richard Damon wrote:
>>>> On 3/27/24 11:09 PM, olcott wrote:
>>>>> On 3/27/2024 9:43 PM, Richard Damon wrote:
>>>>>> On 3/27/24 10:13 PM, olcott wrote:
>>>>>>> On 3/27/2024 8:39 PM, Richard Damon wrote:
>>>>>>>> On 3/27/24 9:10 PM, olcott wrote:
>>>>>>>>> On 3/27/2024 7:48 PM, Richard Damon wrote:
>>>>>>>>>> On 3/27/24 4:10 PM, olcott wrote:
>>>>>>>>>>> On 3/27/2024 2:57 PM, Fred. Zwarts wrote:
>>>>>>>>>>>> Op 27.mrt.2024 om 20:04 schreef olcott:
>>>>>>>>>>>>> 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)
>>>>>>>>>>>> That is a premature conclusion when A is not specified.
>>>>>>>>>>>
>>>>>>>>>>> *simulating abort decider* A(D,D)
>>>>>>>>>>> *simulating abort decider* A(D,D)
>>>>>>>>>>> *simulating abort decider* A(D,D)
>>>>>>>>>>> *simulating abort decider* A(D,D)
>>>>>>>>>>
>>>>>>>>>> Which just shows your ignorance as that doesn't define what A
>>>>>>>>>> actually is, or needs to do.
>>>>>>>>>>
>>>>>>>>>> You are just demonstrating that you don't know what you are
>>>>>>>>>> talking about.
>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>>> It holds if A does not halt. If A returns, then B will halt
>>>>>>>>>>>> (unless aborted).
>>>>>>>>>>>
>>>>>>>>>>> If you honestly don't see that no A can possible return to
>>>>>>>>>>> any simulated B then you lied about your programming skill.
>>>>>>>>>>> Otherwise you can see this and are lying about it.
>>>>>>>>>>
>>>>>>>>>> It may not be able to simulate a B to the point of seeing an A
>>>>>>>>>> return to it,
>>>>>>>>>
>>>>>>>>> *That is the behavior that an abort decider must report on*
>>>>>>>>> *That is the behavior that an abort decider must report on*
>>>>>>>>> *That is the behavior that an abort decider must report on*
>>>>>>>>>
>>>>>>>>> It is not possible to CORRECTLY simulate a B to the point of
>>>>>>>>> seeing
>>>>>>>>> an A return to it because A calls B in recursive simulation.
>>>>>>>>>
>>>>>>>>
>>>>>>>> Nope, it IS possible to simulate any B to the point of seeing A
>>>>>>>> return,
>>>>>>>
>>>>>>> It is impossible for A(B,B) to simulate its input such that any
>>>>>>> A ever returns to any B simulated by A because B calls A in
>>>>>>> recursive
>>>>>>> simulation.
>>>>>>>
>>>>>>
>>>>>> And if the "Definition" of the answer is based on it "Correctly
>>>>>> Simulating its input", which it can not do, then you have a
>>>>>> problem with your definitions.
>>>>>>
>>>>>
>>>>> Every A(B,B) simulates its input until it sees the same thing
>>>>> that you an I have seen for two years.
>>>>
>>>> Which is an INCORECT condition for aborting, as it matches some
>>>> machines that do not need there simulation to be aborted.
>>>>
>>>>>
>>>>>> Your problem is you keep on forgetting that at any given time and
>>>>>> example, A is a SPECIFIC program, with SPECIFIC behavior and it
>>>>>> will either simulate and not abort and not answer, or abort and
>>>>>> not show what its input does.
>>>>>
>>>>> I never forget that.
>>>>> I KNOW THAT IRRELEVANT DIFFERENCES ARE IRRELEVANT
>>>>> I KNOW THAT IRRELEVANT DIFFERENCES ARE IRRELEVANT
>>>>> I KNOW THAT IRRELEVANT DIFFERENCES ARE IRRELEVANT
>>>>
>>>> But you seem to think that some RELEVERNT differences are
>>>> IRrelevant, showing you are just stupid.
>>>>
>>>> If it makes a difference to the answer, it is relevent.
>>>>
>>>>>
>>>>>>
>>>>>> We can use ANOTHER simulator (perhaps a different version of A,
>>>>>> and give it THIS B, connect with that original A, and not itself)
>>>>>> to see the right answer.
>>>>>>
>>>>>
>>>>> Every H(D,D) that simulates its input and does not abort
>>>>> that simulation is wrong.
>>>>>
>>>>> Every H(D,D) that simulates its input and does abort
>>>>> that simulation is correct about this abort decision.
>>>>
>>>> Nope.
>>>>
>>>> Just more of your LIES.
>>>>
>>>
>>> Yet you cannot point out any mistake because you are lying about there
>>> being any mistake. Every time you try to explain your reasoning about
>>> this it always comes down to this:
>>>
>>> *Every H(D,D) that needs to abort its input never needed to abort*
>>> *its input because some other H somewhere else that did not abort*
>>> *its input already aborted its input that it never aborted*
>>>
>>
>> Nope, the fact that you can't even summarize what I said, just shows
>> it is beyound your ability to comprehend.
>>
>> You look at the workd through Olcott glasses, and only see what you want.
>>
>> This makes you blind to the truth, and the truth will crush you.
>>
>> I have explained why you are wrong already elsewhere, and don't need
>> to repeat it.
>
> Yes you are great at dogmatically saying that I am wrong.
> What you are terrible at is showing any mistake because there are
> no mistakes.

I don't think you understand what "Dogma" is.

>
> This is the machine code of D that every H examines.
> 83c4088945fc837dfc007402ebfe8b45fc8be55dc3
> This finite string of bytes never changes.

Right, but as you have admitted, the behavior of that machine code
CHANGES depending on what is at the location of H.

>
> You keep insisting that necessarily irrelevant differences
> between H/D pairs that have nothing to do with the abort
> decision make a significant difference in the abort decision.

Because the behavior of H isn't irrelevent, and your claim that it is
just shows that you are jusdt an ignorant pathological lying idiot.

>
> You already know that these irrelevant differences don't
> make any semantic difference in the abort decision because:
>
> *Every H(D,D) that simulates its input and aborts is equivalent*
> and
> *Every H(D,D) that simulates its input and does not abort is equivalent*

Right, and every H in the first group is wrong because it doesn't answer,

And every H in the second group is wrong because it gives the WRONG answer.

>
> Why lie? (that could count Revelations 21:8 against you).
> Is playing trollish head games worth eternity in the lake
> which burneth with fire and brimstone?
>
>

On 3/28/24 3:20 PM, olcott wrote:
> On 3/28/2024 2:09 PM, Fred. Zwarts wrote:
>> Op 28.mrt.2024 om 15:49 schreef olcott:
>>> On 3/28/2024 7:01 AM, Richard Damon wrote:
>>>> On 3/27/24 11:32 PM, olcott wrote:
>>>>> On 3/27/2024 10:25 PM, Richard Damon wrote:
>>>>>> On 3/27/24 11:09 PM, olcott wrote:
>>>>>>> On 3/27/2024 9:43 PM, Richard Damon wrote:
>>>>>>>> On 3/27/24 10:13 PM, olcott wrote:
>>>>>>>>> On 3/27/2024 8:39 PM, Richard Damon wrote:
>>>>>>>>>> On 3/27/24 9:10 PM, olcott wrote:
>>>>>>>>>>> On 3/27/2024 7:48 PM, Richard Damon wrote:
>>>>>>>>>>>> On 3/27/24 4:10 PM, olcott wrote:
>>>>>>>>>>>>> On 3/27/2024 2:57 PM, Fred. Zwarts wrote:
>>>>>>>>>>>>>> Op 27.mrt.2024 om 20:04 schreef olcott:
>>>>>>>>>>>>>>> 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)
>>>>>>>>>>>>>> That is a premature conclusion when A is not specified.
>>>>>>>>>>>>>
>>>>>>>>>>>>> *simulating abort decider* A(D,D)
>>>>>>>>>>>>> *simulating abort decider* A(D,D)
>>>>>>>>>>>>> *simulating abort decider* A(D,D)
>>>>>>>>>>>>> *simulating abort decider* A(D,D)
>>>>>>>>>>>>
>>>>>>>>>>>> Which just shows your ignorance as that doesn't define what
>>>>>>>>>>>> A actually is, or needs to do.
>>>>>>>>>>>>
>>>>>>>>>>>> You are just demonstrating that you don't know what you are
>>>>>>>>>>>> talking about.
>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>>> It holds if A does not halt. If A returns, then B will
>>>>>>>>>>>>>> halt (unless aborted).
>>>>>>>>>>>>>
>>>>>>>>>>>>> If you honestly don't see that no A can possible return to
>>>>>>>>>>>>> any simulated B then you lied about your programming skill.
>>>>>>>>>>>>> Otherwise you can see this and are lying about it.
>>>>>>>>>>>>
>>>>>>>>>>>> It may not be able to simulate a B to the point of seeing an
>>>>>>>>>>>> A return to it,
>>>>>>>>>>>
>>>>>>>>>>> *That is the behavior that an abort decider must report on*
>>>>>>>>>>> *That is the behavior that an abort decider must report on*
>>>>>>>>>>> *That is the behavior that an abort decider must report on*
>>>>>>>>>>>
>>>>>>>>>>> It is not possible to CORRECTLY simulate a B to the point of
>>>>>>>>>>> seeing
>>>>>>>>>>> an A return to it because A calls B in recursive simulation.
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> Nope, it IS possible to simulate any B to the point of seeing
>>>>>>>>>> A return,
>>>>>>>>>
>>>>>>>>> It is impossible for A(B,B) to simulate its input such that any
>>>>>>>>> A ever returns to any B simulated by A because B calls A in
>>>>>>>>> recursive
>>>>>>>>> simulation.
>>>>>>>>>
>>>>>>>>
>>>>>>>> And if the "Definition" of the answer is based on it "Correctly
>>>>>>>> Simulating its input", which it can not do, then you have a
>>>>>>>> problem with your definitions.
>>>>>>>>
>>>>>>>
>>>>>>> Every A(B,B) simulates its input until it sees the same thing
>>>>>>> that you an I have seen for two years.
>>>>>>
>>>>>> Which is an INCORECT condition for aborting, as it matches some
>>>>>> machines that do not need there simulation to be aborted.
>>>>>>
>>>>>>>
>>>>>>>> Your problem is you keep on forgetting that at any given time
>>>>>>>> and example, A is a SPECIFIC program, with SPECIFIC behavior and
>>>>>>>> it will either simulate and not abort and not answer, or abort
>>>>>>>> and not show what its input does.
>>>>>>>
>>>>>>> I never forget that.
>>>>>>> I KNOW THAT IRRELEVANT DIFFERENCES ARE IRRELEVANT
>>>>>>> I KNOW THAT IRRELEVANT DIFFERENCES ARE IRRELEVANT
>>>>>>> I KNOW THAT IRRELEVANT DIFFERENCES ARE IRRELEVANT
>>>>>>
>>>>>> But you seem to think that some RELEVERNT differences are
>>>>>> IRrelevant, showing you are just stupid.
>>>>>>
>>>>>> If it makes a difference to the answer, it is relevent.
>>>>>>
>>>>>>>
>>>>>>>>
>>>>>>>> We can use ANOTHER simulator (perhaps a different version of A,
>>>>>>>> and give it THIS B, connect with that original A, and not
>>>>>>>> itself) to see the right answer.
>>>>>>>>
>>>>>>>
>>>>>>> Every H(D,D) that simulates its input and does not abort
>>>>>>> that simulation is wrong.
>>>>>>>
>>>>>>> Every H(D,D) that simulates its input and does abort
>>>>>>> that simulation is correct about this abort decision.
>>>>>>
>>>>>> Nope.
>>>>>>
>>>>>> Just more of your LIES.
>>>>>>
>>>>>
>>>>> Yet you cannot point out any mistake because you are lying about there
>>>>> being any mistake. Every time you try to explain your reasoning about
>>>>> this it always comes down to this:
>>>>>
>>>>> *Every H(D,D) that needs to abort its input never needed to abort*
>>>>> *its input because some other H somewhere else that did not abort*
>>>>> *its input already aborted its input that it never aborted*
>>>>>
>>>>
>>>> Nope, the fact that you can't even summarize what I said, just shows
>>>> it is beyound your ability to comprehend.
>>>>
>>>> You look at the workd through Olcott glasses, and only see what you
>>>> want.
>>>>
>>>> This makes you blind to the truth, and the truth will crush you.
>>>>
>>>> I have explained why you are wrong already elsewhere, and don't need
>>>> to repeat it.
>>>
>>> Yes you are great at dogmatically saying that I am wrong.
>>> What you are terrible at is showing any mistake because there are
>>> no mistakes.
>>>
>>> This is the machine code of D that every H examines.
>>> 83c4088945fc837dfc007402ebfe8b45fc8be55dc3
>>> This finite string of bytes never changes.
>>>
>>
>> This string is incomplete. There is a call to an undefined function in
>> it. Therefore, it is not a program, so no decision can be given for
>> it. A decision can be made only, if the code of the missing function
>> is added as well. This will make the string longer. But only then we
>> know the D for which a decision is required. So, olcott should give
>> the string of (not an incomplete program, but of) the complete
>> program, that includes the H.
>> It is very cheating to place all the different H functions at the same
>> address and pretend that we are still speaking of the same program.
>> Therefore, we need a string that describes the full program including H.
>>
>
> 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 }
>
> The question has always been:
> Of every element of the infinite set of H/D pairs where H simulates
> the above input can any implementation of the above H(D,D) ever stop
> running without aborting its simulation of D?
>

On 3/28/2024 7:06 PM, Richard Damon wrote:
> On 3/28/24 3:20 PM, olcott wrote:
>> On 3/28/2024 2:09 PM, Fred. Zwarts wrote:
>>> Op 28.mrt.2024 om 15:49 schreef olcott:
>>>> On 3/28/2024 7:01 AM, Richard Damon wrote:
>>>>> On 3/27/24 11:32 PM, olcott wrote:
>>>>>> On 3/27/2024 10:25 PM, Richard Damon wrote:
>>>>>>> On 3/27/24 11:09 PM, olcott wrote:
>>>>>>>> On 3/27/2024 9:43 PM, Richard Damon wrote:
>>>>>>>>> On 3/27/24 10:13 PM, olcott wrote:
>>>>>>>>>> On 3/27/2024 8:39 PM, Richard Damon wrote:
>>>>>>>>>>> On 3/27/24 9:10 PM, olcott wrote:
>>>>>>>>>>>> On 3/27/2024 7:48 PM, Richard Damon wrote:
>>>>>>>>>>>>> On 3/27/24 4:10 PM, olcott wrote:
>>>>>>>>>>>>>> On 3/27/2024 2:57 PM, Fred. Zwarts wrote:
>>>>>>>>>>>>>>> Op 27.mrt.2024 om 20:04 schreef olcott:
>>>>>>>>>>>>>>>> 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)
>>>>>>>>>>>>>>> That is a premature conclusion when A is not specified.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> *simulating abort decider* A(D,D)
>>>>>>>>>>>>>> *simulating abort decider* A(D,D)
>>>>>>>>>>>>>> *simulating abort decider* A(D,D)
>>>>>>>>>>>>>> *simulating abort decider* A(D,D)
>>>>>>>>>>>>>
>>>>>>>>>>>>> Which just shows your ignorance as that doesn't define what
>>>>>>>>>>>>> A actually is, or needs to do.
>>>>>>>>>>>>>
>>>>>>>>>>>>> You are just demonstrating that you don't know what you are
>>>>>>>>>>>>> talking about.
>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> It holds if A does not halt. If A returns, then B will
>>>>>>>>>>>>>>> halt (unless aborted).
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> If you honestly don't see that no A can possible return to
>>>>>>>>>>>>>> any simulated B then you lied about your programming skill.
>>>>>>>>>>>>>> Otherwise you can see this and are lying about it.
>>>>>>>>>>>>>
>>>>>>>>>>>>> It may not be able to simulate a B to the point of seeing
>>>>>>>>>>>>> an A return to it,
>>>>>>>>>>>>
>>>>>>>>>>>> *That is the behavior that an abort decider must report on*
>>>>>>>>>>>> *That is the behavior that an abort decider must report on*
>>>>>>>>>>>> *That is the behavior that an abort decider must report on*
>>>>>>>>>>>>
>>>>>>>>>>>> It is not possible to CORRECTLY simulate a B to the point of
>>>>>>>>>>>> seeing
>>>>>>>>>>>> an A return to it because A calls B in recursive simulation.
>>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> Nope, it IS possible to simulate any B to the point of seeing
>>>>>>>>>>> A return,
>>>>>>>>>>
>>>>>>>>>> It is impossible for A(B,B) to simulate its input such that any
>>>>>>>>>> A ever returns to any B simulated by A because B calls A in
>>>>>>>>>> recursive
>>>>>>>>>> simulation.
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> And if the "Definition" of the answer is based on it "Correctly
>>>>>>>>> Simulating its input", which it can not do, then you have a
>>>>>>>>> problem with your definitions.
>>>>>>>>>
>>>>>>>>
>>>>>>>> Every A(B,B) simulates its input until it sees the same thing
>>>>>>>> that you an I have seen for two years.
>>>>>>>
>>>>>>> Which is an INCORECT condition for aborting, as it matches some
>>>>>>> machines that do not need there simulation to be aborted.
>>>>>>>
>>>>>>>>
>>>>>>>>> Your problem is you keep on forgetting that at any given time
>>>>>>>>> and example, A is a SPECIFIC program, with SPECIFIC behavior
>>>>>>>>> and it will either simulate and not abort and not answer, or
>>>>>>>>> abort and not show what its input does.
>>>>>>>>
>>>>>>>> I never forget that.
>>>>>>>> I KNOW THAT IRRELEVANT DIFFERENCES ARE IRRELEVANT
>>>>>>>> I KNOW THAT IRRELEVANT DIFFERENCES ARE IRRELEVANT
>>>>>>>> I KNOW THAT IRRELEVANT DIFFERENCES ARE IRRELEVANT
>>>>>>>
>>>>>>> But you seem to think that some RELEVERNT differences are
>>>>>>> IRrelevant, showing you are just stupid.
>>>>>>>
>>>>>>> If it makes a difference to the answer, it is relevent.
>>>>>>>
>>>>>>>>
>>>>>>>>>
>>>>>>>>> We can use ANOTHER simulator (perhaps a different version of A,
>>>>>>>>> and give it THIS B, connect with that original A, and not
>>>>>>>>> itself) to see the right answer.
>>>>>>>>>
>>>>>>>>
>>>>>>>> Every H(D,D) that simulates its input and does not abort
>>>>>>>> that simulation is wrong.
>>>>>>>>
>>>>>>>> Every H(D,D) that simulates its input and does abort
>>>>>>>> that simulation is correct about this abort decision.
>>>>>>>
>>>>>>> Nope.
>>>>>>>
>>>>>>> Just more of your LIES.
>>>>>>>
>>>>>>
>>>>>> Yet you cannot point out any mistake because you are lying about
>>>>>> there
>>>>>> being any mistake. Every time you try to explain your reasoning about
>>>>>> this it always comes down to this:
>>>>>>
>>>>>> *Every H(D,D) that needs to abort its input never needed to abort*
>>>>>> *its input because some other H somewhere else that did not abort*
>>>>>> *its input already aborted its input that it never aborted*
>>>>>>
>>>>>
>>>>> Nope, the fact that you can't even summarize what I said, just
>>>>> shows it is beyound your ability to comprehend.
>>>>>
>>>>> You look at the workd through Olcott glasses, and only see what you
>>>>> want.
>>>>>
>>>>> This makes you blind to the truth, and the truth will crush you.
>>>>>
>>>>> I have explained why you are wrong already elsewhere, and don't
>>>>> need to repeat it.
>>>>
>>>> Yes you are great at dogmatically saying that I am wrong.
>>>> What you are terrible at is showing any mistake because there are
>>>> no mistakes.
>>>>
>>>> This is the machine code of D that every H examines.
>>>> 83c4088945fc837dfc007402ebfe8b45fc8be55dc3
>>>> This finite string of bytes never changes.
>>>>
>>>
>>> This string is incomplete. There is a call to an undefined function
>>> in it. Therefore, it is not a program, so no decision can be given
>>> for it. A decision can be made only, if the code of the missing
>>> function is added as well. This will make the string longer. But only
>>> then we know the D for which a decision is required. So, olcott
>>> should give the string of (not an incomplete program, but of) the
>>> complete program, that includes the H.
>>> It is very cheating to place all the different H functions at the
>>> same address and pretend that we are still speaking of the same program.
>>> Therefore, we need a string that describes the full program including H.
>>>
>>
>> 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 }
>>
>> The question has always been:
>> Of every element of the infinite set of H/D pairs where H simulates
>> the above input can any implementation of the above H(D,D) ever stop
>> running without aborting its simulation of D?
>>
>
> Nope.
>
> The question started out, and remains does the Computation described by
> the input Halt when run.
>
You must have rocks in your head.
I have said 500 freaking times ABORT DECIDER NOT HALT DECIDER
I have said 500 freaking times ABORT DECIDER NOT HALT DECIDER
I have said 500 freaking times ABORT DECIDER NOT HALT DECIDER
I have said 500 freaking times ABORT DECIDER NOT HALT DECIDER
I have said 500 freaking times ABORT DECIDER NOT HALT DECIDER
I have said 500 freaking times ABORT DECIDER NOT HALT DECIDER
I have said 500 freaking times ABORT DECIDER NOT HALT DECIDER
I have said 500 freaking times ABORT DECIDER NOT HALT DECIDER
I have said 500 freaking times ABORT DECIDER NOT HALT DECIDER
I have said 500 freaking times ABORT DECIDER NOT HALT DECIDER
I have said 500 freaking times ABORT DECIDER NOT HALT DECIDER
I have said 500 freaking times ABORT DECIDER NOT HALT DECIDER
I have said 500 freaking times ABORT DECIDER NOT HALT DECIDER
I have said 500 freaking times ABORT DECIDER NOT HALT DECIDER
I have said 500 freaking times ABORT DECIDER NOT HALT DECIDER
I have said 500 freaking times ABORT DECIDER NOT HALT DECIDER
I have said 500 freaking times ABORT DECIDER NOT HALT DECIDER
I have said 500 freaking times ABORT DECIDER NOT HALT DECIDER
I have said 500 freaking times ABORT DECIDER NOT HALT DECIDER
I have said 500 freaking times ABORT DECIDER NOT HALT DECIDER
I have said 500 freaking times ABORT DECIDER NOT HALT DECIDER
I have said 500 freaking times ABORT DECIDER NOT HALT DECIDER
I have said 500 freaking times ABORT DECIDER NOT HALT DECIDER
I have said 500 freaking times ABORT DECIDER NOT HALT DECIDER
I have said 500 freaking times ABORT DECIDER NOT HALT DECIDER
I have said 500 freaking times ABORT DECIDER NOT HALT DECIDER
I have said 500 freaking times ABORT DECIDER NOT HALT DECIDER
I have said 500 freaking times ABORT DECIDER NOT HALT DECIDER
I have said 500 freaking times ABORT DECIDER NOT HALT DECIDER
I have said 500 freaking times ABORT DECIDER NOT HALT DECIDER
I have said 500 freaking times ABORT DECIDER NOT HALT DECIDER
I have said 500 freaking times ABORT DECIDER NOT HALT DECIDER
I have said 500 freaking times ABORT DECIDER NOT HALT DECIDER
I have said 500 freaking times ABORT DECIDER NOT HALT DECIDER
I have said 500 freaking times ABORT DECIDER NOT HALT DECIDER
I have said 500 freaking times ABORT DECIDER NOT HALT DECIDER
I have said 500 freaking times ABORT DECIDER NOT HALT DECIDER
I have said 500 freaking times ABORT DECIDER NOT HALT DECIDER
I have said 500 freaking times ABORT DECIDER NOT HALT DECIDER
I have said 500 freaking times ABORT DECIDER NOT HALT DECIDER
I have said 500 freaking times ABORT DECIDER NOT HALT DECIDER
I have said 500 freaking times ABORT DECIDER NOT HALT DECIDER
I have said 500 freaking times ABORT DECIDER NOT HALT DECIDER
I have said 500 freaking times ABORT DECIDER NOT HALT DECIDER
I have said 500 freaking times ABORT DECIDER NOT HALT DECIDER
I have said 500 freaking times ABORT DECIDER NOT HALT DECIDER
I have said 500 freaking times ABORT DECIDER NOT HALT DECIDER
I have said 500 freaking times ABORT DECIDER NOT HALT DECIDER
I have said 500 freaking times ABORT DECIDER NOT HALT DECIDER
I have said 500 freaking times ABORT DECIDER NOT HALT DECIDER
I have said 500 freaking times ABORT DECIDER NOT HALT DECIDER
I have said 500 freaking times ABORT DECIDER NOT HALT DECIDER
I have said 500 freaking times ABORT DECIDER NOT HALT DECIDER
I have said 500 freaking times ABORT DECIDER NOT HALT DECIDER
I have said 500 freaking times ABORT DECIDER NOT HALT DECIDER
I have said 500 freaking times ABORT DECIDER NOT HALT DECIDER
I have said 500 freaking times ABORT DECIDER NOT HALT DECIDER
I have said 500 freaking times ABORT DECIDER NOT HALT DECIDER
I have said 500 freaking times ABORT DECIDER NOT HALT DECIDER
I have said 500 freaking times ABORT DECIDER NOT HALT DECIDER
I have said 500 freaking times ABORT DECIDER NOT HALT DECIDER
I have said 500 freaking times ABORT DECIDER NOT HALT DECIDER
I have said 500 freaking times ABORT DECIDER NOT HALT DECIDER
I have said 500 freaking times ABORT DECIDER NOT HALT DECIDER
I have said 500 freaking times ABORT DECIDER NOT HALT DECIDER
I have said 500 freaking times ABORT DECIDER NOT HALT DECIDER
I have said 500 freaking times ABORT DECIDER NOT HALT DECIDER
I have said 500 freaking times ABORT DECIDER NOT HALT DECIDER
I have said 500 freaking times ABORT DECIDER NOT HALT DECIDER
I have said 500 freaking times ABORT DECIDER NOT HALT DECIDER
I have said 500 freaking times ABORT DECIDER NOT HALT DECIDER
I have said 500 freaking times ABORT DECIDER NOT HALT DECIDER
I have said 500 freaking times ABORT DECIDER NOT HALT DECIDER
I have said 500 freaking times ABORT DECIDER NOT HALT DECIDER
I have said 500 freaking times ABORT DECIDER NOT HALT DECIDER
I have said 500 freaking times ABORT DECIDER NOT HALT DECIDER
I have said 500 freaking times ABORT DECIDER NOT HALT DECIDER
I have said 500 freaking times ABORT DECIDER NOT HALT DECIDER
I have said 500 freaking times ABORT DECIDER NOT HALT DECIDER
I have said 500 freaking times ABORT DECIDER NOT HALT DECIDER
I have said 500 freaking times ABORT DECIDER NOT HALT DECIDER
I have said 500 freaking times ABORT DECIDER NOT HALT DECIDER
I have said 500 freaking times ABORT DECIDER NOT HALT DECIDER
I have said 500 freaking times ABORT DECIDER NOT HALT DECIDER
I have said 500 freaking times ABORT DECIDER NOT HALT DECIDER
I have said 500 freaking times ABORT DECIDER NOT HALT DECIDER
I have said 500 freaking times ABORT DECIDER NOT HALT DECIDER
I have said 500 freaking times ABORT DECIDER NOT HALT DECIDER
I have said 500 freaking times ABORT DECIDER NOT HALT DECIDER
I have said 500 freaking times ABORT DECIDER NOT HALT DECIDER
I have said 500 freaking times ABORT DECIDER NOT HALT DECIDER
I have said 500 freaking times ABORT DECIDER NOT HALT DECIDER
I have said 500 freaking times ABORT DECIDER NOT HALT DECIDER
I have said 500 freaking times ABORT DECIDER NOT HALT DECIDER
I have said 500 freaking times ABORT DECIDER NOT HALT DECIDER
I have said 500 freaking times ABORT DECIDER NOT HALT DECIDER
I have said 500 freaking times ABORT DECIDER NOT HALT DECIDER
I have said 500 freaking times ABORT DECIDER NOT HALT DECIDER
I have said 500 freaking times ABORT DECIDER NOT HALT DECIDER
I have said 500 freaking times ABORT DECIDER NOT HALT DECIDER
I have said 500 freaking times ABORT DECIDER NOT HALT DECIDER
I have said 500 freaking times ABORT DECIDER NOT HALT DECIDER
I have said 500 freaking times ABORT DECIDER NOT HALT DECIDER
I have said 500 freaking times ABORT DECIDER NOT HALT DECIDER
I have said 500 freaking times ABORT DECIDER NOT HALT DECIDER
I have said 500 freaking times ABORT DECIDER NOT HALT DECIDER
I have said 500 freaking times ABORT DECIDER NOT HALT DECIDER
I have said 500 freaking times ABORT DECIDER NOT HALT DECIDER
I have said 500 freaking times ABORT DECIDER NOT HALT DECIDER
I have said 500 freaking times ABORT DECIDER NOT HALT DECIDER
I have said 500 freaking times ABORT DECIDER NOT HALT DECIDER
I have said 500 freaking times ABORT DECIDER NOT HALT DECIDER
I have said 500 freaking times ABORT DECIDER NOT HALT DECIDER
I have said 500 freaking times ABORT DECIDER NOT HALT DECIDER
I have said 500 freaking times ABORT DECIDER NOT HALT DECIDER
I have said 500 freaking times ABORT DECIDER NOT HALT DECIDER
I have said 500 freaking times ABORT DECIDER NOT HALT DECIDER
I have said 500 freaking times ABORT DECIDER NOT HALT DECIDER
I have said 500 freaking times ABORT DECIDER NOT HALT DECIDER
I have said 500 freaking times ABORT DECIDER NOT HALT DECIDER
I have said 500 freaking times ABORT DECIDER NOT HALT DECIDER
I have said 500 freaking times ABORT DECIDER NOT HALT DECIDER
I have said 500 freaking times ABORT DECIDER NOT HALT DECIDER
I have said 500 freaking times ABORT DECIDER NOT HALT DECIDER
I have said 500 freaking times ABORT DECIDER NOT HALT DECIDER
I have said 500 freaking times ABORT DECIDER NOT HALT DECIDER
I have said 500 freaking times ABORT DECIDER NOT HALT DECIDER
I have said 500 freaking times ABORT DECIDER NOT HALT DECIDER
I have said 500 freaking times ABORT DECIDER NOT HALT DECIDER
I have said 500 freaking times ABORT DECIDER NOT HALT DECIDER
I have said 500 freaking times ABORT DECIDER NOT HALT DECIDER
I have said 500 freaking times ABORT DECIDER NOT HALT DECIDER
I have said 500 freaking times ABORT DECIDER NOT HALT DECIDER
I have said 500 freaking times ABORT DECIDER NOT HALT DECIDER
I have said 500 freaking times ABORT DECIDER NOT HALT DECIDER
I have said 500 freaking times ABORT DECIDER NOT HALT DECIDER
I have said 500 freaking times ABORT DECIDER NOT HALT DECIDER
I have said 500 freaking times ABORT DECIDER NOT HALT DECIDER
I have said 500 freaking times ABORT DECIDER NOT HALT DECIDER
I have said 500 freaking times ABORT DECIDER NOT HALT DECIDER
I have said 500 freaking times ABORT DECIDER NOT HALT DECIDER
I have said 500 freaking times ABORT DECIDER NOT HALT DECIDER
I have said 500 freaking times ABORT DECIDER NOT HALT DECIDER
I have said 500 freaking times ABORT DECIDER NOT HALT DECIDER
I have said 500 freaking times ABORT DECIDER NOT HALT DECIDER
I have said 500 freaking times ABORT DECIDER NOT HALT DECIDER
I have said 500 freaking times ABORT DECIDER NOT HALT DECIDER
I have said 500 freaking times ABORT DECIDER NOT HALT DECIDER
I have said 500 freaking times ABORT DECIDER NOT HALT DECIDER
I have said 500 freaking times ABORT DECIDER NOT HALT DECIDER
I have said 500 freaking times ABORT DECIDER NOT HALT DECIDER
I have said 500 freaking times ABORT DECIDER NOT HALT DECIDER
I have said 500 freaking times ABORT DECIDER NOT HALT DECIDER
I have said 500 freaking times ABORT DECIDER NOT HALT DECIDER
I have said 500 freaking times ABORT DECIDER NOT HALT DECIDER
I have said 500 freaking times ABORT DECIDER NOT HALT DECIDER
I have said 500 freaking times ABORT DECIDER NOT HALT DECIDER
I have said 500 freaking times ABORT DECIDER NOT HALT DECIDER
I have said 500 freaking times ABORT DECIDER NOT HALT DECIDER

On 3/28/2024 7:06 PM, Richard Damon wrote:
> On 3/28/24 10:49 AM, olcott wrote:
>> On 3/28/2024 7:01 AM, Richard Damon wrote:
>>> On 3/27/24 11:32 PM, olcott wrote:
>>>> On 3/27/2024 10:25 PM, Richard Damon wrote:
>>>>> On 3/27/24 11:09 PM, olcott wrote:
>>>>>> On 3/27/2024 9:43 PM, Richard Damon wrote:
>>>>>>> On 3/27/24 10:13 PM, olcott wrote:
>>>>>>>> On 3/27/2024 8:39 PM, Richard Damon wrote:
>>>>>>>>> On 3/27/24 9:10 PM, olcott wrote:
>>>>>>>>>> On 3/27/2024 7:48 PM, Richard Damon wrote:
>>>>>>>>>>> On 3/27/24 4:10 PM, olcott wrote:
>>>>>>>>>>>> On 3/27/2024 2:57 PM, Fred. Zwarts wrote:
>>>>>>>>>>>>> Op 27.mrt.2024 om 20:04 schreef olcott:
>>>>>>>>>>>>>> 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)
>>>>>>>>>>>>> That is a premature conclusion when A is not specified.
>>>>>>>>>>>>
>>>>>>>>>>>> *simulating abort decider* A(D,D)
>>>>>>>>>>>> *simulating abort decider* A(D,D)
>>>>>>>>>>>> *simulating abort decider* A(D,D)
>>>>>>>>>>>> *simulating abort decider* A(D,D)
>>>>>>>>>>>
>>>>>>>>>>> Which just shows your ignorance as that doesn't define what A
>>>>>>>>>>> actually is, or needs to do.
>>>>>>>>>>>
>>>>>>>>>>> You are just demonstrating that you don't know what you are
>>>>>>>>>>> talking about.
>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>>> It holds if A does not halt. If A returns, then B will halt
>>>>>>>>>>>>> (unless aborted).
>>>>>>>>>>>>
>>>>>>>>>>>> If you honestly don't see that no A can possible return to
>>>>>>>>>>>> any simulated B then you lied about your programming skill.
>>>>>>>>>>>> Otherwise you can see this and are lying about it.
>>>>>>>>>>>
>>>>>>>>>>> It may not be able to simulate a B to the point of seeing an
>>>>>>>>>>> A return to it,
>>>>>>>>>>
>>>>>>>>>> *That is the behavior that an abort decider must report on*
>>>>>>>>>> *That is the behavior that an abort decider must report on*
>>>>>>>>>> *That is the behavior that an abort decider must report on*
>>>>>>>>>>
>>>>>>>>>> It is not possible to CORRECTLY simulate a B to the point of
>>>>>>>>>> seeing
>>>>>>>>>> an A return to it because A calls B in recursive simulation.
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> Nope, it IS possible to simulate any B to the point of seeing A
>>>>>>>>> return,
>>>>>>>>
>>>>>>>> It is impossible for A(B,B) to simulate its input such that any
>>>>>>>> A ever returns to any B simulated by A because B calls A in
>>>>>>>> recursive
>>>>>>>> simulation.
>>>>>>>>
>>>>>>>
>>>>>>> And if the "Definition" of the answer is based on it "Correctly
>>>>>>> Simulating its input", which it can not do, then you have a
>>>>>>> problem with your definitions.
>>>>>>>
>>>>>>
>>>>>> Every A(B,B) simulates its input until it sees the same thing
>>>>>> that you an I have seen for two years.
>>>>>
>>>>> Which is an INCORECT condition for aborting, as it matches some
>>>>> machines that do not need there simulation to be aborted.
>>>>>
>>>>>>
>>>>>>> Your problem is you keep on forgetting that at any given time and
>>>>>>> example, A is a SPECIFIC program, with SPECIFIC behavior and it
>>>>>>> will either simulate and not abort and not answer, or abort and
>>>>>>> not show what its input does.
>>>>>>
>>>>>> I never forget that.
>>>>>> I KNOW THAT IRRELEVANT DIFFERENCES ARE IRRELEVANT
>>>>>> I KNOW THAT IRRELEVANT DIFFERENCES ARE IRRELEVANT
>>>>>> I KNOW THAT IRRELEVANT DIFFERENCES ARE IRRELEVANT
>>>>>
>>>>> But you seem to think that some RELEVERNT differences are
>>>>> IRrelevant, showing you are just stupid.
>>>>>
>>>>> If it makes a difference to the answer, it is relevent.
>>>>>
>>>>>>
>>>>>>>
>>>>>>> We can use ANOTHER simulator (perhaps a different version of A,
>>>>>>> and give it THIS B, connect with that original A, and not itself)
>>>>>>> to see the right answer.
>>>>>>>
>>>>>>
>>>>>> Every H(D,D) that simulates its input and does not abort
>>>>>> that simulation is wrong.
>>>>>>
>>>>>> Every H(D,D) that simulates its input and does abort
>>>>>> that simulation is correct about this abort decision.
>>>>>
>>>>> Nope.
>>>>>
>>>>> Just more of your LIES.
>>>>>
>>>>
>>>> Yet you cannot point out any mistake because you are lying about there
>>>> being any mistake. Every time you try to explain your reasoning about
>>>> this it always comes down to this:
>>>>
>>>> *Every H(D,D) that needs to abort its input never needed to abort*
>>>> *its input because some other H somewhere else that did not abort*
>>>> *its input already aborted its input that it never aborted*
>>>>
>>>
>>> Nope, the fact that you can't even summarize what I said, just shows
>>> it is beyound your ability to comprehend.
>>>
>>> You look at the workd through Olcott glasses, and only see what you
>>> want.
>>>
>>> This makes you blind to the truth, and the truth will crush you.
>>>
>>> I have explained why you are wrong already elsewhere, and don't need
>>> to repeat it.
>>
>> Yes you are great at dogmatically saying that I am wrong.
>> What you are terrible at is showing any mistake because there are
>> no mistakes.
>
> I don't think you understand what "Dogma" is.
>
>>
>> This is the machine code of D that every H examines.
>> 83c4088945fc837dfc007402ebfe8b45fc8be55dc3
>> This finite string of bytes never changes.
>
> Right, but as you have admitted, the behavior of that machine code
> CHANGES depending on what is at the location of H.
>

The behavior of D simulated by any H that can possibly exist
remains the same.

>>
>> You keep insisting that necessarily irrelevant differences
>> between H/D pairs that have nothing to do with the abort
>> decision make a significant difference in the abort decision.
>
> Because the behavior of H isn't irrelevent, and your claim that it is
> just shows that you are jusdt an ignorant pathological lying idiot.
>
>>
>> You already know that these irrelevant differences don't
>> make any semantic difference in the abort decision because:
>>
>> *Every H(D,D) that simulates its input and aborts is equivalent*
>> and
>> *Every H(D,D) that simulates its input and does not abort is equivalent*
>
> Right, and every H in the first group is wrong because it doesn't answer,
>
> And every H in the second group is wrong because it gives the WRONG answer.
>
IT IS AN ABORT DECIDER THAT GIVES NO ANSWER IT ONLY ABORTS
IT IS AN ABORT DECIDER THAT GIVES NO ANSWER IT ONLY ABORTS
IT IS AN ABORT DECIDER THAT GIVES NO ANSWER IT ONLY ABORTS
IT IS AN ABORT DECIDER THAT GIVES NO ANSWER IT ONLY ABORTS
IT IS AN ABORT DECIDER THAT GIVES NO ANSWER IT ONLY ABORTS
IT IS AN ABORT DECIDER THAT GIVES NO ANSWER IT ONLY ABORTS
IT IS AN ABORT DECIDER THAT GIVES NO ANSWER IT ONLY ABORTS
IT IS AN ABORT DECIDER THAT GIVES NO ANSWER IT ONLY ABORTS
IT IS AN ABORT DECIDER THAT GIVES NO ANSWER IT ONLY ABORTS
IT IS AN ABORT DECIDER THAT GIVES NO ANSWER IT ONLY ABORTS
IT IS AN ABORT DECIDER THAT GIVES NO ANSWER IT ONLY ABORTS
IT IS AN ABORT DECIDER THAT GIVES NO ANSWER IT ONLY ABORTS
IT IS AN ABORT DECIDER THAT GIVES NO ANSWER IT ONLY ABORTS
IT IS AN ABORT DECIDER THAT GIVES NO ANSWER IT ONLY ABORTS
IT IS AN ABORT DECIDER THAT GIVES NO ANSWER IT ONLY ABORTS
IT IS AN ABORT DECIDER THAT GIVES NO ANSWER IT ONLY ABORTS
IT IS AN ABORT DECIDER THAT GIVES NO ANSWER IT ONLY ABORTS
IT IS AN ABORT DECIDER THAT GIVES NO ANSWER IT ONLY ABORTS
IT IS AN ABORT DECIDER THAT GIVES NO ANSWER IT ONLY ABORTS
IT IS AN ABORT DECIDER THAT GIVES NO ANSWER IT ONLY ABORTS
IT IS AN ABORT DECIDER THAT GIVES NO ANSWER IT ONLY ABORTS
IT IS AN ABORT DECIDER THAT GIVES NO ANSWER IT ONLY ABORTS
IT IS AN ABORT DECIDER THAT GIVES NO ANSWER IT ONLY ABORTS
IT IS AN ABORT DECIDER THAT GIVES NO ANSWER IT ONLY ABORTS
IT IS AN ABORT DECIDER THAT GIVES NO ANSWER IT ONLY ABORTS
IT IS AN ABORT DECIDER THAT GIVES NO ANSWER IT ONLY ABORTS
IT IS AN ABORT DECIDER THAT GIVES NO ANSWER IT ONLY ABORTS
IT IS AN ABORT DECIDER THAT GIVES NO ANSWER IT ONLY ABORTS
IT IS AN ABORT DECIDER THAT GIVES NO ANSWER IT ONLY ABORTS
IT IS AN ABORT DECIDER THAT GIVES NO ANSWER IT ONLY ABORTS
IT IS AN ABORT DECIDER THAT GIVES NO ANSWER IT ONLY ABORTS
IT IS AN ABORT DECIDER THAT GIVES NO ANSWER IT ONLY ABORTS
IT IS AN ABORT DECIDER THAT GIVES NO ANSWER IT ONLY ABORTS
IT IS AN ABORT DECIDER THAT GIVES NO ANSWER IT ONLY ABORTS
IT IS AN ABORT DECIDER THAT GIVES NO ANSWER IT ONLY ABORTS
IT IS AN ABORT DECIDER THAT GIVES NO ANSWER IT ONLY ABORTS
IT IS AN ABORT DECIDER THAT GIVES NO ANSWER IT ONLY ABORTS
IT IS AN ABORT DECIDER THAT GIVES NO ANSWER IT ONLY ABORTS
IT IS AN ABORT DECIDER THAT GIVES NO ANSWER IT ONLY ABORTS
IT IS AN ABORT DECIDER THAT GIVES NO ANSWER IT ONLY ABORTS
IT IS AN ABORT DECIDER THAT GIVES NO ANSWER IT ONLY ABORTS
IT IS AN ABORT DECIDER THAT GIVES NO ANSWER IT ONLY ABORTS
IT IS AN ABORT DECIDER THAT GIVES NO ANSWER IT ONLY ABORTS
IT IS AN ABORT DECIDER THAT GIVES NO ANSWER IT ONLY ABORTS
IT IS AN ABORT DECIDER THAT GIVES NO ANSWER IT ONLY ABORTS
IT IS AN ABORT DECIDER THAT GIVES NO ANSWER IT ONLY ABORTS
IT IS AN ABORT DECIDER THAT GIVES NO ANSWER IT ONLY ABORTS
IT IS AN ABORT DECIDER THAT GIVES NO ANSWER IT ONLY ABORTS
IT IS AN ABORT DECIDER THAT GIVES NO ANSWER IT ONLY ABORTS
IT IS AN ABORT DECIDER THAT GIVES NO ANSWER IT ONLY ABORTS
IT IS AN ABORT DECIDER THAT GIVES NO ANSWER IT ONLY ABORTS
IT IS AN ABORT DECIDER THAT GIVES NO ANSWER IT ONLY ABORTS
IT IS AN ABORT DECIDER THAT GIVES NO ANSWER IT ONLY ABORTS
IT IS AN ABORT DECIDER THAT GIVES NO ANSWER IT ONLY ABORTS
IT IS AN ABORT DECIDER THAT GIVES NO ANSWER IT ONLY ABORTS
IT IS AN ABORT DECIDER THAT GIVES NO ANSWER IT ONLY ABORTS
IT IS AN ABORT DECIDER THAT GIVES NO ANSWER IT ONLY ABORTS
IT IS AN ABORT DECIDER THAT GIVES NO ANSWER IT ONLY ABORTS
IT IS AN ABORT DECIDER THAT GIVES NO ANSWER IT ONLY ABORTS
IT IS AN ABORT DECIDER THAT GIVES NO ANSWER IT ONLY ABORTS
IT IS AN ABORT DECIDER THAT GIVES NO ANSWER IT ONLY ABORTS
IT IS AN ABORT DECIDER THAT GIVES NO ANSWER IT ONLY ABORTS
IT IS AN ABORT DECIDER THAT GIVES NO ANSWER IT ONLY ABORTS
IT IS AN ABORT DECIDER THAT GIVES NO ANSWER IT ONLY ABORTS
IT IS AN ABORT DECIDER THAT GIVES NO ANSWER IT ONLY ABORTS
IT IS AN ABORT DECIDER THAT GIVES NO ANSWER IT ONLY ABORTS
IT IS AN ABORT DECIDER THAT GIVES NO ANSWER IT ONLY ABORTS
IT IS AN ABORT DECIDER THAT GIVES NO ANSWER IT ONLY ABORTS
IT IS AN ABORT DECIDER THAT GIVES NO ANSWER IT ONLY ABORTS
IT IS AN ABORT DECIDER THAT GIVES NO ANSWER IT ONLY ABORTS
IT IS AN ABORT DECIDER THAT GIVES NO ANSWER IT ONLY ABORTS
IT IS AN ABORT DECIDER THAT GIVES NO ANSWER IT ONLY ABORTS
IT IS AN ABORT DECIDER THAT GIVES NO ANSWER IT ONLY ABORTS
IT IS AN ABORT DECIDER THAT GIVES NO ANSWER IT ONLY ABORTS
IT IS AN ABORT DECIDER THAT GIVES NO ANSWER IT ONLY ABORTS
IT IS AN ABORT DECIDER THAT GIVES NO ANSWER IT ONLY ABORTS
IT IS AN ABORT DECIDER THAT GIVES NO ANSWER IT ONLY ABORTS
IT IS AN ABORT DECIDER THAT GIVES NO ANSWER IT ONLY ABORTS
IT IS AN ABORT DECIDER THAT GIVES NO ANSWER IT ONLY ABORTS
IT IS AN ABORT DECIDER THAT GIVES NO ANSWER IT ONLY ABORTS
IT IS AN ABORT DECIDER THAT GIVES NO ANSWER IT ONLY ABORTS
IT IS AN ABORT DECIDER THAT GIVES NO ANSWER IT ONLY ABORTS
IT IS AN ABORT DECIDER THAT GIVES NO ANSWER IT ONLY ABORTS
IT IS AN ABORT DECIDER THAT GIVES NO ANSWER IT ONLY ABORTS
IT IS AN ABORT DECIDER THAT GIVES NO ANSWER IT ONLY ABORTS
IT IS AN ABORT DECIDER THAT GIVES NO ANSWER IT ONLY ABORTS
IT IS AN ABORT DECIDER THAT GIVES NO ANSWER IT ONLY ABORTS
IT IS AN ABORT DECIDER THAT GIVES NO ANSWER IT ONLY ABORTS
IT IS AN ABORT DECIDER THAT GIVES NO ANSWER IT ONLY ABORTS
IT IS AN ABORT DECIDER THAT GIVES NO ANSWER IT ONLY ABORTS
IT IS AN ABORT DECIDER THAT GIVES NO ANSWER IT ONLY ABORTS
IT IS AN ABORT DECIDER THAT GIVES NO ANSWER IT ONLY ABORTS
IT IS AN ABORT DECIDER THAT GIVES NO ANSWER IT ONLY ABORTS
IT IS AN ABORT DECIDER THAT GIVES NO ANSWER IT ONLY ABORTS
IT IS AN ABORT DECIDER THAT GIVES NO ANSWER IT ONLY ABORTS
IT IS AN ABORT DECIDER THAT GIVES NO ANSWER IT ONLY ABORTS
IT IS AN ABORT DECIDER THAT GIVES NO ANSWER IT ONLY ABORTS
IT IS AN ABORT DECIDER THAT GIVES NO ANSWER IT ONLY ABORTS
IT IS AN ABORT DECIDER THAT GIVES NO ANSWER IT ONLY ABORTS
IT IS AN ABORT DECIDER THAT GIVES NO ANSWER IT ONLY ABORTS
IT IS AN ABORT DECIDER THAT GIVES NO ANSWER IT ONLY ABORTS
IT IS AN ABORT DECIDER THAT GIVES NO ANSWER IT ONLY ABORTS
IT IS AN ABORT DECIDER THAT GIVES NO ANSWER IT ONLY ABORTS
IT IS AN ABORT DECIDER THAT GIVES NO ANSWER IT ONLY ABORTS
IT IS AN ABORT DECIDER THAT GIVES NO ANSWER IT ONLY ABORTS
IT IS AN ABORT DECIDER THAT GIVES NO ANSWER IT ONLY ABORTS
IT IS AN ABORT DECIDER THAT GIVES NO ANSWER IT ONLY ABORTS
IT IS AN ABORT DECIDER THAT GIVES NO ANSWER IT ONLY ABORTS
IT IS AN ABORT DECIDER THAT GIVES NO ANSWER IT ONLY ABORTS
IT IS AN ABORT DECIDER THAT GIVES NO ANSWER IT ONLY ABORTS
IT IS AN ABORT DECIDER THAT GIVES NO ANSWER IT ONLY ABORTS
IT IS AN ABORT DECIDER THAT GIVES NO ANSWER IT ONLY ABORTS
IT IS AN ABORT DECIDER THAT GIVES NO ANSWER IT ONLY ABORTS
IT IS AN ABORT DECIDER THAT GIVES NO ANSWER IT ONLY ABORTS
IT IS AN ABORT DECIDER THAT GIVES NO ANSWER IT ONLY ABORTS
IT IS AN ABORT DECIDER THAT GIVES NO ANSWER IT ONLY ABORTS
IT IS AN ABORT DECIDER THAT GIVES NO ANSWER IT ONLY ABORTS
IT IS AN ABORT DECIDER THAT GIVES NO ANSWER IT ONLY ABORTS
IT IS AN ABORT DECIDER THAT GIVES NO ANSWER IT ONLY ABORTS
IT IS AN ABORT DECIDER THAT GIVES NO ANSWER IT ONLY ABORTS
IT IS AN ABORT DECIDER THAT GIVES NO ANSWER IT ONLY ABORTS
IT IS AN ABORT DECIDER THAT GIVES NO ANSWER IT ONLY ABORTS
IT IS AN ABORT DECIDER THAT GIVES NO ANSWER IT ONLY ABORTS
IT IS AN ABORT DECIDER THAT GIVES NO ANSWER IT ONLY ABORTS
IT IS AN ABORT DECIDER THAT GIVES NO ANSWER IT ONLY ABORTS
IT IS AN ABORT DECIDER THAT GIVES NO ANSWER IT ONLY ABORTS
IT IS AN ABORT DECIDER THAT GIVES NO ANSWER IT ONLY ABORTS
IT IS AN ABORT DECIDER THAT GIVES NO ANSWER IT ONLY ABORTS
IT IS AN ABORT DECIDER THAT GIVES NO ANSWER IT ONLY ABORTS
IT IS AN ABORT DECIDER THAT GIVES NO ANSWER IT ONLY ABORTS
IT IS AN ABORT DECIDER THAT GIVES NO ANSWER IT ONLY ABORTS
IT IS AN ABORT DECIDER THAT GIVES NO ANSWER IT ONLY ABORTS
IT IS AN ABORT DECIDER THAT GIVES NO ANSWER IT ONLY ABORTS
IT IS AN ABORT DECIDER THAT GIVES NO ANSWER IT ONLY ABORTS
IT IS AN ABORT DECIDER THAT GIVES NO ANSWER IT ONLY ABORTS
IT IS AN ABORT DECIDER THAT GIVES NO ANSWER IT ONLY ABORTS
IT IS AN ABORT DECIDER THAT GIVES NO ANSWER IT ONLY ABORTS
IT IS AN ABORT DECIDER THAT GIVES NO ANSWER IT ONLY ABORTS
IT IS AN ABORT DECIDER THAT GIVES NO ANSWER IT ONLY ABORTS
IT IS AN ABORT DECIDER THAT GIVES NO ANSWER IT ONLY ABORTS
IT IS AN ABORT DECIDER THAT GIVES NO ANSWER IT ONLY ABORTS
IT IS AN ABORT DECIDER THAT GIVES NO ANSWER IT ONLY ABORTS
IT IS AN ABORT DECIDER THAT GIVES NO ANSWER IT ONLY ABORTS
IT IS AN ABORT DECIDER THAT GIVES NO ANSWER IT ONLY ABORTS
IT IS AN ABORT DECIDER THAT GIVES NO ANSWER IT ONLY ABORTS
IT IS AN ABORT DECIDER THAT GIVES NO ANSWER IT ONLY ABORTS
IT IS AN ABORT DECIDER THAT GIVES NO ANSWER IT ONLY ABORTS
IT IS AN ABORT DECIDER THAT GIVES NO ANSWER IT ONLY ABORTS
IT IS AN ABORT DECIDER THAT GIVES NO ANSWER IT ONLY ABORTS
IT IS AN ABORT DECIDER THAT GIVES NO ANSWER IT ONLY ABORTS
IT IS AN ABORT DECIDER THAT GIVES NO ANSWER IT ONLY ABORTS
IT IS AN ABORT DECIDER THAT GIVES NO ANSWER IT ONLY ABORTS
IT IS AN ABORT DECIDER THAT GIVES NO ANSWER IT ONLY ABORTS
IT IS AN ABORT DECIDER THAT GIVES NO ANSWER IT ONLY ABORTS
IT IS AN ABORT DECIDER THAT GIVES NO ANSWER IT ONLY ABORTS
IT IS AN ABORT DECIDER THAT GIVES NO ANSWER IT ONLY ABORTS
IT IS AN ABORT DECIDER THAT GIVES NO ANSWER IT ONLY ABORTS
IT IS AN ABORT DECIDER THAT GIVES NO ANSWER IT ONLY ABORTS
IT IS AN ABORT DECIDER THAT GIVES NO ANSWER IT ONLY ABORTS
IT IS AN ABORT DECIDER THAT GIVES NO ANSWER IT ONLY ABORTS
IT IS AN ABORT DECIDER THAT GIVES NO ANSWER IT ONLY ABORTS
IT IS AN ABORT DECIDER THAT GIVES NO ANSWER IT ONLY ABORTS
IT IS AN ABORT DECIDER THAT GIVES NO ANSWER IT ONLY ABORTS
IT IS AN ABORT DECIDER THAT GIVES NO ANSWER IT ONLY ABORTS
IT IS AN ABORT DECIDER THAT GIVES NO ANSWER IT ONLY ABORTS
IT IS AN ABORT DECIDER THAT GIVES NO ANSWER IT ONLY ABORTS
IT IS AN ABORT DECIDER THAT GIVES NO ANSWER IT ONLY ABORTS
IT IS AN ABORT DECIDER THAT GIVES NO ANSWER IT ONLY ABORTS
IT IS AN ABORT DECIDER THAT GIVES NO ANSWER IT ONLY ABORTS
IT IS AN ABORT DECIDER THAT GIVES NO ANSWER IT ONLY ABORTS
IT IS AN ABORT DECIDER THAT GIVES NO ANSWER IT ONLY ABORTS
IT IS AN ABORT DECIDER THAT GIVES NO ANSWER IT ONLY ABORTS
IT IS AN ABORT DECIDER THAT GIVES NO ANSWER IT ONLY ABORTS
IT IS AN ABORT DECIDER THAT GIVES NO ANSWER IT ONLY ABORTS
IT IS AN ABORT DECIDER THAT GIVES NO ANSWER IT ONLY ABORTS

On 3/28/24 10:01 PM, olcott wrote:
> On 3/28/2024 7:06 PM, Richard Damon wrote:
>> On 3/28/24 10:49 AM, olcott wrote:
>>> On 3/28/2024 7:01 AM, Richard Damon wrote:
>>>> On 3/27/24 11:32 PM, olcott wrote:
>>>>> On 3/27/2024 10:25 PM, Richard Damon wrote:
>>>>>> On 3/27/24 11:09 PM, olcott wrote:
>>>>>>> On 3/27/2024 9:43 PM, Richard Damon wrote:
>>>>>>>> On 3/27/24 10:13 PM, olcott wrote:
>>>>>>>>> On 3/27/2024 8:39 PM, Richard Damon wrote:
>>>>>>>>>> On 3/27/24 9:10 PM, olcott wrote:
>>>>>>>>>>> On 3/27/2024 7:48 PM, Richard Damon wrote:
>>>>>>>>>>>> On 3/27/24 4:10 PM, olcott wrote:
>>>>>>>>>>>>> On 3/27/2024 2:57 PM, Fred. Zwarts wrote:
>>>>>>>>>>>>>> Op 27.mrt.2024 om 20:04 schreef olcott:
>>>>>>>>>>>>>>> 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)
>>>>>>>>>>>>>> That is a premature conclusion when A is not specified.
>>>>>>>>>>>>>
>>>>>>>>>>>>> *simulating abort decider* A(D,D)
>>>>>>>>>>>>> *simulating abort decider* A(D,D)
>>>>>>>>>>>>> *simulating abort decider* A(D,D)
>>>>>>>>>>>>> *simulating abort decider* A(D,D)
>>>>>>>>>>>>
>>>>>>>>>>>> Which just shows your ignorance as that doesn't define what
>>>>>>>>>>>> A actually is, or needs to do.
>>>>>>>>>>>>
>>>>>>>>>>>> You are just demonstrating that you don't know what you are
>>>>>>>>>>>> talking about.
>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>>> It holds if A does not halt. If A returns, then B will
>>>>>>>>>>>>>> halt (unless aborted).
>>>>>>>>>>>>>
>>>>>>>>>>>>> If you honestly don't see that no A can possible return to
>>>>>>>>>>>>> any simulated B then you lied about your programming skill.
>>>>>>>>>>>>> Otherwise you can see this and are lying about it.
>>>>>>>>>>>>
>>>>>>>>>>>> It may not be able to simulate a B to the point of seeing an
>>>>>>>>>>>> A return to it,
>>>>>>>>>>>
>>>>>>>>>>> *That is the behavior that an abort decider must report on*
>>>>>>>>>>> *That is the behavior that an abort decider must report on*
>>>>>>>>>>> *That is the behavior that an abort decider must report on*
>>>>>>>>>>>
>>>>>>>>>>> It is not possible to CORRECTLY simulate a B to the point of
>>>>>>>>>>> seeing
>>>>>>>>>>> an A return to it because A calls B in recursive simulation.
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> Nope, it IS possible to simulate any B to the point of seeing
>>>>>>>>>> A return,
>>>>>>>>>
>>>>>>>>> It is impossible for A(B,B) to simulate its input such that any
>>>>>>>>> A ever returns to any B simulated by A because B calls A in
>>>>>>>>> recursive
>>>>>>>>> simulation.
>>>>>>>>>
>>>>>>>>
>>>>>>>> And if the "Definition" of the answer is based on it "Correctly
>>>>>>>> Simulating its input", which it can not do, then you have a
>>>>>>>> problem with your definitions.
>>>>>>>>
>>>>>>>
>>>>>>> Every A(B,B) simulates its input until it sees the same thing
>>>>>>> that you an I have seen for two years.
>>>>>>
>>>>>> Which is an INCORECT condition for aborting, as it matches some
>>>>>> machines that do not need there simulation to be aborted.
>>>>>>
>>>>>>>
>>>>>>>> Your problem is you keep on forgetting that at any given time
>>>>>>>> and example, A is a SPECIFIC program, with SPECIFIC behavior and
>>>>>>>> it will either simulate and not abort and not answer, or abort
>>>>>>>> and not show what its input does.
>>>>>>>
>>>>>>> I never forget that.
>>>>>>> I KNOW THAT IRRELEVANT DIFFERENCES ARE IRRELEVANT
>>>>>>> I KNOW THAT IRRELEVANT DIFFERENCES ARE IRRELEVANT
>>>>>>> I KNOW THAT IRRELEVANT DIFFERENCES ARE IRRELEVANT
>>>>>>
>>>>>> But you seem to think that some RELEVERNT differences are
>>>>>> IRrelevant, showing you are just stupid.
>>>>>>
>>>>>> If it makes a difference to the answer, it is relevent.
>>>>>>
>>>>>>>
>>>>>>>>
>>>>>>>> We can use ANOTHER simulator (perhaps a different version of A,
>>>>>>>> and give it THIS B, connect with that original A, and not
>>>>>>>> itself) to see the right answer.
>>>>>>>>
>>>>>>>
>>>>>>> Every H(D,D) that simulates its input and does not abort
>>>>>>> that simulation is wrong.
>>>>>>>
>>>>>>> Every H(D,D) that simulates its input and does abort
>>>>>>> that simulation is correct about this abort decision.
>>>>>>
>>>>>> Nope.
>>>>>>
>>>>>> Just more of your LIES.
>>>>>>
>>>>>
>>>>> Yet you cannot point out any mistake because you are lying about there
>>>>> being any mistake. Every time you try to explain your reasoning about
>>>>> this it always comes down to this:
>>>>>
>>>>> *Every H(D,D) that needs to abort its input never needed to abort*
>>>>> *its input because some other H somewhere else that did not abort*
>>>>> *its input already aborted its input that it never aborted*
>>>>>
>>>>
>>>> Nope, the fact that you can't even summarize what I said, just shows
>>>> it is beyound your ability to comprehend.
>>>>
>>>> You look at the workd through Olcott glasses, and only see what you
>>>> want.
>>>>
>>>> This makes you blind to the truth, and the truth will crush you.
>>>>
>>>> I have explained why you are wrong already elsewhere, and don't need
>>>> to repeat it.
>>>
>>> Yes you are great at dogmatically saying that I am wrong.
>>> What you are terrible at is showing any mistake because there are
>>> no mistakes.
>>
>> I don't think you understand what "Dogma" is.
>>
>>>
>>> This is the machine code of D that every H examines.
>>> 83c4088945fc837dfc007402ebfe8b45fc8be55dc3
>>> This finite string of bytes never changes.
>>
>> Right, but as you have admitted, the behavior of that machine code
>> CHANGES depending on what is at the location of H.
>>
>
> The behavior of D simulated by any H that can possibly exist
> remains the same.

On 3/28/24 9:57 PM, olcott wrote:
> On 3/28/2024 7:06 PM, Richard Damon wrote:
>> On 3/28/24 3:20 PM, olcott wrote:
>>> On 3/28/2024 2:09 PM, Fred. Zwarts wrote:
>>>> Op 28.mrt.2024 om 15:49 schreef olcott:
>>>>> On 3/28/2024 7:01 AM, Richard Damon wrote:
>>>>>> On 3/27/24 11:32 PM, olcott wrote:
>>>>>>> On 3/27/2024 10:25 PM, Richard Damon wrote:
>>>>>>>> On 3/27/24 11:09 PM, olcott wrote:
>>>>>>>>> On 3/27/2024 9:43 PM, Richard Damon wrote:
>>>>>>>>>> On 3/27/24 10:13 PM, olcott wrote:
>>>>>>>>>>> On 3/27/2024 8:39 PM, Richard Damon wrote:
>>>>>>>>>>>> On 3/27/24 9:10 PM, olcott wrote:
>>>>>>>>>>>>> On 3/27/2024 7:48 PM, Richard Damon wrote:
>>>>>>>>>>>>>> On 3/27/24 4:10 PM, olcott wrote:
>>>>>>>>>>>>>>> On 3/27/2024 2:57 PM, Fred. Zwarts wrote:
>>>>>>>>>>>>>>>> Op 27.mrt.2024 om 20:04 schreef olcott:
>>>>>>>>>>>>>>>>> 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)
>>>>>>>>>>>>>>>> That is a premature conclusion when A is not specified.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> *simulating abort decider* A(D,D)
>>>>>>>>>>>>>>> *simulating abort decider* A(D,D)
>>>>>>>>>>>>>>> *simulating abort decider* A(D,D)
>>>>>>>>>>>>>>> *simulating abort decider* A(D,D)
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> Which just shows your ignorance as that doesn't define
>>>>>>>>>>>>>> what A actually is, or needs to do.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> You are just demonstrating that you don't know what you
>>>>>>>>>>>>>> are talking about.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> It holds if A does not halt. If A returns, then B will
>>>>>>>>>>>>>>>> halt (unless aborted).
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> If you honestly don't see that no A can possible return to
>>>>>>>>>>>>>>> any simulated B then you lied about your programming skill.
>>>>>>>>>>>>>>> Otherwise you can see this and are lying about it.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> It may not be able to simulate a B to the point of seeing
>>>>>>>>>>>>>> an A return to it,
>>>>>>>>>>>>>
>>>>>>>>>>>>> *That is the behavior that an abort decider must report on*
>>>>>>>>>>>>> *That is the behavior that an abort decider must report on*
>>>>>>>>>>>>> *That is the behavior that an abort decider must report on*
>>>>>>>>>>>>>
>>>>>>>>>>>>> It is not possible to CORRECTLY simulate a B to the point
>>>>>>>>>>>>> of seeing
>>>>>>>>>>>>> an A return to it because A calls B in recursive simulation.
>>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> Nope, it IS possible to simulate any B to the point of
>>>>>>>>>>>> seeing A return,
>>>>>>>>>>>
>>>>>>>>>>> It is impossible for A(B,B) to simulate its input such that any
>>>>>>>>>>> A ever returns to any B simulated by A because B calls A in
>>>>>>>>>>> recursive
>>>>>>>>>>> simulation.
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> And if the "Definition" of the answer is based on it
>>>>>>>>>> "Correctly Simulating its input", which it can not do, then
>>>>>>>>>> you have a problem with your definitions.
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> Every A(B,B) simulates its input until it sees the same thing
>>>>>>>>> that you an I have seen for two years.
>>>>>>>>
>>>>>>>> Which is an INCORECT condition for aborting, as it matches some
>>>>>>>> machines that do not need there simulation to be aborted.
>>>>>>>>
>>>>>>>>>
>>>>>>>>>> Your problem is you keep on forgetting that at any given time
>>>>>>>>>> and example, A is a SPECIFIC program, with SPECIFIC behavior
>>>>>>>>>> and it will either simulate and not abort and not answer, or
>>>>>>>>>> abort and not show what its input does.
>>>>>>>>>
>>>>>>>>> I never forget that.
>>>>>>>>> I KNOW THAT IRRELEVANT DIFFERENCES ARE IRRELEVANT
>>>>>>>>> I KNOW THAT IRRELEVANT DIFFERENCES ARE IRRELEVANT
>>>>>>>>> I KNOW THAT IRRELEVANT DIFFERENCES ARE IRRELEVANT
>>>>>>>>
>>>>>>>> But you seem to think that some RELEVERNT differences are
>>>>>>>> IRrelevant, showing you are just stupid.
>>>>>>>>
>>>>>>>> If it makes a difference to the answer, it is relevent.
>>>>>>>>
>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> We can use ANOTHER simulator (perhaps a different version of
>>>>>>>>>> A, and give it THIS B, connect with that original A, and not
>>>>>>>>>> itself) to see the right answer.
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> Every H(D,D) that simulates its input and does not abort
>>>>>>>>> that simulation is wrong.
>>>>>>>>>
>>>>>>>>> Every H(D,D) that simulates its input and does abort
>>>>>>>>> that simulation is correct about this abort decision.
>>>>>>>>
>>>>>>>> Nope.
>>>>>>>>
>>>>>>>> Just more of your LIES.
>>>>>>>>
>>>>>>>
>>>>>>> Yet you cannot point out any mistake because you are lying about
>>>>>>> there
>>>>>>> being any mistake. Every time you try to explain your reasoning
>>>>>>> about
>>>>>>> this it always comes down to this:
>>>>>>>
>>>>>>> *Every H(D,D) that needs to abort its input never needed to abort*
>>>>>>> *its input because some other H somewhere else that did not abort*
>>>>>>> *its input already aborted its input that it never aborted*
>>>>>>>
>>>>>>
>>>>>> Nope, the fact that you can't even summarize what I said, just
>>>>>> shows it is beyound your ability to comprehend.
>>>>>>
>>>>>> You look at the workd through Olcott glasses, and only see what
>>>>>> you want.
>>>>>>
>>>>>> This makes you blind to the truth, and the truth will crush you.
>>>>>>
>>>>>> I have explained why you are wrong already elsewhere, and don't
>>>>>> need to repeat it.
>>>>>
>>>>> Yes you are great at dogmatically saying that I am wrong.
>>>>> What you are terrible at is showing any mistake because there are
>>>>> no mistakes.
>>>>>
>>>>> This is the machine code of D that every H examines.
>>>>> 83c4088945fc837dfc007402ebfe8b45fc8be55dc3
>>>>> This finite string of bytes never changes.
>>>>>
>>>>
>>>> This string is incomplete. There is a call to an undefined function
>>>> in it. Therefore, it is not a program, so no decision can be given
>>>> for it. A decision can be made only, if the code of the missing
>>>> function is added as well. This will make the string longer. But
>>>> only then we know the D for which a decision is required. So, olcott
>>>> should give the string of (not an incomplete program, but of) the
>>>> complete program, that includes the H.
>>>> It is very cheating to place all the different H functions at the
>>>> same address and pretend that we are still speaking of the same
>>>> program.
>>>> Therefore, we need a string that describes the full program
>>>> including H.
>>>>
>>>
>>> 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 }
>>>
>>> The question has always been:
>>> Of every element of the infinite set of H/D pairs where H simulates
>>> the above input can any implementation of the above H(D,D) ever stop
>>> running without aborting its simulation of D?
>>>
>>
>> Nope.
>>
>> The question started out, and remains does the Computation described
>> by the input Halt when run.
>>
> You must have rocks in your head.
> I have said 500 freaking times ABORT DECIDER NOT HALT DECIDER

On 3/28/2024 9:50 PM, Richard Damon wrote:
> On 3/28/24 9:57 PM, olcott wrote:
>> On 3/28/2024 7:06 PM, Richard Damon wrote:
>>> On 3/28/24 3:20 PM, olcott wrote:
>>>> On 3/28/2024 2:09 PM, Fred. Zwarts wrote:
>>>>> Op 28.mrt.2024 om 15:49 schreef olcott:
>>>>>> On 3/28/2024 7:01 AM, Richard Damon wrote:
>>>>>>> On 3/27/24 11:32 PM, olcott wrote:
>>>>>>>> On 3/27/2024 10:25 PM, Richard Damon wrote:
>>>>>>>>> On 3/27/24 11:09 PM, olcott wrote:
>>>>>>>>>> On 3/27/2024 9:43 PM, Richard Damon wrote:
>>>>>>>>>>> On 3/27/24 10:13 PM, olcott wrote:
>>>>>>>>>>>> On 3/27/2024 8:39 PM, Richard Damon wrote:
>>>>>>>>>>>>> On 3/27/24 9:10 PM, olcott wrote:
>>>>>>>>>>>>>> On 3/27/2024 7:48 PM, Richard Damon wrote:
>>>>>>>>>>>>>>> On 3/27/24 4:10 PM, olcott wrote:
>>>>>>>>>>>>>>>> On 3/27/2024 2:57 PM, Fred. Zwarts wrote:
>>>>>>>>>>>>>>>>> Op 27.mrt.2024 om 20:04 schreef olcott:
>>>>>>>>>>>>>>>>>> 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)
>>>>>>>>>>>>>>>>> That is a premature conclusion when A is not specified.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> *simulating abort decider* A(D,D)
>>>>>>>>>>>>>>>> *simulating abort decider* A(D,D)
>>>>>>>>>>>>>>>> *simulating abort decider* A(D,D)
>>>>>>>>>>>>>>>> *simulating abort decider* A(D,D)
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> Which just shows your ignorance as that doesn't define
>>>>>>>>>>>>>>> what A actually is, or needs to do.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> You are just demonstrating that you don't know what you
>>>>>>>>>>>>>>> are talking about.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> It holds if A does not halt. If A returns, then B will
>>>>>>>>>>>>>>>>> halt (unless aborted).
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> If you honestly don't see that no A can possible return to
>>>>>>>>>>>>>>>> any simulated B then you lied about your programming skill.
>>>>>>>>>>>>>>>> Otherwise you can see this and are lying about it.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> It may not be able to simulate a B to the point of seeing
>>>>>>>>>>>>>>> an A return to it,
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> *That is the behavior that an abort decider must report on*
>>>>>>>>>>>>>> *That is the behavior that an abort decider must report on*
>>>>>>>>>>>>>> *That is the behavior that an abort decider must report on*
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> It is not possible to CORRECTLY simulate a B to the point
>>>>>>>>>>>>>> of seeing
>>>>>>>>>>>>>> an A return to it because A calls B in recursive simulation.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>> Nope, it IS possible to simulate any B to the point of
>>>>>>>>>>>>> seeing A return,
>>>>>>>>>>>>
>>>>>>>>>>>> It is impossible for A(B,B) to simulate its input such that any
>>>>>>>>>>>> A ever returns to any B simulated by A because B calls A in
>>>>>>>>>>>> recursive
>>>>>>>>>>>> simulation.
>>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> And if the "Definition" of the answer is based on it
>>>>>>>>>>> "Correctly Simulating its input", which it can not do, then
>>>>>>>>>>> you have a problem with your definitions.
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> Every A(B,B) simulates its input until it sees the same thing
>>>>>>>>>> that you an I have seen for two years.
>>>>>>>>>
>>>>>>>>> Which is an INCORECT condition for aborting, as it matches some
>>>>>>>>> machines that do not need there simulation to be aborted.
>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>>> Your problem is you keep on forgetting that at any given time
>>>>>>>>>>> and example, A is a SPECIFIC program, with SPECIFIC behavior
>>>>>>>>>>> and it will either simulate and not abort and not answer, or
>>>>>>>>>>> abort and not show what its input does.
>>>>>>>>>>
>>>>>>>>>> I never forget that.
>>>>>>>>>> I KNOW THAT IRRELEVANT DIFFERENCES ARE IRRELEVANT
>>>>>>>>>> I KNOW THAT IRRELEVANT DIFFERENCES ARE IRRELEVANT
>>>>>>>>>> I KNOW THAT IRRELEVANT DIFFERENCES ARE IRRELEVANT
>>>>>>>>>
>>>>>>>>> But you seem to think that some RELEVERNT differences are
>>>>>>>>> IRrelevant, showing you are just stupid.
>>>>>>>>>
>>>>>>>>> If it makes a difference to the answer, it is relevent.
>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> We can use ANOTHER simulator (perhaps a different version of
>>>>>>>>>>> A, and give it THIS B, connect with that original A, and not
>>>>>>>>>>> itself) to see the right answer.
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> Every H(D,D) that simulates its input and does not abort
>>>>>>>>>> that simulation is wrong.
>>>>>>>>>>
>>>>>>>>>> Every H(D,D) that simulates its input and does abort
>>>>>>>>>> that simulation is correct about this abort decision.
>>>>>>>>>
>>>>>>>>> Nope.
>>>>>>>>>
>>>>>>>>> Just more of your LIES.
>>>>>>>>>
>>>>>>>>
>>>>>>>> Yet you cannot point out any mistake because you are lying about
>>>>>>>> there
>>>>>>>> being any mistake. Every time you try to explain your reasoning
>>>>>>>> about
>>>>>>>> this it always comes down to this:
>>>>>>>>
>>>>>>>> *Every H(D,D) that needs to abort its input never needed to abort*
>>>>>>>> *its input because some other H somewhere else that did not abort*
>>>>>>>> *its input already aborted its input that it never aborted*
>>>>>>>>
>>>>>>>
>>>>>>> Nope, the fact that you can't even summarize what I said, just
>>>>>>> shows it is beyound your ability to comprehend.
>>>>>>>
>>>>>>> You look at the workd through Olcott glasses, and only see what
>>>>>>> you want.
>>>>>>>
>>>>>>> This makes you blind to the truth, and the truth will crush you.
>>>>>>>
>>>>>>> I have explained why you are wrong already elsewhere, and don't
>>>>>>> need to repeat it.
>>>>>>
>>>>>> Yes you are great at dogmatically saying that I am wrong.
>>>>>> What you are terrible at is showing any mistake because there are
>>>>>> no mistakes.
>>>>>>
>>>>>> This is the machine code of D that every H examines.
>>>>>> 83c4088945fc837dfc007402ebfe8b45fc8be55dc3
>>>>>> This finite string of bytes never changes.
>>>>>>
>>>>>
>>>>> This string is incomplete. There is a call to an undefined function
>>>>> in it. Therefore, it is not a program, so no decision can be given
>>>>> for it. A decision can be made only, if the code of the missing
>>>>> function is added as well. This will make the string longer. But
>>>>> only then we know the D for which a decision is required. So,
>>>>> olcott should give the string of (not an incomplete program, but
>>>>> of) the complete program, that includes the H.
>>>>> It is very cheating to place all the different H functions at the
>>>>> same address and pretend that we are still speaking of the same
>>>>> program.
>>>>> Therefore, we need a string that describes the full program
>>>>> including H.
>>>>>
>>>>
>>>> 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 }
>>>>
>>>> The question has always been:
>>>> Of every element of the infinite set of H/D pairs where H simulates
>>>> the above input can any implementation of the above H(D,D) ever stop
>>>> running without aborting its simulation of D?
>>>>
>>>
>>> Nope.
>>>
>>> The question started out, and remains does the Computation described
>>> by the input Halt when run.
>>>
>> You must have rocks in your head.
>> I have said 500 freaking times ABORT DECIDER NOT HALT DECIDER
>
> Then why does D put the return value into a variable called Halt_Status?
>