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.

They can never report on the non-halting behavior of what their inputs
did do in the past.

You have been confused about this for your last 1000 messages.

--
Copyright 2022 Pete Olcott

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