void P(u32 x)
{ if (H(x, x))
HERE: goto HERE;
return;
}

int main()
{ P(P);
}

_P()
[000012e7](01) 55 push ebp
[000012e8](02) 8bec mov ebp,esp
[000012ea](03) 8b4508 mov eax,[ebp+08]
[000012ed](01) 50 push eax
[000012ee](03) 8b4d08 mov ecx,[ebp+08]
[000012f1](01) 51 push ecx
[000012f2](05) e880feffff call 00001177 // call H
[000012f7](03) 83c408 add esp,+08
[000012fa](02) 85c0 test eax,eax
[000012fc](02) 7402 jz 00001300
[000012fe](02) ebfe jmp 000012fe
[00001300](01) 5d pop ebp
[00001301](01) c3 ret
Size in bytes:(0027) [00001301]

_main()
[00001307](01) 55 push ebp
[00001308](02) 8bec mov ebp,esp
[0000130a](05) 68e7120000 push 000012e7 // push P
[0000130f](05) e8d3ffffff call 000012e7 // call P
[00001314](03) 83c404 add esp,+04
[00001317](02) 33c0 xor eax,eax
[00001319](01) 5d pop ebp
[0000131a](01) c3 ret
Size in bytes:(0020) [0000131a]

machine stack stack machine assembly
address address data code language
======== ======== ======== ========= =============
[00001307][00102190][00000000] 55 push ebp
[00001308][00102190][00000000] 8bec mov ebp,esp
[0000130a][0010218c][000012e7] 68e7120000 push 000012e7 // push P
[0000130f][00102188][00001314] e8d3ffffff call 000012e7 // call P
[000012e7][00102184][00102190] 55 push ebp // enter executed P
[000012e8][00102184][00102190] 8bec mov ebp,esp
[000012ea][00102184][00102190] 8b4508 mov eax,[ebp+08]
[000012ed][00102180][000012e7] 50 push eax // push P
[000012ee][00102180][000012e7] 8b4d08 mov ecx,[ebp+08]
[000012f1][0010217c][000012e7] 51 push ecx // push P
[000012f2][00102178][000012f7] e880feffff call 00001177 // call H

Begin Local Halt Decider Simulation Execution Trace Stored at:212244
[000012e7][00212230][00212234] 55 push ebp // enter emulated P
[000012e8][00212230][00212234] 8bec mov ebp,esp
[000012ea][00212230][00212234] 8b4508 mov eax,[ebp+08]
[000012ed][0021222c][000012e7] 50 push eax // push P
[000012ee][0021222c][000012e7] 8b4d08 mov ecx,[ebp+08]
[000012f1][00212228][000012e7] 51 push ecx // push P
[000012f2][00212224][000012f7] e880feffff call 00001177 // call H
[000012e7][0025cc58][0025cc5c] 55 push ebp // enter emulated P
[000012e8][0025cc58][0025cc5c] 8bec mov ebp,esp
[000012ea][0025cc58][0025cc5c] 8b4508 mov eax,[ebp+08]
[000012ed][0025cc54][000012e7] 50 push eax // push P
[000012ee][0025cc54][000012e7] 8b4d08 mov ecx,[ebp+08]
[000012f1][0025cc50][000012e7] 51 push ecx // push P
[000012f2][0025cc4c][000012f7] e880feffff call 00001177 // call H
Local Halt Decider: Infinite Recursion Detected Simulation Stopped

It is completely obvious that when H(P,P) correctly emulates its input
that it must emulate the first seven instructions of P. Because the
seventh instruction of P repeats this process we know with complete
certainty that the correct and complete emulation of P by H would never
reach its final “ret” instruction, thus never halts.

[000012f7][00102184][00102190] 83c408 add esp,+08
[000012fa][00102184][00102190] 85c0 test eax,eax
[000012fc][00102184][00102190] 7402 jz 00001300
[00001300][00102188][00001314] 5d pop ebp
[00001301][0010218c][000012e7] c3 ret // executed P halts
[00001314][00102190][00000000] 83c404 add esp,+04
[00001317][00102190][00000000] 33c0 xor eax,eax
[00001319][00102194][00100000] 5d pop ebp
[0000131a][00102198][00000000] c3 ret // main() halts
Number of Instructions Executed(15900)

On Thu, 9 Jun 2022 10:46:14 -0500
olcott <NoOne@NoWhere.com> wrote:

> void P(u32 x)
> {
> if (H(x, x))
> HERE: goto HERE;
> return;
> }
>
> int main()
> {
> P(P);
> }
>
> _P()
> [000012e7](01) 55 push ebp
> [000012e8](02) 8bec mov ebp,esp
> [000012ea](03) 8b4508 mov eax,[ebp+08]
> [000012ed](01) 50 push eax
> [000012ee](03) 8b4d08 mov ecx,[ebp+08]
> [000012f1](01) 51 push ecx
> [000012f2](05) e880feffff call 00001177 // call H
> [000012f7](03) 83c408 add esp,+08
> [000012fa](02) 85c0 test eax,eax
> [000012fc](02) 7402 jz 00001300
> [000012fe](02) ebfe jmp 000012fe
> [00001300](01) 5d pop ebp
> [00001301](01) c3 ret
> Size in bytes:(0027) [00001301]
>
> _main()
> [00001307](01) 55 push ebp
> [00001308](02) 8bec mov ebp,esp
> [0000130a](05) 68e7120000 push 000012e7 // push P
> [0000130f](05) e8d3ffffff call 000012e7 // call P
> [00001314](03) 83c404 add esp,+04
> [00001317](02) 33c0 xor eax,eax
> [00001319](01) 5d pop ebp
> [0000131a](01) c3 ret
> Size in bytes:(0020) [0000131a]
>
> machine stack stack machine assembly
> address address data code language
> ======== ======== ======== ========= ============> [00001307][00102190][00000000] 55 push ebp
> [00001308][00102190][00000000] 8bec mov ebp,esp
> [0000130a][0010218c][000012e7] 68e7120000 push 000012e7 // push P
> [0000130f][00102188][00001314] e8d3ffffff call 000012e7 // call P
> [000012e7][00102184][00102190] 55 push ebp // enter
> executed P [000012e8][00102184][00102190] 8bec mov ebp,esp
> [000012ea][00102184][00102190] 8b4508 mov eax,[ebp+08]
> [000012ed][00102180][000012e7] 50 push eax // push P
> [000012ee][00102180][000012e7] 8b4d08 mov ecx,[ebp+08]
> [000012f1][0010217c][000012e7] 51 push ecx // push P
> [000012f2][00102178][000012f7] e880feffff call 00001177 // call H
>
> Begin Local Halt Decider Simulation Execution Trace Stored at:212244
> [000012e7][00212230][00212234] 55 push ebp // enter
> emulated P [000012e8][00212230][00212234] 8bec mov ebp,esp
> [000012ea][00212230][00212234] 8b4508 mov eax,[ebp+08]
> [000012ed][0021222c][000012e7] 50 push eax // push P
> [000012ee][0021222c][000012e7] 8b4d08 mov ecx,[ebp+08]
> [000012f1][00212228][000012e7] 51 push ecx // push P
> [000012f2][00212224][000012f7] e880feffff call 00001177 // call H
> [000012e7][0025cc58][0025cc5c] 55 push ebp // enter
> emulated P [000012e8][0025cc58][0025cc5c] 8bec mov ebp,esp
> [000012ea][0025cc58][0025cc5c] 8b4508 mov eax,[ebp+08]
> [000012ed][0025cc54][000012e7] 50 push eax // push P
> [000012ee][0025cc54][000012e7] 8b4d08 mov ecx,[ebp+08]
> [000012f1][0025cc50][000012e7] 51 push ecx // push P
> [000012f2][0025cc4c][000012f7] e880feffff call 00001177 // call H
> Local Halt Decider: Infinite Recursion Detected Simulation Stopped
>
> It is completely obvious that when H(P,P) correctly emulates its
> input that it must emulate the first seven instructions of P. Because
> the seventh instruction of P repeats this process we know with
> complete certainty that the correct and complete emulation of P by H
> would never reach its final “ret” instruction, thus never halts.

Only because that is how your simulation detector, S (not H), works by
using an erroneous recursion. If P would have halted (i.e. when being
decided on by a proper halt decider with no recursion) then your S gets
the answer wrong so it is not a halt decider.

/Flibble

On 6/9/2022 12:06 PM, Mr Flibble wrote:
> On Thu, 9 Jun 2022 10:46:14 -0500
> olcott <NoOne@NoWhere.com> wrote:
>
>> void P(u32 x)
>> {
>> if (H(x, x))
>> HERE: goto HERE;
>> return;
>> }
>>
>> int main()
>> {
>> P(P);
>> }
>>
>> _P()
>> [000012e7](01) 55 push ebp
>> [000012e8](02) 8bec mov ebp,esp
>> [000012ea](03) 8b4508 mov eax,[ebp+08]
>> [000012ed](01) 50 push eax
>> [000012ee](03) 8b4d08 mov ecx,[ebp+08]
>> [000012f1](01) 51 push ecx
>> [000012f2](05) e880feffff call 00001177 // call H
>> [000012f7](03) 83c408 add esp,+08
>> [000012fa](02) 85c0 test eax,eax
>> [000012fc](02) 7402 jz 00001300
>> [000012fe](02) ebfe jmp 000012fe
>> [00001300](01) 5d pop ebp
>> [00001301](01) c3 ret
>> Size in bytes:(0027) [00001301]
>>
>> _main()
>> [00001307](01) 55 push ebp
>> [00001308](02) 8bec mov ebp,esp
>> [0000130a](05) 68e7120000 push 000012e7 // push P
>> [0000130f](05) e8d3ffffff call 000012e7 // call P
>> [00001314](03) 83c404 add esp,+04
>> [00001317](02) 33c0 xor eax,eax
>> [00001319](01) 5d pop ebp
>> [0000131a](01) c3 ret
>> Size in bytes:(0020) [0000131a]
>>
>> machine stack stack machine assembly
>> address address data code language
>> ======== ======== ======== ========= =============
>> [00001307][00102190][00000000] 55 push ebp
>> [00001308][00102190][00000000] 8bec mov ebp,esp
>> [0000130a][0010218c][000012e7] 68e7120000 push 000012e7 // push P
>> [0000130f][00102188][00001314] e8d3ffffff call 000012e7 // call P
>> [000012e7][00102184][00102190] 55 push ebp // enter
>> executed P [000012e8][00102184][00102190] 8bec mov ebp,esp
>> [000012ea][00102184][00102190] 8b4508 mov eax,[ebp+08]
>> [000012ed][00102180][000012e7] 50 push eax // push P
>> [000012ee][00102180][000012e7] 8b4d08 mov ecx,[ebp+08]
>> [000012f1][0010217c][000012e7] 51 push ecx // push P
>> [000012f2][00102178][000012f7] e880feffff call 00001177 // call H
>>
>> Begin Local Halt Decider Simulation Execution Trace Stored at:212244
>> [000012e7][00212230][00212234] 55 push ebp // enter
>> emulated P [000012e8][00212230][00212234] 8bec mov ebp,esp
>> [000012ea][00212230][00212234] 8b4508 mov eax,[ebp+08]
>> [000012ed][0021222c][000012e7] 50 push eax // push P
>> [000012ee][0021222c][000012e7] 8b4d08 mov ecx,[ebp+08]
>> [000012f1][00212228][000012e7] 51 push ecx // push P
>> [000012f2][00212224][000012f7] e880feffff call 00001177 // call H
>> [000012e7][0025cc58][0025cc5c] 55 push ebp // enter
>> emulated P [000012e8][0025cc58][0025cc5c] 8bec mov ebp,esp
>> [000012ea][0025cc58][0025cc5c] 8b4508 mov eax,[ebp+08]
>> [000012ed][0025cc54][000012e7] 50 push eax // push P
>> [000012ee][0025cc54][000012e7] 8b4d08 mov ecx,[ebp+08]
>> [000012f1][0025cc50][000012e7] 51 push ecx // push P
>> [000012f2][0025cc4c][000012f7] e880feffff call 00001177 // call H
>> Local Halt Decider: Infinite Recursion Detected Simulation Stopped
>>
>> It is completely obvious that when H(P,P) correctly emulates its
>> input that it must emulate the first seven instructions of P. Because
>> the seventh instruction of P repeats this process we know with
>> complete certainty that the correct and complete emulation of P by H
>> would never reach its final “ret” instruction, thus never halts.
>
> Only because that is how your simulation detector, S (not H), works by
> using an erroneous recursion.

In other words you are stupidly saying that when a correct x86 emulation
of the input to H(P,P) reaches the machine address of P [000012f2] where
the machine code specifies that P must call H(P,P) the correct emulation
of P would do something else besides what the x86 machine code at
address [000012f2] specifies.

> If P would have halted (i.e. when being
> decided on by a proper halt decider with no recursion) then your S gets
> the answer wrong so it is not a halt decider.
>
> /Flibble
>

--
Copyright 2022 Pete Olcott

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

On 6/9/22 13:32, olcott wrote:
> On 6/9/2022 12:06 PM, Mr Flibble wrote:
>> On Thu, 9 Jun 2022 10:46:14 -0500
>> olcott <NoOne@NoWhere.com> wrote:
>>
>>> void P(u32 x)
>>> {
>>>     if (H(x, x))
>>>       HERE: goto HERE;
>>>     return;
>>> }
>>>
>>> int main()
>>> {
>>>     P(P);
>>> }
>>>
>>> _P()
>>> [000012e7](01)  55              push ebp
>>> [000012e8](02)  8bec            mov ebp,esp
>>> [000012ea](03)  8b4508          mov eax,[ebp+08]
>>> [000012ed](01)  50              push eax
>>> [000012ee](03)  8b4d08          mov ecx,[ebp+08]
>>> [000012f1](01)  51              push ecx
>>> [000012f2](05)  e880feffff      call 00001177 // call H
>>> [000012f7](03)  83c408          add esp,+08
>>> [000012fa](02)  85c0            test eax,eax
>>> [000012fc](02)  7402            jz 00001300
>>> [000012fe](02)  ebfe            jmp 000012fe
>>> [00001300](01)  5d              pop ebp
>>> [00001301](01)  c3              ret
>>> Size in bytes:(0027) [00001301]
>>>
>>> _main()
>>> [00001307](01)  55              push ebp
>>> [00001308](02)  8bec            mov ebp,esp
>>> [0000130a](05)  68e7120000      push 000012e7 // push P
>>> [0000130f](05)  e8d3ffffff      call 000012e7 // call P
>>> [00001314](03)  83c404          add esp,+04
>>> [00001317](02)  33c0            xor eax,eax
>>> [00001319](01)  5d              pop ebp
>>> [0000131a](01)  c3              ret
>>> Size in bytes:(0020) [0000131a]
>>>
>>>    machine   stack     stack     machine    assembly
>>>    address   address   data      code       language
>>>    ========  ========  ========  =========  =============
>>> [00001307][00102190][00000000] 55         push ebp
>>> [00001308][00102190][00000000] 8bec       mov ebp,esp
>>> [0000130a][0010218c][000012e7] 68e7120000 push 000012e7 // push P
>>> [0000130f][00102188][00001314] e8d3ffffff call 000012e7 // call P
>>> [000012e7][00102184][00102190] 55         push ebp      // enter
>>> executed P [000012e8][00102184][00102190] 8bec       mov ebp,esp
>>> [000012ea][00102184][00102190] 8b4508     mov eax,[ebp+08]
>>> [000012ed][00102180][000012e7] 50         push eax      // push P
>>> [000012ee][00102180][000012e7] 8b4d08     mov ecx,[ebp+08]
>>> [000012f1][0010217c][000012e7] 51         push ecx      // push P
>>> [000012f2][00102178][000012f7] e880feffff call 00001177 // call H
>>>
>>> Begin Local Halt Decider Simulation   Execution Trace Stored at:212244
>>> [000012e7][00212230][00212234] 55          push ebp      // enter
>>> emulated P [000012e8][00212230][00212234] 8bec        mov ebp,esp
>>> [000012ea][00212230][00212234] 8b4508      mov eax,[ebp+08]
>>> [000012ed][0021222c][000012e7] 50          push eax      // push P
>>> [000012ee][0021222c][000012e7] 8b4d08      mov ecx,[ebp+08]
>>> [000012f1][00212228][000012e7] 51          push ecx      // push P
>>> [000012f2][00212224][000012f7] e880feffff  call 00001177 // call H
>>> [000012e7][0025cc58][0025cc5c] 55          push ebp      // enter
>>> emulated P [000012e8][0025cc58][0025cc5c] 8bec        mov ebp,esp
>>> [000012ea][0025cc58][0025cc5c] 8b4508      mov eax,[ebp+08]
>>> [000012ed][0025cc54][000012e7] 50          push eax      // push P
>>> [000012ee][0025cc54][000012e7] 8b4d08      mov ecx,[ebp+08]
>>> [000012f1][0025cc50][000012e7] 51          push ecx      // push P
>>> [000012f2][0025cc4c][000012f7] e880feffff  call 00001177 // call H
>>> Local Halt Decider: Infinite Recursion Detected Simulation Stopped
>>>
>>> It is completely obvious that when H(P,P) correctly emulates its
>>> input that it must emulate the first seven instructions of P. Because
>>> the seventh instruction of P repeats this process we know with
>>> complete certainty that the correct and complete emulation of P by H
>>> would never reach its final “ret” instruction, thus never halts.
>>
>> Only because that is how your simulation detector, S (not H), works by
>> using an erroneous recursion.
>
> In other words you are stupidly saying that when a correct x86 emulation
> of the input to H(P,P) reaches the machine address of P [000012f2] where
> the machine code specifies that P must call H(P,P) the correct emulation
> of P would do something else besides what the x86 machine code at
> address [000012f2] specifies.
>
>> If P would have halted (i.e. when being
>> decided on by a proper halt decider with no recursion) then your S gets
>> the answer wrong so it is not a halt decider.
>>
>> /Flibble
>>
>
>
Constantly insulting those who disagree with you make you look stupid,
not then.

On 6/9/2022 1:58 PM, rthiebaud wrote:
> On 6/9/22 13:32, olcott wrote:
>> On 6/9/2022 12:06 PM, Mr Flibble wrote:
>>> On Thu, 9 Jun 2022 10:46:14 -0500
>>> olcott <NoOne@NoWhere.com> wrote:
>>>
>>>> void P(u32 x)
>>>> {
>>>>     if (H(x, x))
>>>>       HERE: goto HERE;
>>>>     return;
>>>> }
>>>>
>>>> int main()
>>>> {
>>>>     P(P);
>>>> }
>>>>
>>>> _P()
>>>> [000012e7](01)  55              push ebp
>>>> [000012e8](02)  8bec            mov ebp,esp
>>>> [000012ea](03)  8b4508          mov eax,[ebp+08]
>>>> [000012ed](01)  50              push eax
>>>> [000012ee](03)  8b4d08          mov ecx,[ebp+08]
>>>> [000012f1](01)  51              push ecx
>>>> [000012f2](05)  e880feffff      call 00001177 // call H
>>>> [000012f7](03)  83c408          add esp,+08
>>>> [000012fa](02)  85c0            test eax,eax
>>>> [000012fc](02)  7402            jz 00001300
>>>> [000012fe](02)  ebfe            jmp 000012fe
>>>> [00001300](01)  5d              pop ebp
>>>> [00001301](01)  c3              ret
>>>> Size in bytes:(0027) [00001301]
>>>>
>>>> _main()
>>>> [00001307](01)  55              push ebp
>>>> [00001308](02)  8bec            mov ebp,esp
>>>> [0000130a](05)  68e7120000      push 000012e7 // push P
>>>> [0000130f](05)  e8d3ffffff      call 000012e7 // call P
>>>> [00001314](03)  83c404          add esp,+04
>>>> [00001317](02)  33c0            xor eax,eax
>>>> [00001319](01)  5d              pop ebp
>>>> [0000131a](01)  c3              ret
>>>> Size in bytes:(0020) [0000131a]
>>>>
>>>>    machine   stack     stack     machine    assembly
>>>>    address   address   data      code       language
>>>>    ========  ========  ========  =========  =============
>>>> [00001307][00102190][00000000] 55         push ebp
>>>> [00001308][00102190][00000000] 8bec       mov ebp,esp
>>>> [0000130a][0010218c][000012e7] 68e7120000 push 000012e7 // push P
>>>> [0000130f][00102188][00001314] e8d3ffffff call 000012e7 // call P
>>>> [000012e7][00102184][00102190] 55         push ebp      // enter
>>>> executed P [000012e8][00102184][00102190] 8bec       mov ebp,esp
>>>> [000012ea][00102184][00102190] 8b4508     mov eax,[ebp+08]
>>>> [000012ed][00102180][000012e7] 50         push eax      // push P
>>>> [000012ee][00102180][000012e7] 8b4d08     mov ecx,[ebp+08]
>>>> [000012f1][0010217c][000012e7] 51         push ecx      // push P
>>>> [000012f2][00102178][000012f7] e880feffff call 00001177 // call H
>>>>
>>>> Begin Local Halt Decider Simulation   Execution Trace Stored at:212244
>>>> [000012e7][00212230][00212234] 55          push ebp      // enter
>>>> emulated P [000012e8][00212230][00212234] 8bec        mov ebp,esp
>>>> [000012ea][00212230][00212234] 8b4508      mov eax,[ebp+08]
>>>> [000012ed][0021222c][000012e7] 50          push eax      // push P
>>>> [000012ee][0021222c][000012e7] 8b4d08      mov ecx,[ebp+08]
>>>> [000012f1][00212228][000012e7] 51          push ecx      // push P
>>>> [000012f2][00212224][000012f7] e880feffff  call 00001177 // call H
>>>> [000012e7][0025cc58][0025cc5c] 55          push ebp      // enter
>>>> emulated P [000012e8][0025cc58][0025cc5c] 8bec        mov ebp,esp
>>>> [000012ea][0025cc58][0025cc5c] 8b4508      mov eax,[ebp+08]
>>>> [000012ed][0025cc54][000012e7] 50          push eax      // push P
>>>> [000012ee][0025cc54][000012e7] 8b4d08      mov ecx,[ebp+08]
>>>> [000012f1][0025cc50][000012e7] 51          push ecx      // push P
>>>> [000012f2][0025cc4c][000012f7] e880feffff  call 00001177 // call H
>>>> Local Halt Decider: Infinite Recursion Detected Simulation Stopped
>>>>
>>>> It is completely obvious that when H(P,P) correctly emulates its
>>>> input that it must emulate the first seven instructions of P. Because
>>>> the seventh instruction of P repeats this process we know with
>>>> complete certainty that the correct and complete emulation of P by H
>>>> would never reach its final “ret” instruction, thus never halts.
>>>
>>> Only because that is how your simulation detector, S (not H), works by
>>> using an erroneous recursion.
>>
>> In other words you are stupidly saying that when a correct x86
>> emulation of the input to H(P,P) reaches the machine address of P
>> [000012f2] where the machine code specifies that P must call H(P,P)
>> the correct emulation of P would do something else besides what the
>> x86 machine code at address [000012f2] specifies.
>>
>>> If P would have halted (i.e. when being
>>> decided on by a proper halt decider with no recursion) then your S gets
>>> the answer wrong so it is not a halt decider.
>>>
>>> /Flibble
>>>
>>
>>
> Constantly insulting those who disagree with you make you look stupid,
> not then.

I have been through this exact same material many hundreds of times with
them and they just don't get it. I am proven to be correct on the basis
of verified facts that are simply beyond their intellectual capacity.

Before I started calling them stupid casual onlookers could far too
easily guess that they are correct and I am incorrect.

Instead of calling them stupid I could say that every competent software
engineer would agree that I am correct and they are incorrect. The
problem with this is that they simply presume that they are competent so
I had to use words that much more sharply draw the distinction.

--
Copyright 2022 Pete Olcott

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

olcott <NoOne@NoWhere.com> wrote:

> Before I started calling them stupid casual onlookers could far too
> easily guess that they are correct and I am incorrect.

It's good that you started calling them stupid, now casual onlookers no
longer have doubts that they are correct and you are incorrect.

--
/* * * Otto J. Makela <om@iki.fi> * * * * * * * * * */
/* Phone: +358 40 765 5772, ICBM: N 60 10' E 24 55' */
/* Mail: Mechelininkatu 26 B 27, FI-00100 Helsinki */
/* * * Computers Rule 01001111 01001011 * * * * * * */

On 6/10/2022 10:07 AM, Otto J. Makela wrote:
> olcott <NoOne@NoWhere.com> wrote:
>
>> Before I started calling them stupid casual onlookers could far too
>> easily guess that they are correct and I am incorrect.
>
> It's good that you started calling them stupid, now casual onlookers no
> longer have doubts that they are correct and you are incorrect.
>

Sure eveyone knows that a wild guess on the basis of credibility
supersedes and overrides the verified facts.

--
Copyright 2022 Pete Olcott

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

On 09.06.22 21:35, olcott wrote:
> On 6/9/2022 1:58 PM, rthiebaud wrote:
>> On 6/9/22 13:32, olcott wrote:
>>> On 6/9/2022 12:06 PM, Mr Flibble wrote:
>>>> On Thu, 9 Jun 2022 10:46:14 -0500
>>>> olcott <NoOne@NoWhere.com> wrote:
>>>>
>>>>> void P(u32 x)
>>>>> {
>>>>>     if (H(x, x))
>>>>>       HERE: goto HERE;
>>>>>     return;
>>>>> }
>>>>>
>>>>> int main()
>>>>> {
>>>>>     P(P);
>>>>> }
>>>>>
>>>>> _P()
>>>>> [000012e7](01)  55              push ebp
>>>>> [000012e8](02)  8bec            mov ebp,esp
>>>>> [000012ea](03)  8b4508          mov eax,[ebp+08]
>>>>> [000012ed](01)  50              push eax
>>>>> [000012ee](03)  8b4d08          mov ecx,[ebp+08]
>>>>> [000012f1](01)  51              push ecx
>>>>> [000012f2](05)  e880feffff      call 00001177 // call H
>>>>> [000012f7](03)  83c408          add esp,+08
>>>>> [000012fa](02)  85c0            test eax,eax
>>>>> [000012fc](02)  7402            jz 00001300
>>>>> [000012fe](02)  ebfe            jmp 000012fe
>>>>> [00001300](01)  5d              pop ebp
>>>>> [00001301](01)  c3              ret
>>>>> Size in bytes:(0027) [00001301]
>>>>>
>>>>> _main()
>>>>> [00001307](01)  55              push ebp
>>>>> [00001308](02)  8bec            mov ebp,esp
>>>>> [0000130a](05)  68e7120000      push 000012e7 // push P
>>>>> [0000130f](05)  e8d3ffffff      call 000012e7 // call P
>>>>> [00001314](03)  83c404          add esp,+04
>>>>> [00001317](02)  33c0            xor eax,eax
>>>>> [00001319](01)  5d              pop ebp
>>>>> [0000131a](01)  c3              ret
>>>>> Size in bytes:(0020) [0000131a]
>>>>>
>>>>>    machine   stack     stack     machine    assembly
>>>>>    address   address   data      code       language
>>>>>    ========  ========  ========  =========  =============
>>>>> [00001307][00102190][00000000] 55         push ebp
>>>>> [00001308][00102190][00000000] 8bec       mov ebp,esp
>>>>> [0000130a][0010218c][000012e7] 68e7120000 push 000012e7 // push P
>>>>> [0000130f][00102188][00001314] e8d3ffffff call 000012e7 // call P
>>>>> [000012e7][00102184][00102190] 55         push ebp      // enter
>>>>> executed P [000012e8][00102184][00102190] 8bec       mov ebp,esp
>>>>> [000012ea][00102184][00102190] 8b4508     mov eax,[ebp+08]
>>>>> [000012ed][00102180][000012e7] 50         push eax      // push P
>>>>> [000012ee][00102180][000012e7] 8b4d08     mov ecx,[ebp+08]
>>>>> [000012f1][0010217c][000012e7] 51         push ecx      // push P
>>>>> [000012f2][00102178][000012f7] e880feffff call 00001177 // call H
>>>>>
>>>>> Begin Local Halt Decider Simulation   Execution Trace Stored at:212244
>>>>> [000012e7][00212230][00212234] 55          push ebp      // enter
>>>>> emulated P [000012e8][00212230][00212234] 8bec        mov ebp,esp
>>>>> [000012ea][00212230][00212234] 8b4508      mov eax,[ebp+08]
>>>>> [000012ed][0021222c][000012e7] 50          push eax      // push P
>>>>> [000012ee][0021222c][000012e7] 8b4d08      mov ecx,[ebp+08]
>>>>> [000012f1][00212228][000012e7] 51          push ecx      // push P
>>>>> [000012f2][00212224][000012f7] e880feffff  call 00001177 // call H
>>>>> [000012e7][0025cc58][0025cc5c] 55          push ebp      // enter
>>>>> emulated P [000012e8][0025cc58][0025cc5c] 8bec        mov ebp,esp
>>>>> [000012ea][0025cc58][0025cc5c] 8b4508      mov eax,[ebp+08]
>>>>> [000012ed][0025cc54][000012e7] 50          push eax      // push P
>>>>> [000012ee][0025cc54][000012e7] 8b4d08      mov ecx,[ebp+08]
>>>>> [000012f1][0025cc50][000012e7] 51          push ecx      // push P
>>>>> [000012f2][0025cc4c][000012f7] e880feffff  call 00001177 // call H
>>>>> Local Halt Decider: Infinite Recursion Detected Simulation Stopped
>>>>>
>>>>> It is completely obvious that when H(P,P) correctly emulates its
>>>>> input that it must emulate the first seven instructions of P. Because
>>>>> the seventh instruction of P repeats this process we know with
>>>>> complete certainty that the correct and complete emulation of P by H
>>>>> would never reach its final “ret” instruction, thus never halts.
>>>>
>>>> Only because that is how your simulation detector, S (not H), works by
>>>> using an erroneous recursion.
>>>
>>> In other words you are stupidly saying that when a correct x86
>>> emulation of the input to H(P,P) reaches the machine address of P
>>> [000012f2] where the machine code specifies that P must call H(P,P)
>>> the correct emulation of P would do something else besides what the
>>> x86 machine code at address [000012f2] specifies.
>>>
>>>> If P would have halted (i.e. when being
>>>> decided on by a proper halt decider with no recursion) then your S gets
>>>> the answer wrong so it is not a halt decider.
>>>>
>>>> /Flibble
>>>>
>>>
>>>
>> Constantly insulting those who disagree with you make you look stupid,
>> not then.
>
> I have been through this exact same material many hundreds of times with
> them and they just don't get it. I am proven to be correct on the basis
> of verified facts that are simply beyond their intellectual capacity.
>
If you have been proven to be correct, why do you keep trying to
convince them that they are wrong? Repeating thousands of times that you
are right and they are wrong will not make you any righter or them any
more wrong. Do you want to make the world a better place? I'm afraid
that is a lost battle.

> Before I started calling them stupid casual onlookers could far too
> easily guess that they are correct and I am incorrect.
>
> Instead of calling them stupid I could say that every competent software
> engineer would agree that I am correct and they are incorrect. The
> problem with this is that they simply presume that they are competent so
> I had to use words that much more sharply draw the distinction.
>
>
>
>
>

On 6/10/2022 11:17 PM, Freethinker wrote:
> On 09.06.22 21:35, olcott wrote:
>> On 6/9/2022 1:58 PM, rthiebaud wrote:
>>> On 6/9/22 13:32, olcott wrote:
>>>> On 6/9/2022 12:06 PM, Mr Flibble wrote:
>>>>> On Thu, 9 Jun 2022 10:46:14 -0500
>>>>> olcott <NoOne@NoWhere.com> wrote:
>>>>>
>>>>>> void P(u32 x)
>>>>>> {
>>>>>>     if (H(x, x))
>>>>>>       HERE: goto HERE;
>>>>>>     return;
>>>>>> }
>>>>>>
>>>>>> int main()
>>>>>> {
>>>>>>     P(P);
>>>>>> }
>>>>>>
>>>>>> _P()
>>>>>> [000012e7](01)  55              push ebp
>>>>>> [000012e8](02)  8bec            mov ebp,esp
>>>>>> [000012ea](03)  8b4508          mov eax,[ebp+08]
>>>>>> [000012ed](01)  50              push eax
>>>>>> [000012ee](03)  8b4d08          mov ecx,[ebp+08]
>>>>>> [000012f1](01)  51              push ecx
>>>>>> [000012f2](05)  e880feffff      call 00001177 // call H
>>>>>> [000012f7](03)  83c408          add esp,+08
>>>>>> [000012fa](02)  85c0            test eax,eax
>>>>>> [000012fc](02)  7402            jz 00001300
>>>>>> [000012fe](02)  ebfe            jmp 000012fe
>>>>>> [00001300](01)  5d              pop ebp
>>>>>> [00001301](01)  c3              ret
>>>>>> Size in bytes:(0027) [00001301]
>>>>>>
>>>>>> _main()
>>>>>> [00001307](01)  55              push ebp
>>>>>> [00001308](02)  8bec            mov ebp,esp
>>>>>> [0000130a](05)  68e7120000      push 000012e7 // push P
>>>>>> [0000130f](05)  e8d3ffffff      call 000012e7 // call P
>>>>>> [00001314](03)  83c404          add esp,+04
>>>>>> [00001317](02)  33c0            xor eax,eax
>>>>>> [00001319](01)  5d              pop ebp
>>>>>> [0000131a](01)  c3              ret
>>>>>> Size in bytes:(0020) [0000131a]
>>>>>>
>>>>>>    machine   stack     stack     machine    assembly
>>>>>>    address   address   data      code       language
>>>>>>    ========  ========  ========  =========  =============
>>>>>> [00001307][00102190][00000000] 55         push ebp
>>>>>> [00001308][00102190][00000000] 8bec       mov ebp,esp
>>>>>> [0000130a][0010218c][000012e7] 68e7120000 push 000012e7 // push P
>>>>>> [0000130f][00102188][00001314] e8d3ffffff call 000012e7 // call P
>>>>>> [000012e7][00102184][00102190] 55         push ebp      // enter
>>>>>> executed P [000012e8][00102184][00102190] 8bec       mov ebp,esp
>>>>>> [000012ea][00102184][00102190] 8b4508     mov eax,[ebp+08]
>>>>>> [000012ed][00102180][000012e7] 50         push eax      // push P
>>>>>> [000012ee][00102180][000012e7] 8b4d08     mov ecx,[ebp+08]
>>>>>> [000012f1][0010217c][000012e7] 51         push ecx      // push P
>>>>>> [000012f2][00102178][000012f7] e880feffff call 00001177 // call H
>>>>>>
>>>>>> Begin Local Halt Decider Simulation   Execution Trace Stored
>>>>>> at:212244
>>>>>> [000012e7][00212230][00212234] 55          push ebp      // enter
>>>>>> emulated P [000012e8][00212230][00212234] 8bec        mov ebp,esp
>>>>>> [000012ea][00212230][00212234] 8b4508      mov eax,[ebp+08]
>>>>>> [000012ed][0021222c][000012e7] 50          push eax      // push P
>>>>>> [000012ee][0021222c][000012e7] 8b4d08      mov ecx,[ebp+08]
>>>>>> [000012f1][00212228][000012e7] 51          push ecx      // push P
>>>>>> [000012f2][00212224][000012f7] e880feffff  call 00001177 // call H
>>>>>> [000012e7][0025cc58][0025cc5c] 55          push ebp      // enter
>>>>>> emulated P [000012e8][0025cc58][0025cc5c] 8bec        mov ebp,esp
>>>>>> [000012ea][0025cc58][0025cc5c] 8b4508      mov eax,[ebp+08]
>>>>>> [000012ed][0025cc54][000012e7] 50          push eax      // push P
>>>>>> [000012ee][0025cc54][000012e7] 8b4d08      mov ecx,[ebp+08]
>>>>>> [000012f1][0025cc50][000012e7] 51          push ecx      // push P
>>>>>> [000012f2][0025cc4c][000012f7] e880feffff  call 00001177 // call H
>>>>>> Local Halt Decider: Infinite Recursion Detected Simulation Stopped
>>>>>>
>>>>>> It is completely obvious that when H(P,P) correctly emulates its
>>>>>> input that it must emulate the first seven instructions of P. Because
>>>>>> the seventh instruction of P repeats this process we know with
>>>>>> complete certainty that the correct and complete emulation of P by H
>>>>>> would never reach its final “ret” instruction, thus never halts.
>>>>>
>>>>> Only because that is how your simulation detector, S (not H), works by
>>>>> using an erroneous recursion.
>>>>
>>>> In other words you are stupidly saying that when a correct x86
>>>> emulation of the input to H(P,P) reaches the machine address of P
>>>> [000012f2] where the machine code specifies that P must call H(P,P)
>>>> the correct emulation of P would do something else besides what the
>>>> x86 machine code at address [000012f2] specifies.
>>>>
>>>>> If P would have halted (i.e. when being
>>>>> decided on by a proper halt decider with no recursion) then your S
>>>>> gets
>>>>> the answer wrong so it is not a halt decider.
>>>>>
>>>>> /Flibble
>>>>>
>>>>
>>>>
>>> Constantly insulting those who disagree with you make you look
>>> stupid, not then.
>>
>> I have been through this exact same material many hundreds of times
>> with them and they just don't get it. I am proven to be correct on the
>> basis of verified facts that are simply beyond their intellectual
>> capacity.
>>
> If you have been proven to be correct, why do you keep trying to
> convince them that they are wrong? Repeating thousands of times that you
> are right and they are wrong will not make you any righter or them any
> more wrong. Do you want to make the world a better place? I'm afraid
> that is a lost battle.
>

The issue is that verified facts prove that I am correct yet my
reviewers consistently disagree with easily verified facts.

I need honest and competent reviewer here to verify the software
engineering of my claims. My prior reviewers are either dishonest or
incompetent.

>> Before I started calling them stupid casual onlookers could far too
>> easily guess that they are correct and I am incorrect.
>>
>> Instead of calling them stupid I could say that every competent
>> software engineer would agree that I am correct and they are
>> incorrect. The problem with this is that they simply presume that they
>> are competent so I had to use words that much more sharply draw the
>> distinction.
>>
>>
>>
>>
>>
>

--
Copyright 2022 Pete Olcott

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

On 6/11/22 10:04 AM, olcott wrote:
>>
>
> The issue is that verified facts prove that I am correct yet my
> reviewers consistently disagree with easily verified facts.
>
> I need honest and competent reviewer here to verify the software
> engineering of my claims. My prior reviewers are either dishonest or
> incompetent.

No, you need to honest with yourself.

"Verified" normally means by an independent source, not yourself. "Self
Verification" isn't really verification. Your claims have NEVER be
"verified", and in fact, you refuse to provide the means to let someone
actualy verify them since the key is the software you claim to have
writen, but won't let anyone else see.

Your claimed "proofs" are full of holes, and when people point them out
you just "cover your ears" and go "Blah-Blah-Blah I can't hear you".

This doesn't make the flaws go away, just proves that you don't care
about truth.

Your whole argument is based on flawed logic and false definitions, but
you refuse to look at them.

On 6/11/2022 11:07 AM, Richard Damon wrote:
> On 6/11/22 10:04 AM, olcott wrote:
>>>
>>
>> The issue is that verified facts prove that I am correct yet my
>> reviewers consistently disagree with easily verified facts.
>>
>> I need honest and competent reviewer here to verify the software
>> engineering of my claims. My prior reviewers are either dishonest or
>> incompetent.
>
> No, you need to honest with yourself.
>
> "Verified" normally means by an independent source, not yourself.

When dealing with objectively verifiable facts and not subjective
judgement calls validation is axiomatic.

The x86 language is a formal mathematical language in that the semantics
specified by programs written in this language have zero ambiguity or
leeway for different subjective interpretation of their meaning.

When I say that this specifies and infinite loop anyone that disagrees
simply objectively incorrect.

_Infinite_Loop()
[00001316](01) 55 push ebp
[00001317](02) 8bec mov ebp,esp
[00001319](02) ebfe jmp 00001319
[0000131b](01) 5d pop ebp
[0000131c](01) c3 ret
Size in bytes:(0007) [0000131c]

All recent rebuttals of my work have taken the form of disagreeing with
the x86 language.

--
Copyright 2022 Pete Olcott

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

On Sat, 11 Jun 2022 12:06:44 -0500
olcott <NoOne@NoWhere.com> wrote:

> On 6/11/2022 11:07 AM, Richard Damon wrote:
> > On 6/11/22 10:04 AM, olcott wrote:
> >>>
> >>
> >> The issue is that verified facts prove that I am correct yet my
> >> reviewers consistently disagree with easily verified facts.
> >>
> >> I need honest and competent reviewer here to verify the software
> >> engineering of my claims. My prior reviewers are either dishonest
> >> or incompetent.
> >
> > No, you need to honest with yourself.
> >
> > "Verified" normally means by an independent source, not yourself.
>
> When dealing with objectively verifiable facts and not subjective
> judgement calls validation is axiomatic.
>
> The x86 language is a formal mathematical language in that the
> semantics specified by programs written in this language have zero
> ambiguity or leeway for different subjective interpretation of their
> meaning.
>
> When I say that this specifies and infinite loop anyone that
> disagrees simply objectively incorrect.
>
> _Infinite_Loop()
> [00001316](01) 55 push ebp
> [00001317](02) 8bec mov ebp,esp
> [00001319](02) ebfe jmp 00001319
> [0000131b](01) 5d pop ebp
> [0000131c](01) c3 ret
> Size in bytes:(0007) [0000131c]
>
> All recent rebuttals of my work have taken the form of disagreeing
> with the x86 language.
But you assert the infinite loop is unreachable in P so what is
the point of posting its disassembly here?

/Flibble

Il 09/06/2022 17:46, olcott ha scritto:
> void P(u32 x)
> {
>   if (H(x, x))
>     HERE: goto HERE;
>   return;
> }
>
> int main()
> {
>   P(P);
> }
>
> _P()
> [000012e7](01)  55              push ebp
> [000012e8](02)  8bec            mov ebp,esp
> [000012ea](03)  8b4508          mov eax,[ebp+08]
> [000012ed](01)  50              push eax
> [000012ee](03)  8b4d08          mov ecx,[ebp+08]
> [000012f1](01)  51              push ecx
> [000012f2](05)  e880feffff      call 00001177 // call H
> [000012f7](03)  83c408          add esp,+08
> [000012fa](02)  85c0            test eax,eax
> [000012fc](02)  7402            jz 00001300
> [000012fe](02)  ebfe            jmp 000012fe
> [00001300](01)  5d              pop ebp
> [00001301](01)  c3              ret
> Size in bytes:(0027) [00001301]
>
> _main()
> [00001307](01)  55              push ebp
> [00001308](02)  8bec            mov ebp,esp
> [0000130a](05)  68e7120000      push 000012e7 // push P
> [0000130f](05)  e8d3ffffff      call 000012e7 // call P
> [00001314](03)  83c404          add esp,+04
> [00001317](02)  33c0            xor eax,eax
> [00001319](01)  5d              pop ebp
> [0000131a](01)  c3              ret
> Size in bytes:(0020) [0000131a]
>
>  machine   stack     stack     machine    assembly
>  address   address   data      code       language
>  ========  ========  ========  =========  =============
> [00001307][00102190][00000000] 55         push ebp
> [00001308][00102190][00000000] 8bec       mov ebp,esp
> [0000130a][0010218c][000012e7] 68e7120000 push 000012e7 // push P
> [0000130f][00102188][00001314] e8d3ffffff call 000012e7 // call P
> [000012e7][00102184][00102190] 55         push ebp      // enter executed P
> [000012e8][00102184][00102190] 8bec       mov ebp,esp
> [000012ea][00102184][00102190] 8b4508     mov eax,[ebp+08]
> [000012ed][00102180][000012e7] 50         push eax      // push P
> [000012ee][00102180][000012e7] 8b4d08     mov ecx,[ebp+08]
> [000012f1][0010217c][000012e7] 51         push ecx      // push P
> [000012f2][00102178][000012f7] e880feffff call 00001177 // call H
>
> Begin Local Halt Decider Simulation   Execution Trace Stored at:212244
> [000012e7][00212230][00212234] 55          push ebp      // enter
> emulated P
> [000012e8][00212230][00212234] 8bec        mov ebp,esp
> [000012ea][00212230][00212234] 8b4508      mov eax,[ebp+08]
> [000012ed][0021222c][000012e7] 50          push eax      // push P
> [000012ee][0021222c][000012e7] 8b4d08      mov ecx,[ebp+08]
> [000012f1][00212228][000012e7] 51          push ecx      // push P
> [000012f2][00212224][000012f7] e880feffff  call 00001177 // call H
> [000012e7][0025cc58][0025cc5c] 55          push ebp      // enter
> emulated P
> [000012e8][0025cc58][0025cc5c] 8bec        mov ebp,esp
> [000012ea][0025cc58][0025cc5c] 8b4508      mov eax,[ebp+08]
> [000012ed][0025cc54][000012e7] 50          push eax      // push P
> [000012ee][0025cc54][000012e7] 8b4d08      mov ecx,[ebp+08]
> [000012f1][0025cc50][000012e7] 51          push ecx      // push P
> [000012f2][0025cc4c][000012f7] e880feffff  call 00001177 // call H
> Local Halt Decider: Infinite Recursion Detected Simulation Stopped
>
> It is completely obvious that when H(P,P) correctly emulates its input
> that it must emulate the first seven instructions of P. Because the
> seventh instruction of P repeats this process we know with complete
> certainty that the correct and complete emulation of P by H would never
> reach its final “ret” instruction, thus never halts.
>
> [000012f7][00102184][00102190] 83c408      add esp,+08
> [000012fa][00102184][00102190] 85c0        test eax,eax
> [000012fc][00102184][00102190] 7402        jz 00001300
> [00001300][00102188][00001314] 5d          pop ebp
> [00001301][0010218c][000012e7] c3          ret           // executed P
> halts
> [00001314][00102190][00000000] 83c404      add esp,+04
> [00001317][00102190][00000000] 33c0        xor eax,eax
> [00001319][00102194][00100000] 5d          pop ebp
> [0000131a][00102198][00000000] c3          ret          // main() halts
> Number of Instructions Executed(15900)

one thing could be refuted: the way the code is written you could
corrupt the stack and get unexpected results. unfortunately I could only
guess what "u32" is but the following example clarifies my objection.

#include <stdint.h>

typedef uint32_t u32;

int H(u32 v1, u32 v2)
{ return v1 == v2;
}

void P(void (*p)())
{ u32 x = (u32)p; /* warning here */

if (H(x, x))
HERE: goto HERE;
return;
}

int main()
{ P(P);
}

12|warning: cast from pointer to integer of different size
[-Wpointer-to-int-cast]|

On 6/11/2022 12:28 PM, Mr Flibble wrote:
> On Sat, 11 Jun 2022 12:06:44 -0500
> olcott <NoOne@NoWhere.com> wrote:
>
>> On 6/11/2022 11:07 AM, Richard Damon wrote:
>>> On 6/11/22 10:04 AM, olcott wrote:
>>>>>
>>>>
>>>> The issue is that verified facts prove that I am correct yet my
>>>> reviewers consistently disagree with easily verified facts.
>>>>
>>>> I need honest and competent reviewer here to verify the software
>>>> engineering of my claims. My prior reviewers are either dishonest
>>>> or incompetent.
>>>
>>> No, you need to honest with yourself.
>>>
>>> "Verified" normally means by an independent source, not yourself.
>>
>> When dealing with objectively verifiable facts and not subjective
>> judgement calls validation is axiomatic.
>>
>> The x86 language is a formal mathematical language in that the
>> semantics specified by programs written in this language have zero
>> ambiguity or leeway for different subjective interpretation of their
>> meaning.
>>
>> When I say that this specifies and infinite loop anyone that
>> disagrees simply objectively incorrect.
>>
>> _Infinite_Loop()
>> [00001316](01) 55 push ebp
>> [00001317](02) 8bec mov ebp,esp
>> [00001319](02) ebfe jmp 00001319
>> [0000131b](01) 5d pop ebp
>> [0000131c](01) c3 ret
>> Size in bytes:(0007) [0000131c]
>>
>> All recent rebuttals of my work have taken the form of disagreeing
>> with the x86 language.
>
> But you assert the infinite loop is unreachable in P so what is
> the point of posting its disassembly here?
>
> /Flibble
>

Did you notice that the name of the above function is not P?

--
Copyright 2022 Pete Olcott

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

On 6/11/2022 12:38 PM, jak wrote:
> Il 09/06/2022 17:46, olcott ha scritto:
>> void P(u32 x)
>> {
>>    if (H(x, x))
>>      HERE: goto HERE;
>>    return;
>> }
>>
>> int main()
>> {
>>    P(P);
>> }
>>
>> _P()
>> [000012e7](01)  55              push ebp
>> [000012e8](02)  8bec            mov ebp,esp
>> [000012ea](03)  8b4508          mov eax,[ebp+08]
>> [000012ed](01)  50              push eax
>> [000012ee](03)  8b4d08          mov ecx,[ebp+08]
>> [000012f1](01)  51              push ecx
>> [000012f2](05)  e880feffff      call 00001177 // call H
>> [000012f7](03)  83c408          add esp,+08
>> [000012fa](02)  85c0            test eax,eax
>> [000012fc](02)  7402            jz 00001300
>> [000012fe](02)  ebfe            jmp 000012fe
>> [00001300](01)  5d              pop ebp
>> [00001301](01)  c3              ret
>> Size in bytes:(0027) [00001301]
>>
>> _main()
>> [00001307](01)  55              push ebp
>> [00001308](02)  8bec            mov ebp,esp
>> [0000130a](05)  68e7120000      push 000012e7 // push P
>> [0000130f](05)  e8d3ffffff      call 000012e7 // call P
>> [00001314](03)  83c404          add esp,+04
>> [00001317](02)  33c0            xor eax,eax
>> [00001319](01)  5d              pop ebp
>> [0000131a](01)  c3              ret
>> Size in bytes:(0020) [0000131a]
>>
>>   machine   stack     stack     machine    assembly
>>   address   address   data      code       language
>>   ========  ========  ========  =========  =============
>> [00001307][00102190][00000000] 55         push ebp
>> [00001308][00102190][00000000] 8bec       mov ebp,esp
>> [0000130a][0010218c][000012e7] 68e7120000 push 000012e7 // push P
>> [0000130f][00102188][00001314] e8d3ffffff call 000012e7 // call P
>> [000012e7][00102184][00102190] 55         push ebp      // enter
>> executed P
>> [000012e8][00102184][00102190] 8bec       mov ebp,esp
>> [000012ea][00102184][00102190] 8b4508     mov eax,[ebp+08]
>> [000012ed][00102180][000012e7] 50         push eax      // push P
>> [000012ee][00102180][000012e7] 8b4d08     mov ecx,[ebp+08]
>> [000012f1][0010217c][000012e7] 51         push ecx      // push P
>> [000012f2][00102178][000012f7] e880feffff call 00001177 // call H
>>
>> Begin Local Halt Decider Simulation   Execution Trace Stored at:212244
>> [000012e7][00212230][00212234] 55          push ebp      // enter
>> emulated P
>> [000012e8][00212230][00212234] 8bec        mov ebp,esp
>> [000012ea][00212230][00212234] 8b4508      mov eax,[ebp+08]
>> [000012ed][0021222c][000012e7] 50          push eax      // push P
>> [000012ee][0021222c][000012e7] 8b4d08      mov ecx,[ebp+08]
>> [000012f1][00212228][000012e7] 51          push ecx      // push P
>> [000012f2][00212224][000012f7] e880feffff  call 00001177 // call H
>> [000012e7][0025cc58][0025cc5c] 55          push ebp      // enter
>> emulated P
>> [000012e8][0025cc58][0025cc5c] 8bec        mov ebp,esp
>> [000012ea][0025cc58][0025cc5c] 8b4508      mov eax,[ebp+08]
>> [000012ed][0025cc54][000012e7] 50          push eax      // push P
>> [000012ee][0025cc54][000012e7] 8b4d08      mov ecx,[ebp+08]
>> [000012f1][0025cc50][000012e7] 51          push ecx      // push P
>> [000012f2][0025cc4c][000012f7] e880feffff  call 00001177 // call H
>> Local Halt Decider: Infinite Recursion Detected Simulation Stopped
>>
>> It is completely obvious that when H(P,P) correctly emulates its input
>> that it must emulate the first seven instructions of P. Because the
>> seventh instruction of P repeats this process we know with complete
>> certainty that the correct and complete emulation of P by H would
>> never reach its final “ret” instruction, thus never halts.
>>
>> [000012f7][00102184][00102190] 83c408      add esp,+08
>> [000012fa][00102184][00102190] 85c0        test eax,eax
>> [000012fc][00102184][00102190] 7402        jz 00001300
>> [00001300][00102188][00001314] 5d          pop ebp
>> [00001301][0010218c][000012e7] c3          ret           // executed P
>> halts
>> [00001314][00102190][00000000] 83c404      add esp,+04
>> [00001317][00102190][00000000] 33c0        xor eax,eax
>> [00001319][00102194][00100000] 5d          pop ebp
>> [0000131a][00102198][00000000] c3          ret          // main() halts
>> Number of Instructions Executed(15900)
>
> one thing could be refuted: the way the code is written you could
> corrupt the stack and get unexpected results. unfortunately I could only
> guess what "u32" is but the following example clarifies my objection.
>

I am running an x86 emulator in 32 bit mode so I force all machine
addresses to be 32 bits. The code must be compiled in 32-bit mode.

It is stipulated that H performs a pure x86 emulation on its input
unless and until H correctly detects that the complete x86 emulation of
its input would never stop running.

> #include <stdint.h>
>
> typedef uint32_t u32;
>
> int H(u32 v1, u32 v2)
> {
>     return v1 == v2;
> }
>
> void P(void (*p)())
> {
>     u32 x = (u32)p; /* warning here */
>
>     if (H(x, x))
>         HERE: goto HERE;
>     return;
> }
>
> int main()
> {
>   P(P);
> }
>
> 12|warning: cast from pointer to integer of different size
> [-Wpointer-to-int-cast]|

--
Copyright 2022 Pete Olcott

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

On Sat, 11 Jun 2022 12:39:14 -0500
olcott <NoOne@NoWhere.com> wrote:

> On 6/11/2022 12:28 PM, Mr Flibble wrote:
> > On Sat, 11 Jun 2022 12:06:44 -0500
> > olcott <NoOne@NoWhere.com> wrote:
> >
> >> On 6/11/2022 11:07 AM, Richard Damon wrote:
> >>> On 6/11/22 10:04 AM, olcott wrote:
> >>>>>
> >>>>
> >>>> The issue is that verified facts prove that I am correct yet my
> >>>> reviewers consistently disagree with easily verified facts.
> >>>>
> >>>> I need honest and competent reviewer here to verify the software
> >>>> engineering of my claims. My prior reviewers are either dishonest
> >>>> or incompetent.
> >>>
> >>> No, you need to honest with yourself.
> >>>
> >>> "Verified" normally means by an independent source, not yourself.
> >>>
> >>
> >> When dealing with objectively verifiable facts and not subjective
> >> judgement calls validation is axiomatic.
> >>
> >> The x86 language is a formal mathematical language in that the
> >> semantics specified by programs written in this language have zero
> >> ambiguity or leeway for different subjective interpretation of
> >> their meaning.
> >>
> >> When I say that this specifies and infinite loop anyone that
> >> disagrees simply objectively incorrect.
> >>
> >> _Infinite_Loop()
> >> [00001316](01) 55 push ebp
> >> [00001317](02) 8bec mov ebp,esp
> >> [00001319](02) ebfe jmp 00001319
> >> [0000131b](01) 5d pop ebp
> >> [0000131c](01) c3 ret
> >> Size in bytes:(0007) [0000131c]
> >>
> >> All recent rebuttals of my work have taken the form of disagreeing
> >> with the x86 language.
> >
> > But you assert the infinite loop is unreachable in P so what is
> > the point of posting its disassembly here?
> >
> > /Flibble
> >
>
> Did you notice that the name of the above function is not P?
Why post the trace of an infinite loop if the infinite loop in P isn't
reachable? What point are you trying to make? You have already refused
to divulge your algorithm for detecting infinite loops; this trace
provides no insight into your method whatsoever. Either publish source
code or keep shouting into the void.

/Flibble

On 6/11/2022 12:53 PM, Mr Flibble wrote:
> On Sat, 11 Jun 2022 12:39:14 -0500
> olcott <NoOne@NoWhere.com> wrote:
>
>> On 6/11/2022 12:28 PM, Mr Flibble wrote:
>>> On Sat, 11 Jun 2022 12:06:44 -0500
>>> olcott <NoOne@NoWhere.com> wrote:
>>>
>>>> On 6/11/2022 11:07 AM, Richard Damon wrote:
>>>>> On 6/11/22 10:04 AM, olcott wrote:
>>>>>>>
>>>>>>
>>>>>> The issue is that verified facts prove that I am correct yet my
>>>>>> reviewers consistently disagree with easily verified facts.
>>>>>>
>>>>>> I need honest and competent reviewer here to verify the software
>>>>>> engineering of my claims. My prior reviewers are either dishonest
>>>>>> or incompetent.
>>>>>
>>>>> No, you need to honest with yourself.
>>>>>
>>>>> "Verified" normally means by an independent source, not yourself.
>>>>>
>>>>
>>>> When dealing with objectively verifiable facts and not subjective
>>>> judgement calls validation is axiomatic.
>>>>
>>>> The x86 language is a formal mathematical language in that the
>>>> semantics specified by programs written in this language have zero
>>>> ambiguity or leeway for different subjective interpretation of
>>>> their meaning.
>>>>
>>>> When I say that this specifies and infinite loop anyone that
>>>> disagrees simply objectively incorrect.
>>>>
>>>> _Infinite_Loop()
>>>> [00001316](01) 55 push ebp
>>>> [00001317](02) 8bec mov ebp,esp
>>>> [00001319](02) ebfe jmp 00001319
>>>> [0000131b](01) 5d pop ebp
>>>> [0000131c](01) c3 ret
>>>> Size in bytes:(0007) [0000131c]
>>>>
>>>> All recent rebuttals of my work have taken the form of disagreeing
>>>> with the x86 language.
>>>
>>> But you assert the infinite loop is unreachable in P so what is
>>> the point of posting its disassembly here?
>>>
>>> /Flibble
>>>
>>
>> Did you notice that the name of the above function is not P?
>
> Why post the trace of an infinite loop if the infinite loop in P isn't
> reachable? What point are you trying to make?

The point that I just made is that when anyone disagrees with the x86
language then they are necessary incorrect.

The concrete example above shown an infinite loop thus anyone that
disagrees that it is an infinite loop is wrong.

> You have already refused
> to divulge your algorithm for detecting infinite loops;

The algorithm for detecting the above infinite loop is self-evident to
all competent software engineers.

That you cannot begin to imagine what this algorithm is proves your
complete incompetence.

> this trace
> provides no insight into your method whatsoever. Either publish source
> code or keep shouting into the void.
>
> /Flibble
>

--
Copyright 2022 Pete Olcott

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

On Sat, 11 Jun 2022 13:01:28 -0500
olcott <NoOne@NoWhere.com> wrote:

> On 6/11/2022 12:53 PM, Mr Flibble wrote:
> > On Sat, 11 Jun 2022 12:39:14 -0500
> > olcott <NoOne@NoWhere.com> wrote:
> >
> >> On 6/11/2022 12:28 PM, Mr Flibble wrote:
> >>> On Sat, 11 Jun 2022 12:06:44 -0500
> >>> olcott <NoOne@NoWhere.com> wrote:
> >>>
> >>>> On 6/11/2022 11:07 AM, Richard Damon wrote:
> >>>>> On 6/11/22 10:04 AM, olcott wrote:
> >>>>>>>
> >>>>>>
> >>>>>> The issue is that verified facts prove that I am correct yet my
> >>>>>> reviewers consistently disagree with easily verified facts.
> >>>>>>
> >>>>>> I need honest and competent reviewer here to verify the
> >>>>>> software engineering of my claims. My prior reviewers are
> >>>>>> either dishonest or incompetent.
> >>>>>
> >>>>> No, you need to honest with yourself.
> >>>>>
> >>>>> "Verified" normally means by an independent source, not
> >>>>> yourself.
> >>>>
> >>>> When dealing with objectively verifiable facts and not subjective
> >>>> judgement calls validation is axiomatic.
> >>>>
> >>>> The x86 language is a formal mathematical language in that the
> >>>> semantics specified by programs written in this language have
> >>>> zero ambiguity or leeway for different subjective interpretation
> >>>> of their meaning.
> >>>>
> >>>> When I say that this specifies and infinite loop anyone that
> >>>> disagrees simply objectively incorrect.
> >>>>
> >>>> _Infinite_Loop()
> >>>> [00001316](01) 55 push ebp
> >>>> [00001317](02) 8bec mov ebp,esp
> >>>> [00001319](02) ebfe jmp 00001319
> >>>> [0000131b](01) 5d pop ebp
> >>>> [0000131c](01) c3 ret
> >>>> Size in bytes:(0007) [0000131c]
> >>>>
> >>>> All recent rebuttals of my work have taken the form of
> >>>> disagreeing with the x86 language.
> >>>
> >>> But you assert the infinite loop is unreachable in P so what is
> >>> the point of posting its disassembly here?
> >>>
> >>> /Flibble
> >>>
> >>
> >> Did you notice that the name of the above function is not P?
> >
> > Why post the trace of an infinite loop if the infinite loop in P
> > isn't reachable? What point are you trying to make?
>
> The point that I just made is that when anyone disagrees with the x86
> language then they are necessary incorrect.
>
> The concrete example above shown an infinite loop thus anyone that
> disagrees that it is an infinite loop is wrong.
>
> > You have already refused
> > to divulge your algorithm for detecting infinite loops;
>
> The algorithm for detecting the above infinite loop is self-evident
> to all competent software engineers.

It isn't self-evident at all. You could be doing naive pattern matching
looking for the emulation of the x86 opcodes "EB FE" or you could be
doing something less naive such as detecting the same machine (CPU/RAM)
state when the same instruction pointer register is set more than once.

>
> That you cannot begin to imagine what this algorithm is proves your
> complete incompetence.

I can imagine several of ways of doing it; why do you refuse to divulge
how you do it? What are you trying to hide?

/Flibble

On 6/11/2022 1:11 PM, Mr Flibble wrote:
> On Sat, 11 Jun 2022 13:01:28 -0500
> olcott <NoOne@NoWhere.com> wrote:
>
>> On 6/11/2022 12:53 PM, Mr Flibble wrote:
>>> On Sat, 11 Jun 2022 12:39:14 -0500
>>> olcott <NoOne@NoWhere.com> wrote:
>>>
>>>> On 6/11/2022 12:28 PM, Mr Flibble wrote:
>>>>> On Sat, 11 Jun 2022 12:06:44 -0500
>>>>> olcott <NoOne@NoWhere.com> wrote:
>>>>>
>>>>>> On 6/11/2022 11:07 AM, Richard Damon wrote:
>>>>>>> On 6/11/22 10:04 AM, olcott wrote:
>>>>>>>>>
>>>>>>>>
>>>>>>>> The issue is that verified facts prove that I am correct yet my
>>>>>>>> reviewers consistently disagree with easily verified facts.
>>>>>>>>
>>>>>>>> I need honest and competent reviewer here to verify the
>>>>>>>> software engineering of my claims. My prior reviewers are
>>>>>>>> either dishonest or incompetent.
>>>>>>>
>>>>>>> No, you need to honest with yourself.
>>>>>>>
>>>>>>> "Verified" normally means by an independent source, not
>>>>>>> yourself.
>>>>>>
>>>>>> When dealing with objectively verifiable facts and not subjective
>>>>>> judgement calls validation is axiomatic.
>>>>>>
>>>>>> The x86 language is a formal mathematical language in that the
>>>>>> semantics specified by programs written in this language have
>>>>>> zero ambiguity or leeway for different subjective interpretation
>>>>>> of their meaning.
>>>>>>
>>>>>> When I say that this specifies and infinite loop anyone that
>>>>>> disagrees simply objectively incorrect.
>>>>>>
>>>>>> _Infinite_Loop()
>>>>>> [00001316](01) 55 push ebp
>>>>>> [00001317](02) 8bec mov ebp,esp
>>>>>> [00001319](02) ebfe jmp 00001319
>>>>>> [0000131b](01) 5d pop ebp
>>>>>> [0000131c](01) c3 ret
>>>>>> Size in bytes:(0007) [0000131c]
>>>>>>
>>>>>> All recent rebuttals of my work have taken the form of
>>>>>> disagreeing with the x86 language.
>>>>>
>>>>> But you assert the infinite loop is unreachable in P so what is
>>>>> the point of posting its disassembly here?
>>>>>
>>>>> /Flibble
>>>>>
>>>>
>>>> Did you notice that the name of the above function is not P?
>>>
>>> Why post the trace of an infinite loop if the infinite loop in P
>>> isn't reachable? What point are you trying to make?
>>
>> The point that I just made is that when anyone disagrees with the x86
>> language then they are necessary incorrect.
>>
>> The concrete example above shown an infinite loop thus anyone that
>> disagrees that it is an infinite loop is wrong.
>>
>>> You have already refused
>>> to divulge your algorithm for detecting infinite loops;
>>
>> The algorithm for detecting the above infinite loop is self-evident
>> to all competent software engineers.
>
> It isn't self-evident at all. You could be doing naive pattern matching
> looking for the emulation of the x86 opcodes "EB FE" or you could be
> doing something less naive such as detecting the same machine (CPU/RAM)
> state when the same instruction pointer register is set more than once.
>

In other words you expressly acknowledge that you are woefully
incompetent to determine what a correct infinite loop detector would do.

>>
>> That you cannot begin to imagine what this algorithm is proves your
>> complete incompetence.
>
> I can imagine several of ways of doing it; why do you refuse to divulge
> how you do it? What are you trying to hide?
>
> /Flibble
>

Can you imagine one correct way that it can be done?
If you can then this proves that such a way exists.
If you can't then this proves that you are woefully incompetent.

--
Copyright 2022 Pete Olcott

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

On Sat, 11 Jun 2022 13:16:17 -0500
olcott <NoOne@NoWhere.com> wrote:

> On 6/11/2022 1:11 PM, Mr Flibble wrote:
> > On Sat, 11 Jun 2022 13:01:28 -0500
> > olcott <NoOne@NoWhere.com> wrote:
> >
> >> On 6/11/2022 12:53 PM, Mr Flibble wrote:
> >>> On Sat, 11 Jun 2022 12:39:14 -0500
> >>> olcott <NoOne@NoWhere.com> wrote:
> >>>
> >>>> On 6/11/2022 12:28 PM, Mr Flibble wrote:
> >>>>> On Sat, 11 Jun 2022 12:06:44 -0500
> >>>>> olcott <NoOne@NoWhere.com> wrote:
> >>>>>
> >>>>>> On 6/11/2022 11:07 AM, Richard Damon wrote:
> >>>>>>> On 6/11/22 10:04 AM, olcott wrote:
> >>>>>>>>>
> >>>>>>>>
> >>>>>>>> The issue is that verified facts prove that I am correct yet
> >>>>>>>> my reviewers consistently disagree with easily verified
> >>>>>>>> facts.
> >>>>>>>>
> >>>>>>>> I need honest and competent reviewer here to verify the
> >>>>>>>> software engineering of my claims. My prior reviewers are
> >>>>>>>> either dishonest or incompetent.
> >>>>>>>
> >>>>>>> No, you need to honest with yourself.
> >>>>>>>
> >>>>>>> "Verified" normally means by an independent source, not
> >>>>>>> yourself.
> >>>>>>
> >>>>>> When dealing with objectively verifiable facts and not
> >>>>>> subjective judgement calls validation is axiomatic.
> >>>>>>
> >>>>>> The x86 language is a formal mathematical language in that the
> >>>>>> semantics specified by programs written in this language have
> >>>>>> zero ambiguity or leeway for different subjective
> >>>>>> interpretation of their meaning.
> >>>>>>
> >>>>>> When I say that this specifies and infinite loop anyone that
> >>>>>> disagrees simply objectively incorrect.
> >>>>>>
> >>>>>> _Infinite_Loop()
> >>>>>> [00001316](01) 55 push ebp
> >>>>>> [00001317](02) 8bec mov ebp,esp
> >>>>>> [00001319](02) ebfe jmp 00001319
> >>>>>> [0000131b](01) 5d pop ebp
> >>>>>> [0000131c](01) c3 ret
> >>>>>> Size in bytes:(0007) [0000131c]
> >>>>>>
> >>>>>> All recent rebuttals of my work have taken the form of
> >>>>>> disagreeing with the x86 language.
> >>>>>
> >>>>> But you assert the infinite loop is unreachable in P so what is
> >>>>> the point of posting its disassembly here?
> >>>>>
> >>>>> /Flibble
> >>>>>
> >>>>
> >>>> Did you notice that the name of the above function is not P?
> >>>
> >>> Why post the trace of an infinite loop if the infinite loop in P
> >>> isn't reachable? What point are you trying to make?
> >>
> >> The point that I just made is that when anyone disagrees with the
> >> x86 language then they are necessary incorrect.
> >>
> >> The concrete example above shown an infinite loop thus anyone that
> >> disagrees that it is an infinite loop is wrong.
> >>
> >>> You have already refused
> >>> to divulge your algorithm for detecting infinite loops;
> >>
> >> The algorithm for detecting the above infinite loop is self-evident
> >> to all competent software engineers.
> >
> > It isn't self-evident at all. You could be doing naive pattern
> > matching looking for the emulation of the x86 opcodes "EB FE" or
> > you could be doing something less naive such as detecting the same
> > machine (CPU/RAM) state when the same instruction pointer register
> > is set more than once.
>
> In other words you expressly acknowledge that you are woefully
> incompetent to determine what a correct infinite loop detector would
> do.

The mask is slipping. You've got nothing but smoke and mirrors.

/Flibble

On 6/11/2022 1:17 PM, Mr Flibble wrote:
> On Sat, 11 Jun 2022 13:16:17 -0500
> olcott <NoOne@NoWhere.com> wrote:
>
>> On 6/11/2022 1:11 PM, Mr Flibble wrote:
>>> On Sat, 11 Jun 2022 13:01:28 -0500
>>> olcott <NoOne@NoWhere.com> wrote:
>>>
>>>> On 6/11/2022 12:53 PM, Mr Flibble wrote:
>>>>> On Sat, 11 Jun 2022 12:39:14 -0500
>>>>> olcott <NoOne@NoWhere.com> wrote:
>>>>>
>>>>>> On 6/11/2022 12:28 PM, Mr Flibble wrote:
>>>>>>> On Sat, 11 Jun 2022 12:06:44 -0500
>>>>>>> olcott <NoOne@NoWhere.com> wrote:
>>>>>>>
>>>>>>>> On 6/11/2022 11:07 AM, Richard Damon wrote:
>>>>>>>>> On 6/11/22 10:04 AM, olcott wrote:
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> The issue is that verified facts prove that I am correct yet
>>>>>>>>>> my reviewers consistently disagree with easily verified
>>>>>>>>>> facts.
>>>>>>>>>>
>>>>>>>>>> I need honest and competent reviewer here to verify the
>>>>>>>>>> software engineering of my claims. My prior reviewers are
>>>>>>>>>> either dishonest or incompetent.
>>>>>>>>>
>>>>>>>>> No, you need to honest with yourself.
>>>>>>>>>
>>>>>>>>> "Verified" normally means by an independent source, not
>>>>>>>>> yourself.
>>>>>>>>
>>>>>>>> When dealing with objectively verifiable facts and not
>>>>>>>> subjective judgement calls validation is axiomatic.
>>>>>>>>
>>>>>>>> The x86 language is a formal mathematical language in that the
>>>>>>>> semantics specified by programs written in this language have
>>>>>>>> zero ambiguity or leeway for different subjective
>>>>>>>> interpretation of their meaning.
>>>>>>>>
>>>>>>>> When I say that this specifies and infinite loop anyone that
>>>>>>>> disagrees simply objectively incorrect.
>>>>>>>>
>>>>>>>> _Infinite_Loop()
>>>>>>>> [00001316](01) 55 push ebp
>>>>>>>> [00001317](02) 8bec mov ebp,esp
>>>>>>>> [00001319](02) ebfe jmp 00001319
>>>>>>>> [0000131b](01) 5d pop ebp
>>>>>>>> [0000131c](01) c3 ret
>>>>>>>> Size in bytes:(0007) [0000131c]
>>>>>>>>
>>>>>>>> All recent rebuttals of my work have taken the form of
>>>>>>>> disagreeing with the x86 language.
>>>>>>>
>>>>>>> But you assert the infinite loop is unreachable in P so what is
>>>>>>> the point of posting its disassembly here?
>>>>>>>
>>>>>>> /Flibble
>>>>>>>
>>>>>>
>>>>>> Did you notice that the name of the above function is not P?
>>>>>
>>>>> Why post the trace of an infinite loop if the infinite loop in P
>>>>> isn't reachable? What point are you trying to make?
>>>>
>>>> The point that I just made is that when anyone disagrees with the
>>>> x86 language then they are necessary incorrect.
>>>>
>>>> The concrete example above shown an infinite loop thus anyone that
>>>> disagrees that it is an infinite loop is wrong.
>>>>
>>>>> You have already refused
>>>>> to divulge your algorithm for detecting infinite loops;
>>>>
>>>> The algorithm for detecting the above infinite loop is self-evident
>>>> to all competent software engineers.
>>>
>>> It isn't self-evident at all. You could be doing naive pattern
>>> matching looking for the emulation of the x86 opcodes "EB FE" or
>>> you could be doing something less naive such as detecting the same
>>> machine (CPU/RAM) state when the same instruction pointer register
>>> is set more than once.
>>
>> In other words you expressly acknowledge that you are woefully
>> incompetent to determine what a correct infinite loop detector would
>> do.
>
> The mask is slipping. You've got nothing but smoke and mirrors.
>
> /Flibble
>

Every competent software engineer here can easily determine the
algorithm for recognizing an infinite loop from the following behavior
pattern. That you cannot do this proves your incompetence.

Begin Local Halt Decider Simulation Execution Trace Stored at:212343
[00001342][00212333][00212337] 55 push ebp
[00001343][00212333][00212337] 8bec mov ebp,esp
[00001345][00212333][00212337] ebfe jmp 00001345
[00001345][00212333][00212337] ebfe jmp 00001345
Local Halt Decider: Infinite Loop Detected Simulation Stopped

--
Copyright 2022 Pete Olcott

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

On Sat, 11 Jun 2022 13:21:25 -0500
olcott <NoOne@NoWhere.com> wrote:

> On 6/11/2022 1:17 PM, Mr Flibble wrote:
> > On Sat, 11 Jun 2022 13:16:17 -0500
> > olcott <NoOne@NoWhere.com> wrote:
> >
> >> On 6/11/2022 1:11 PM, Mr Flibble wrote:
> >>> On Sat, 11 Jun 2022 13:01:28 -0500
> >>> olcott <NoOne@NoWhere.com> wrote:
> >>>
> >>>> On 6/11/2022 12:53 PM, Mr Flibble wrote:
> >>>>> On Sat, 11 Jun 2022 12:39:14 -0500
> >>>>> olcott <NoOne@NoWhere.com> wrote:
> >>>>>
> >>>>>> On 6/11/2022 12:28 PM, Mr Flibble wrote:
> >>>>>>> On Sat, 11 Jun 2022 12:06:44 -0500
> >>>>>>> olcott <NoOne@NoWhere.com> wrote:
> >>>>>>>
> >>>>>>>> On 6/11/2022 11:07 AM, Richard Damon wrote:
> >>>>>>>>> On 6/11/22 10:04 AM, olcott wrote:
> >>>>>>>>>>>
> >>>>>>>>>>
> >>>>>>>>>> The issue is that verified facts prove that I am correct
> >>>>>>>>>> yet my reviewers consistently disagree with easily verified
> >>>>>>>>>> facts.
> >>>>>>>>>>
> >>>>>>>>>> I need honest and competent reviewer here to verify the
> >>>>>>>>>> software engineering of my claims. My prior reviewers are
> >>>>>>>>>> either dishonest or incompetent.
> >>>>>>>>>
> >>>>>>>>> No, you need to honest with yourself.
> >>>>>>>>>
> >>>>>>>>> "Verified" normally means by an independent source, not
> >>>>>>>>> yourself.
> >>>>>>>>
> >>>>>>>> When dealing with objectively verifiable facts and not
> >>>>>>>> subjective judgement calls validation is axiomatic.
> >>>>>>>>
> >>>>>>>> The x86 language is a formal mathematical language in that
> >>>>>>>> the semantics specified by programs written in this language
> >>>>>>>> have zero ambiguity or leeway for different subjective
> >>>>>>>> interpretation of their meaning.
> >>>>>>>>
> >>>>>>>> When I say that this specifies and infinite loop anyone that
> >>>>>>>> disagrees simply objectively incorrect.
> >>>>>>>>
> >>>>>>>> _Infinite_Loop()
> >>>>>>>> [00001316](01) 55 push ebp
> >>>>>>>> [00001317](02) 8bec mov ebp,esp
> >>>>>>>> [00001319](02) ebfe jmp 00001319
> >>>>>>>> [0000131b](01) 5d pop ebp
> >>>>>>>> [0000131c](01) c3 ret
> >>>>>>>> Size in bytes:(0007) [0000131c]
> >>>>>>>>
> >>>>>>>> All recent rebuttals of my work have taken the form of
> >>>>>>>> disagreeing with the x86 language.
> >>>>>>>
> >>>>>>> But you assert the infinite loop is unreachable in P so what
> >>>>>>> is the point of posting its disassembly here?
> >>>>>>>
> >>>>>>> /Flibble
> >>>>>>>
> >>>>>>
> >>>>>> Did you notice that the name of the above function is not P?
> >>>>>
> >>>>> Why post the trace of an infinite loop if the infinite loop in P
> >>>>> isn't reachable? What point are you trying to make?
> >>>>
> >>>> The point that I just made is that when anyone disagrees with the
> >>>> x86 language then they are necessary incorrect.
> >>>>
> >>>> The concrete example above shown an infinite loop thus anyone
> >>>> that disagrees that it is an infinite loop is wrong.
> >>>>
> >>>>> You have already refused
> >>>>> to divulge your algorithm for detecting infinite loops;
> >>>>
> >>>> The algorithm for detecting the above infinite loop is
> >>>> self-evident to all competent software engineers.
> >>>
> >>> It isn't self-evident at all. You could be doing naive pattern
> >>> matching looking for the emulation of the x86 opcodes "EB FE" or
> >>> you could be doing something less naive such as detecting the same
> >>> machine (CPU/RAM) state when the same instruction pointer register
> >>> is set more than once.
> >>
> >> In other words you expressly acknowledge that you are woefully
> >> incompetent to determine what a correct infinite loop detector
> >> would do.
> >
> > The mask is slipping. You've got nothing but smoke and mirrors.
> >
> > /Flibble
> >
>
> Every competent software engineer here can easily determine the
> algorithm for recognizing an infinite loop from the following
> behavior pattern. That you cannot do this proves your incompetence.
>
> Begin Local Halt Decider Simulation Execution Trace Stored at:212343
> [00001342][00212333][00212337] 55 push ebp
> [00001343][00212333][00212337] 8bec mov ebp,esp
> [00001345][00212333][00212337] ebfe jmp 00001345
> [00001345][00212333][00212337] ebfe jmp 00001345
> Local Halt Decider: Infinite Loop Detected Simulation Stopped
Your vacuous meaningless insults reveal more about your character than
anything else. As far as the subject at hand is concerned: all you've
got is smoke and mirrors.

/Flibble

On 6/11/2022 1:23 PM, Mr Flibble wrote:
> On Sat, 11 Jun 2022 13:21:25 -0500
> olcott <NoOne@NoWhere.com> wrote:
>
>> On 6/11/2022 1:17 PM, Mr Flibble wrote:
>>> On Sat, 11 Jun 2022 13:16:17 -0500
>>> olcott <NoOne@NoWhere.com> wrote:
>>>
>>>> On 6/11/2022 1:11 PM, Mr Flibble wrote:
>>>>> On Sat, 11 Jun 2022 13:01:28 -0500
>>>>> olcott <NoOne@NoWhere.com> wrote:
>>>>>
>>>>>> On 6/11/2022 12:53 PM, Mr Flibble wrote:
>>>>>>> On Sat, 11 Jun 2022 12:39:14 -0500
>>>>>>> olcott <NoOne@NoWhere.com> wrote:
>>>>>>>
>>>>>>>> On 6/11/2022 12:28 PM, Mr Flibble wrote:
>>>>>>>>> On Sat, 11 Jun 2022 12:06:44 -0500
>>>>>>>>> olcott <NoOne@NoWhere.com> wrote:
>>>>>>>>>
>>>>>>>>>> On 6/11/2022 11:07 AM, Richard Damon wrote:
>>>>>>>>>>> On 6/11/22 10:04 AM, olcott wrote:
>>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> The issue is that verified facts prove that I am correct
>>>>>>>>>>>> yet my reviewers consistently disagree with easily verified
>>>>>>>>>>>> facts.
>>>>>>>>>>>>
>>>>>>>>>>>> I need honest and competent reviewer here to verify the
>>>>>>>>>>>> software engineering of my claims. My prior reviewers are
>>>>>>>>>>>> either dishonest or incompetent.
>>>>>>>>>>>
>>>>>>>>>>> No, you need to honest with yourself.
>>>>>>>>>>>
>>>>>>>>>>> "Verified" normally means by an independent source, not
>>>>>>>>>>> yourself.
>>>>>>>>>>
>>>>>>>>>> When dealing with objectively verifiable facts and not
>>>>>>>>>> subjective judgement calls validation is axiomatic.
>>>>>>>>>>
>>>>>>>>>> The x86 language is a formal mathematical language in that
>>>>>>>>>> the semantics specified by programs written in this language
>>>>>>>>>> have zero ambiguity or leeway for different subjective
>>>>>>>>>> interpretation of their meaning.
>>>>>>>>>>
>>>>>>>>>> When I say that this specifies and infinite loop anyone that
>>>>>>>>>> disagrees simply objectively incorrect.
>>>>>>>>>>
>>>>>>>>>> _Infinite_Loop()
>>>>>>>>>> [00001316](01) 55 push ebp
>>>>>>>>>> [00001317](02) 8bec mov ebp,esp
>>>>>>>>>> [00001319](02) ebfe jmp 00001319
>>>>>>>>>> [0000131b](01) 5d pop ebp
>>>>>>>>>> [0000131c](01) c3 ret
>>>>>>>>>> Size in bytes:(0007) [0000131c]
>>>>>>>>>>
>>>>>>>>>> All recent rebuttals of my work have taken the form of
>>>>>>>>>> disagreeing with the x86 language.
>>>>>>>>>
>>>>>>>>> But you assert the infinite loop is unreachable in P so what
>>>>>>>>> is the point of posting its disassembly here?
>>>>>>>>>
>>>>>>>>> /Flibble
>>>>>>>>>
>>>>>>>>
>>>>>>>> Did you notice that the name of the above function is not P?
>>>>>>>
>>>>>>> Why post the trace of an infinite loop if the infinite loop in P
>>>>>>> isn't reachable? What point are you trying to make?
>>>>>>
>>>>>> The point that I just made is that when anyone disagrees with the
>>>>>> x86 language then they are necessary incorrect.
>>>>>>
>>>>>> The concrete example above shown an infinite loop thus anyone
>>>>>> that disagrees that it is an infinite loop is wrong.
>>>>>>
>>>>>>> You have already refused
>>>>>>> to divulge your algorithm for detecting infinite loops;
>>>>>>
>>>>>> The algorithm for detecting the above infinite loop is
>>>>>> self-evident to all competent software engineers.
>>>>>
>>>>> It isn't self-evident at all. You could be doing naive pattern
>>>>> matching looking for the emulation of the x86 opcodes "EB FE" or
>>>>> you could be doing something less naive such as detecting the same
>>>>> machine (CPU/RAM) state when the same instruction pointer register
>>>>> is set more than once.
>>>>
>>>> In other words you expressly acknowledge that you are woefully
>>>> incompetent to determine what a correct infinite loop detector
>>>> would do.
>>>
>>> The mask is slipping. You've got nothing but smoke and mirrors.
>>>
>>> /Flibble
>>>
>>
>> Every competent software engineer here can easily determine the
>> algorithm for recognizing an infinite loop from the following
>> behavior pattern. That you cannot do this proves your incompetence.
>>
>> Begin Local Halt Decider Simulation Execution Trace Stored at:212343
>> [00001342][00212333][00212337] 55 push ebp
>> [00001343][00212333][00212337] 8bec mov ebp,esp
>> [00001345][00212333][00212337] ebfe jmp 00001345
>> [00001345][00212333][00212337] ebfe jmp 00001345
>> Local Halt Decider: Infinite Loop Detected Simulation Stopped
>
> Your vacuous meaningless insults reveal more about your character than
> anything else.

It is an easily objectively verifiable fact that every competent
software engineer can correctly determine the trivial algorithm required
to recognize the above infinite behavior pattern.

> As far as the subject at hand is concerned: all you've
> got is smoke and mirrors.
>
> /Flibble
>
>

--
Copyright 2022 Pete Olcott

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

On Sat, 11 Jun 2022 13:28:24 -0500
olcott <NoOne@NoWhere.com> wrote:

> On 6/11/2022 1:23 PM, Mr Flibble wrote:
> > On Sat, 11 Jun 2022 13:21:25 -0500
> > olcott <NoOne@NoWhere.com> wrote:
> >
> >> On 6/11/2022 1:17 PM, Mr Flibble wrote:
> >>> On Sat, 11 Jun 2022 13:16:17 -0500
> >>> olcott <NoOne@NoWhere.com> wrote:
> >>>
> >>>> On 6/11/2022 1:11 PM, Mr Flibble wrote:
> >>>>> On Sat, 11 Jun 2022 13:01:28 -0500
> >>>>> olcott <NoOne@NoWhere.com> wrote:
> >>>>>
> >>>>>> On 6/11/2022 12:53 PM, Mr Flibble wrote:
> >>>>>>> On Sat, 11 Jun 2022 12:39:14 -0500
> >>>>>>> olcott <NoOne@NoWhere.com> wrote:
> >>>>>>>
> >>>>>>>> On 6/11/2022 12:28 PM, Mr Flibble wrote:
> >>>>>>>>> On Sat, 11 Jun 2022 12:06:44 -0500
> >>>>>>>>> olcott <NoOne@NoWhere.com> wrote:
> >>>>>>>>>
> >>>>>>>>>> On 6/11/2022 11:07 AM, Richard Damon wrote:
> >>>>>>>>>>> On 6/11/22 10:04 AM, olcott wrote:
> >>>>>>>>>>>>>
> >>>>>>>>>>>>
> >>>>>>>>>>>> The issue is that verified facts prove that I am correct
> >>>>>>>>>>>> yet my reviewers consistently disagree with easily
> >>>>>>>>>>>> verified facts.
> >>>>>>>>>>>>
> >>>>>>>>>>>> I need honest and competent reviewer here to verify the
> >>>>>>>>>>>> software engineering of my claims. My prior reviewers are
> >>>>>>>>>>>> either dishonest or incompetent.
> >>>>>>>>>>>
> >>>>>>>>>>> No, you need to honest with yourself.
> >>>>>>>>>>>
> >>>>>>>>>>> "Verified" normally means by an independent source, not
> >>>>>>>>>>> yourself.
> >>>>>>>>>>
> >>>>>>>>>> When dealing with objectively verifiable facts and not
> >>>>>>>>>> subjective judgement calls validation is axiomatic.
> >>>>>>>>>>
> >>>>>>>>>> The x86 language is a formal mathematical language in that
> >>>>>>>>>> the semantics specified by programs written in this
> >>>>>>>>>> language have zero ambiguity or leeway for different
> >>>>>>>>>> subjective interpretation of their meaning.
> >>>>>>>>>>
> >>>>>>>>>> When I say that this specifies and infinite loop anyone
> >>>>>>>>>> that disagrees simply objectively incorrect.
> >>>>>>>>>>
> >>>>>>>>>> _Infinite_Loop()
> >>>>>>>>>> [00001316](01) 55 push ebp
> >>>>>>>>>> [00001317](02) 8bec mov ebp,esp
> >>>>>>>>>> [00001319](02) ebfe jmp 00001319
> >>>>>>>>>> [0000131b](01) 5d pop ebp
> >>>>>>>>>> [0000131c](01) c3 ret
> >>>>>>>>>> Size in bytes:(0007) [0000131c]
> >>>>>>>>>>
> >>>>>>>>>> All recent rebuttals of my work have taken the form of
> >>>>>>>>>> disagreeing with the x86 language.
> >>>>>>>>>
> >>>>>>>>> But you assert the infinite loop is unreachable in P so what
> >>>>>>>>> is the point of posting its disassembly here?
> >>>>>>>>>
> >>>>>>>>> /Flibble
> >>>>>>>>>
> >>>>>>>>
> >>>>>>>> Did you notice that the name of the above function is not P?
> >>>>>>>>
> >>>>>>>
> >>>>>>> Why post the trace of an infinite loop if the infinite loop
> >>>>>>> in P isn't reachable? What point are you trying to make?
> >>>>>>
> >>>>>> The point that I just made is that when anyone disagrees with
> >>>>>> the x86 language then they are necessary incorrect.
> >>>>>>
> >>>>>> The concrete example above shown an infinite loop thus anyone
> >>>>>> that disagrees that it is an infinite loop is wrong.
> >>>>>>
> >>>>>>> You have already refused
> >>>>>>> to divulge your algorithm for detecting infinite loops;
> >>>>>>
> >>>>>> The algorithm for detecting the above infinite loop is
> >>>>>> self-evident to all competent software engineers.
> >>>>>
> >>>>> It isn't self-evident at all. You could be doing naive pattern
> >>>>> matching looking for the emulation of the x86 opcodes "EB FE" or
> >>>>> you could be doing something less naive such as detecting the
> >>>>> same machine (CPU/RAM) state when the same instruction pointer
> >>>>> register is set more than once.
> >>>>
> >>>> In other words you expressly acknowledge that you are woefully
> >>>> incompetent to determine what a correct infinite loop detector
> >>>> would do.
> >>>
> >>> The mask is slipping. You've got nothing but smoke and mirrors.
> >>>
> >>> /Flibble
> >>>
> >>
> >> Every competent software engineer here can easily determine the
> >> algorithm for recognizing an infinite loop from the following
> >> behavior pattern. That you cannot do this proves your incompetence.
> >>
> >> Begin Local Halt Decider Simulation Execution Trace Stored
> >> at:212343 [00001342][00212333][00212337] 55 push ebp
> >> [00001343][00212333][00212337] 8bec mov ebp,esp
> >> [00001345][00212333][00212337] ebfe jmp 00001345
> >> [00001345][00212333][00212337] ebfe jmp 00001345
> >> Local Halt Decider: Infinite Loop Detected Simulation Stopped
> >
> > Your vacuous meaningless insults reveal more about your character
> > than anything else.
>
> It is an easily objectively verifiable fact that every competent
> software engineer can correctly determine the trivial algorithm
> required to recognize the above infinite behavior pattern.

There are 2^n (n proportional to machine RAM size) different ways of
expressing an infinite loop; the above infinite loop is the most
trivial case and is easily detected however you are not telling us how
you detect the *general* case.

How would you detect the following infinite loop:

void foo()
{ bool stop = false;
while(!stop)
{
stop = FUBAR();
}
}

Where FUBAR can be trivial or complex with or without branching logic
predicated on arbitrary program input that is disguising the fact that
it always returns false?

/Flibble

On 6/11/22 1:06 PM, olcott wrote:
> On 6/11/2022 11:07 AM, Richard Damon wrote:
>> On 6/11/22 10:04 AM, olcott wrote:
>>>>
>>>
>>> The issue is that verified facts prove that I am correct yet my
>>> reviewers consistently disagree with easily verified facts.
>>>
>>> I need honest and competent reviewer here to verify the software
>>> engineering of my claims. My prior reviewers are either dishonest or
>>> incompetent.
>>
>> No, you need to honest with yourself.
>>
>> "Verified" normally means by an independent source, not yourself.
>
> When dealing with objectively verifiable facts and not subjective
> judgement calls validation is axiomatic.
>
> The x86 language is a formal mathematical language in that the semantics
> specified by programs written in this language have zero ambiguity or
> leeway for different subjective interpretation of their meaning.
>
> When I say that this specifies and infinite loop anyone that disagrees
> simply objectively incorrect.
>
> _Infinite_Loop()
> [00001316](01)  55              push ebp
> [00001317](02)  8bec            mov ebp,esp
> [00001319](02)  ebfe            jmp 00001319
> [0000131b](01)  5d              pop ebp
> [0000131c](01)  c3              ret
> Size in bytes:(0007) [0000131c]
>
> All recent rebuttals of my work have taken the form of disagreeing with
> the x86 language.
>

And yet, when you talk about x86 execution you say that call H doesn't
cause the first instruction of H to execute and be traced.

You logic is inconsitent.

Also, no one has argued that Infinite Loop can't be correctly decided,
as it exactly matchs a well proven pattern. The problem is you think
that just because there is a pattern for Infinite_Loop() that there also
is a pattern for your P().

You just don't seem to understand what is proven and what isn't.

Note also, you aren't allowed to create your own "axioms" in an existing
formal logic to redefine terms.

If you want to actually FORMALLY PROVE your statement, BASED on the
axioms, go ahead. make sure you actually quote the axioms you are using
and if you don't think we will recognize them give you sources.

Note, "Meaning of the Words" and phrases like that are NOT proofs, you
can quote a formal definition and show how something matches it to prove
the definition applies.

For instance, a Halting Machine is a Machine that reaches its final
state. Note, the references the MACHINE itself, not a "simulation" of
said machine, and Turing Machines, once defined don't stop until they
reach a final state.