On 3/28/2024 9:22 PM, Richard Damon wrote:
> On 3/28/24 10:01 PM, olcott wrote:

<snip>

>>> 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.
>
> Nope.
>
> The behavior of D CHANGES based on the H it attaches to.
>

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

The behavior of directly executed D(D) is not the behavior of D
simulated by any H.

> You are just PROVING that you are LYING about H.
>

No I am proving that your ADD is worse than you thought.

<snip>

>> IT IS AN ABORT DECIDER THAT GIVES NO ANSWER IT ONLY ABORTS
>> IT IS AN ABORT DECIDER THAT GIVES NO ANSWER IT ONLY ABORT
> Then why does D use the answer?
>
> I guess you are just admitting that your setup is incoherent.
>

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

> And ALL Deciders give an answer.
>

If you need to then pretend that H(D,D) returns 1 for abort
and 0 for not aborted. Since this value is never used it
is irrelevant.

> Maybe in your case, there is only one answer, I aborted.
>
> But then, the mapping it is deciding on must be a trivial mapping, so H
> might as well return.
>

It is not trivial, where the Hell did you get that?
It is the same H that we always had with the return
values swapped and ignored.

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

On 3/28/24 10:58 PM, olcott wrote:
> 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?
>>
>
> That is a reasonable point.
> 01 void D(ptr x) // ptr is pointer to void function
> 02 {
> 03   H(x, x);
> 04   return;
> 05 }
> 06
> 07 void main()
> 08 {
> 09   H(D,D);
> 10 }

On 3/28/24 11:34 PM, olcott wrote:
> On 3/28/2024 9:22 PM, Richard Damon wrote:
>> On 3/28/24 10:01 PM, olcott wrote:
>
> <snip>
>
>>>> 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.
>>
>> Nope.
>>
>> The behavior of D CHANGES based on the H it attaches to.
>>
>
> The behavior of D simulated by any H that can possibly exist
> remains the same.

Nope. Since you are using a "meaningless" term, it is just a non-truth
bearer. Partial simulations do not reveal behavior, only complete
simulations.

This means that the only Hs that meet your "definition" of H are those
that act like UTMs, and thus NO H that meets your specification are
deciders.

>
> The behavior of directly executed D(D) is not the behavior of D
> simulated by any H.

Then H is not "Correctly Simulating" its input. PERIOD.

>
>> You are just PROVING that you are LYING about H.
>>
>
> No I am proving that your ADD is worse than you thought.

Nope. You are proving that you are LYING about your H.

>
> <snip>
>
>>> IT IS AN ABORT DECIDER THAT GIVES NO ANSWER IT ONLY ABORTS
>>> IT IS AN ABORT DECIDER THAT GIVES NO ANSWER IT ONLY ABORT
>> Then why does D use the answer?
>>
>> I guess you are just admitting that your setup is incoherent.
>>
>
> 01 void D(ptr x) // ptr is pointer to void function
> 02 {
> 03   H(x, x);
> 04   return;
> 05 }
> 06
> 07 void main()
> 08 {
> 09   H(D,D);
> 10 }

So?

Does H return at all?

If so, D is Halting and H doesn't need to abort.

If H doesn't return, it isn't a decider.

It seems, that what you are trying to define as your H is one that would
be satisfied by:

void H(ptr x, ptr y) {
return;
}

Which is a trivial program and thus not interesting.

>
>> And ALL Deciders give an answer.
>>
>
> If you need to then pretend that H(D,D) returns 1 for abort
> and 0 for not aborted. Since this value is never used it
> is irrelevant.

But if 1 means that it NEEDED to abort, then it is just wrong.

If it just means that it DID abort, then it has no definition of what it
needs to do be correct, and thus the trivial answer becomes:

int H(ptr x, ptr y) {
return 1;
}

because of course, just always aborting would be the "correct answer"

>
>> Maybe in your case, there is only one answer, I aborted.
>>
>> But then, the mapping it is deciding on must be a trivial mapping, so
>> H might as well return.
>>
>
> It is not trivial, where the Hell did you get that?
> It is the same H that we always had with the return
> values swapped and ignored.
>

But then the CORRECT answer for your above D is 0, as D(D) Halts, and
thus doesn't NEED to be aborted, but you H(D,D) returns 1.

So, you are just caught in your lie again.

On 3/29/2024 8:13 AM, Richard Damon wrote:
> On 3/28/24 11:34 PM, olcott wrote:
>> On 3/28/2024 9:22 PM, Richard Damon wrote:
>>> On 3/28/24 10:01 PM, olcott wrote:
>>
>> <snip>
>>
>>>>> 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.
>>>
>>> Nope.
>>>
>>> The behavior of D CHANGES based on the H it attaches to.
>>>
>>
>> The behavior of D simulated by any H that can possibly exist
>> remains the same.
>
> Nope. Since you are using a "meaningless" term, it is just a non-truth
> bearer. Partial simulations do not reveal behavior, only complete
> simulations.
>

Yes and your same reasoning says that mathematical induction can't
possibly work. No finite sequences of steps can every be extrapolated
to an in finite number of steps.

Are you trying to get away with saying that you simply do not
"believe in" mathematical induction?

> This means that the only Hs that meet your "definition" of H are those
> that act like UTMs, and thus NO H that meets your specification are
> deciders.
>

You are too much of a liar. If you don't quit
I am going to give up on you.

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

On 3/29/2024 8:13 AM, Richard Damon wrote:
> On 3/28/24 10:58 PM, olcott wrote:
>> 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?
>>>
>>
>> That is a reasonable point.
>> 01 void D(ptr x) // ptr is pointer to void function
>> 02 {
>> 03   H(x, x);
>> 04   return;
>> 05 }
>> 06
>> 07 void main()
>> 08 {
>> 09   H(D,D);
>> 10 }
>
> So, since this D will ALWAYS halt (if H gives an answer) why does H need
> to "abort" it? Can it not figure out that it will give an answer and
> that the input will halt?
>

On 3/29/24 11:51 AM, olcott wrote:
> On 3/29/2024 8:13 AM, Richard Damon wrote:
>> On 3/28/24 11:34 PM, olcott wrote:
>>> On 3/28/2024 9:22 PM, Richard Damon wrote:
>>>> On 3/28/24 10:01 PM, olcott wrote:
>>>
>>> <snip>
>>>
>>>>>> 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.
>>>>
>>>> Nope.
>>>>
>>>> The behavior of D CHANGES based on the H it attaches to.
>>>>
>>>
>>> The behavior of D simulated by any H that can possibly exist
>>> remains the same.
>>
>> Nope. Since you are using a "meaningless" term, it is just a non-truth
>> bearer. Partial simulations do not reveal behavior, only complete
>> simulations.
>>
>
> Yes and your same reasoning says that mathematical induction can't
> possibly work. No finite sequences of steps can every be extrapolated
> to an in finite number of steps.
>

Why do you say that?

I guess you don't think all the Natural Numbers exist.

You are just showing that you are using incorrect logic;

> Are you trying to get away with saying that you simply do not
> "believe in" mathematical induction?

You need to show that actual steps that PROVE your induction, which I
don't think you actually know what they are.

>
>> This means that the only Hs that meet your "definition" of H are those
>> that act like UTMs, and thus NO H that meets your specification are
>> deciders.
>>
>
> You are too much of a liar. If you don't quit
> I am going to give up on you.
>

Nope, Show the LIE.

You LIE when you claim others LIE but can not show the actual incorrect
statement.

You hit the problem that there ARE actual definitions and you will need
to try to "misquote" one to try to show a lie, and then your lie becomes
too obvious for you.

On 3/29/24 11:52 AM, olcott wrote:
> On 3/29/2024 8:13 AM, Richard Damon wrote:
>> On 3/28/24 10:58 PM, olcott wrote:
>>> 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?
>>>>
>>>
>>> That is a reasonable point.
>>> 01 void D(ptr x) // ptr is pointer to void function
>>> 02 {
>>> 03   H(x, x);
>>> 04   return;
>>> 05 }
>>> 06
>>> 07 void main()
>>> 08 {
>>> 09   H(D,D);
>>> 10 }
>>
>> So, since this D will ALWAYS halt (if H gives an answer) why does H
>> need to "abort" it? Can it not figure out that it will give an answer
>> and that the input will halt?
>>
>
> You are too much of a liar.
> If you don't quit I am going to give up on you.
>
>

On 3/29/2024 12:02 PM, Richard Damon wrote:
> On 3/29/24 11:52 AM, olcott wrote:
>> On 3/29/2024 8:13 AM, Richard Damon wrote:
>>> On 3/28/24 10:58 PM, olcott wrote:
>>>> 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?
>>>>>
>>>>
>>>> That is a reasonable point.
>>>> 01 void D(ptr x) // ptr is pointer to void function
>>>> 02 {
>>>> 03   H(x, x);
>>>> 04   return;
>>>> 05 }
>>>> 06
>>>> 07 void main()
>>>> 08 {
>>>> 09   H(D,D);
>>>> 10 }
>>>
>>> So, since this D will ALWAYS halt (if H gives an answer) why does H
>>> need to "abort" it? Can it not figure out that it will give an answer
>>> and that the input will halt?
>>>
>>
>> You are too much of a liar.
>> If you don't quit I am going to give up on you.
>>
>>
>
> But what is the LIE?
>
> Does not D halt when run if H gives an answer?
>
> Should not a correct simulator be able to simulate all of an input that
> halts?
>
> Your problem is you lie to yourself about the basic definitions,

On 3/29/2024 12:02 PM, Richard Damon wrote:
> On 3/29/24 11:51 AM, olcott wrote:
>> On 3/29/2024 8:13 AM, Richard Damon wrote:
>>> On 3/28/24 11:34 PM, olcott wrote:
>>>> On 3/28/2024 9:22 PM, Richard Damon wrote:
>>>>> On 3/28/24 10:01 PM, olcott wrote:
>>>>
>>>> <snip>
>>>>
>>>>>>> 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.
>>>>>
>>>>> Nope.
>>>>>
>>>>> The behavior of D CHANGES based on the H it attaches to.
>>>>>
>>>>
>>>> The behavior of D simulated by any H that can possibly exist
>>>> remains the same.
>>>
>>> Nope. Since you are using a "meaningless" term, it is just a
>>> non-truth bearer. Partial simulations do not reveal behavior, only
>>> complete simulations.
>>>
>>
>> Yes and your same reasoning says that mathematical induction can't
>> possibly work. No finite sequences of steps can every be extrapolated
>> to an in finite number of steps.
>>
>
> Why do you say that?
>
> I guess you don't think all the Natural Numbers exist.
>
> You are just showing that you are using incorrect logic;
>
>> Are you trying to get away with saying that you simply do not
>> "believe in" mathematical induction?
>
> You need to show that actual steps that PROVE your induction, which I
> don't think you actually know what they are.
>

You already know these steps as you have implicitly admitted when
you repeatedly said that when no H(D,D) aborts its simulation then
H(D,D) never halts.

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

On 3/29/24 1:09 PM, olcott wrote:
> On 3/29/2024 12:02 PM, Richard Damon wrote:
>> On 3/29/24 11:52 AM, olcott wrote:
>>> On 3/29/2024 8:13 AM, Richard Damon wrote:
>>>> On 3/28/24 10:58 PM, olcott wrote:
>>>>> 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?
>>>>>>
>>>>>
>>>>> That is a reasonable point.
>>>>> 01 void D(ptr x) // ptr is pointer to void function
>>>>> 02 {
>>>>> 03   H(x, x);
>>>>> 04   return;
>>>>> 05 }
>>>>> 06
>>>>> 07 void main()
>>>>> 08 {
>>>>> 09   H(D,D);
>>>>> 10 }
>>>>
>>>> So, since this D will ALWAYS halt (if H gives an answer) why does H
>>>> need to "abort" it? Can it not figure out that it will give an
>>>> answer and that the input will halt?
>>>>
>>>
>>> You are too much of a liar.
>>> If you don't quit I am going to give up on you.
>>>
>>>
>>
>> But what is the LIE?
>>
>> Does not D halt when run if H gives an answer?
>>
>> Should not a correct simulator be able to simulate all of an input
>> that halts?
>>
>> Your problem is you lie to yourself about the basic definitions,
>
> H(D,D) is correct to abort its input and you know this,
> that makes your statement to the contrary an INTENTIONAL
> falsehood and not any honest mistake.
>

On 3/29/24 1:12 PM, olcott wrote:
> On 3/29/2024 12:02 PM, Richard Damon wrote:
>> On 3/29/24 11:51 AM, olcott wrote:
>>> On 3/29/2024 8:13 AM, Richard Damon wrote:
>>>> On 3/28/24 11:34 PM, olcott wrote:
>>>>> On 3/28/2024 9:22 PM, Richard Damon wrote:
>>>>>> On 3/28/24 10:01 PM, olcott wrote:
>>>>>
>>>>> <snip>
>>>>>
>>>>>>>> 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.
>>>>>>
>>>>>> Nope.
>>>>>>
>>>>>> The behavior of D CHANGES based on the H it attaches to.
>>>>>>
>>>>>
>>>>> The behavior of D simulated by any H that can possibly exist
>>>>> remains the same.
>>>>
>>>> Nope. Since you are using a "meaningless" term, it is just a
>>>> non-truth bearer. Partial simulations do not reveal behavior, only
>>>> complete simulations.
>>>>
>>>
>>> Yes and your same reasoning says that mathematical induction can't
>>> possibly work. No finite sequences of steps can every be extrapolated
>>> to an in finite number of steps.
>>>
>>
>> Why do you say that?
>>
>> I guess you don't think all the Natural Numbers exist.
>>
>> You are just showing that you are using incorrect logic;
>>
>>> Are you trying to get away with saying that you simply do not
>>> "believe in" mathematical induction?
>>
>> You need to show that actual steps that PROVE your induction, which I
>> don't think you actually know what they are.
>>
>
> You already know these steps as you have implicitly admitted when
> you repeatedly said that when no H(D,D) aborts its simulation then
> H(D,D) never halts.
>
>

Nope, since D changes behavior with a change of the definition of H.

That statement is not applicable.

The behavior of D for ANY other H has no bearing on the behavior of D
with this H.

To claim otherwise is just a LIE.

On 3/29/2024 12:24 PM, Richard Damon wrote:
> On 3/29/24 1:12 PM, olcott wrote:
>> On 3/29/2024 12:02 PM, Richard Damon wrote:
>>> On 3/29/24 11:51 AM, olcott wrote:
>>>> On 3/29/2024 8:13 AM, Richard Damon wrote:
>>>>> On 3/28/24 11:34 PM, olcott wrote:
>>>>>> On 3/28/2024 9:22 PM, Richard Damon wrote:
>>>>>>> On 3/28/24 10:01 PM, olcott wrote:
>>>>>>
>>>>>> <snip>
>>>>>>
>>>>>>>>> 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.
>>>>>>>
>>>>>>> Nope.
>>>>>>>
>>>>>>> The behavior of D CHANGES based on the H it attaches to.
>>>>>>>
>>>>>>
>>>>>> The behavior of D simulated by any H that can possibly exist
>>>>>> remains the same.
>>>>>
>>>>> Nope. Since you are using a "meaningless" term, it is just a
>>>>> non-truth bearer. Partial simulations do not reveal behavior, only
>>>>> complete simulations.
>>>>>
>>>>
>>>> Yes and your same reasoning says that mathematical induction can't
>>>> possibly work. No finite sequences of steps can every be extrapolated
>>>> to an in finite number of steps.
>>>>
>>>
>>> Why do you say that?
>>>
>>> I guess you don't think all the Natural Numbers exist.
>>>
>>> You are just showing that you are using incorrect logic;
>>>
>>>> Are you trying to get away with saying that you simply do not
>>>> "believe in" mathematical induction?
>>>
>>> You need to show that actual steps that PROVE your induction, which I
>>> don't think you actually know what they are.
>>>
>>
>> You already know these steps as you have implicitly admitted when
>> you repeatedly said that when no H(D,D) aborts its simulation then
>> H(D,D) never halts.
>>
>>
>
> Nope, since D changes behavior with a change of the definition of H.
>

You know this is a lie yet say it anyway.
That would seem to fall under Revelations 21:8.
D has the exact same behavior when simulated by any H.

> That statement is not applicable.
>
> The behavior of D for ANY other H has no bearing on the behavior of D
> with this H.
>
> To claim otherwise is just a LIE.

I am not and never have been intentionally saying anything
that is false.

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

On 3/29/24 1:28 PM, olcott wrote:
> On 3/29/2024 12:24 PM, Richard Damon wrote:
>> On 3/29/24 1:12 PM, olcott wrote:
>>> On 3/29/2024 12:02 PM, Richard Damon wrote:
>>>> On 3/29/24 11:51 AM, olcott wrote:
>>>>> On 3/29/2024 8:13 AM, Richard Damon wrote:
>>>>>> On 3/28/24 11:34 PM, olcott wrote:
>>>>>>> On 3/28/2024 9:22 PM, Richard Damon wrote:
>>>>>>>> On 3/28/24 10:01 PM, olcott wrote:
>>>>>>>
>>>>>>> <snip>
>>>>>>>
>>>>>>>>>> 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.
>>>>>>>>
>>>>>>>> Nope.
>>>>>>>>
>>>>>>>> The behavior of D CHANGES based on the H it attaches to.
>>>>>>>>
>>>>>>>
>>>>>>> The behavior of D simulated by any H that can possibly exist
>>>>>>> remains the same.
>>>>>>
>>>>>> Nope. Since you are using a "meaningless" term, it is just a
>>>>>> non-truth bearer. Partial simulations do not reveal behavior, only
>>>>>> complete simulations.
>>>>>>
>>>>>
>>>>> Yes and your same reasoning says that mathematical induction can't
>>>>> possibly work. No finite sequences of steps can every be extrapolated
>>>>> to an in finite number of steps.
>>>>>
>>>>
>>>> Why do you say that?
>>>>
>>>> I guess you don't think all the Natural Numbers exist.
>>>>
>>>> You are just showing that you are using incorrect logic;
>>>>
>>>>> Are you trying to get away with saying that you simply do not
>>>>> "believe in" mathematical induction?
>>>>
>>>> You need to show that actual steps that PROVE your induction, which
>>>> I don't think you actually know what they are.
>>>>
>>>
>>> You already know these steps as you have implicitly admitted when
>>> you repeatedly said that when no H(D,D) aborts its simulation then
>>> H(D,D) never halts.
>>>
>>>
>>
>> Nope, since D changes behavior with a change of the definition of H.
>>
>
> You know this is a lie yet say it anyway.

So, you think that a D that calls an H that loops forever has the same
behavior as a D that calls an H that returns 0?

THAT is the LIE, that gets you to Revelations 21:8

> That would seem to fall under Revelations 21:8.
> D has the exact same behavior when simulated by any H.

Nope.

Just shows that any H that aborts is simulation doesn't do a "Correct
Simulaiton" that shows behavior.

THAT is another of your great lies.

>
>> That statement is not applicable.
>>
>> The behavior of D for ANY other H has no bearing on the behavior of D
>> with this H.
>>
>> To claim otherwise is just a LIE.
>
> I am not and never have been intentionally saying anything
> that is false.
>

If that it true, then you are mentally a MORON.

How is not making a copy of H to put into H_Hat following the
instructions of Linz exactly?

Or, it is just you don't know the meaning of "Truth"?

Is that how you got of the child porn charges? You were mentally
incompetent?

On 3/29/24 11:51 AM, olcott wrote:
> On 3/29/2024 8:13 AM, Richard Damon wrote:
>> On 3/28/24 11:34 PM, olcott wrote:
>>> On 3/28/2024 9:22 PM, Richard Damon wrote:
>>>> On 3/28/24 10:01 PM, olcott wrote:
>>>
>>> <snip>
>>>
>>>>>> 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.
>>>>
>>>> Nope.
>>>>
>>>> The behavior of D CHANGES based on the H it attaches to.
>>>>
>>>
>>> The behavior of D simulated by any H that can possibly exist
>>> remains the same.
>>
>> Nope. Since you are using a "meaningless" term, it is just a non-truth
>> bearer. Partial simulations do not reveal behavior, only complete
>> simulations.
>>
>
> Yes and your same reasoning says that mathematical induction can't
> possibly work. No finite sequences of steps can every be extrapolated
> to an in finite number of steps.

Why do you say that?
What correct reasoning am I saying doesn't work?

You are NOT using "Mathematical Induction".

If you think you are, state your proof of the base case, and the proof
yof your induction step.

If you don't know what those mean, you don't know what induction is.
>
> Are you trying to get away with saying that you simply do not
> "believe in" mathematical induction?

Of course not. Just that you don't seem to know what it is, but use it
as a "magical buzz word".

>
>> This means that the only Hs that meet your "definition" of H are those
>> that act like UTMs, and thus NO H that meets your specification are
>> deciders.
>>
>
> You are too much of a liar. If you don't quit
> I am going to give up on you.
>

You have never show a statement of mine to actually be a LIE. Only that
I disagree with your lies when I point out the truth.

On 3/29/2024 12:28 PM, olcott wrote:
> On 3/29/2024 12:24 PM, Richard Damon wrote:
>> On 3/29/24 1:12 PM, olcott wrote:
>>> On 3/29/2024 12:02 PM, Richard Damon wrote:
>>>> On 3/29/24 11:51 AM, olcott wrote:
>>>>> On 3/29/2024 8:13 AM, Richard Damon wrote:
>>>>>> On 3/28/24 11:34 PM, olcott wrote:
>>>>>>> On 3/28/2024 9:22 PM, Richard Damon wrote:
>>>>>>>> On 3/28/24 10:01 PM, olcott wrote:
>>>>>>>
>>>>>>> <snip>
>>>>>>>
>>>>>>>>>> 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.
>>>>>>>>
>>>>>>>> Nope.
>>>>>>>>
>>>>>>>> The behavior of D CHANGES based on the H it attaches to.
>>>>>>>>
>>>>>>>
>>>>>>> The behavior of D simulated by any H that can possibly exist
>>>>>>> remains the same.
>>>>>>
>>>>>> Nope. Since you are using a "meaningless" term, it is just a
>>>>>> non-truth bearer. Partial simulations do not reveal behavior, only
>>>>>> complete simulations.
>>>>>>
>>>>>
>>>>> Yes and your same reasoning says that mathematical induction can't
>>>>> possibly work. No finite sequences of steps can every be extrapolated
>>>>> to an in finite number of steps.
>>>>>
>>>>
>>>> Why do you say that?
>>>>
>>>> I guess you don't think all the Natural Numbers exist.
>>>>
>>>> You are just showing that you are using incorrect logic;
>>>>
>>>>> Are you trying to get away with saying that you simply do not
>>>>> "believe in" mathematical induction?
>>>>
>>>> You need to show that actual steps that PROVE your induction, which
>>>> I don't think you actually know what they are.
>>>>
>>>
>>> You already know these steps as you have implicitly admitted when
>>> you repeatedly said that when no H(D,D) aborts its simulation then
>>> H(D,D) never halts.
>>>
>>>
>>
>> Nope, since D changes behavior with a change of the definition of H.
>>
>
> You know this is a lie yet say it anyway.
> That would seem to fall under Revelations 21:8.
> D has the exact same behavior when simulated by any H.
>
>> That statement is not applicable.
>>
>> The behavior of D for ANY other H has no bearing on the behavior of D
>> with this H.
>>
>> To claim otherwise is just a LIE.
>
> I am not and never have been intentionally saying anything
> that is false.
>

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

On 3/29/24 10:24 PM, olcott wrote:

> test

You do know there are groups designed to do that?