On 11/12/2021 10:48 PM, Richard Damon wrote:
> On 11/12/21 11:07 PM, olcott wrote:
>> On 11/12/2021 9:41 PM, Richard Damon wrote:
>>> On 11/12/21 10:25 PM, olcott wrote:
>>>> On 11/12/2021 8:19 PM, Richard Damon wrote:
>>>>> On 11/12/21 8:59 PM, olcott wrote:
>>>>>> On 11/12/2021 7:47 PM, André G. Isaak wrote:
>>>>>>> On 2021-11-12 15:53, olcott wrote:
>>>>>>>
>>>>>>>> The ultimate measure of the halt status of an input is its
>>>>>>>> behavior when directly executed.
>>>>>>>
>>>>>>> The input itself doesn't have a halt status.
>>>>>>
>>>>>> In this case it does. Ben simplified my syntax.
>>>>>
>>>>> Nope.
>>>>>
>>>>> This just shows that you don't have a valid Turing Model in place.
>>>>>
>>>>> A sting of bytes does not in of itself have a Halting Status.
>>>>>
>>>>> Interpreting that string as a set of instructions by executing it,
>>>>> makes it have one.
>>>>>
>>>>> Basically, your x(y) to be implemented in a Turing Machine would
>>>>> likely be putting in the code for a UTM there, and the tape would
>>>>> need to be loaded with a representation of the function P and all
>>>>> the code of H that it calls, including that UTM.
>>>>>
>>>>> That input tape, still, doesn't have behavior on its own. but ONLY
>>>>> as viewed as either the representation of an actual Turing Machine,
>>>>> or as the input to a UTM (which is what you do here).
>>>>>
>>>>> FAIL.
>>>>>
>>>>
>>>>
>>>> computation that halts
>>>> a computation is said to halt whenever it enters a final state.
>>>> (Linz:1990:234)
>>>>
>>>
>>> Right, THE COMPUTATION, not a partial simulation of one.
>>> Note Non-Halting is defined as NEVER halting after unlimited number
>>> of steps.
>>>
>>> Not failing to reach the halt state after executing only a limited
>>> fixed number of steps.
>>>
>>> FAIL
>>>
>>>
>>>> computer science decider
>>>> a decider is a machine that accepts or rejects inputs.
>>>> https://cs.stackexchange.com/questions/84433/what-is-decider
>>>>
>>>> halt decider
>>>> A halt decider accept or rejects an input on the basis of whether or
>>>> not the direct execution or pure simulation of this input would ever
>>>> reach a final state of this input.
>>>>
>>>
>>> RIGHT, only FULL DIRECT EXECTUTION or PURE SIMULATION.
>>>
>>>
>>>
>>>
>>>> _P()
>>>> [00001a5e](01)  55              push ebp
>>>> [00001a5f](02)  8bec            mov ebp,esp
>>>> [00001a61](03)  8b4508          mov eax,[ebp+08]
>>>> [00001a64](01)  50              push eax        // push P
>>>> [00001a65](03)  8b4d08          mov ecx,[ebp+08]
>>>> [00001a68](01)  51              push ecx        // push P
>>>> [00001a69](05)  e810000000      call 00001a7e   // call H
>>>> [00001a6e](03)  83c408          add esp,+08
>>>> [00001a71](01)  5d              pop ebp
>>>> [00001a72](01)  c3              ret
>>>> Size in bytes:(0021) [00001a72]
>>>>
>>>>
>>>> H(P,P)==0 is correct for every H at machine address 00001a7e with
>>>> the above string of machine language bytes as its input.
>>>>
>>>
>>> Nope.
>>>
>>> If H is defined in a way that aborts its simulation and returns a
>>> value in finite time then the DIRECT EXECTUTION of P will reach that
>>> terminal state.
>> No this is not true. For the precisely defined computation of H(P,P)
>> the input P never gets past 00001a69.
>>
>
> NOPE. You can not provide an H that has H(P,P) returning 0 and also the
> direct execution of P(P) doesn't halt.
>
> Yes, there are H's that never abort their operation and results in a
> P(P) that is non-halting, but those H's never return the value 0 for
> H(P,P).
>
> If you are making the assertion that such an H exists, the challenge is
> to provide it.
>
> Failure means you admit to lying.

All rebuttals must take this form:
Find an invocation of H(P,P) at machine address 00001a7e such that the
simulation or execution of (the exact byte sequence of) P reaches its
final address of 00001a72.

--
Copyright 2021 Pete Olcott

"Great spirits have always encountered violent opposition from mediocre
minds." Einstein

On 11/13/21 12:46 AM, olcott wrote:
> On 11/12/2021 10:48 PM, Richard Damon wrote:
>> On 11/12/21 11:07 PM, olcott wrote:
>>> On 11/12/2021 9:41 PM, Richard Damon wrote:
>>>> On 11/12/21 10:25 PM, olcott wrote:
>>>>> On 11/12/2021 8:19 PM, Richard Damon wrote:
>>>>>> On 11/12/21 8:59 PM, olcott wrote:
>>>>>>> On 11/12/2021 7:47 PM, André G. Isaak wrote:
>>>>>>>> On 2021-11-12 15:53, olcott wrote:
>>>>>>>>
>>>>>>>>> The ultimate measure of the halt status of an input is its
>>>>>>>>> behavior when directly executed.
>>>>>>>>
>>>>>>>> The input itself doesn't have a halt status.
>>>>>>>
>>>>>>> In this case it does. Ben simplified my syntax.
>>>>>>
>>>>>> Nope.
>>>>>>
>>>>>> This just shows that you don't have a valid Turing Model in place.
>>>>>>
>>>>>> A sting of bytes does not in of itself have a Halting Status.
>>>>>>
>>>>>> Interpreting that string as a set of instructions by executing it,
>>>>>> makes it have one.
>>>>>>
>>>>>> Basically, your x(y) to be implemented in a Turing Machine would
>>>>>> likely be putting in the code for a UTM there, and the tape would
>>>>>> need to be loaded with a representation of the function P and all
>>>>>> the code of H that it calls, including that UTM.
>>>>>>
>>>>>> That input tape, still, doesn't have behavior on its own. but ONLY
>>>>>> as viewed as either the representation of an actual Turing
>>>>>> Machine, or as the input to a UTM (which is what you do here).
>>>>>>
>>>>>> FAIL.
>>>>>>
>>>>>
>>>>>
>>>>> computation that halts
>>>>> a computation is said to halt whenever it enters a final state.
>>>>> (Linz:1990:234)
>>>>>
>>>>
>>>> Right, THE COMPUTATION, not a partial simulation of one.
>>>> Note Non-Halting is defined as NEVER halting after unlimited number
>>>> of steps.
>>>>
>>>> Not failing to reach the halt state after executing only a limited
>>>> fixed number of steps.
>>>>
>>>> FAIL
>>>>
>>>>
>>>>> computer science decider
>>>>> a decider is a machine that accepts or rejects inputs.
>>>>> https://cs.stackexchange.com/questions/84433/what-is-decider
>>>>>
>>>>> halt decider
>>>>> A halt decider accept or rejects an input on the basis of whether
>>>>> or not the direct execution or pure simulation of this input would
>>>>> ever reach a final state of this input.
>>>>>
>>>>
>>>> RIGHT, only FULL DIRECT EXECTUTION or PURE SIMULATION.
>>>>
>>>>
>>>>
>>>>
>>>>> _P()
>>>>> [00001a5e](01)  55              push ebp
>>>>> [00001a5f](02)  8bec            mov ebp,esp
>>>>> [00001a61](03)  8b4508          mov eax,[ebp+08]
>>>>> [00001a64](01)  50              push eax        // push P
>>>>> [00001a65](03)  8b4d08          mov ecx,[ebp+08]
>>>>> [00001a68](01)  51              push ecx        // push P
>>>>> [00001a69](05)  e810000000      call 00001a7e   // call H
>>>>> [00001a6e](03)  83c408          add esp,+08
>>>>> [00001a71](01)  5d              pop ebp
>>>>> [00001a72](01)  c3              ret
>>>>> Size in bytes:(0021) [00001a72]
>>>>>
>>>>>
>>>>> H(P,P)==0 is correct for every H at machine address 00001a7e with
>>>>> the above string of machine language bytes as its input.
>>>>>
>>>>
>>>> Nope.
>>>>
>>>> If H is defined in a way that aborts its simulation and returns a
>>>> value in finite time then the DIRECT EXECTUTION of P will reach that
>>>> terminal state.
>>> No this is not true. For the precisely defined computation of H(P,P)
>>> the input P never gets past 00001a69.
>>>
>>
>> NOPE. You can not provide an H that has H(P,P) returning 0 and also
>> the direct execution of P(P) doesn't halt.
>>
>> Yes, there are H's that never abort their operation and results in a
>> P(P) that is non-halting, but those H's never return the value 0 for
>> H(P,P).
>>
>> If you are making the assertion that such an H exists, the challenge
>> is to provide it.
>>
>> Failure means you admit to lying.
>
>
> All rebuttals must take this form:
> Find an invocation of H(P,P) at machine address 00001a7e such that the
> simulation or execution of (the exact byte sequence of) P reaches its
> final address of 00001a72.
>
>

No, they don't. You LIE when you make that claim.

The criteria you are asking for has NOTHING to do with the REQUIRED
DEFINITION OF HALTING, which is based on the behavior of the program
when DIRECTLY RUN.

ANY H(P,P) which returns 0 to the call of H(P,P) will get to 1A72 when
that P is run directly.

This has been proven, and you even agreed to it.

I, and the world, will take this as your admission of being a LIAR.

That is going to be your eternal legacy, branded as a LIAR, not willing
to admit that you don't understand what you talk about.

On 11/13/2021 7:17 AM, Richard Damon wrote:
> On 11/13/21 12:46 AM, olcott wrote:
>> On 11/12/2021 10:48 PM, Richard Damon wrote:
>>> On 11/12/21 11:07 PM, olcott wrote:
>>>> On 11/12/2021 9:41 PM, Richard Damon wrote:
>>>>> On 11/12/21 10:25 PM, olcott wrote:
>>>>>> On 11/12/2021 8:19 PM, Richard Damon wrote:
>>>>>>> On 11/12/21 8:59 PM, olcott wrote:
>>>>>>>> On 11/12/2021 7:47 PM, André G. Isaak wrote:
>>>>>>>>> On 2021-11-12 15:53, olcott wrote:
>>>>>>>>>
>>>>>>>>>> The ultimate measure of the halt status of an input is its
>>>>>>>>>> behavior when directly executed.
>>>>>>>>>
>>>>>>>>> The input itself doesn't have a halt status.
>>>>>>>>
>>>>>>>> In this case it does. Ben simplified my syntax.
>>>>>>>
>>>>>>> Nope.
>>>>>>>
>>>>>>> This just shows that you don't have a valid Turing Model in place.
>>>>>>>
>>>>>>> A sting of bytes does not in of itself have a Halting Status.
>>>>>>>
>>>>>>> Interpreting that string as a set of instructions by executing
>>>>>>> it, makes it have one.
>>>>>>>
>>>>>>> Basically, your x(y) to be implemented in a Turing Machine would
>>>>>>> likely be putting in the code for a UTM there, and the tape would
>>>>>>> need to be loaded with a representation of the function P and all
>>>>>>> the code of H that it calls, including that UTM.
>>>>>>>
>>>>>>> That input tape, still, doesn't have behavior on its own. but
>>>>>>> ONLY as viewed as either the representation of an actual Turing
>>>>>>> Machine, or as the input to a UTM (which is what you do here).
>>>>>>>
>>>>>>> FAIL.
>>>>>>>
>>>>>>
>>>>>>
>>>>>> computation that halts
>>>>>> a computation is said to halt whenever it enters a final state.
>>>>>> (Linz:1990:234)
>>>>>>
>>>>>
>>>>> Right, THE COMPUTATION, not a partial simulation of one.
>>>>> Note Non-Halting is defined as NEVER halting after unlimited number
>>>>> of steps.
>>>>>
>>>>> Not failing to reach the halt state after executing only a limited
>>>>> fixed number of steps.
>>>>>
>>>>> FAIL
>>>>>
>>>>>
>>>>>> computer science decider
>>>>>> a decider is a machine that accepts or rejects inputs.
>>>>>> https://cs.stackexchange.com/questions/84433/what-is-decider
>>>>>>
>>>>>> halt decider
>>>>>> A halt decider accept or rejects an input on the basis of whether
>>>>>> or not the direct execution or pure simulation of this input would
>>>>>> ever reach a final state of this input.
>>>>>>
>>>>>
>>>>> RIGHT, only FULL DIRECT EXECTUTION or PURE SIMULATION.
>>>>>
>>>>>
>>>>>
>>>>>
>>>>>> _P()
>>>>>> [00001a5e](01)  55              push ebp
>>>>>> [00001a5f](02)  8bec            mov ebp,esp
>>>>>> [00001a61](03)  8b4508          mov eax,[ebp+08]
>>>>>> [00001a64](01)  50              push eax        // push P
>>>>>> [00001a65](03)  8b4d08          mov ecx,[ebp+08]
>>>>>> [00001a68](01)  51              push ecx        // push P
>>>>>> [00001a69](05)  e810000000      call 00001a7e   // call H
>>>>>> [00001a6e](03)  83c408          add esp,+08
>>>>>> [00001a71](01)  5d              pop ebp
>>>>>> [00001a72](01)  c3              ret
>>>>>> Size in bytes:(0021) [00001a72]
>>>>>>
>>>>>>
>>>>>> H(P,P)==0 is correct for every H at machine address 00001a7e with
>>>>>> the above string of machine language bytes as its input.
>>>>>>
>>>>>
>>>>> Nope.
>>>>>
>>>>> If H is defined in a way that aborts its simulation and returns a
>>>>> value in finite time then the DIRECT EXECTUTION of P will reach
>>>>> that terminal state.
>>>> No this is not true. For the precisely defined computation of H(P,P)
>>>> the input P never gets past 00001a69.
>>>>
>>>
>>> NOPE. You can not provide an H that has H(P,P) returning 0 and also
>>> the direct execution of P(P) doesn't halt.
>>>
>>> Yes, there are H's that never abort their operation and results in a
>>> P(P) that is non-halting, but those H's never return the value 0 for
>>> H(P,P).
>>>
>>> If you are making the assertion that such an H exists, the challenge
>>> is to provide it.
>>>
>>> Failure means you admit to lying.
>>
>>
>> All rebuttals must take this form:
>> Find an invocation of H(P,P) at machine address 00001a7e such that the
>> simulation or execution of (the exact byte sequence of) P reaches its
>> final address of 00001a72.
>>
>>
>
>
> No, they don't. You LIE when you make that claim.
>
> The criteria you are asking for has NOTHING to do with the REQUIRED
> DEFINITION OF HALTING, which is based on the behavior of the program
> when DIRECTLY RUN.
>

halt decider (Olcott 2021)
A halt decider accepts or rejects an input on the basis of whether or
not the direct execution or (possibly partial) pure simulation of this
input would ever reach a final state of this input.

I claim that the halt status for a specific H(P,P) is never halting
therefore every correct rebuttal must show that one of these instances
halts.

> ANY H(P,P) which returns 0 to the call of H(P,P) will get to 1A72 when
> that P is run directly.
>
> This has been proven, and you even agreed to it.
>
> I, and the world, will take this as your admission of being a LIAR.
>
> That is going to be your eternal legacy, branded as a LIAR, not willing
> to admit that you don't understand what you talk about.
>
>

--
Copyright 2021 Pete Olcott

Talent hits a target no one else can hit;
Genius hits a target no one else can see.
Arthur Schopenhauer

On 11/13/21 8:57 AM, olcott wrote:
> On 11/13/2021 7:17 AM, Richard Damon wrote:
>> On 11/13/21 12:46 AM, olcott wrote:
>>> On 11/12/2021 10:48 PM, Richard Damon wrote:
>>>> On 11/12/21 11:07 PM, olcott wrote:
>>>>> On 11/12/2021 9:41 PM, Richard Damon wrote:
>>>>>> On 11/12/21 10:25 PM, olcott wrote:
>>>>>>> On 11/12/2021 8:19 PM, Richard Damon wrote:
>>>>>>>> On 11/12/21 8:59 PM, olcott wrote:
>>>>>>>>> On 11/12/2021 7:47 PM, André G. Isaak wrote:
>>>>>>>>>> On 2021-11-12 15:53, olcott wrote:
>>>>>>>>>>
>>>>>>>>>>> The ultimate measure of the halt status of an input is its
>>>>>>>>>>> behavior when directly executed.
>>>>>>>>>>
>>>>>>>>>> The input itself doesn't have a halt status.
>>>>>>>>>
>>>>>>>>> In this case it does. Ben simplified my syntax.
>>>>>>>>
>>>>>>>> Nope.
>>>>>>>>
>>>>>>>> This just shows that you don't have a valid Turing Model in place.
>>>>>>>>
>>>>>>>> A sting of bytes does not in of itself have a Halting Status.
>>>>>>>>
>>>>>>>> Interpreting that string as a set of instructions by executing
>>>>>>>> it, makes it have one.
>>>>>>>>
>>>>>>>> Basically, your x(y) to be implemented in a Turing Machine would
>>>>>>>> likely be putting in the code for a UTM there, and the tape
>>>>>>>> would need to be loaded with a representation of the function P
>>>>>>>> and all the code of H that it calls, including that UTM.
>>>>>>>>
>>>>>>>> That input tape, still, doesn't have behavior on its own. but
>>>>>>>> ONLY as viewed as either the representation of an actual Turing
>>>>>>>> Machine, or as the input to a UTM (which is what you do here).
>>>>>>>>
>>>>>>>> FAIL.
>>>>>>>>
>>>>>>>
>>>>>>>
>>>>>>> computation that halts
>>>>>>> a computation is said to halt whenever it enters a final state.
>>>>>>> (Linz:1990:234)
>>>>>>>
>>>>>>
>>>>>> Right, THE COMPUTATION, not a partial simulation of one.
>>>>>> Note Non-Halting is defined as NEVER halting after unlimited
>>>>>> number of steps.
>>>>>>
>>>>>> Not failing to reach the halt state after executing only a limited
>>>>>> fixed number of steps.
>>>>>>
>>>>>> FAIL
>>>>>>
>>>>>>
>>>>>>> computer science decider
>>>>>>> a decider is a machine that accepts or rejects inputs.
>>>>>>> https://cs.stackexchange.com/questions/84433/what-is-decider
>>>>>>>
>>>>>>> halt decider
>>>>>>> A halt decider accept or rejects an input on the basis of whether
>>>>>>> or not the direct execution or pure simulation of this input
>>>>>>> would ever reach a final state of this input.
>>>>>>>
>>>>>>
>>>>>> RIGHT, only FULL DIRECT EXECTUTION or PURE SIMULATION.
>>>>>>
>>>>>>
>>>>>>
>>>>>>
>>>>>>> _P()
>>>>>>> [00001a5e](01)  55              push ebp
>>>>>>> [00001a5f](02)  8bec            mov ebp,esp
>>>>>>> [00001a61](03)  8b4508          mov eax,[ebp+08]
>>>>>>> [00001a64](01)  50              push eax        // push P
>>>>>>> [00001a65](03)  8b4d08          mov ecx,[ebp+08]
>>>>>>> [00001a68](01)  51              push ecx        // push P
>>>>>>> [00001a69](05)  e810000000      call 00001a7e   // call H
>>>>>>> [00001a6e](03)  83c408          add esp,+08
>>>>>>> [00001a71](01)  5d              pop ebp
>>>>>>> [00001a72](01)  c3              ret
>>>>>>> Size in bytes:(0021) [00001a72]
>>>>>>>
>>>>>>>
>>>>>>> H(P,P)==0 is correct for every H at machine address 00001a7e with
>>>>>>> the above string of machine language bytes as its input.
>>>>>>>
>>>>>>
>>>>>> Nope.
>>>>>>
>>>>>> If H is defined in a way that aborts its simulation and returns a
>>>>>> value in finite time then the DIRECT EXECTUTION of P will reach
>>>>>> that terminal state.
>>>>> No this is not true. For the precisely defined computation of
>>>>> H(P,P) the input P never gets past 00001a69.
>>>>>
>>>>
>>>> NOPE. You can not provide an H that has H(P,P) returning 0 and also
>>>> the direct execution of P(P) doesn't halt.
>>>>
>>>> Yes, there are H's that never abort their operation and results in a
>>>> P(P) that is non-halting, but those H's never return the value 0 for
>>>> H(P,P).
>>>>
>>>> If you are making the assertion that such an H exists, the challenge
>>>> is to provide it.
>>>>
>>>> Failure means you admit to lying.
>>>
>>>
>>> All rebuttals must take this form:
>>> Find an invocation of H(P,P) at machine address 00001a7e such that
>>> the simulation or execution of (the exact byte sequence of) P reaches
>>> its final address of 00001a72.
>>>
>>>
>>
>>
>> No, they don't. You LIE when you make that claim.
>>
>> The criteria you are asking for has NOTHING to do with the REQUIRED
>> DEFINITION OF HALTING, which is based on the behavior of the program
>> when DIRECTLY RUN.
>>
>
> halt decider (Olcott 2021)
> A halt decider accepts or rejects an input on the basis of whether or
> not the direct execution or (possibly partial) pure simulation of this
> input would ever reach a final state of this input.
>
> I claim that the halt status for a specific H(P,P) is never halting
> therefore every correct rebuttal must show that one of these instances
> halts.
>

So, given that H(P,P) rejects P, which MEANS that it returns the value
of 0 from a 'call' to H(P,P) in some finite time.

Therefore a simple trace of the function P being directly executed is:

[00001a5e](01) 55 push ebp
[00001a5f](02) 8bec mov ebp,esp
[00001a61](03) 8b4508 mov eax,[ebp+08]
[00001a64](01) 50 push eax // push P
[00001a65](03) 8b4d08 mov ecx,[ebp+08]
[00001a68](01) 51 push ecx // push P
[00001a69](05) e810000000 call 00001a7e // call H

// Trace inside H not provided as you refuse to provide the code for H.
// BUT we know from the stipulation that H will reject P(P) in finite
// time, that in finite time it WILL return the value 0

[00001a6e](03) 83c408 add esp,+08
[00001a71](01) 5d pop ebp
[00001a72](01) c3 ret

THERE.

SHow what is wrong with this DIRECT execution of P(P).

Remember, the 'halt status' that H needs to decide on is the halt status
of the machine that the input represents, that is in this case the
computation P(P).

You are stuck with the fact that since H is defined to be a Turing
Machine, all copies of H will behave the same, so if the deciding copy
of H returns 0 for the call H(P,P) so will the copy in P.

If you want to claim otherwise, H no longer meets the requirements to BE
a decider.

FAIL.

>> ANY H(P,P) which returns 0 to the call of H(P,P) will get to 1A72 when
>> that P is run directly.
>>
>> This has been proven, and you even agreed to it.
>>
>> I, and the world, will take this as your admission of being a LIAR.
>>
>> That is going to be your eternal legacy, branded as a LIAR, not
>> willing to admit that you don't understand what you talk about.
>>
>>
>
>

On 11/13/2021 8:42 AM, Richard Damon wrote:
> On 11/13/21 8:57 AM, olcott wrote:
>> On 11/13/2021 7:17 AM, Richard Damon wrote:
>>> On 11/13/21 12:46 AM, olcott wrote:
>>>> On 11/12/2021 10:48 PM, Richard Damon wrote:
>>>>> On 11/12/21 11:07 PM, olcott wrote:
>>>>>> On 11/12/2021 9:41 PM, Richard Damon wrote:
>>>>>>> On 11/12/21 10:25 PM, olcott wrote:
>>>>>>>> On 11/12/2021 8:19 PM, Richard Damon wrote:
>>>>>>>>> On 11/12/21 8:59 PM, olcott wrote:
>>>>>>>>>> On 11/12/2021 7:47 PM, André G. Isaak wrote:
>>>>>>>>>>> On 2021-11-12 15:53, olcott wrote:
>>>>>>>>>>>
>>>>>>>>>>>> The ultimate measure of the halt status of an input is its
>>>>>>>>>>>> behavior when directly executed.
>>>>>>>>>>>
>>>>>>>>>>> The input itself doesn't have a halt status.
>>>>>>>>>>
>>>>>>>>>> In this case it does. Ben simplified my syntax.
>>>>>>>>>
>>>>>>>>> Nope.
>>>>>>>>>
>>>>>>>>> This just shows that you don't have a valid Turing Model in place.
>>>>>>>>>
>>>>>>>>> A sting of bytes does not in of itself have a Halting Status.
>>>>>>>>>
>>>>>>>>> Interpreting that string as a set of instructions by executing
>>>>>>>>> it, makes it have one.
>>>>>>>>>
>>>>>>>>> Basically, your x(y) to be implemented in a Turing Machine
>>>>>>>>> would likely be putting in the code for a UTM there, and the
>>>>>>>>> tape would need to be loaded with a representation of the
>>>>>>>>> function P and all the code of H that it calls, including that
>>>>>>>>> UTM.
>>>>>>>>>
>>>>>>>>> That input tape, still, doesn't have behavior on its own. but
>>>>>>>>> ONLY as viewed as either the representation of an actual Turing
>>>>>>>>> Machine, or as the input to a UTM (which is what you do here).
>>>>>>>>>
>>>>>>>>> FAIL.
>>>>>>>>>
>>>>>>>>
>>>>>>>>
>>>>>>>> computation that halts
>>>>>>>> a computation is said to halt whenever it enters a final state.
>>>>>>>> (Linz:1990:234)
>>>>>>>>
>>>>>>>
>>>>>>> Right, THE COMPUTATION, not a partial simulation of one.
>>>>>>> Note Non-Halting is defined as NEVER halting after unlimited
>>>>>>> number of steps.
>>>>>>>
>>>>>>> Not failing to reach the halt state after executing only a
>>>>>>> limited fixed number of steps.
>>>>>>>
>>>>>>> FAIL
>>>>>>>
>>>>>>>
>>>>>>>> computer science decider
>>>>>>>> a decider is a machine that accepts or rejects inputs.
>>>>>>>> https://cs.stackexchange.com/questions/84433/what-is-decider
>>>>>>>>
>>>>>>>> halt decider
>>>>>>>> A halt decider accept or rejects an input on the basis of
>>>>>>>> whether or not the direct execution or pure simulation of this
>>>>>>>> input would ever reach a final state of this input.
>>>>>>>>
>>>>>>>
>>>>>>> RIGHT, only FULL DIRECT EXECTUTION or PURE SIMULATION.
>>>>>>>
>>>>>>>
>>>>>>>
>>>>>>>
>>>>>>>> _P()
>>>>>>>> [00001a5e](01)  55              push ebp
>>>>>>>> [00001a5f](02)  8bec            mov ebp,esp
>>>>>>>> [00001a61](03)  8b4508          mov eax,[ebp+08]
>>>>>>>> [00001a64](01)  50              push eax        // push P
>>>>>>>> [00001a65](03)  8b4d08          mov ecx,[ebp+08]
>>>>>>>> [00001a68](01)  51              push ecx        // push P
>>>>>>>> [00001a69](05)  e810000000      call 00001a7e   // call H
>>>>>>>> [00001a6e](03)  83c408          add esp,+08
>>>>>>>> [00001a71](01)  5d              pop ebp
>>>>>>>> [00001a72](01)  c3              ret
>>>>>>>> Size in bytes:(0021) [00001a72]
>>>>>>>>
>>>>>>>>
>>>>>>>> H(P,P)==0 is correct for every H at machine address 00001a7e
>>>>>>>> with the above string of machine language bytes as its input.
>>>>>>>>
>>>>>>>
>>>>>>> Nope.
>>>>>>>
>>>>>>> If H is defined in a way that aborts its simulation and returns a
>>>>>>> value in finite time then the DIRECT EXECTUTION of P will reach
>>>>>>> that terminal state.
>>>>>> No this is not true. For the precisely defined computation of
>>>>>> H(P,P) the input P never gets past 00001a69.
>>>>>>
>>>>>
>>>>> NOPE. You can not provide an H that has H(P,P) returning 0 and also
>>>>> the direct execution of P(P) doesn't halt.
>>>>>
>>>>> Yes, there are H's that never abort their operation and results in
>>>>> a P(P) that is non-halting, but those H's never return the value 0
>>>>> for H(P,P).
>>>>>
>>>>> If you are making the assertion that such an H exists, the
>>>>> challenge is to provide it.
>>>>>
>>>>> Failure means you admit to lying.
>>>>
>>>>
>>>> All rebuttals must take this form:
>>>> Find an invocation of H(P,P) at machine address 00001a7e such that
>>>> the simulation or execution of (the exact byte sequence of) P
>>>> reaches its final address of 00001a72.
>>>>
>>>>
>>>
>>>
>>> No, they don't. You LIE when you make that claim.
>>>
>>> The criteria you are asking for has NOTHING to do with the REQUIRED
>>> DEFINITION OF HALTING, which is based on the behavior of the program
>>> when DIRECTLY RUN.
>>>
>>
>> halt decider (Olcott 2021)
>> A halt decider accepts or rejects an input on the basis of whether or
>> not the direct execution or (possibly partial) pure simulation of this
>> input would ever reach a final state of this input.
>>
>> I claim that the halt status for a specific H(P,P) is never halting
>> therefore every correct rebuttal must show that one of these instances
>> halts.
>>
>
> So, given that H(P,P) rejects P, which MEANS that it returns the value
> of 0 from a 'call' to H(P,P) in some finite time.
>
> Therefore a simple trace of the function P being directly executed is:
>
> [00001a5e](01)  55              push ebp
> [00001a5f](02)  8bec            mov ebp,esp
> [00001a61](03)  8b4508          mov eax,[ebp+08]
> [00001a64](01)  50              push eax        // push P
> [00001a65](03)  8b4d08          mov ecx,[ebp+08]
> [00001a68](01)  51              push ecx        // push P
> [00001a69](05)  e810000000      call 00001a7e   // call H
>
> // Trace inside H not provided as you refuse to provide the code for H.
> // BUT we know from the stipulation that H will reject P(P) in finite
> // time, that in finite time it WILL return the value 0
>
> [00001a6e](03)  83c408          add esp,+08
> [00001a71](01)  5d              pop ebp
> [00001a72](01)  c3              ret
>
>
> THERE.
>
> SHow what is wrong with this DIRECT execution of P(P).
>
>
> Remember, the 'halt status' that H needs to decide on is the halt status
> of the machine that the input represents, that is in this case the
> computation P(P).
>
> You are stuck with the fact that since H is defined to be a Turing
> Machine, all copies of H will behave the same, so if the deciding copy
> of H returns 0 for the call H(P,P) so will the copy in P.
>
> If you want to claim otherwise, H no longer meets the requirements to BE
> a decider.
>
> FAIL.
>

On 11/13/21 9:54 AM, olcott wrote:
> On 11/13/2021 8:42 AM, Richard Damon wrote:
>> On 11/13/21 8:57 AM, olcott wrote:
>>> On 11/13/2021 7:17 AM, Richard Damon wrote:
>>>> On 11/13/21 12:46 AM, olcott wrote:
>>>>> On 11/12/2021 10:48 PM, Richard Damon wrote:
>>>>>> On 11/12/21 11:07 PM, olcott wrote:
>>>>>>> On 11/12/2021 9:41 PM, Richard Damon wrote:
>>>>>>>> On 11/12/21 10:25 PM, olcott wrote:
>>>>>>>>> On 11/12/2021 8:19 PM, Richard Damon wrote:
>>>>>>>>>> On 11/12/21 8:59 PM, olcott wrote:
>>>>>>>>>>> On 11/12/2021 7:47 PM, André G. Isaak wrote:
>>>>>>>>>>>> On 2021-11-12 15:53, olcott wrote:
>>>>>>>>>>>>
>>>>>>>>>>>>> The ultimate measure of the halt status of an input is its
>>>>>>>>>>>>> behavior when directly executed.
>>>>>>>>>>>>
>>>>>>>>>>>> The input itself doesn't have a halt status.
>>>>>>>>>>>
>>>>>>>>>>> In this case it does. Ben simplified my syntax.
>>>>>>>>>>
>>>>>>>>>> Nope.
>>>>>>>>>>
>>>>>>>>>> This just shows that you don't have a valid Turing Model in
>>>>>>>>>> place.
>>>>>>>>>>
>>>>>>>>>> A sting of bytes does not in of itself have a Halting Status.
>>>>>>>>>>
>>>>>>>>>> Interpreting that string as a set of instructions by executing
>>>>>>>>>> it, makes it have one.
>>>>>>>>>>
>>>>>>>>>> Basically, your x(y) to be implemented in a Turing Machine
>>>>>>>>>> would likely be putting in the code for a UTM there, and the
>>>>>>>>>> tape would need to be loaded with a representation of the
>>>>>>>>>> function P and all the code of H that it calls, including that
>>>>>>>>>> UTM.
>>>>>>>>>>
>>>>>>>>>> That input tape, still, doesn't have behavior on its own. but
>>>>>>>>>> ONLY as viewed as either the representation of an actual
>>>>>>>>>> Turing Machine, or as the input to a UTM (which is what you do
>>>>>>>>>> here).
>>>>>>>>>>
>>>>>>>>>> FAIL.
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>>
>>>>>>>>> computation that halts
>>>>>>>>> a computation is said to halt whenever it enters a final state.
>>>>>>>>> (Linz:1990:234)
>>>>>>>>>
>>>>>>>>
>>>>>>>> Right, THE COMPUTATION, not a partial simulation of one.
>>>>>>>> Note Non-Halting is defined as NEVER halting after unlimited
>>>>>>>> number of steps.
>>>>>>>>
>>>>>>>> Not failing to reach the halt state after executing only a
>>>>>>>> limited fixed number of steps.
>>>>>>>>
>>>>>>>> FAIL
>>>>>>>>
>>>>>>>>
>>>>>>>>> computer science decider
>>>>>>>>> a decider is a machine that accepts or rejects inputs.
>>>>>>>>> https://cs.stackexchange.com/questions/84433/what-is-decider
>>>>>>>>>
>>>>>>>>> halt decider
>>>>>>>>> A halt decider accept or rejects an input on the basis of
>>>>>>>>> whether or not the direct execution or pure simulation of this
>>>>>>>>> input would ever reach a final state of this input.
>>>>>>>>>
>>>>>>>>
>>>>>>>> RIGHT, only FULL DIRECT EXECTUTION or PURE SIMULATION.
>>>>>>>>
>>>>>>>>
>>>>>>>>
>>>>>>>>
>>>>>>>>> _P()
>>>>>>>>> [00001a5e](01)  55              push ebp
>>>>>>>>> [00001a5f](02)  8bec            mov ebp,esp
>>>>>>>>> [00001a61](03)  8b4508          mov eax,[ebp+08]
>>>>>>>>> [00001a64](01)  50              push eax        // push P
>>>>>>>>> [00001a65](03)  8b4d08          mov ecx,[ebp+08]
>>>>>>>>> [00001a68](01)  51              push ecx        // push P
>>>>>>>>> [00001a69](05)  e810000000      call 00001a7e   // call H
>>>>>>>>> [00001a6e](03)  83c408          add esp,+08
>>>>>>>>> [00001a71](01)  5d              pop ebp
>>>>>>>>> [00001a72](01)  c3              ret
>>>>>>>>> Size in bytes:(0021) [00001a72]
>>>>>>>>>
>>>>>>>>>
>>>>>>>>> H(P,P)==0 is correct for every H at machine address 00001a7e
>>>>>>>>> with the above string of machine language bytes as its input.
>>>>>>>>>
>>>>>>>>
>>>>>>>> Nope.
>>>>>>>>
>>>>>>>> If H is defined in a way that aborts its simulation and returns
>>>>>>>> a value in finite time then the DIRECT EXECTUTION of P will
>>>>>>>> reach that terminal state.
>>>>>>> No this is not true. For the precisely defined computation of
>>>>>>> H(P,P) the input P never gets past 00001a69.
>>>>>>>
>>>>>>
>>>>>> NOPE. You can not provide an H that has H(P,P) returning 0 and
>>>>>> also the direct execution of P(P) doesn't halt.
>>>>>>
>>>>>> Yes, there are H's that never abort their operation and results in
>>>>>> a P(P) that is non-halting, but those H's never return the value 0
>>>>>> for H(P,P).
>>>>>>
>>>>>> If you are making the assertion that such an H exists, the
>>>>>> challenge is to provide it.
>>>>>>
>>>>>> Failure means you admit to lying.
>>>>>
>>>>>
>>>>> All rebuttals must take this form:
>>>>> Find an invocation of H(P,P) at machine address 00001a7e such that
>>>>> the simulation or execution of (the exact byte sequence of) P
>>>>> reaches its final address of 00001a72.
>>>>>
>>>>>
>>>>
>>>>
>>>> No, they don't. You LIE when you make that claim.
>>>>
>>>> The criteria you are asking for has NOTHING to do with the REQUIRED
>>>> DEFINITION OF HALTING, which is based on the behavior of the program
>>>> when DIRECTLY RUN.
>>>>
>>>
>>> halt decider (Olcott 2021)
>>> A halt decider accepts or rejects an input on the basis of whether or
>>> not the direct execution or (possibly partial) pure simulation of
>>> this input would ever reach a final state of this input.
>>>
>>> I claim that the halt status for a specific H(P,P) is never halting
>>> therefore every correct rebuttal must show that one of these
>>> instances halts.
>>>
>>
>> So, given that H(P,P) rejects P, which MEANS that it returns the value
>> of 0 from a 'call' to H(P,P) in some finite time.
>>
>> Therefore a simple trace of the function P being directly executed is:
>>
>> [00001a5e](01)  55              push ebp
>> [00001a5f](02)  8bec            mov ebp,esp
>> [00001a61](03)  8b4508          mov eax,[ebp+08]
>> [00001a64](01)  50              push eax        // push P
>> [00001a65](03)  8b4d08          mov ecx,[ebp+08]
>> [00001a68](01)  51              push ecx        // push P
>> [00001a69](05)  e810000000      call 00001a7e   // call H
>>
>> // Trace inside H not provided as you refuse to provide the code for H.
>> // BUT we know from the stipulation that H will reject P(P) in finite
>> // time, that in finite time it WILL return the value 0
>>
>> [00001a6e](03)  83c408          add esp,+08
>> [00001a71](01)  5d              pop ebp
>> [00001a72](01)  c3              ret
>>
>>
>> THERE.
>>
>> SHow what is wrong with this DIRECT execution of P(P).
>>
>>
>> Remember, the 'halt status' that H needs to decide on is the halt
>> status of the machine that the input represents, that is in this case
>> the computation P(P).
>>
>> You are stuck with the fact that since H is defined to be a Turing
>> Machine, all copies of H will behave the same, so if the deciding copy
>> of H returns 0 for the call H(P,P) so will the copy in P.
>>
>> If you want to claim otherwise, H no longer meets the requirements to
>> BE a decider.
>>
>> FAIL.
>>
>
> Find a counter-example to this:
>
> _P()
> [00001a5e](01)  55              push ebp
> [00001a5f](02)  8bec            mov ebp,esp
> [00001a61](03)  8b4508          mov eax,[ebp+08]
> [00001a64](01)  50              push eax        // push P
> [00001a65](03)  8b4d08          mov ecx,[ebp+08]
> [00001a68](01)  51              push ecx        // push P
> [00001a69](05)  e810000000      call 00001a7e   // call H
> [00001a6e](03)  83c408          add esp,+08
> [00001a71](01)  5d              pop ebp
> [00001a72](01)  c3              ret
> Size in bytes:(0021) [00001a72]
>
> H(P,P)==0 is correct for every H at machine address 00001a7e with the
> above string of machine language bytes as its input.
>
> **All rebuttals must take this form**
> Find an invocation of H(P,P) at machine address 00001a7e such that the
> simulation or execution of (the exact byte sequence of) P reaches its
> final address of 00001a72.
>

On 11/13/2021 9:13 AM, Richard Damon wrote:
> On 11/13/21 9:54 AM, olcott wrote:
>> On 11/13/2021 8:42 AM, Richard Damon wrote:
>>> On 11/13/21 8:57 AM, olcott wrote:
>>>> On 11/13/2021 7:17 AM, Richard Damon wrote:
>>>>> On 11/13/21 12:46 AM, olcott wrote:
>>>>>> On 11/12/2021 10:48 PM, Richard Damon wrote:
>>>>>>> On 11/12/21 11:07 PM, olcott wrote:
>>>>>>>> On 11/12/2021 9:41 PM, Richard Damon wrote:
>>>>>>>>> On 11/12/21 10:25 PM, olcott wrote:
>>>>>>>>>> On 11/12/2021 8:19 PM, Richard Damon wrote:
>>>>>>>>>>> On 11/12/21 8:59 PM, olcott wrote:
>>>>>>>>>>>> On 11/12/2021 7:47 PM, André G. Isaak wrote:
>>>>>>>>>>>>> On 2021-11-12 15:53, olcott wrote:
>>>>>>>>>>>>>
>>>>>>>>>>>>>> The ultimate measure of the halt status of an input is its
>>>>>>>>>>>>>> behavior when directly executed.
>>>>>>>>>>>>>
>>>>>>>>>>>>> The input itself doesn't have a halt status.
>>>>>>>>>>>>
>>>>>>>>>>>> In this case it does. Ben simplified my syntax.
>>>>>>>>>>>
>>>>>>>>>>> Nope.
>>>>>>>>>>>
>>>>>>>>>>> This just shows that you don't have a valid Turing Model in
>>>>>>>>>>> place.
>>>>>>>>>>>
>>>>>>>>>>> A sting of bytes does not in of itself have a Halting Status.
>>>>>>>>>>>
>>>>>>>>>>> Interpreting that string as a set of instructions by
>>>>>>>>>>> executing it, makes it have one.
>>>>>>>>>>>
>>>>>>>>>>> Basically, your x(y) to be implemented in a Turing Machine
>>>>>>>>>>> would likely be putting in the code for a UTM there, and the
>>>>>>>>>>> tape would need to be loaded with a representation of the
>>>>>>>>>>> function P and all the code of H that it calls, including
>>>>>>>>>>> that UTM.
>>>>>>>>>>>
>>>>>>>>>>> That input tape, still, doesn't have behavior on its own. but
>>>>>>>>>>> ONLY as viewed as either the representation of an actual
>>>>>>>>>>> Turing Machine, or as the input to a UTM (which is what you
>>>>>>>>>>> do here).
>>>>>>>>>>>
>>>>>>>>>>> FAIL.
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> computation that halts
>>>>>>>>>> a computation is said to halt whenever it enters a final
>>>>>>>>>> state. (Linz:1990:234)
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> Right, THE COMPUTATION, not a partial simulation of one.
>>>>>>>>> Note Non-Halting is defined as NEVER halting after unlimited
>>>>>>>>> number of steps.
>>>>>>>>>
>>>>>>>>> Not failing to reach the halt state after executing only a
>>>>>>>>> limited fixed number of steps.
>>>>>>>>>
>>>>>>>>> FAIL
>>>>>>>>>
>>>>>>>>>
>>>>>>>>>> computer science decider
>>>>>>>>>> a decider is a machine that accepts or rejects inputs.
>>>>>>>>>> https://cs.stackexchange.com/questions/84433/what-is-decider
>>>>>>>>>>
>>>>>>>>>> halt decider
>>>>>>>>>> A halt decider accept or rejects an input on the basis of
>>>>>>>>>> whether or not the direct execution or pure simulation of this
>>>>>>>>>> input would ever reach a final state of this input.
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> RIGHT, only FULL DIRECT EXECTUTION or PURE SIMULATION.
>>>>>>>>>
>>>>>>>>>
>>>>>>>>>
>>>>>>>>>
>>>>>>>>>> _P()
>>>>>>>>>> [00001a5e](01)  55              push ebp
>>>>>>>>>> [00001a5f](02)  8bec            mov ebp,esp
>>>>>>>>>> [00001a61](03)  8b4508          mov eax,[ebp+08]
>>>>>>>>>> [00001a64](01)  50              push eax        // push P
>>>>>>>>>> [00001a65](03)  8b4d08          mov ecx,[ebp+08]
>>>>>>>>>> [00001a68](01)  51              push ecx        // push P
>>>>>>>>>> [00001a69](05)  e810000000      call 00001a7e   // call H
>>>>>>>>>> [00001a6e](03)  83c408          add esp,+08
>>>>>>>>>> [00001a71](01)  5d              pop ebp
>>>>>>>>>> [00001a72](01)  c3              ret
>>>>>>>>>> Size in bytes:(0021) [00001a72]
>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> H(P,P)==0 is correct for every H at machine address 00001a7e
>>>>>>>>>> with the above string of machine language bytes as its input.
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> Nope.
>>>>>>>>>
>>>>>>>>> If H is defined in a way that aborts its simulation and returns
>>>>>>>>> a value in finite time then the DIRECT EXECTUTION of P will
>>>>>>>>> reach that terminal state.
>>>>>>>> No this is not true. For the precisely defined computation of
>>>>>>>> H(P,P) the input P never gets past 00001a69.
>>>>>>>>
>>>>>>>
>>>>>>> NOPE. You can not provide an H that has H(P,P) returning 0 and
>>>>>>> also the direct execution of P(P) doesn't halt.
>>>>>>>
>>>>>>> Yes, there are H's that never abort their operation and results
>>>>>>> in a P(P) that is non-halting, but those H's never return the
>>>>>>> value 0 for H(P,P).
>>>>>>>
>>>>>>> If you are making the assertion that such an H exists, the
>>>>>>> challenge is to provide it.
>>>>>>>
>>>>>>> Failure means you admit to lying.
>>>>>>
>>>>>>
>>>>>> All rebuttals must take this form:
>>>>>> Find an invocation of H(P,P) at machine address 00001a7e such that
>>>>>> the simulation or execution of (the exact byte sequence of) P
>>>>>> reaches its final address of 00001a72.
>>>>>>
>>>>>>
>>>>>
>>>>>
>>>>> No, they don't. You LIE when you make that claim.
>>>>>
>>>>> The criteria you are asking for has NOTHING to do with the REQUIRED
>>>>> DEFINITION OF HALTING, which is based on the behavior of the
>>>>> program when DIRECTLY RUN.
>>>>>
>>>>
>>>> halt decider (Olcott 2021)
>>>> A halt decider accepts or rejects an input on the basis of whether
>>>> or not the direct execution or (possibly partial) pure simulation of
>>>> this input would ever reach a final state of this input.
>>>>
>>>> I claim that the halt status for a specific H(P,P) is never halting
>>>> therefore every correct rebuttal must show that one of these
>>>> instances halts.
>>>>
>>>
>>> So, given that H(P,P) rejects P, which MEANS that it returns the
>>> value of 0 from a 'call' to H(P,P) in some finite time.
>>>
>>> Therefore a simple trace of the function P being directly executed is:
>>>
>>> [00001a5e](01)  55              push ebp
>>> [00001a5f](02)  8bec            mov ebp,esp
>>> [00001a61](03)  8b4508          mov eax,[ebp+08]
>>> [00001a64](01)  50              push eax        // push P
>>> [00001a65](03)  8b4d08          mov ecx,[ebp+08]
>>> [00001a68](01)  51              push ecx        // push P
>>> [00001a69](05)  e810000000      call 00001a7e   // call H
>>>
>>> // Trace inside H not provided as you refuse to provide the code for H.
>>> // BUT we know from the stipulation that H will reject P(P) in finite
>>> // time, that in finite time it WILL return the value 0
>>>
>>> [00001a6e](03)  83c408          add esp,+08
>>> [00001a71](01)  5d              pop ebp
>>> [00001a72](01)  c3              ret
>>>
>>>
>>> THERE.
>>>
>>> SHow what is wrong with this DIRECT execution of P(P).
>>>
>>>
>>> Remember, the 'halt status' that H needs to decide on is the halt
>>> status of the machine that the input represents, that is in this case
>>> the computation P(P).
>>>
>>> You are stuck with the fact that since H is defined to be a Turing
>>> Machine, all copies of H will behave the same, so if the deciding
>>> copy of H returns 0 for the call H(P,P) so will the copy in P.
>>>
>>> If you want to claim otherwise, H no longer meets the requirements to
>>> BE a decider.
>>>
>>> FAIL.
>>>
>>
>> Find a counter-example to this:
>>
>> _P()
>> [00001a5e](01)  55              push ebp
>> [00001a5f](02)  8bec            mov ebp,esp
>> [00001a61](03)  8b4508          mov eax,[ebp+08]
>> [00001a64](01)  50              push eax        // push P
>> [00001a65](03)  8b4d08          mov ecx,[ebp+08]
>> [00001a68](01)  51              push ecx        // push P
>> [00001a69](05)  e810000000      call 00001a7e   // call H
>> [00001a6e](03)  83c408          add esp,+08
>> [00001a71](01)  5d              pop ebp
>> [00001a72](01)  c3              ret
>> Size in bytes:(0021) [00001a72]
>>
>> H(P,P)==0 is correct for every H at machine address 00001a7e with the
>> above string of machine language bytes as its input.
>>
>> **All rebuttals must take this form**
>> Find an invocation of H(P,P) at machine address 00001a7e such that the
>> simulation or execution of (the exact byte sequence of) P reaches its
>> final address of 00001a72.
>>
>
> It rebuts itself.
>
> Given that the call to H will return in finite time, then that sequence
> of bytes will be executed.
That merely proves that you really aren't paying attention.
The above specification applies to every H that can possibly exist
including ones that do not return in finite time.

On 11/13/21 10:19 AM, olcott wrote:
> On 11/13/2021 9:13 AM, Richard Damon wrote:
>> On 11/13/21 9:54 AM, olcott wrote:
>>> On 11/13/2021 8:42 AM, Richard Damon wrote:
>>>> On 11/13/21 8:57 AM, olcott wrote:
>>>>> On 11/13/2021 7:17 AM, Richard Damon wrote:
>>>>>> On 11/13/21 12:46 AM, olcott wrote:
>>>>>>> On 11/12/2021 10:48 PM, Richard Damon wrote:
>>>>>>>> On 11/12/21 11:07 PM, olcott wrote:
>>>>>>>>> On 11/12/2021 9:41 PM, Richard Damon wrote:
>>>>>>>>>> On 11/12/21 10:25 PM, olcott wrote:
>>>>>>>>>>> On 11/12/2021 8:19 PM, Richard Damon wrote:
>>>>>>>>>>>> On 11/12/21 8:59 PM, olcott wrote:
>>>>>>>>>>>>> On 11/12/2021 7:47 PM, André G. Isaak wrote:
>>>>>>>>>>>>>> On 2021-11-12 15:53, olcott wrote:
>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> The ultimate measure of the halt status of an input is
>>>>>>>>>>>>>>> its behavior when directly executed.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> The input itself doesn't have a halt status.
>>>>>>>>>>>>>
>>>>>>>>>>>>> In this case it does. Ben simplified my syntax.
>>>>>>>>>>>>
>>>>>>>>>>>> Nope.
>>>>>>>>>>>>
>>>>>>>>>>>> This just shows that you don't have a valid Turing Model in
>>>>>>>>>>>> place.
>>>>>>>>>>>>
>>>>>>>>>>>> A sting of bytes does not in of itself have a Halting Status.
>>>>>>>>>>>>
>>>>>>>>>>>> Interpreting that string as a set of instructions by
>>>>>>>>>>>> executing it, makes it have one.
>>>>>>>>>>>>
>>>>>>>>>>>> Basically, your x(y) to be implemented in a Turing Machine
>>>>>>>>>>>> would likely be putting in the code for a UTM there, and the
>>>>>>>>>>>> tape would need to be loaded with a representation of the
>>>>>>>>>>>> function P and all the code of H that it calls, including
>>>>>>>>>>>> that UTM.
>>>>>>>>>>>>
>>>>>>>>>>>> That input tape, still, doesn't have behavior on its own.
>>>>>>>>>>>> but ONLY as viewed as either the representation of an actual
>>>>>>>>>>>> Turing Machine, or as the input to a UTM (which is what you
>>>>>>>>>>>> do here).
>>>>>>>>>>>>
>>>>>>>>>>>> FAIL.
>>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> computation that halts
>>>>>>>>>>> a computation is said to halt whenever it enters a final
>>>>>>>>>>> state. (Linz:1990:234)
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> Right, THE COMPUTATION, not a partial simulation of one.
>>>>>>>>>> Note Non-Halting is defined as NEVER halting after unlimited
>>>>>>>>>> number of steps.
>>>>>>>>>>
>>>>>>>>>> Not failing to reach the halt state after executing only a
>>>>>>>>>> limited fixed number of steps.
>>>>>>>>>>
>>>>>>>>>> FAIL
>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>>> computer science decider
>>>>>>>>>>> a decider is a machine that accepts or rejects inputs.
>>>>>>>>>>> https://cs.stackexchange.com/questions/84433/what-is-decider
>>>>>>>>>>>
>>>>>>>>>>> halt decider
>>>>>>>>>>> A halt decider accept or rejects an input on the basis of
>>>>>>>>>>> whether or not the direct execution or pure simulation of
>>>>>>>>>>> this input would ever reach a final state of this input.
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> RIGHT, only FULL DIRECT EXECTUTION or PURE SIMULATION.
>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>>> _P()
>>>>>>>>>>> [00001a5e](01)  55              push ebp
>>>>>>>>>>> [00001a5f](02)  8bec            mov ebp,esp
>>>>>>>>>>> [00001a61](03)  8b4508          mov eax,[ebp+08]
>>>>>>>>>>> [00001a64](01)  50              push eax        // push P
>>>>>>>>>>> [00001a65](03)  8b4d08          mov ecx,[ebp+08]
>>>>>>>>>>> [00001a68](01)  51              push ecx        // push P
>>>>>>>>>>> [00001a69](05)  e810000000      call 00001a7e   // call H
>>>>>>>>>>> [00001a6e](03)  83c408          add esp,+08
>>>>>>>>>>> [00001a71](01)  5d              pop ebp
>>>>>>>>>>> [00001a72](01)  c3              ret
>>>>>>>>>>> Size in bytes:(0021) [00001a72]
>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> H(P,P)==0 is correct for every H at machine address 00001a7e
>>>>>>>>>>> with the above string of machine language bytes as its input.
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> Nope.
>>>>>>>>>>
>>>>>>>>>> If H is defined in a way that aborts its simulation and
>>>>>>>>>> returns a value in finite time then the DIRECT EXECTUTION of P
>>>>>>>>>> will reach that terminal state.
>>>>>>>>> No this is not true. For the precisely defined computation of
>>>>>>>>> H(P,P) the input P never gets past 00001a69.
>>>>>>>>>
>>>>>>>>
>>>>>>>> NOPE. You can not provide an H that has H(P,P) returning 0 and
>>>>>>>> also the direct execution of P(P) doesn't halt.
>>>>>>>>
>>>>>>>> Yes, there are H's that never abort their operation and results
>>>>>>>> in a P(P) that is non-halting, but those H's never return the
>>>>>>>> value 0 for H(P,P).
>>>>>>>>
>>>>>>>> If you are making the assertion that such an H exists, the
>>>>>>>> challenge is to provide it.
>>>>>>>>
>>>>>>>> Failure means you admit to lying.
>>>>>>>
>>>>>>>
>>>>>>> All rebuttals must take this form:
>>>>>>> Find an invocation of H(P,P) at machine address 00001a7e such
>>>>>>> that the simulation or execution of (the exact byte sequence of)
>>>>>>> P reaches its final address of 00001a72.
>>>>>>>
>>>>>>>
>>>>>>
>>>>>>
>>>>>> No, they don't. You LIE when you make that claim.
>>>>>>
>>>>>> The criteria you are asking for has NOTHING to do with the
>>>>>> REQUIRED DEFINITION OF HALTING, which is based on the behavior of
>>>>>> the program when DIRECTLY RUN.
>>>>>>
>>>>>
>>>>> halt decider (Olcott 2021)
>>>>> A halt decider accepts or rejects an input on the basis of whether
>>>>> or not the direct execution or (possibly partial) pure simulation
>>>>> of this input would ever reach a final state of this input.
>>>>>
>>>>> I claim that the halt status for a specific H(P,P) is never halting
>>>>> therefore every correct rebuttal must show that one of these
>>>>> instances halts.
>>>>>
>>>>
>>>> So, given that H(P,P) rejects P, which MEANS that it returns the
>>>> value of 0 from a 'call' to H(P,P) in some finite time.
>>>>
>>>> Therefore a simple trace of the function P being directly executed is:
>>>>
>>>> [00001a5e](01)  55              push ebp
>>>> [00001a5f](02)  8bec            mov ebp,esp
>>>> [00001a61](03)  8b4508          mov eax,[ebp+08]
>>>> [00001a64](01)  50              push eax        // push P
>>>> [00001a65](03)  8b4d08          mov ecx,[ebp+08]
>>>> [00001a68](01)  51              push ecx        // push P
>>>> [00001a69](05)  e810000000      call 00001a7e   // call H
>>>>
>>>> // Trace inside H not provided as you refuse to provide the code for H.
>>>> // BUT we know from the stipulation that H will reject P(P) in finite
>>>> // time, that in finite time it WILL return the value 0
>>>>
>>>> [00001a6e](03)  83c408          add esp,+08
>>>> [00001a71](01)  5d              pop ebp
>>>> [00001a72](01)  c3              ret
>>>>
>>>>
>>>> THERE.
>>>>
>>>> SHow what is wrong with this DIRECT execution of P(P).
>>>>
>>>>
>>>> Remember, the 'halt status' that H needs to decide on is the halt
>>>> status of the machine that the input represents, that is in this
>>>> case the computation P(P).
>>>>
>>>> You are stuck with the fact that since H is defined to be a Turing
>>>> Machine, all copies of H will behave the same, so if the deciding
>>>> copy of H returns 0 for the call H(P,P) so will the copy in P.
>>>>
>>>> If you want to claim otherwise, H no longer meets the requirements
>>>> to BE a decider.
>>>>
>>>> FAIL.
>>>>
>>>
>>> Find a counter-example to this:
>>>
>>> _P()
>>> [00001a5e](01)  55              push ebp
>>> [00001a5f](02)  8bec            mov ebp,esp
>>> [00001a61](03)  8b4508          mov eax,[ebp+08]
>>> [00001a64](01)  50              push eax        // push P
>>> [00001a65](03)  8b4d08          mov ecx,[ebp+08]
>>> [00001a68](01)  51              push ecx        // push P
>>> [00001a69](05)  e810000000      call 00001a7e   // call H
>>> [00001a6e](03)  83c408          add esp,+08
>>> [00001a71](01)  5d              pop ebp
>>> [00001a72](01)  c3              ret
>>> Size in bytes:(0021) [00001a72]
>>>
>>> H(P,P)==0 is correct for every H at machine address 00001a7e with the
>>> above string of machine language bytes as its input.
>>>
>>> **All rebuttals must take this form**
>>> Find an invocation of H(P,P) at machine address 00001a7e such that
>>> the simulation or execution of (the exact byte sequence of) P reaches
>>> its final address of 00001a72.
>>>
>>
>> It rebuts itself.
>>
>> Given that the call to H will return in finite time, then that
>> sequence of bytes will be executed.
> That merely proves that you really aren't paying attention.
> The above specification applies to every H that can possibly exist
> including ones that do not return in finite time.
>
>

On 11/13/2021 9:30 AM, Richard Damon wrote:
> On 11/13/21 10:19 AM, olcott wrote:
>> On 11/13/2021 9:13 AM, Richard Damon wrote:
>>> On 11/13/21 9:54 AM, olcott wrote:
>>>> On 11/13/2021 8:42 AM, Richard Damon wrote:
>>>>> On 11/13/21 8:57 AM, olcott wrote:
>>>>>> On 11/13/2021 7:17 AM, Richard Damon wrote:
>>>>>>> On 11/13/21 12:46 AM, olcott wrote:
>>>>>>>> On 11/12/2021 10:48 PM, Richard Damon wrote:
>>>>>>>>> On 11/12/21 11:07 PM, olcott wrote:
>>>>>>>>>> On 11/12/2021 9:41 PM, Richard Damon wrote:
>>>>>>>>>>> On 11/12/21 10:25 PM, olcott wrote:
>>>>>>>>>>>> On 11/12/2021 8:19 PM, Richard Damon wrote:
>>>>>>>>>>>>> On 11/12/21 8:59 PM, olcott wrote:
>>>>>>>>>>>>>> On 11/12/2021 7:47 PM, André G. Isaak wrote:
>>>>>>>>>>>>>>> On 2021-11-12 15:53, olcott wrote:
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> The ultimate measure of the halt status of an input is
>>>>>>>>>>>>>>>> its behavior when directly executed.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> The input itself doesn't have a halt status.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> In this case it does. Ben simplified my syntax.
>>>>>>>>>>>>>
>>>>>>>>>>>>> Nope.
>>>>>>>>>>>>>
>>>>>>>>>>>>> This just shows that you don't have a valid Turing Model in
>>>>>>>>>>>>> place.
>>>>>>>>>>>>>
>>>>>>>>>>>>> A sting of bytes does not in of itself have a Halting Status.
>>>>>>>>>>>>>
>>>>>>>>>>>>> Interpreting that string as a set of instructions by
>>>>>>>>>>>>> executing it, makes it have one.
>>>>>>>>>>>>>
>>>>>>>>>>>>> Basically, your x(y) to be implemented in a Turing Machine
>>>>>>>>>>>>> would likely be putting in the code for a UTM there, and
>>>>>>>>>>>>> the tape would need to be loaded with a representation of
>>>>>>>>>>>>> the function P and all the code of H that it calls,
>>>>>>>>>>>>> including that UTM.
>>>>>>>>>>>>>
>>>>>>>>>>>>> That input tape, still, doesn't have behavior on its own.
>>>>>>>>>>>>> but ONLY as viewed as either the representation of an
>>>>>>>>>>>>> actual Turing Machine, or as the input to a UTM (which is
>>>>>>>>>>>>> what you do here).
>>>>>>>>>>>>>
>>>>>>>>>>>>> FAIL.
>>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> computation that halts
>>>>>>>>>>>> a computation is said to halt whenever it enters a final
>>>>>>>>>>>> state. (Linz:1990:234)
>>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> Right, THE COMPUTATION, not a partial simulation of one.
>>>>>>>>>>> Note Non-Halting is defined as NEVER halting after unlimited
>>>>>>>>>>> number of steps.
>>>>>>>>>>>
>>>>>>>>>>> Not failing to reach the halt state after executing only a
>>>>>>>>>>> limited fixed number of steps.
>>>>>>>>>>>
>>>>>>>>>>> FAIL
>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>>> computer science decider
>>>>>>>>>>>> a decider is a machine that accepts or rejects inputs.
>>>>>>>>>>>> https://cs.stackexchange.com/questions/84433/what-is-decider
>>>>>>>>>>>>
>>>>>>>>>>>> halt decider
>>>>>>>>>>>> A halt decider accept or rejects an input on the basis of
>>>>>>>>>>>> whether or not the direct execution or pure simulation of
>>>>>>>>>>>> this input would ever reach a final state of this input.
>>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> RIGHT, only FULL DIRECT EXECTUTION or PURE SIMULATION.
>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>>> _P()
>>>>>>>>>>>> [00001a5e](01)  55              push ebp
>>>>>>>>>>>> [00001a5f](02)  8bec            mov ebp,esp
>>>>>>>>>>>> [00001a61](03)  8b4508          mov eax,[ebp+08]
>>>>>>>>>>>> [00001a64](01)  50              push eax        // push P
>>>>>>>>>>>> [00001a65](03)  8b4d08          mov ecx,[ebp+08]
>>>>>>>>>>>> [00001a68](01)  51              push ecx        // push P
>>>>>>>>>>>> [00001a69](05)  e810000000      call 00001a7e   // call H
>>>>>>>>>>>> [00001a6e](03)  83c408          add esp,+08
>>>>>>>>>>>> [00001a71](01)  5d              pop ebp
>>>>>>>>>>>> [00001a72](01)  c3              ret
>>>>>>>>>>>> Size in bytes:(0021) [00001a72]
>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> H(P,P)==0 is correct for every H at machine address 00001a7e
>>>>>>>>>>>> with the above string of machine language bytes as its input.
>>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> Nope.
>>>>>>>>>>>
>>>>>>>>>>> If H is defined in a way that aborts its simulation and
>>>>>>>>>>> returns a value in finite time then the DIRECT EXECTUTION of
>>>>>>>>>>> P will reach that terminal state.
>>>>>>>>>> No this is not true. For the precisely defined computation of
>>>>>>>>>> H(P,P) the input P never gets past 00001a69.
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> NOPE. You can not provide an H that has H(P,P) returning 0 and
>>>>>>>>> also the direct execution of P(P) doesn't halt.
>>>>>>>>>
>>>>>>>>> Yes, there are H's that never abort their operation and results
>>>>>>>>> in a P(P) that is non-halting, but those H's never return the
>>>>>>>>> value 0 for H(P,P).
>>>>>>>>>
>>>>>>>>> If you are making the assertion that such an H exists, the
>>>>>>>>> challenge is to provide it.
>>>>>>>>>
>>>>>>>>> Failure means you admit to lying.
>>>>>>>>
>>>>>>>>
>>>>>>>> All rebuttals must take this form:
>>>>>>>> Find an invocation of H(P,P) at machine address 00001a7e such
>>>>>>>> that the simulation or execution of (the exact byte sequence of)
>>>>>>>> P reaches its final address of 00001a72.
>>>>>>>>
>>>>>>>>
>>>>>>>
>>>>>>>
>>>>>>> No, they don't. You LIE when you make that claim.
>>>>>>>
>>>>>>> The criteria you are asking for has NOTHING to do with the
>>>>>>> REQUIRED DEFINITION OF HALTING, which is based on the behavior of
>>>>>>> the program when DIRECTLY RUN.
>>>>>>>
>>>>>>
>>>>>> halt decider (Olcott 2021)
>>>>>> A halt decider accepts or rejects an input on the basis of whether
>>>>>> or not the direct execution or (possibly partial) pure simulation
>>>>>> of this input would ever reach a final state of this input.
>>>>>>
>>>>>> I claim that the halt status for a specific H(P,P) is never
>>>>>> halting therefore every correct rebuttal must show that one of
>>>>>> these instances halts.
>>>>>>
>>>>>
>>>>> So, given that H(P,P) rejects P, which MEANS that it returns the
>>>>> value of 0 from a 'call' to H(P,P) in some finite time.
>>>>>
>>>>> Therefore a simple trace of the function P being directly executed is:
>>>>>
>>>>> [00001a5e](01)  55              push ebp
>>>>> [00001a5f](02)  8bec            mov ebp,esp
>>>>> [00001a61](03)  8b4508          mov eax,[ebp+08]
>>>>> [00001a64](01)  50              push eax        // push P
>>>>> [00001a65](03)  8b4d08          mov ecx,[ebp+08]
>>>>> [00001a68](01)  51              push ecx        // push P
>>>>> [00001a69](05)  e810000000      call 00001a7e   // call H
>>>>>
>>>>> // Trace inside H not provided as you refuse to provide the code
>>>>> for H.
>>>>> // BUT we know from the stipulation that H will reject P(P) in finite
>>>>> // time, that in finite time it WILL return the value 0
>>>>>
>>>>> [00001a6e](03)  83c408          add esp,+08
>>>>> [00001a71](01)  5d              pop ebp
>>>>> [00001a72](01)  c3              ret
>>>>>
>>>>>
>>>>> THERE.
>>>>>
>>>>> SHow what is wrong with this DIRECT execution of P(P).
>>>>>
>>>>>
>>>>> Remember, the 'halt status' that H needs to decide on is the halt
>>>>> status of the machine that the input represents, that is in this
>>>>> case the computation P(P).
>>>>>
>>>>> You are stuck with the fact that since H is defined to be a Turing
>>>>> Machine, all copies of H will behave the same, so if the deciding
>>>>> copy of H returns 0 for the call H(P,P) so will the copy in P.
>>>>>
>>>>> If you want to claim otherwise, H no longer meets the requirements
>>>>> to BE a decider.
>>>>>
>>>>> FAIL.
>>>>>
>>>>
>>>> Find a counter-example to this:
>>>>
>>>> _P()
>>>> [00001a5e](01)  55              push ebp
>>>> [00001a5f](02)  8bec            mov ebp,esp
>>>> [00001a61](03)  8b4508          mov eax,[ebp+08]
>>>> [00001a64](01)  50              push eax        // push P
>>>> [00001a65](03)  8b4d08          mov ecx,[ebp+08]
>>>> [00001a68](01)  51              push ecx        // push P
>>>> [00001a69](05)  e810000000      call 00001a7e   // call H
>>>> [00001a6e](03)  83c408          add esp,+08
>>>> [00001a71](01)  5d              pop ebp
>>>> [00001a72](01)  c3              ret
>>>> Size in bytes:(0021) [00001a72]
>>>>
>>>> H(P,P)==0 is correct for every H at machine address 00001a7e with
>>>> the above string of machine language bytes as its input.
>>>>
>>>> **All rebuttals must take this form**
>>>> Find an invocation of H(P,P) at machine address 00001a7e such that
>>>> the simulation or execution of (the exact byte sequence of) P
>>>> reaches its final address of 00001a72.
>>>>
>>>
>>> It rebuts itself.
>>>
>>> Given that the call to H will return in finite time, then that
>>> sequence of bytes will be executed.
>> That merely proves that you really aren't paying attention.
>> The above specification applies to every H that can possibly exist
>> including ones that do not return in finite time.
>>
>>
>
> Except that ones that don't return in finite time are not possible
> counter examples to the Halting problem.
>
> You seem to have lost your way.
When the specific P is executed or simulated by every element of an
infinte set of differently defined H never halts then H(P,P)==0 is
always correct no matter what H actually does.

On 11/13/21 11:01 AM, olcott wrote:
> On 11/13/2021 9:30 AM, Richard Damon wrote:
>>
>> Except that ones that don't return in finite time are not possible
>> counter examples to the Halting problem.
>>
>> You seem to have lost your way.
> When the specific P is executed or simulated by every element of an
> infinte set of differently defined H never halts then H(P,P)==0 is
> always correct no matter what H actually does.

Except that is nonsense, as every H in that set needs to worry about the
P that is specific to IT.

>
> The subset of these that return 0 are correct halt deciders for their
> input.
>

But, if that P is NOT the P derived from it, they are not counter
examples to Linz.

It doesn't matter if some Hi can correctly decide an infinite number of
Pj correctly if it doesn't get Pi correct.

In every case, when Hi is asked to compute Hi(Pi,Pi) then one of the
following to things happen:

1) Either Hi{Pi,Pi) does not return the value 0, or
2) Hi(Pi,Pi) does return the value 0, but Pi(Pi) halts.

In both cases Hi fails to be a counter example for Linz.

FAIL.

You HAVE lost your way and trying to claim meaningless statements.

On 11/13/2021 10:10 AM, Richard Damon wrote:
>
> On 11/13/21 11:01 AM, olcott wrote:
>> On 11/13/2021 9:30 AM, Richard Damon wrote:
>>>
>>> Except that ones that don't return in finite time are not possible
>>> counter examples to the Halting problem.
>>>
>>> You seem to have lost your way.
>> When the specific P is executed or simulated by every element of an
>> infinte set of differently defined H never halts then H(P,P)==0 is
>> always correct no matter what H actually does.
>
> Except that is nonsense, as every H in that set needs to worry about the
> P that is specific to IT.

It is nonsense that a computation has the emotional state of worry.

>
>>
>> The subset of these that return 0 are correct halt deciders for their
>> input.
>>
>
> But, if that P is NOT the P derived from it, they are not counter
> examples to Linz.
>
> It doesn't matter if some Hi can correctly decide an infinite number of
> Pj correctly if it doesn't get Pi correct.
>
> In every case, when Hi is asked to compute Hi(Pi,Pi) then one of the
> following to things happen:
>
> 1) Either Hi{Pi,Pi) does not return the value 0, or
> 2) Hi(Pi,Pi) does return the value 0, but Pi(Pi) halts.
>
> In both cases Hi fails to be a counter example for Linz.
>
> FAIL.
>
> You HAVE lost your way and trying to claim meaningless statements.

--
Copyright 2021 Pete Olcott

Talent hits a target no one else can hit;
Genius hits a target no one else can see.
Arthur Schopenhauer

On 11/13/21 11:29 AM, olcott wrote:
> On 11/13/2021 10:10 AM, Richard Damon wrote:
>>
>> On 11/13/21 11:01 AM, olcott wrote:
>>> On 11/13/2021 9:30 AM, Richard Damon wrote:
>>>>
>>>> Except that ones that don't return in finite time are not possible
>>>> counter examples to the Halting problem.
>>>>
>>>> You seem to have lost your way.
>>> When the specific P is executed or simulated by every element of an
>>> infinte set of differently defined H never halts then H(P,P)==0 is
>>> always correct no matter what H actually does.
>>
>> Except that is nonsense, as every H in that set needs to worry about
>> the P that is specific to IT.
>
> It is nonsense that a computation has the emotional state of worry.

Ok, to be precise, the only case that MATTERS (for your proof) is that H
needs to get right its answer for the P that was specific to it.

None of you Hs get right the answer for the P built from them, thus none
of you Hs are counter example to Linz, so YOU FAIL.

>
>>
>>>
>>> The subset of these that return 0 are correct halt deciders for their
>>> input.
>>>
>>
>> But, if that P is NOT the P derived from it, they are not counter
>> examples to Linz.
>>
>> It doesn't matter if some Hi can correctly decide an infinite number
>> of Pj correctly if it doesn't get Pi correct.
>>
>> In every case, when Hi is asked to compute Hi(Pi,Pi) then one of the
>> following to things happen:
>>
>> 1) Either Hi{Pi,Pi) does not return the value 0, or
>> 2) Hi(Pi,Pi) does return the value 0, but Pi(Pi) halts.
>>
>> In both cases Hi fails to be a counter example for Linz.
>>
>> FAIL.
>>
>> You HAVE lost your way and trying to claim meaningless statements.
>
>