On 6/19/22 6:25 PM, olcott wrote:
> On 6/19/2022 4:56 PM, Richard Damon wrote:
>> On 6/19/22 5:34 PM, olcott wrote:
>>> On 6/19/2022 4:23 PM, Richard Damon wrote:
>>>>
>>>> On 6/19/22 4:55 PM, olcott wrote:
>>>>> On 6/19/2022 3:50 PM, Richard Damon wrote:
>>>>>> On 6/19/22 4:34 PM, olcott wrote:
>>>>>>> On 6/19/2022 3:19 PM, Richard Damon wrote:
>>>>>>>>
>>>>>>>> On 6/19/22 3:17 PM, olcott wrote:
>>>>>>>>> On 6/19/2022 1:43 PM, Richard Damon wrote:
>>>>>>>>>> On 6/19/22 2:30 PM, olcott wrote:
>>>>>>>>>>> On 6/19/2022 1:20 PM, Richard Damon wrote:
>>>>>>>>>>>> On 6/19/22 2:08 PM, olcott wrote:
>>>>>>>>>>>>> On 6/19/2022 12:40 PM, Mr Flibble wrote:
>>>>>>>>>>>>>> On Sun, 19 Jun 2022 12:16:05 -0500
>>>>>>>>>>>>>> olcott <NoOne@NoWhere.com> wrote:
>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> On 6/19/2022 12:01 PM, Mr Flibble wrote:
>>>>>>>>>>>>>>>> On Sun, 19 Jun 2022 11:23:24 -0500
>>>>>>>>>>>>>>>> olcott <NoOne@NoWhere.com> wrote:
>>>>>>>>>>>>>>>>> On 6/19/2022 11:01 AM, Mr Flibble wrote:
>>>>>>>>>>>>>>>>>> On Sun, 19 Jun 2022 10:39:34 -0500
>>>>>>>>>>>>>>>>>> olcott <NoOne@NoWhere.com> wrote:
>>>>>>>>>>>>>>>>>>> On 6/19/2022 10:23 AM, Mr Flibble wrote:
>>>>>>>>>>>>>>>>>>>> On Sun, 19 Jun 2022 10:13:00 -0500
>>>>>>>>>>>>>>>>>>>> olcott <NoOne@NoWhere.com> wrote:
>>>>>>>>>>>>>>>>>>>>> computation that halts … the Turing machine will
>>>>>>>>>>>>>>>>>>>>> halt whenever
>>>>>>>>>>>>>>>>>>>>> it enters a final state. (Linz:1990:234)
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> A halt decider must compute the mapping from its
>>>>>>>>>>>>>>>>>>>>> inputs to an
>>>>>>>>>>>>>>>>>>>>> accept or reject state on the basis of the actual
>>>>>>>>>>>>>>>>>>>>> behavior of
>>>>>>>>>>>>>>>>>>>>> these actual inputs.
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> When a simulating halt decider rejects all inputs as
>>>>>>>>>>>>>>>>>>>>> non-halting whenever it correctly detects [in a
>>>>>>>>>>>>>>>>>>>>> finite number
>>>>>>>>>>>>>>>>>>>>> of steps] that its correct and complete simulation
>>>>>>>>>>>>>>>>>>>>> of its
>>>>>>>>>>>>>>>>>>>>> input would never reach [a] final state of this
>>>>>>>>>>>>>>>>>>>>> input then all
>>>>>>>>>>>>>>>>>>>>> [these] inputs (including pathological inputs) are
>>>>>>>>>>>>>>>>>>>>> decided
>>>>>>>>>>>>>>>>>>>>> correctly.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> void Px(u32 x)
>>>>>>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>>>>>>>        H(x, x);
>>>>>>>>>>>>>>>>>>>>        return;
>>>>>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> int main()
>>>>>>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>>>>>>>        Output("Input_Halts = ", H((u32)Px, (u32)Px));
>>>>>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> ...[000013e8][00102357][00000000] 83c408
>>>>>>>>>>>>>>>>>>>> add esp,+08
>>>>>>>>>>>>>>>>>>>> ...[000013eb][00102353][00000000] 50 push eax
>>>>>>>>>>>>>>>>>>>> ...[000013ec][0010234f][00000427] 6827040000 push
>>>>>>>>>>>>>>>>>>>> 00000427
>>>>>>>>>>>>>>>>>>>> ---[000013f1][0010234f][00000427] e880f0ffff call
>>>>>>>>>>>>>>>>>>>> 00000476
>>>>>>>>>>>>>>>>>>>> Input_Halts = 0
>>>>>>>>>>>>>>>>>>>> ...[000013f6][00102357][00000000] 83c408
>>>>>>>>>>>>>>>>>>>> add esp,+08
>>>>>>>>>>>>>>>>>>>> ...[000013f9][00102357][00000000] 33c0
>>>>>>>>>>>>>>>>>>>> xor eax,eax
>>>>>>>>>>>>>>>>>>>> ...[000013fb][0010235b][00100000] 5d
>>>>>>>>>>>>>>>>>>>> pop ebp
>>>>>>>>>>>>>>>>>>>> ...[000013fc][0010235f][00000004] c3              ret
>>>>>>>>>>>>>>>>>>>> Number of Instructions Executed(16120)
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> It gets the answer wrong, i.e. input has not been
>>>>>>>>>>>>>>>>>>>> decided
>>>>>>>>>>>>>>>>>>>> correctly. QED.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> /Flibble
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> _P()
>>>>>>>>>>>>>>>>>>> [000010fa](01)  55              push ebp
>>>>>>>>>>>>>>>>>>> [000010fb](02)  8bec            mov ebp,esp
>>>>>>>>>>>>>>>>>>> [000010fd](03)  8b4508          mov eax,[ebp+08]
>>>>>>>>>>>>>>>>>>> [00001100](01)  50              push eax       // push P
>>>>>>>>>>>>>>>>>>> [00001101](03)  8b4d08          mov ecx,[ebp+08]
>>>>>>>>>>>>>>>>>>> [00001104](01)  51              push ecx       // push P
>>>>>>>>>>>>>>>>>>> [00001105](05)  e800feffff      call 00000f0a  // call H
>>>>>>>>>>>>>>>>>>> [0000110a](03)  83c408          add esp,+08
>>>>>>>>>>>>>>>>>>> [0000110d](02)  85c0            test eax,eax
>>>>>>>>>>>>>>>>>>> [0000110f](02)  7402            jz 00001113
>>>>>>>>>>>>>>>>>>> [00001111](02)  ebfe            jmp 00001111
>>>>>>>>>>>>>>>>>>> [00001113](01)  5d              pop ebp
>>>>>>>>>>>>>>>>>>> [00001114](01)  c3              ret
>>>>>>>>>>>>>>>>>>> Size in bytes:(0027) [00001114]
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> Begin Simulation   Execution Trace Stored at:211ee2
>>>>>>>>>>>>>>>>>>> ...[000010da][00211ece][00211ed2] 55         push ebp
>>>>>>>>>>>>>>>>>>> ...[000010db][00211ece][00211ed2] 8bec       mov ebp,esp
>>>>>>>>>>>>>>>>>>> ...[000010dd][00211ece][00211ed2] 8b4508     mov
>>>>>>>>>>>>>>>>>>> eax,[ebp+08]
>>>>>>>>>>>>>>>>>>> ...[000010e0][00211eca][000010da] 50         push
>>>>>>>>>>>>>>>>>>> eax      //
>>>>>>>>>>>>>>>>>>> push P ...[000010e1][00211eca][000010da] 8b4d08     mov
>>>>>>>>>>>>>>>>>>> ecx,[ebp+08] ...[000010e4][00211ec6][000010da] 51 push
>>>>>>>>>>>>>>>>>>> ecx      // push P ...[000010e5][00211ec2][000010ea]
>>>>>>>>>>>>>>>>>>> e820feffff
>>>>>>>>>>>>>>>>>>> call 00000f0a // call H Infinitely Recursive
>>>>>>>>>>>>>>>>>>> Simulation Detected
>>>>>>>>>>>>>>>>>>> Simulation Stopped
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> *All technically competent software engineers* will
>>>>>>>>>>>>>>>>>>> see that
>>>>>>>>>>>>>>>>>>> when H bases its halt status decision on whether or
>>>>>>>>>>>>>>>>>>> not its
>>>>>>>>>>>>>>>>>>> complete and correct x86 emulation of its input would
>>>>>>>>>>>>>>>>>>> ever reach
>>>>>>>>>>>>>>>>>>> the "ret" instruction of this input that H is correct
>>>>>>>>>>>>>>>>>>> to reject
>>>>>>>>>>>>>>>>>>> this input.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> void Px(u32 x)
>>>>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>>>>>       H(x, x);
>>>>>>>>>>>>>>>>>>       return;
>>>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> int main()
>>>>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>>>>>       Output("Input_Halts = ", H((u32)Px, (u32)Px));
>>>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> ...[000013e8][00102357][00000000] 83c408          add
>>>>>>>>>>>>>>>>>> esp,+08
>>>>>>>>>>>>>>>>>> ...[000013eb][00102353][00000000] 50              push
>>>>>>>>>>>>>>>>>> eax
>>>>>>>>>>>>>>>>>> ...[000013ec][0010234f][00000427] 6827040000      push
>>>>>>>>>>>>>>>>>> 00000427
>>>>>>>>>>>>>>>>>> ---[000013f1][0010234f][00000427] e880f0ffff      call
>>>>>>>>>>>>>>>>>> 00000476
>>>>>>>>>>>>>>>>>> Input_Halts = 0
>>>>>>>>>>>>>>>>>> ...[000013f6][00102357][00000000] 83c408          add
>>>>>>>>>>>>>>>>>> esp,+08
>>>>>>>>>>>>>>>>>> ...[000013f9][00102357][00000000] 33c0            xor
>>>>>>>>>>>>>>>>>> eax,eax
>>>>>>>>>>>>>>>>>> ...[000013fb][0010235b][00100000] 5d              pop ebp
>>>>>>>>>>>>>>>>>> ...[000013fc][0010235f][00000004] c3              ret
>>>>>>>>>>>>>>>>>> Number of Instructions Executed(16120)
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> It gets the answer wrong, i.e. input has not been decided
>>>>>>>>>>>>>>>>>> correctly. QED.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> /Flibble
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> *All technically competent software engineers*
>>>>>>>>>>>>>>>> void Px(u32 x)
>>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>>>      H(x, x);
>>>>>>>>>>>>>>>>      return;
>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> int main()
>>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>>>      Output("Input_Halts = ", H((u32)Px, (u32)Px));
>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> ...[000013e8][00102357][00000000] 83c408          add
>>>>>>>>>>>>>>>> esp,+08
>>>>>>>>>>>>>>>> ...[000013eb][00102353][00000000] 50              push eax
>>>>>>>>>>>>>>>> ...[000013ec][0010234f][00000427] 6827040000      push
>>>>>>>>>>>>>>>> 00000427
>>>>>>>>>>>>>>>> ---[000013f1][0010234f][00000427] e880f0ffff      call
>>>>>>>>>>>>>>>> 00000476
>>>>>>>>>>>>>>>> Input_Halts = 0
>>>>>>>>>>>>>>>> ...[000013f6][00102357][00000000] 83c408          add
>>>>>>>>>>>>>>>> esp,+08
>>>>>>>>>>>>>>>> ...[000013f9][00102357][00000000] 33c0            xor
>>>>>>>>>>>>>>>> eax,eax
>>>>>>>>>>>>>>>> ...[000013fb][0010235b][00100000] 5d              pop ebp
>>>>>>>>>>>>>>>> ...[000013fc][0010235f][00000004] c3              ret
>>>>>>>>>>>>>>>> Number of Instructions Executed(16120)
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> It gets the answer wrong, i.e. input has not been
>>>>>>>>>>>>>>>> decided correctly.
>>>>>>>>>>>>>>>> QED.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> /Flibble
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> Because it is an easily verified fact that the correct
>>>>>>>>>>>>>>> and complete
>>>>>>>>>>>>>>> x86 emulation of the input to H(P,P) by H would never
>>>>>>>>>>>>>>> reach the "ret"
>>>>>>>>>>>>>>> instruction of P and this is the criterion measure for H
>>>>>>>>>>>>>>> to reject
>>>>>>>>>>>>>>> its input how do you figure that H gets the wrong answer?
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> What I am saying is a logical tautology the same as when
>>>>>>>>>>>>>>> we know that
>>>>>>>>>>>>>>> X is a black cat then we know that X is a cat.
>>>>>>>>>>>>>> We are talking about Px, not P. We are talking about your
>>>>>>>>>>>>>> H not
>>>>>>>>>>>>>> analysing what its input actually does and instead
>>>>>>>>>>>>>> assuming that an
>>>>>>>>>>>>>> input that calls H is always pathological.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> void Px(u32 x)
>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>     H(x, x);
>>>>>>>>>>>>>>     return;
>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> int main()
>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>     Output("Input_Halts = ", H((u32)Px, (u32)Px));
>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> ...[000013e8][00102357][00000000] 83c408          add esp,+08
>>>>>>>>>>>>>> ...[000013eb][00102353][00000000] 50              push eax
>>>>>>>>>>>>>> ...[000013ec][0010234f][00000427] 6827040000      push
>>>>>>>>>>>>>> 00000427
>>>>>>>>>>>>>> ---[000013f1][0010234f][00000427] e880f0ffff      call
>>>>>>>>>>>>>> 00000476
>>>>>>>>>>>>>> Input_Halts = 0
>>>>>>>>>>>>>> ...[000013f6][00102357][00000000] 83c408          add esp,+08
>>>>>>>>>>>>>> ...[000013f9][00102357][00000000] 33c0            xor eax,eax
>>>>>>>>>>>>>> ...[000013fb][0010235b][00100000] 5d              pop ebp
>>>>>>>>>>>>>> ...[000013fc][0010235f][00000004] c3              ret
>>>>>>>>>>>>>> Number of Instructions Executed(16120)
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> It gets the answer wrong, i.e. input has not been decided
>>>>>>>>>>>>>> correctly.
>>>>>>>>>>>>>> QED.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> /Flibble
>>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>> DO YOU AGREE WITH THIS?
>>>>>>>>>>>>> H(Px,Px) does correctly determine that the complete and
>>>>>>>>>>>>> correct x86 emulation of its input would never reach the
>>>>>>>>>>>>> "ret" instruction of Px.
>>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> That is only true if H never returns ANY answer (and thus
>>>>>>>>>>>> fails to be a decider).
>>>>>>>>>>> Competent software engineers will understand that when the
>>>>>>>>>>> behavior of Px matches this pattern that correct and complete
>>>>>>>>>>> x86 emulation of the input to H(Px,Px) by H would never reach
>>>>>>>>>>> the "ret" instruction of Px:
>>>>>>>>>>>
>>>>>>>>>>> H knows its own machine address and on this basis:
>>>>>>>>>>> (a) H recognizes that Px is calling H with the same arguments
>>>>>>>>>>> that H was called with.
>>>>>>>>>>> (b) There are no instructions in Px that could possibly
>>>>>>>>>>> escape this infinitely recursive emulation.
>>>>>>>>>>> (c) H aborts its emulation of Px before Px its call to H is
>>>>>>>>>>> invoked.
>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> Only if H never aborts. If H does abort, then Px(Px), whose
>>>>>>>>>> behavior exactly matches the CORRECT emulation of the input to
>>>>>>>>>> H(Px,Px) BY DEFINITION shows this.
>>>>>>>>>
>>>>>>>>> The question is: Would (future tense) the complete and correct
>>>>>>>>> x86 emulation of the input to H(Px,Px) by H ever reach the
>>>>>>>>> "ret" instruction of Px.
>>>>>>>>
>>>>>>>> What "Future Tense".
>>>>>>> A halt decider must always correctly determine whether or not its
>>>>>>> input WOULD halt. If halt deciders reported what the behavior of
>>>>>>> its input
>>>>>>> DOES then like you said it would never report on non halting inputs.
>>>>>>>
>>>>>>> All non-simulating halt deciders can only report on what their input
>>>>>>> WOULD do and not what their input DOES because non-simulating halt
>>>>>>> deciders are static rather than dynamic analyzers.
>>>>>>>
>>>>>>
>>>>>> Would only in the sense of condition of testing, not time.
>>>>> Halt deciders must always predict what their non-halting inputs
>>>>> would do in the future if they were executed.
>>>>
>>>> Why?
>>>>
>>>> There is no actual requirement to execute the machine, only know
>>>> what would happen if at some point we did do that execution either
>>>> in the past or the future.
>>>>
>>>>>
>>>>> They can never report on the non-halting behavior of what their
>>>>> inputs did do in the past.
>>>>
>>>> Why not?
>>>
>>> If they are simulating halt deciders they can
>>> never report on
>>> never report on
>>> never report on
>>> never report on
>>> never report on
>>>
>>> the non-halting behavior
>>> the non-halting behavior
>>> the non-halting behavior
>>> the non-halting behavior
>>> the non-halting behavior
>>>
>>> of what their inputs did do in the past
>>> of what their inputs did do in the past
>>> of what their inputs did do in the past
>>> of what their inputs did do in the past
>>> of what their inputs did do in the past
>>>
>>> Because as you have said 1000 times they would be
>>> stuck simulating this non-halting input forever.
>>>
>>> If they are not simulating halt deciders they can
>>> never report on
>>> never report on
>>> never report on
>>> never report on
>>> never report on
>>>
>>> the non-halting behavior
>>> the non-halting behavior
>>> the non-halting behavior
>>> the non-halting behavior
>>> the non-halting behavior
>>>
>>> Because they are not even examining behavior they are
>>> only static analyzers that do not look at dynamic behavior.
>>>
>>> Therefore halt deciders can never report on the non-halting behavior
>>> of what their inputs did do in the past.
>>>
>>> Therefore halt deciders can never report on the non-halting behavior
>>> of what their inputs did do in the past.
>>>
>>> Therefore halt deciders can never report on the non-halting behavior
>>> of what their inputs did do in the past.
>>>
>>> Therefore halt deciders can never report on the non-halting behavior
>>> of what their inputs did do in the past.
>>>
>>> Therefore halt deciders can never report on the non-halting behavior
>>> of what their inputs did do in the past.
>>>
>>>
>>
>> Regressing back to a two year old again I see.
>
> That I have to tell you the same thing hundreds and hundreds of times
> before you notice that I said it once is best handled by plonking you.

No, it says you don't know how to justify your possition, so you can't
get into actual clarification, so you revert to just making the same
wrong/misleading statements over and over.

I note, you don't bother answering any of my questions, either because
they are above your understanding, or answering them would require you
to admit to your errors.

You will note that I don't need to keep repeating my own statements over
and over, but just point to fundamental principles that are part of the
field.

If you want to disagree with one of these, say so, and show why that
basic principle doesn't apply here. Just remember, you don't get to
change the basic rules and still be working on the Halting Problem in
Computation Theory.

That means, the correct answer is based on, and ONLY based on, the
behavior of the actual machine in question. In this case, that is the
PROGRAM P with arguemnt P, built as per Linz that asks H what the
program P with argument P would do, and then does the opposite, would do.

Symboolically, H(M,x) accepts (returns 1) if M(x) returns in finite
time, and H(M,x) rejects (returns 0 in finite steps) if M(x) will never
return even after being run for an umbounded number of steps.

Doesn't matter if this doesn't match what you think is fair to ask, that
is the question that H needs to answer, and the Theory says that no such
decider is creatable. You claims that you can't ask the question just
would confirm that, if you can't ask the question, you can't get the
answer to that question you couldn't ask.

>
>>
>> Why can't H report on the behavior of what its input represents did in
>> the past?
>
>
>