novaBBS - comp.theory - Re: H(P,P)==0 as a pure function of its inputs is fully operational

H(P,P)==0 as a pure function of its inputs is fully operational

<l86dnSvJRcj4rjD_nZ2dnUU7_83NnZ2d@giganews.com>

https://www.novabbs.com/devel/article-flat.php?id=34534&group=comp.theory#34534

copy link Newsgroups: comp.theory comp.ai.philosophy sci.logic sci.math

Path: i2pn2.org!i2pn.org!weretis.net!feeder6.news.weretis.net!news.misty.com!border2.nntp.dca1.giganews.com!nntp.giganews.com!buffer2.nntp.dca1.giganews.com!news.giganews.com.POSTED!not-for-mail
NNTP-Posting-Date: Fri, 17 Jun 2022 21:07:33 -0500
Date: Fri, 17 Jun 2022 21:07:31 -0500
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:91.0) Gecko/20100101
Thunderbird/91.10.0
Newsgroups: comp.theory,comp.ai.philosophy,sci.logic,sci.math
Content-Language: en-US
From: NoO...@NoWhere.com (olcott)
Subject: H(P,P)==0 as a pure function of its inputs is fully operational
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Message-ID: <l86dnSvJRcj4rjD_nZ2dnUU7_83NnZ2d@giganews.com>
Lines: 97
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-oU0B9dGQd3CeYSMUKUCgCOx/8YxTmEMJRq0G5LQ/tmBleyd7nioSAR8ChUXbpO4lkYOwBmlV9ag1PJu!VNV8LuxM8rTfAefEhNlWtH/oNILAhR/bKDMbulKa9bw58AAxrZtnMNYTuA79TFT1eAU/9qWwNcAd
X-Complaints-To: abuse@giganews.com
X-DMCA-Notifications: http://www.giganews.com/info/dmca.html
X-Abuse-and-DMCA-Info: Please be sure to forward a copy of ALL headers
X-Abuse-and-DMCA-Info: Otherwise we will be unable to process your complaint properly
X-Postfilter: 1.3.40
X-Original-Bytes: 5221

by: olcott - Sat, 18 Jun 2022 02:07 UTC

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 the final
state of this input that all [these] inputs (including pathological
inputs) are decided correctly.

*computation that halts* … the Turing machine will halt whenever it
enters a final state. (Linz:1990:234)

Linz, Peter 1990. An Introduction to Formal Languages and Automata.
Lexington/Toronto: D. C. Heath and Company. (317-320)

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

int main()
{ Output("Input_Halts = ", H((u32)P, (u32)P));
}

_P()
[0000127e](01) 55 push ebp
[0000127f](02) 8bec mov ebp,esp
[00001281](03) 8b4508 mov eax,[ebp+08]
[00001284](01) 50 push eax
[00001285](03) 8b4d08 mov ecx,[ebp+08]
[00001288](01) 51 push ecx
[00001289](05) e820feffff call 000010ae
[0000128e](03) 83c408 add esp,+08
[00001291](02) 85c0 test eax,eax
[00001293](02) 7402 jz 00001297
[00001295](02) ebfe jmp 00001295
[00001297](01) 5d pop ebp
[00001298](01) c3 ret
Size in bytes:(0027) [00001298]

_main()
[0000129e](01) 55 push ebp
[0000129f](02) 8bec mov ebp,esp
[000012a1](05) 687e120000 push 0000127e
[000012a6](05) 687e120000 push 0000127e
[000012ab](05) e8fefdffff call 000010ae
[000012b0](03) 83c408 add esp,+08
[000012b3](01) 50 push eax
[000012b4](05) 680f040000 push 0000040f
[000012b9](05) e8a0f1ffff call 0000045e
[000012be](03) 83c408 add esp,+08
[000012c1](02) 33c0 xor eax,eax
[000012c3](01) 5d pop ebp
[000012c4](01) c3 ret
Size in bytes:(0039) [000012c4]

machine stack stack machine assembly
address address data code language
======== ======== ======== ========= =============
....[0000129e][0010201f][00000000] 55 push ebp
....[0000129f][0010201f][00000000] 8bec mov ebp,esp
....[000012a1][0010201b][0000127e] 687e120000 push 0000127e // push P
....[000012a6][00102017][0000127e] 687e120000 push 0000127e // push P
....[000012ab][00102013][000012b0] e8fefdffff call 000010ae // call H

*Begin Local Halt Decider Simulation* Execution Trace Stored at:2120d3
....[0000127e][002120bf][002120c3] 55 push ebp
....[0000127f][002120bf][002120c3] 8bec mov ebp,esp
....[00001281][002120bf][002120c3] 8b4508 mov eax,[ebp+08]
....[00001284][002120bb][0000127e] 50 push eax // push P
....[00001285][002120bb][0000127e] 8b4d08 mov ecx,[ebp+08]
....[00001288][002120b7][0000127e] 51 push ecx // push P
....[00001289][002120b3][0000128e] e820feffff call 000010ae // call H
*Infinitely Recursive Simulation Detected Simulation Stopped*

H knows its own machine address and on this basis
H recognizes that P is calling H with its same arguments that it
was called with and there are no instructions preceding this call that
could possibly escape infinitely recursive emulation so H aborts its
emulation of P before P even makes its first call to H.

....[000012b0][0010201f][00000000] 83c408 add esp,+08
....[000012b3][0010201b][00000000] 50 push eax
....[000012b4][00102017][0000040f] 680f040000 push 0000040f
---[000012b9][00102017][0000040f] e8a0f1ffff call 0000045e
Input_Halts = 0
....[000012be][0010201f][00000000] 83c408 add esp,+08
....[000012c1][0010201f][00000000] 33c0 xor eax,eax
....[000012c3][00102023][00100000] 5d pop ebp
....[000012c4][00102027][00000004] c3 ret
Number of Instructions Executed(1134) == 17 pages

Halting problem undecidability and infinitely nested simulation (V5)

https://www.researchgate.net/publication/359984584_Halting_problem_undecidability_and_infinitely_nested_simulation_V5

Re: H(P,P)==0 as a pure function of its inputs is fully operational

<BeudncOZ09-9qDD_nZ2dnUU7_83NnZ2d@giganews.com>

copy mid

https://www.novabbs.com/devel/article-flat.php?id=34535&group=comp.theory#34535

copy link Newsgroups: comp.theory comp.ai.philosophy sci.logic sci.math

Path: i2pn2.org!i2pn.org!weretis.net!feeder6.news.weretis.net!news.misty.com!border2.nntp.dca1.giganews.com!nntp.giganews.com!buffer2.nntp.dca1.giganews.com!buffer1.nntp.dca1.giganews.com!news.giganews.com.POSTED!not-for-mail
NNTP-Posting-Date: Fri, 17 Jun 2022 21:14:56 -0500
Date: Fri, 17 Jun 2022 21:14:55 -0500
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:91.0) Gecko/20100101
Thunderbird/91.10.0
Subject: Re: H(P,P)==0 as a pure function of its inputs is fully operational
Content-Language: en-US
Newsgroups: comp.theory,comp.ai.philosophy,sci.logic,sci.math
References: <l86dnSvJRcj4rjD_nZ2dnUU7_83NnZ2d@giganews.com>
From: NoO...@NoWhere.com (olcott)
In-Reply-To: <l86dnSvJRcj4rjD_nZ2dnUU7_83NnZ2d@giganews.com>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Message-ID: <BeudncOZ09-9qDD_nZ2dnUU7_83NnZ2d@giganews.com>
Lines: 109
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-vOThep+LhHQtz7wtFdJ6tijBaYoc5ptRo9Tlhiy6/zYTz1w2Qc+hAIQYullBCTA+GzrKQk63aXIiOzo!F36N173PNb6nJG82k/ScblKfxuIouagBXVvYtD+vuEuWaO8hN30sq0kOPatc0MUI4/DCaMcbJX+v
X-Complaints-To: abuse@giganews.com
X-DMCA-Notifications: http://www.giganews.com/info/dmca.html
X-Abuse-and-DMCA-Info: Please be sure to forward a copy of ALL headers
X-Abuse-and-DMCA-Info: Otherwise we will be unable to process your complaint properly
X-Postfilter: 1.3.40
X-Original-Bytes: 6142

by: olcott - Sat, 18 Jun 2022 02:14 UTC

On 6/17/2022 9:07 PM, olcott wrote:
> 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 the final
> state of this input that all [these] inputs (including pathological
> inputs) are decided correctly.
>
> *computation that halts* … the Turing machine will halt whenever it
> enters a final state. (Linz:1990:234)
>
> Linz, Peter 1990. An Introduction to Formal Languages and Automata.
> Lexington/Toronto: D. C. Heath and Company. (317-320)
>
> void P(u32 x)
> {
> if (H(x, x))
>     HERE: goto HERE;
> return;
> }
>
> int main()
> {
> Output("Input_Halts = ", H((u32)P, (u32)P));
> }
>
> _P()
> [0000127e](01) 55              push ebp
> [0000127f](02) 8bec            mov ebp,esp
> [00001281](03) 8b4508          mov eax,[ebp+08]
> [00001284](01) 50              push eax
> [00001285](03) 8b4d08          mov ecx,[ebp+08]
> [00001288](01) 51              push ecx
> [00001289](05) e820feffff      call 000010ae
> [0000128e](03) 83c408          add esp,+08
> [00001291](02) 85c0            test eax,eax
> [00001293](02) 7402            jz 00001297
> [00001295](02) ebfe            jmp 00001295
> [00001297](01) 5d              pop ebp
> [00001298](01) c3              ret
> Size in bytes:(0027) [00001298]
>
> _main()
> [0000129e](01) 55              push ebp
> [0000129f](02) 8bec            mov ebp,esp
> [000012a1](05) 687e120000      push 0000127e
> [000012a6](05) 687e120000      push 0000127e
> [000012ab](05) e8fefdffff      call 000010ae
> [000012b0](03) 83c408          add esp,+08
> [000012b3](01) 50              push eax
> [000012b4](05) 680f040000      push 0000040f
> [000012b9](05) e8a0f1ffff      call 0000045e
> [000012be](03) 83c408          add esp,+08
> [000012c1](02) 33c0            xor eax,eax
> [000012c3](01) 5d              pop ebp
> [000012c4](01) c3              ret
> Size in bytes:(0039) [000012c4]
>
>     machine   stack     stack     machine    assembly
>     address   address   data      code       language
>     ======== ======== ======== ========= =============
> ...[0000129e][0010201f][00000000] 55         push ebp
> ...[0000129f][0010201f][00000000] 8bec       mov ebp,esp
> ...[000012a1][0010201b][0000127e] 687e120000 push 0000127e // push P
> ...[000012a6][00102017][0000127e] 687e120000 push 0000127e // push P
> ...[000012ab][00102013][000012b0] e8fefdffff call 000010ae // call H
>
> *Begin Local Halt Decider Simulation*   Execution Trace Stored at:2120d3
> ...[0000127e][002120bf][002120c3] 55         push ebp
> ...[0000127f][002120bf][002120c3] 8bec       mov ebp,esp
> ...[00001281][002120bf][002120c3] 8b4508     mov eax,[ebp+08]
> ...[00001284][002120bb][0000127e] 50         push eax      // push P
> ...[00001285][002120bb][0000127e] 8b4d08     mov ecx,[ebp+08]
> ...[00001288][002120b7][0000127e] 51         push ecx      // push P
> ...[00001289][002120b3][0000128e] e820feffff call 000010ae // call H
> *Infinitely Recursive Simulation Detected Simulation Stopped*
>

H knows its own machine address and on this basis:
(a) H recognizes that P is calling H with its same arguments that it was
called with.
(b) There are no instructions in P that could possibly escape this
infinitely recursive emulation.
(c) H aborts its emulation of P before P even makes its first call to H.

> ...[000012b0][0010201f][00000000] 83c408     add esp,+08
> ...[000012b3][0010201b][00000000] 50         push eax
> ...[000012b4][00102017][0000040f] 680f040000 push 0000040f
> ---[000012b9][00102017][0000040f] e8a0f1ffff call 0000045e
> Input_Halts = 0
> ...[000012be][0010201f][00000000] 83c408     add esp,+08
> ...[000012c1][0010201f][00000000] 33c0       xor eax,eax
> ...[000012c3][00102023][00100000] 5d         pop ebp
> ...[000012c4][00102027][00000004] c3         ret
> Number of Instructions Executed(1134) == 17 pages
>
>
>
> Halting problem undecidability and infinitely nested simulation (V5)
>
> https://www.researchgate.net/publication/359984584_Halting_problem_undecidability_and_infinitely_nested_simulation_V5
>

--
Copyright 2022 Pete Olcott

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

Re: H(P,P)==0 as a pure function of its inputs is fully operational

<JbydnTjtY73AqzD_nZ2dnUU7_83NnZ2d@giganews.com>

copy mid

https://www.novabbs.com/devel/article-flat.php?id=34536&group=comp.theory#34536

copy link Newsgroups: comp.theory comp.ai.philosophy sci.logic sci.math

Path: i2pn2.org!i2pn.org!weretis.net!feeder6.news.weretis.net!1.us.feeder.erje.net!3.us.feeder.erje.net!feeder.erje.net!border1.nntp.dca1.giganews.com!nntp.giganews.com!buffer1.nntp.dca1.giganews.com!news.giganews.com.POSTED!not-for-mail
NNTP-Posting-Date: Fri, 17 Jun 2022 21:20:13 -0500
Date: Fri, 17 Jun 2022 21:20:12 -0500
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:91.0) Gecko/20100101
Thunderbird/91.10.0
Subject: Re: H(P,P)==0 as a pure function of its inputs is fully operational
Content-Language: en-US
Newsgroups: comp.theory,comp.ai.philosophy,sci.logic,sci.math
References: <l86dnSvJRcj4rjD_nZ2dnUU7_83NnZ2d@giganews.com>
<BeudncOZ09-9qDD_nZ2dnUU7_83NnZ2d@giganews.com>
From: NoO...@NoWhere.com (olcott)
In-Reply-To: <BeudncOZ09-9qDD_nZ2dnUU7_83NnZ2d@giganews.com>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Message-ID: <JbydnTjtY73AqzD_nZ2dnUU7_83NnZ2d@giganews.com>
Lines: 114
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-77BI4QWwAnYR+PZR/kxFfisMVxy3iVmulxG6PuSITatKhNLfgF6l738S4SAvETRuTVcOlZlJlEgJJM+!bzPWycRvvZimZgQx+1dALj/saGv9ui0u4RmFIAHR8ST2BWzbrF8D7aF7awFx0CLtGbAB85f3/m5Y
X-Complaints-To: abuse@giganews.com
X-DMCA-Notifications: http://www.giganews.com/info/dmca.html
X-Abuse-and-DMCA-Info: Please be sure to forward a copy of ALL headers
X-Abuse-and-DMCA-Info: Otherwise we will be unable to process your complaint properly
X-Postfilter: 1.3.40
X-Original-Bytes: 6336

by: olcott - Sat, 18 Jun 2022 02:20 UTC

On 6/17/2022 9:14 PM, olcott wrote:
> On 6/17/2022 9:07 PM, olcott wrote:
>> 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 the
>> final state of this input that all [these] inputs (including
>> pathological inputs) are decided correctly.
>>
>> *computation that halts* … the Turing machine will halt whenever it
>> enters a final state. (Linz:1990:234)
>>
>> Linz, Peter 1990. An Introduction to Formal Languages and Automata.
>> Lexington/Toronto: D. C. Heath and Company. (317-320)
>>
>> void P(u32 x)
>> {
>>    if (H(x, x))
>>      HERE: goto HERE;
>>    return;
>> }
>>
>> int main()
>> {
>>    Output("Input_Halts = ", H((u32)P, (u32)P));
>> }
>>
>> _P()
>> [0000127e](01) 55              push ebp
>> [0000127f](02) 8bec            mov ebp,esp
>> [00001281](03) 8b4508          mov eax,[ebp+08]
>> [00001284](01) 50              push eax
>> [00001285](03) 8b4d08          mov ecx,[ebp+08]
>> [00001288](01) 51              push ecx
>> [00001289](05) e820feffff      call 000010ae
>> [0000128e](03) 83c408          add esp,+08
>> [00001291](02) 85c0            test eax,eax
>> [00001293](02) 7402            jz 00001297
>> [00001295](02) ebfe            jmp 00001295
>> [00001297](01) 5d              pop ebp
>> [00001298](01) c3              ret
>> Size in bytes:(0027) [00001298]
>>
>> _main()
>> [0000129e](01) 55              push ebp
>> [0000129f](02) 8bec            mov ebp,esp
>> [000012a1](05) 687e120000      push 0000127e
>> [000012a6](05) 687e120000      push 0000127e
>> [000012ab](05) e8fefdffff      call 000010ae
>> [000012b0](03) 83c408          add esp,+08
>> [000012b3](01) 50              push eax
>> [000012b4](05) 680f040000      push 0000040f
>> [000012b9](05) e8a0f1ffff      call 0000045e
>> [000012be](03) 83c408          add esp,+08
>> [000012c1](02) 33c0            xor eax,eax
>> [000012c3](01) 5d              pop ebp
>> [000012c4](01) c3              ret
>> Size in bytes:(0039) [000012c4]
>>
>>      machine   stack     stack     machine    assembly
>>      address   address   data      code       language
>>      ======== ======== ======== ========= =============
>> ...[0000129e][0010201f][00000000] 55         push ebp
>> ...[0000129f][0010201f][00000000] 8bec       mov ebp,esp
>> ...[000012a1][0010201b][0000127e] 687e120000 push 0000127e // push P
>> ...[000012a6][00102017][0000127e] 687e120000 push 0000127e // push P
>> ...[000012ab][00102013][000012b0] e8fefdffff call 000010ae // call H
>>
>> *Begin Local Halt Decider Simulation*   Execution Trace Stored at:2120d3
>> ...[0000127e][002120bf][002120c3] 55         push ebp
>> ...[0000127f][002120bf][002120c3] 8bec       mov ebp,esp
>> ...[00001281][002120bf][002120c3] 8b4508     mov eax,[ebp+08]
>> ...[00001284][002120bb][0000127e] 50         push eax      // push P
>> ...[00001285][002120bb][0000127e] 8b4d08     mov ecx,[ebp+08]
>> ...[00001288][002120b7][0000127e] 51         push ecx      // push P
>> ...[00001289][002120b3][0000128e] e820feffff call 000010ae // call H
>> *Infinitely Recursive Simulation Detected Simulation Stopped*
>>
>
> H knows its own machine address and on this basis:
> (a) H recognizes that P is calling H with its same arguments that it was
> called with.
> (b) There are no instructions in P that could possibly escape this
> infinitely recursive emulation.

>
>> ...[000012b0][0010201f][00000000] 83c408     add esp,+08
>> ...[000012b3][0010201b][00000000] 50         push eax
>> ...[000012b4][00102017][0000040f] 680f040000 push 0000040f
>> ---[000012b9][00102017][0000040f] e8a0f1ffff call 0000045e
>> Input_Halts = 0
>> ...[000012be][0010201f][00000000] 83c408     add esp,+08
>> ...[000012c1][0010201f][00000000] 33c0       xor eax,eax
>> ...[000012c3][00102023][00100000] 5d         pop ebp
>> ...[000012c4][00102027][00000004] c3         ret
>> Number of Instructions Executed(1134) == 17 pages
>>
>>
>>
>> Halting problem undecidability and infinitely nested simulation (V5)
>>
>> https://www.researchgate.net/publication/359984584_Halting_problem_undecidability_and_infinitely_nested_simulation_V5
>>
>
>

--
Copyright 2022 Pete Olcott

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

Re: H(P,P)==0 as a pure function of its inputs is fully operational V2

<tJ6dnXUMIcBopTD_nZ2dnUU7_8zNnZ2d@giganews.com>

copy mid

https://www.novabbs.com/devel/article-flat.php?id=34537&group=comp.theory#34537

copy link Newsgroups: comp.theory comp.ai.philosophy sci.logic sci.math

Path: i2pn2.org!i2pn.org!weretis.net!feeder6.news.weretis.net!news.misty.com!border2.nntp.dca1.giganews.com!nntp.giganews.com!buffer2.nntp.dca1.giganews.com!news.giganews.com.POSTED!not-for-mail
NNTP-Posting-Date: Fri, 17 Jun 2022 21:31:17 -0500
Date: Fri, 17 Jun 2022 21:31:16 -0500
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:91.0) Gecko/20100101
Thunderbird/91.10.0
Subject: Re: H(P,P)==0 as a pure function of its inputs is fully operational
V2
Content-Language: en-US
Newsgroups: comp.theory,comp.ai.philosophy,sci.logic,sci.math
References: <l86dnSvJRcj4rjD_nZ2dnUU7_83NnZ2d@giganews.com>
From: NoO...@NoWhere.com (olcott)
In-Reply-To: <l86dnSvJRcj4rjD_nZ2dnUU7_83NnZ2d@giganews.com>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Message-ID: <tJ6dnXUMIcBopTD_nZ2dnUU7_8zNnZ2d@giganews.com>
Lines: 97
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-zWU0oE05wXE213EKzf9mWQaPpWpD+zQpnXt6rrY/HECnJvbxjjNdRgoml3W+CyfaaoZA07U01NTI751!SrQkk+y+r5FkOIASf0YXa7PBwC76DhMnkAutStKMXSEZXJuFLtlKG4Wod8pEKZeY/slDXtx8YBvt
X-Complaints-To: abuse@giganews.com
X-DMCA-Notifications: http://www.giganews.com/info/dmca.html
X-Abuse-and-DMCA-Info: Please be sure to forward a copy of ALL headers
X-Abuse-and-DMCA-Info: Otherwise we will be unable to process your complaint properly
X-Postfilter: 1.3.40
X-Original-Bytes: 5353

by: olcott - Sat, 18 Jun 2022 02:31 UTC

*computation that halts* … the Turing machine will halt whenever it
enters a final state. (Linz:1990:234)

Linz, Peter 1990. An Introduction to Formal Languages and Automata.
Lexington/Toronto: D. C. Heath and Company. (317-320)

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

int main()
{ Output("Input_Halts = ", H((u32)P, (u32)P));
}

Halting problem undecidability and infinitely nested simulation (V5)

https://www.researchgate.net/publication/359984584_Halting_problem_undecidability_and_infinitely_nested_simulation_V5

Re: H(P,P)==0 as a pure function of its inputs is fully operational

<%tbrK.101334$ntj.65215@fx15.iad>

copy mid

https://www.novabbs.com/devel/article-flat.php?id=34538&group=comp.theory#34538

copy link Newsgroups: comp.theory comp.ai.philosophy sci.logic sci.math

Path: i2pn2.org!i2pn.org!usenet.blueworldhosting.com!feed1.usenet.blueworldhosting.com!peer02.iad!feed-me.highwinds-media.com!news.highwinds-media.com!fx15.iad.POSTED!not-for-mail
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:91.0)
Gecko/20100101 Thunderbird/91.10.0
Subject: Re: H(P,P)==0 as a pure function of its inputs is fully operational
Content-Language: en-US
Newsgroups: comp.theory,comp.ai.philosophy,sci.logic,sci.math
References: <l86dnSvJRcj4rjD_nZ2dnUU7_83NnZ2d@giganews.com>
From: Rich...@Damon-Family.org (Richard Damon)
In-Reply-To: <l86dnSvJRcj4rjD_nZ2dnUU7_83NnZ2d@giganews.com>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Lines: 123
Message-ID: <%tbrK.101334$ntj.65215@fx15.iad>
X-Complaints-To: abuse@easynews.com
Organization: Forte - www.forteinc.com
X-Complaints-Info: Please be sure to forward a copy of ALL headers otherwise we will be unable to process your complaint properly.
Date: Fri, 17 Jun 2022 23:18:19 -0400
X-Received-Bytes: 6554

by: Richard Damon - Sat, 18 Jun 2022 03:18 UTC

On 6/17/22 10:07 PM, olcott wrote:
> 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 the final
> state of this input that all [these] inputs (including pathological
> inputs) are decided correctly.
>
> *computation that halts* … the Turing machine will halt whenever it
> enters a final state. (Linz:1990:234)

Right, so for H to have CORRECTLY decided non-halting, then the TURING
MACHINE that it was deciding on must not halt. Since H(P,P) is defined
to be deciding on P(P) (or P was built wrong) and since P(P) as a
directly run function returns if H(P,P) returns 0, that can not be a
correct answer.

Your claim that this isn't what H(P,P) means, just says that you lied
that P was built by the Linz formula and your whole proof just becomes a
lie.

>
> Linz, Peter 1990. An Introduction to Formal Languages and Automata.
> Lexington/Toronto: D. C. Heath and Company. (317-320)
>
> void P(u32 x)
> {
> if (H(x, x))
>     HERE: goto HERE;
> return;
> }
>
> int main()
> {
> Output("Input_Halts = ", H((u32)P, (u32)P));
> }
>
> _P()
> [0000127e](01) 55              push ebp
> [0000127f](02) 8bec            mov ebp,esp
> [00001281](03) 8b4508          mov eax,[ebp+08]
> [00001284](01) 50              push eax
> [00001285](03) 8b4d08          mov ecx,[ebp+08]
> [00001288](01) 51              push ecx
> [00001289](05) e820feffff      call 000010ae
> [0000128e](03) 83c408          add esp,+08
> [00001291](02) 85c0            test eax,eax
> [00001293](02) 7402            jz 00001297
> [00001295](02) ebfe            jmp 00001295
> [00001297](01) 5d              pop ebp
> [00001298](01) c3              ret
> Size in bytes:(0027) [00001298]
>
> _main()
> [0000129e](01) 55              push ebp
> [0000129f](02) 8bec            mov ebp,esp
> [000012a1](05) 687e120000      push 0000127e
> [000012a6](05) 687e120000      push 0000127e
> [000012ab](05) e8fefdffff      call 000010ae
> [000012b0](03) 83c408          add esp,+08
> [000012b3](01) 50              push eax
> [000012b4](05) 680f040000      push 0000040f
> [000012b9](05) e8a0f1ffff      call 0000045e
> [000012be](03) 83c408          add esp,+08
> [000012c1](02) 33c0            xor eax,eax
> [000012c3](01) 5d              pop ebp
> [000012c4](01) c3              ret
> Size in bytes:(0039) [000012c4]
>
>     machine   stack     stack     machine    assembly
>     address   address   data      code       language
>     ======== ======== ======== ========= =============
> ...[0000129e][0010201f][00000000] 55         push ebp
> ...[0000129f][0010201f][00000000] 8bec       mov ebp,esp
> ...[000012a1][0010201b][0000127e] 687e120000 push 0000127e // push P
> ...[000012a6][00102017][0000127e] 687e120000 push 0000127e // push P
> ...[000012ab][00102013][000012b0] e8fefdffff call 000010ae // call H
>
> *Begin Local Halt Decider Simulation*   Execution Trace Stored at:2120d3
> ...[0000127e][002120bf][002120c3] 55         push ebp
> ...[0000127f][002120bf][002120c3] 8bec       mov ebp,esp
> ...[00001281][002120bf][002120c3] 8b4508     mov eax,[ebp+08]
> ...[00001284][002120bb][0000127e] 50         push eax      // push P
> ...[00001285][002120bb][0000127e] 8b4d08     mov ecx,[ebp+08]
> ...[00001288][002120b7][0000127e] 51         push ecx      // push P
> ...[00001289][002120b3][0000128e] e820feffff call 000010ae // call H
> *Infinitely Recursive Simulation Detected Simulation Stopped*
>
> H knows its own machine address and on this basis
> H recognizes that P is calling H with its same arguments that it
> was called with and there are no instructions preceding this call that
> could possibly escape infinitely recursive emulation so H aborts its
> emulation of P before P even makes its first call to H.
>

But that isn't the criteria. The criteria is will the funtion provided
as an input return when called with the second parameter.

It doesn't matter that the code in the C function doesn't have any
stopping code, it is enough that H contains it, since that H is part of
the mathematical/computatinal function P and part of its behaivor.

If H doesn't have a condition to stop it, the H fails to be a decider.

Which way does H fail?

On Fri, 17 Jun 2022 21:07:31 -0500
olcott <NoOne@NoWhere.com> wrote:

> 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 the
> final state of this input that all [these] inputs (including
> pathological inputs) are decided correctly.
>
> *computation that halts* … the Turing machine will halt whenever it
> enters a final state. (Linz:1990:234)
>
> Linz, Peter 1990. An Introduction to Formal Languages and Automata.
> Lexington/Toronto: D. C. Heath and Company. (317-320)
>
> void P(u32 x)
> {
> if (H(x, x))
> HERE: goto HERE;
> return;
> }
>
> int main()
> {
> Output("Input_Halts = ", H((u32)P, (u32)P));
> }
>
> _P()
> [0000127e](01) 55 push ebp
> [0000127f](02) 8bec mov ebp,esp
> [00001281](03) 8b4508 mov eax,[ebp+08]
> [00001284](01) 50 push eax
> [00001285](03) 8b4d08 mov ecx,[ebp+08]
> [00001288](01) 51 push ecx
> [00001289](05) e820feffff call 000010ae
> [0000128e](03) 83c408 add esp,+08
> [00001291](02) 85c0 test eax,eax
> [00001293](02) 7402 jz 00001297
> [00001295](02) ebfe jmp 00001295
> [00001297](01) 5d pop ebp
> [00001298](01) c3 ret
> Size in bytes:(0027) [00001298]
>
> _main()
> [0000129e](01) 55 push ebp
> [0000129f](02) 8bec mov ebp,esp
> [000012a1](05) 687e120000 push 0000127e
> [000012a6](05) 687e120000 push 0000127e
> [000012ab](05) e8fefdffff call 000010ae
> [000012b0](03) 83c408 add esp,+08
> [000012b3](01) 50 push eax
> [000012b4](05) 680f040000 push 0000040f
> [000012b9](05) e8a0f1ffff call 0000045e
> [000012be](03) 83c408 add esp,+08
> [000012c1](02) 33c0 xor eax,eax
> [000012c3](01) 5d pop ebp
> [000012c4](01) c3 ret
> Size in bytes:(0039) [000012c4]
>
> machine stack stack machine assembly
> address address data code language
> ======== ======== ======== ========= ============> ...[0000129e][0010201f][00000000] 55 push ebp
> ...[0000129f][0010201f][00000000] 8bec mov ebp,esp
> ...[000012a1][0010201b][0000127e] 687e120000 push 0000127e // push P
> ...[000012a6][00102017][0000127e] 687e120000 push 0000127e // push P
> ...[000012ab][00102013][000012b0] e8fefdffff call 000010ae // call H
>
> *Begin Local Halt Decider Simulation* Execution Trace Stored
> at:2120d3 ...[0000127e][002120bf][002120c3] 55 push ebp
> ...[0000127f][002120bf][002120c3] 8bec mov ebp,esp
> ...[00001281][002120bf][002120c3] 8b4508 mov eax,[ebp+08]
> ...[00001284][002120bb][0000127e] 50 push eax // push P
> ...[00001285][002120bb][0000127e] 8b4d08 mov ecx,[ebp+08]
> ...[00001288][002120b7][0000127e] 51 push ecx // push P
> ...[00001289][002120b3][0000128e] e820feffff call 000010ae // call H
> *Infinitely Recursive Simulation Detected Simulation Stopped*
>
> H knows its own machine address and on this basis
> H recognizes that P is calling H with its same arguments that it
> was called with and there are no instructions preceding this call that
> could possibly escape infinitely recursive emulation so H aborts its
> emulation of P before P even makes its first call to H.
>
> ...[000012b0][0010201f][00000000] 83c408 add esp,+08
> ...[000012b3][0010201b][00000000] 50 push eax
> ...[000012b4][00102017][0000040f] 680f040000 push 0000040f
> ---[000012b9][00102017][0000040f] e8a0f1ffff call 0000045e
> Input_Halts = 0
> ...[000012be][0010201f][00000000] 83c408 add esp,+08
> ...[000012c1][0010201f][00000000] 33c0 xor eax,eax
> ...[000012c3][00102023][00100000] 5d pop ebp
> ...[000012c4][00102027][00000004] c3 ret
> Number of Instructions Executed(1134) == 17 pages
>
>
>
> Halting problem undecidability and infinitely nested simulation (V5)
>
> https://www.researchgate.net/publication/359984584_Halting_problem_undecidability_and_infinitely_nested_simulation_V5

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

Re: H(P,P)==0 as a pure function of its inputs is fully operational

<AqCdnRVT97k7STD_nZ2dnUU7_81g4p2d@giganews.com>

copy mid

https://www.novabbs.com/devel/article-flat.php?id=34551&group=comp.theory#34551

copy link Newsgroups: comp.theory comp.ai.philosophy sci.logic sci.math

Path: i2pn2.org!i2pn.org!weretis.net!feeder6.news.weretis.net!news.misty.com!border2.nntp.dca1.giganews.com!nntp.giganews.com!buffer2.nntp.dca1.giganews.com!buffer1.nntp.dca1.giganews.com!news.giganews.com.POSTED!not-for-mail
NNTP-Posting-Date: Sat, 18 Jun 2022 08:35:34 -0500
Date: Sat, 18 Jun 2022 08:35:36 -0500
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:91.0) Gecko/20100101
Thunderbird/91.10.0
Subject: Re: H(P,P)==0 as a pure function of its inputs is fully operational
Content-Language: en-US
Newsgroups: comp.theory,comp.ai.philosophy,sci.logic,sci.math
References: <l86dnSvJRcj4rjD_nZ2dnUU7_83NnZ2d@giganews.com>
<20220618142334.000029bd@reddwarf.jmc>
From: NoO...@NoWhere.com (olcott)
In-Reply-To: <20220618142334.000029bd@reddwarf.jmc>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Message-ID: <AqCdnRVT97k7STD_nZ2dnUU7_81g4p2d@giganews.com>
Lines: 154
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-ncWmobbB5vbreUEaZJDTJNTZp4GyTnmVB3gFPG4sT3vXGajJgqwxTo9PACrm5Ixwb5IT7a6z8pUruhQ!bb9d0zSThifpAgsYtTXTYVW4PNCzyQYD6q3AFOqTkWMymudLLfb/5mabbprPMl21URRnhCB/5egp
X-Complaints-To: abuse@giganews.com
X-DMCA-Notifications: http://www.giganews.com/info/dmca.html
X-Abuse-and-DMCA-Info: Please be sure to forward a copy of ALL headers
X-Abuse-and-DMCA-Info: Otherwise we will be unable to process your complaint properly
X-Postfilter: 1.3.40
X-Original-Bytes: 7399

by: olcott - Sat, 18 Jun 2022 13:35 UTC

On 6/18/2022 8:23 AM, Mr Flibble wrote:
> On Fri, 17 Jun 2022 21:07:31 -0500
> olcott <NoOne@NoWhere.com> wrote:
>
>> 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 the
>> final state of this input that all [these] inputs (including
>> pathological inputs) are decided correctly.
>>
>> *computation that halts* … the Turing machine will halt whenever it
>> enters a final state. (Linz:1990:234)
>>
>> Linz, Peter 1990. An Introduction to Formal Languages and Automata.
>> Lexington/Toronto: D. C. Heath and Company. (317-320)
>>
>> void P(u32 x)
>> {
>> if (H(x, x))
>> HERE: goto HERE;
>> return;
>> }
>>
>> int main()
>> {
>> Output("Input_Halts = ", H((u32)P, (u32)P));
>> }
>>
>> _P()
>> [0000127e](01) 55 push ebp
>> [0000127f](02) 8bec mov ebp,esp
>> [00001281](03) 8b4508 mov eax,[ebp+08]
>> [00001284](01) 50 push eax
>> [00001285](03) 8b4d08 mov ecx,[ebp+08]
>> [00001288](01) 51 push ecx
>> [00001289](05) e820feffff call 000010ae
>> [0000128e](03) 83c408 add esp,+08
>> [00001291](02) 85c0 test eax,eax
>> [00001293](02) 7402 jz 00001297
>> [00001295](02) ebfe jmp 00001295
>> [00001297](01) 5d pop ebp
>> [00001298](01) c3 ret
>> Size in bytes:(0027) [00001298]
>>
>> _main()
>> [0000129e](01) 55 push ebp
>> [0000129f](02) 8bec mov ebp,esp
>> [000012a1](05) 687e120000 push 0000127e
>> [000012a6](05) 687e120000 push 0000127e
>> [000012ab](05) e8fefdffff call 000010ae
>> [000012b0](03) 83c408 add esp,+08
>> [000012b3](01) 50 push eax
>> [000012b4](05) 680f040000 push 0000040f
>> [000012b9](05) e8a0f1ffff call 0000045e
>> [000012be](03) 83c408 add esp,+08
>> [000012c1](02) 33c0 xor eax,eax
>> [000012c3](01) 5d pop ebp
>> [000012c4](01) c3 ret
>> Size in bytes:(0039) [000012c4]
>>
>> machine stack stack machine assembly
>> address address data code language
>> ======== ======== ======== ========= =============
>> ...[0000129e][0010201f][00000000] 55 push ebp
>> ...[0000129f][0010201f][00000000] 8bec mov ebp,esp
>> ...[000012a1][0010201b][0000127e] 687e120000 push 0000127e // push P
>> ...[000012a6][00102017][0000127e] 687e120000 push 0000127e // push P
>> ...[000012ab][00102013][000012b0] e8fefdffff call 000010ae // call H
>>
>> *Begin Local Halt Decider Simulation* Execution Trace Stored
>> at:2120d3 ...[0000127e][002120bf][002120c3] 55 push ebp
>> ...[0000127f][002120bf][002120c3] 8bec mov ebp,esp
>> ...[00001281][002120bf][002120c3] 8b4508 mov eax,[ebp+08]
>> ...[00001284][002120bb][0000127e] 50 push eax // push P
>> ...[00001285][002120bb][0000127e] 8b4d08 mov ecx,[ebp+08]
>> ...[00001288][002120b7][0000127e] 51 push ecx // push P
>> ...[00001289][002120b3][0000128e] e820feffff call 000010ae // call H
>> *Infinitely Recursive Simulation Detected Simulation Stopped*
>>
>> H knows its own machine address and on this basis
>> H recognizes that P is calling H with its same arguments that it
>> was called with and there are no instructions preceding this call that
>> could possibly escape infinitely recursive emulation so H aborts its
>> emulation of P before P even makes its first call to H.
>>
>> ...[000012b0][0010201f][00000000] 83c408 add esp,+08
>> ...[000012b3][0010201b][00000000] 50 push eax
>> ...[000012b4][00102017][0000040f] 680f040000 push 0000040f
>> ---[000012b9][00102017][0000040f] e8a0f1ffff call 0000045e
>> Input_Halts = 0
>> ...[000012be][0010201f][00000000] 83c408 add esp,+08
>> ...[000012c1][0010201f][00000000] 33c0 xor eax,eax
>> ...[000012c3][00102023][00100000] 5d pop ebp
>> ...[000012c4][00102027][00000004] c3 ret
>> Number of Instructions Executed(1134) == 17 pages
>>
>>
>>
>> Halting problem undecidability and infinitely nested simulation (V5)
>>
>> https://www.researchgate.net/publication/359984584_Halting_problem_undecidability_and_infinitely_nested_simulation_V5
>
> 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
>

(X) H(P,P) correctly determines (in a finite number of steps) that the
correct and complete x86 emulation of its input would never reach the
"ret" instruction (AKA final state) of this input.

(Y) computation that halts … the Turing machine will halt whenever it
enters a final state. (Linz:1990:234)

(Z) H(P,P) has correctly determined that its input is non-halting.

When we know that X & Y proves Z and we know X & Y then Z is proved.
*Failing to agree with this last line is sufficient evidence of dishonesty*

Linz, Peter 1990. An Introduction to Formal Languages and Automata.
Lexington/Toronto: D. C. Heath and Company. (317-320)

--
Copyright 2022 Pete Olcott

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

Re: H(P,P)==0 as a pure function of its inputs is fully operational

<7bfce095-b38f-482a-84f7-8f463e86280bn@googlegroups.com>

copy mid

https://www.novabbs.com/devel/article-flat.php?id=34552&group=comp.theory#34552

copy link Newsgroups: comp.theory

X-Received: by 2002:adf:e189:0:b0:218:45f0:5c0a with SMTP id az9-20020adfe189000000b0021845f05c0amr13816215wrb.683.1655559556196;
Sat, 18 Jun 2022 06:39:16 -0700 (PDT)
X-Received: by 2002:a81:6c48:0:b0:317:a816:552a with SMTP id
h69-20020a816c48000000b00317a816552amr1164271ywc.99.1655559555553; Sat, 18
Jun 2022 06:39:15 -0700 (PDT)
Path: i2pn2.org!i2pn.org!weretis.net!feeder8.news.weretis.net!proxad.net!feeder1-2.proxad.net!209.85.128.87.MISMATCH!news-out.google.com!nntp.google.com!postnews.google.com!google-groups.googlegroups.com!not-for-mail
Newsgroups: comp.theory
Date: Sat, 18 Jun 2022 06:39:15 -0700 (PDT)
In-Reply-To: <l86dnSvJRcj4rjD_nZ2dnUU7_83NnZ2d@giganews.com>
Injection-Info: google-groups.googlegroups.com; posting-host=124.218.76.41; posting-account=A1PyIwoAAACCahK0CVYFlDZG8JWzz_Go
NNTP-Posting-Host: 124.218.76.41
References: <l86dnSvJRcj4rjD_nZ2dnUU7_83NnZ2d@giganews.com>
User-Agent: G2/1.0
MIME-Version: 1.0
Message-ID: <7bfce095-b38f-482a-84f7-8f463e86280bn@googlegroups.com>
Subject: Re: H(P,P)==0 as a pure function of its inputs is fully operational
From: wynii...@gmail.com (wij)
Injection-Date: Sat, 18 Jun 2022 13:39:16 +0000
Content-Type: text/plain; charset="UTF-8"
Content-Transfer-Encoding: quoted-printable

by: wij - Sat, 18 Jun 2022 13:39 UTC

On Saturday, 18 June 2022 at 10:07:40 UTC+8, olcott wrote:
> 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 the final
> state of this input that all [these] inputs (including pathological
> inputs) are decided correctly.
>
> *computation that halts* … the Turing machine will halt whenever it
> enters a final state. (Linz:1990:234)
>
> Linz, Peter 1990. An Introduction to Formal Languages and Automata.
> Lexington/Toronto: D. C. Heath and Company. (317-320)
>
> void P(u32 x)
> {
> if (H(x, x))
> HERE: goto HERE;
> return;
> }
>
> int main()
> {
> Output("Input_Halts = ", H((u32)P, (u32)P));
> }
>
> _P()
> [0000127e](01) 55 push ebp
> [0000127f](02) 8bec mov ebp,esp
> [00001281](03) 8b4508 mov eax,[ebp+08]
> [00001284](01) 50 push eax
> [00001285](03) 8b4d08 mov ecx,[ebp+08]
> [00001288](01) 51 push ecx
> [00001289](05) e820feffff call 000010ae
> [0000128e](03) 83c408 add esp,+08
> [00001291](02) 85c0 test eax,eax
> [00001293](02) 7402 jz 00001297
> [00001295](02) ebfe jmp 00001295
> [00001297](01) 5d pop ebp
> [00001298](01) c3 ret
> Size in bytes:(0027) [00001298]
>
> _main()
> [0000129e](01) 55 push ebp
> [0000129f](02) 8bec mov ebp,esp
> [000012a1](05) 687e120000 push 0000127e
> [000012a6](05) 687e120000 push 0000127e
> [000012ab](05) e8fefdffff call 000010ae
> [000012b0](03) 83c408 add esp,+08
> [000012b3](01) 50 push eax
> [000012b4](05) 680f040000 push 0000040f
> [000012b9](05) e8a0f1ffff call 0000045e
> [000012be](03) 83c408 add esp,+08
> [000012c1](02) 33c0 xor eax,eax
> [000012c3](01) 5d pop ebp
> [000012c4](01) c3 ret
> Size in bytes:(0039) [000012c4]
>
> machine stack stack machine assembly
> address address data code language
> ======== ======== ======== ========= =============
> ...[0000129e][0010201f][00000000] 55 push ebp
> ...[0000129f][0010201f][00000000] 8bec mov ebp,esp
> ...[000012a1][0010201b][0000127e] 687e120000 push 0000127e // push P
> ...[000012a6][00102017][0000127e] 687e120000 push 0000127e // push P
> ...[000012ab][00102013][000012b0] e8fefdffff call 000010ae // call H
>
> *Begin Local Halt Decider Simulation* Execution Trace Stored at:2120d3
> ...[0000127e][002120bf][002120c3] 55 push ebp
> ...[0000127f][002120bf][002120c3] 8bec mov ebp,esp
> ...[00001281][002120bf][002120c3] 8b4508 mov eax,[ebp+08]
> ...[00001284][002120bb][0000127e] 50 push eax // push P
> ...[00001285][002120bb][0000127e] 8b4d08 mov ecx,[ebp+08]
> ...[00001288][002120b7][0000127e] 51 push ecx // push P
> ...[00001289][002120b3][0000128e] e820feffff call 000010ae // call H
> *Infinitely Recursive Simulation Detected Simulation Stopped*
>
> H knows its own machine address and on this basis
> H recognizes that P is calling H with its same arguments that it
> was called with and there are no instructions preceding this call that
> could possibly escape infinitely recursive emulation so H aborts its
> emulation of P before P even makes its first call to H.
>
> ...[000012b0][0010201f][00000000] 83c408 add esp,+08
> ...[000012b3][0010201b][00000000] 50 push eax
> ...[000012b4][00102017][0000040f] 680f040000 push 0000040f
> ---[000012b9][00102017][0000040f] e8a0f1ffff call 0000045e
> Input_Halts = 0
> ...[000012be][0010201f][00000000] 83c408 add esp,+08
> ...[000012c1][0010201f][00000000] 33c0 xor eax,eax
> ...[000012c3][00102023][00100000] 5d pop ebp
> ...[000012c4][00102027][00000004] c3 ret
> Number of Instructions Executed(1134) == 17 pages
>
>
>
> Halting problem undecidability and infinitely nested simulation (V5)
>
> https://www.researchgate.net/publication/359984584_Halting_problem_undecidability_and_infinitely_nested_simulation_V5

GUR is repeatedly proved:
olcott can never provide a real halting decider except a verbal one.
Thanks olcott.

Re: H(P,P)==0 as a pure function of its inputs is fully operational

<20220618145325.0000368e@reddwarf.jmc>

copy mid

https://www.novabbs.com/devel/article-flat.php?id=34555&group=comp.theory#34555

copy link Newsgroups: comp.theory comp.ai.philosophy sci.logic sci.math

Path: i2pn2.org!i2pn.org!aioe.org!news.uzoreto.com!feeder.usenetexpress.com!tr1.eu1.usenetexpress.com!81.171.65.16.MISMATCH!peer03.ams4!peer.am4.highwinds-media.com!news.highwinds-media.com!fx04.ams4.POSTED!not-for-mail
From: flib...@reddwarf.jmc (Mr Flibble)
Newsgroups: comp.theory,comp.ai.philosophy,sci.logic,sci.math
Subject: Re: H(P,P)==0 as a pure function of its inputs is fully operational
Message-ID: <20220618145325.0000368e@reddwarf.jmc>
References: <l86dnSvJRcj4rjD_nZ2dnUU7_83NnZ2d@giganews.com> <20220618142334.000029bd@reddwarf.jmc> <AqCdnRVT97k7STD_nZ2dnUU7_81g4p2d@giganews.com>
Organization: Jupiter Mining Corp
X-Newsreader: Claws Mail 3.17.8 (GTK+ 2.24.33; x86_64-w64-mingw32)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: quoted-printable
Lines: 165
X-Complaints-To: abuse@eweka.nl
NNTP-Posting-Date: Sat, 18 Jun 2022 13:53:25 UTC
Date: Sat, 18 Jun 2022 14:53:25 +0100
X-Received-Bytes: 7384

by: Mr Flibble - Sat, 18 Jun 2022 13:53 UTC

On Sat, 18 Jun 2022 08:35:36 -0500
olcott <NoOne@NoWhere.com> wrote:

> On 6/18/2022 8:23 AM, Mr Flibble wrote:
> > On Fri, 17 Jun 2022 21:07:31 -0500
> > olcott <NoOne@NoWhere.com> wrote:
> >
> >> 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
> >> the final state of this input that all [these] inputs (including
> >> pathological inputs) are decided correctly.
> >>
> >> *computation that halts* … the Turing machine will halt whenever it
> >> enters a final state. (Linz:1990:234)
> >>
> >> Linz, Peter 1990. An Introduction to Formal Languages and Automata.
> >> Lexington/Toronto: D. C. Heath and Company. (317-320)
> >>
> >> void P(u32 x)
> >> {
> >> if (H(x, x))
> >> HERE: goto HERE;
> >> return;
> >> }
> >>
> >> int main()
> >> {
> >> Output("Input_Halts = ", H((u32)P, (u32)P));
> >> }
> >>
> >> _P()
> >> [0000127e](01) 55 push ebp
> >> [0000127f](02) 8bec mov ebp,esp
> >> [00001281](03) 8b4508 mov eax,[ebp+08]
> >> [00001284](01) 50 push eax
> >> [00001285](03) 8b4d08 mov ecx,[ebp+08]
> >> [00001288](01) 51 push ecx
> >> [00001289](05) e820feffff call 000010ae
> >> [0000128e](03) 83c408 add esp,+08
> >> [00001291](02) 85c0 test eax,eax
> >> [00001293](02) 7402 jz 00001297
> >> [00001295](02) ebfe jmp 00001295
> >> [00001297](01) 5d pop ebp
> >> [00001298](01) c3 ret
> >> Size in bytes:(0027) [00001298]
> >>
> >> _main()
> >> [0000129e](01) 55 push ebp
> >> [0000129f](02) 8bec mov ebp,esp
> >> [000012a1](05) 687e120000 push 0000127e
> >> [000012a6](05) 687e120000 push 0000127e
> >> [000012ab](05) e8fefdffff call 000010ae
> >> [000012b0](03) 83c408 add esp,+08
> >> [000012b3](01) 50 push eax
> >> [000012b4](05) 680f040000 push 0000040f
> >> [000012b9](05) e8a0f1ffff call 0000045e
> >> [000012be](03) 83c408 add esp,+08
> >> [000012c1](02) 33c0 xor eax,eax
> >> [000012c3](01) 5d pop ebp
> >> [000012c4](01) c3 ret
> >> Size in bytes:(0039) [000012c4]
> >>
> >> machine stack stack machine assembly
> >> address address data code language
> >> ======== ======== ======== ========= ============> >> ...[0000129e][0010201f][00000000] 55 push ebp
> >> ...[0000129f][0010201f][00000000] 8bec mov ebp,esp
> >> ...[000012a1][0010201b][0000127e] 687e120000 push 0000127e // push
> >> P ...[000012a6][00102017][0000127e] 687e120000 push 0000127e //
> >> push P ...[000012ab][00102013][000012b0] e8fefdffff call 000010ae
> >> // call H
> >>
> >> *Begin Local Halt Decider Simulation* Execution Trace Stored
> >> at:2120d3 ...[0000127e][002120bf][002120c3] 55 push ebp
> >> ...[0000127f][002120bf][002120c3] 8bec mov ebp,esp
> >> ...[00001281][002120bf][002120c3] 8b4508 mov eax,[ebp+08]
> >> ...[00001284][002120bb][0000127e] 50 push eax // push
> >> P ...[00001285][002120bb][0000127e] 8b4d08 mov ecx,[ebp+08]
> >> ...[00001288][002120b7][0000127e] 51 push ecx // push
> >> P ...[00001289][002120b3][0000128e] e820feffff call 000010ae //
> >> call H *Infinitely Recursive Simulation Detected Simulation
> >> Stopped*
> >>
> >> H knows its own machine address and on this basis
> >> H recognizes that P is calling H with its same arguments that it
> >> was called with and there are no instructions preceding this call
> >> that could possibly escape infinitely recursive emulation so H
> >> aborts its emulation of P before P even makes its first call to H.
> >>
> >> ...[000012b0][0010201f][00000000] 83c408 add esp,+08
> >> ...[000012b3][0010201b][00000000] 50 push eax
> >> ...[000012b4][00102017][0000040f] 680f040000 push 0000040f
> >> ---[000012b9][00102017][0000040f] e8a0f1ffff call 0000045e
> >> Input_Halts = 0
> >> ...[000012be][0010201f][00000000] 83c408 add esp,+08
> >> ...[000012c1][0010201f][00000000] 33c0 xor eax,eax
> >> ...[000012c3][00102023][00100000] 5d pop ebp
> >> ...[000012c4][00102027][00000004] c3 ret
> >> Number of Instructions Executed(1134) == 17 pages
> >>
> >>
> >>
> >> Halting problem undecidability and infinitely nested simulation
> >> (V5)
> >>
> >> https://www.researchgate.net/publication/359984584_Halting_problem_undecidability_and_infinitely_nested_simulation_V5
> >>
> >
> > 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
> >
>
> (X) H(P,P) correctly determines (in a finite number of steps) that
> the correct and complete x86 emulation of its input would never reach
> the "ret" instruction (AKA final state) of this input.
>
> (Y) computation that halts … the Turing machine will halt whenever it
> enters a final state. (Linz:1990:234)
>
> (Z) H(P,P) has correctly determined that its input is non-halting.
>
> When we know that X & Y proves Z and we know X & Y then Z is proved.
> *Failing to agree with this last line is sufficient evidence of
> dishonesty*
>
>
>
> Linz, Peter 1990. An Introduction to Formal Languages and Automata.
> Lexington/Toronto: D. C. Heath and Company. (317-320)

It gets the answer wrong, i.e. input has not been decided correctly.
QED.

/Flibble

Re: H(P,P)==0 as a pure function of its inputs is fully operational

<t8udnTpiCtbbRzD_nZ2dnUU7_81g4p2d@giganews.com>

copy mid

https://www.novabbs.com/devel/article-flat.php?id=34556&group=comp.theory#34556

copy link Newsgroups: comp.theory comp.ai.philosophy sci.logic sci.math

Path: i2pn2.org!i2pn.org!weretis.net!feeder6.news.weretis.net!news.misty.com!border2.nntp.dca1.giganews.com!nntp.giganews.com!buffer2.nntp.dca1.giganews.com!buffer1.nntp.dca1.giganews.com!news.giganews.com.POSTED!not-for-mail
NNTP-Posting-Date: Sat, 18 Jun 2022 08:59:34 -0500
Date: Sat, 18 Jun 2022 08:59:36 -0500
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:91.0) Gecko/20100101
Thunderbird/91.10.0
Subject: Re: H(P,P)==0 as a pure function of its inputs is fully operational
Content-Language: en-US
Newsgroups: comp.theory,comp.ai.philosophy,sci.logic,sci.math
References: <l86dnSvJRcj4rjD_nZ2dnUU7_83NnZ2d@giganews.com>
<20220618142334.000029bd@reddwarf.jmc>
<AqCdnRVT97k7STD_nZ2dnUU7_81g4p2d@giganews.com>
<20220618145325.0000368e@reddwarf.jmc>
From: NoO...@NoWhere.com (olcott)
In-Reply-To: <20220618145325.0000368e@reddwarf.jmc>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Message-ID: <t8udnTpiCtbbRzD_nZ2dnUU7_81g4p2d@giganews.com>
Lines: 174
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-uc1o5IoKO71dGG3ihWxRiU3WsoF+YdK05g/D5Mq56nT2MoYas8/tzJHFxmin3xhsonbL4GuSemzoeqr!U2jovXr2b0YOWQQmRG5gNP88fRWhYRB7yJeha210mlJboaaOwnJaa6EuYiCwchwsWEwHE8FN5ZtM
X-Complaints-To: abuse@giganews.com
X-DMCA-Notifications: http://www.giganews.com/info/dmca.html
X-Abuse-and-DMCA-Info: Please be sure to forward a copy of ALL headers
X-Abuse-and-DMCA-Info: Otherwise we will be unable to process your complaint properly
X-Postfilter: 1.3.40
X-Original-Bytes: 8242

by: olcott - Sat, 18 Jun 2022 13:59 UTC

On 6/18/2022 8:53 AM, Mr Flibble wrote:
> On Sat, 18 Jun 2022 08:35:36 -0500
> olcott <NoOne@NoWhere.com> wrote:
>
>> On 6/18/2022 8:23 AM, Mr Flibble wrote:
>>> On Fri, 17 Jun 2022 21:07:31 -0500
>>> olcott <NoOne@NoWhere.com> wrote:
>>>
>>>> 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
>>>> the final state of this input that all [these] inputs (including
>>>> pathological inputs) are decided correctly.
>>>>
>>>> *computation that halts* … the Turing machine will halt whenever it
>>>> enters a final state. (Linz:1990:234)
>>>>
>>>> Linz, Peter 1990. An Introduction to Formal Languages and Automata.
>>>> Lexington/Toronto: D. C. Heath and Company. (317-320)
>>>>
>>>> void P(u32 x)
>>>> {
>>>> if (H(x, x))
>>>> HERE: goto HERE;
>>>> return;
>>>> }
>>>>
>>>> int main()
>>>> {
>>>> Output("Input_Halts = ", H((u32)P, (u32)P));
>>>> }
>>>>
>>>> _P()
>>>> [0000127e](01) 55 push ebp
>>>> [0000127f](02) 8bec mov ebp,esp
>>>> [00001281](03) 8b4508 mov eax,[ebp+08]
>>>> [00001284](01) 50 push eax
>>>> [00001285](03) 8b4d08 mov ecx,[ebp+08]
>>>> [00001288](01) 51 push ecx
>>>> [00001289](05) e820feffff call 000010ae
>>>> [0000128e](03) 83c408 add esp,+08
>>>> [00001291](02) 85c0 test eax,eax
>>>> [00001293](02) 7402 jz 00001297
>>>> [00001295](02) ebfe jmp 00001295
>>>> [00001297](01) 5d pop ebp
>>>> [00001298](01) c3 ret
>>>> Size in bytes:(0027) [00001298]
>>>>
>>>> _main()
>>>> [0000129e](01) 55 push ebp
>>>> [0000129f](02) 8bec mov ebp,esp
>>>> [000012a1](05) 687e120000 push 0000127e
>>>> [000012a6](05) 687e120000 push 0000127e
>>>> [000012ab](05) e8fefdffff call 000010ae
>>>> [000012b0](03) 83c408 add esp,+08
>>>> [000012b3](01) 50 push eax
>>>> [000012b4](05) 680f040000 push 0000040f
>>>> [000012b9](05) e8a0f1ffff call 0000045e
>>>> [000012be](03) 83c408 add esp,+08
>>>> [000012c1](02) 33c0 xor eax,eax
>>>> [000012c3](01) 5d pop ebp
>>>> [000012c4](01) c3 ret
>>>> Size in bytes:(0039) [000012c4]
>>>>
>>>> machine stack stack machine assembly
>>>> address address data code language
>>>> ======== ======== ======== ========= =============
>>>> ...[0000129e][0010201f][00000000] 55 push ebp
>>>> ...[0000129f][0010201f][00000000] 8bec mov ebp,esp
>>>> ...[000012a1][0010201b][0000127e] 687e120000 push 0000127e // push
>>>> P ...[000012a6][00102017][0000127e] 687e120000 push 0000127e //
>>>> push P ...[000012ab][00102013][000012b0] e8fefdffff call 000010ae
>>>> // call H
>>>>
>>>> *Begin Local Halt Decider Simulation* Execution Trace Stored
>>>> at:2120d3 ...[0000127e][002120bf][002120c3] 55 push ebp
>>>> ...[0000127f][002120bf][002120c3] 8bec mov ebp,esp
>>>> ...[00001281][002120bf][002120c3] 8b4508 mov eax,[ebp+08]
>>>> ...[00001284][002120bb][0000127e] 50 push eax // push
>>>> P ...[00001285][002120bb][0000127e] 8b4d08 mov ecx,[ebp+08]
>>>> ...[00001288][002120b7][0000127e] 51 push ecx // push
>>>> P ...[00001289][002120b3][0000128e] e820feffff call 000010ae //
>>>> call H *Infinitely Recursive Simulation Detected Simulation
>>>> Stopped*
>>>>
>>>> H knows its own machine address and on this basis
>>>> H recognizes that P is calling H with its same arguments that it
>>>> was called with and there are no instructions preceding this call
>>>> that could possibly escape infinitely recursive emulation so H
>>>> aborts its emulation of P before P even makes its first call to H.
>>>>
>>>> ...[000012b0][0010201f][00000000] 83c408 add esp,+08
>>>> ...[000012b3][0010201b][00000000] 50 push eax
>>>> ...[000012b4][00102017][0000040f] 680f040000 push 0000040f
>>>> ---[000012b9][00102017][0000040f] e8a0f1ffff call 0000045e
>>>> Input_Halts = 0
>>>> ...[000012be][0010201f][00000000] 83c408 add esp,+08
>>>> ...[000012c1][0010201f][00000000] 33c0 xor eax,eax
>>>> ...[000012c3][00102023][00100000] 5d pop ebp
>>>> ...[000012c4][00102027][00000004] c3 ret
>>>> Number of Instructions Executed(1134) == 17 pages
>>>>
>>>>
>>>>
>>>> Halting problem undecidability and infinitely nested simulation
>>>> (V5)
>>>>
>>>> https://www.researchgate.net/publication/359984584_Halting_problem_undecidability_and_infinitely_nested_simulation_V5
>>>>
>>>
>>> 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
>>>
>>
>> (X) H(P,P) correctly determines (in a finite number of steps) that
>> the correct and complete x86 emulation of its input would never reach
>> the "ret" instruction (AKA final state) of this input.
>>
>> (Y) computation that halts … the Turing machine will halt whenever it
>> enters a final state. (Linz:1990:234)
>>
>> (Z) H(P,P) has correctly determined that its input is non-halting.
>>
>> When we know that X & Y proves Z and we know X & Y then Z is proved.
>> *Failing to agree with this last line is sufficient evidence of
>> dishonesty*
>>
>>
>>
>> Linz, Peter 1990. An Introduction to Formal Languages and Automata.
>> Lexington/Toronto: D. C. Heath and Company. (317-320)
>
> It gets the answer wrong, i.e. input has not been decided correctly.
> QED.
>
> /Flibble
>

When we know that X & Y proves Z and we know X & Y then Z is proved.
*Failing to agree with this last line is sufficient evidence of dishonesty*

Sufficient evidence of dishonesty!

--
Copyright 2022 Pete Olcott

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

Re: H(P,P)==0 as a pure function of its inputs is fully operational

<t8kmje$1cfl$3@gioia.aioe.org>

copy mid

https://www.novabbs.com/devel/article-flat.php?id=34557&group=comp.theory#34557

copy link Newsgroups: comp.theory

Path: i2pn2.org!i2pn.org!aioe.org!7a25jG6pUKCqa0zKnKnvdg.user.46.165.242.75.POSTED!not-for-mail
From: pyt...@example.invalid (Python)
Newsgroups: comp.theory
Subject: Re: H(P,P)==0 as a pure function of its inputs is fully operational
Date: Sat, 18 Jun 2022 16:14:12 +0200
Organization: Aioe.org NNTP Server
Message-ID: <t8kmje$1cfl$3@gioia.aioe.org>
References: <l86dnSvJRcj4rjD_nZ2dnUU7_83NnZ2d@giganews.com>
<20220618142334.000029bd@reddwarf.jmc>
<AqCdnRVT97k7STD_nZ2dnUU7_81g4p2d@giganews.com>
<20220618145325.0000368e@reddwarf.jmc>
<t8udnTpiCtbbRzD_nZ2dnUU7_81g4p2d@giganews.com>
Mime-Version: 1.0
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 7bit
Injection-Info: gioia.aioe.org; logging-data="45557"; posting-host="7a25jG6pUKCqa0zKnKnvdg.user.gioia.aioe.org"; mail-complaints-to="abuse@aioe.org";
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.13; rv:91.0)
Gecko/20100101 Thunderbird/91.10.0
Content-Language: fr
X-Notice: Filtered by postfilter v. 0.9.2

by: Python - Sat, 18 Jun 2022 14:14 UTC

Demented bigot and crank Peter Olcott wrote:
> On 6/18/2022 8:53 AM, Mr Flibble wrote:
....
>> It gets the answer wrong, i.e. input has not been decided correctly.
>> QED.
>>
>> /Flibble
>>
>
> When we know that X & Y proves Z and we know X & Y then Z is proved.
> *Failing to agree with this last line is sufficient evidence of dishonesty*

Your sophistry does not have this form, Peter.

> Sufficient evidence of dishonesty!

Yours? Definitely.

AGAIN: STOP MULTIPOSTING WITHOUT FOLLOWUP, ASSHOLE!!!

Re: H(P,P)==0 as a pure function of its inputs is fully operational

<q5lrK.1704$vd2.903@fx39.iad>

copy mid

https://www.novabbs.com/devel/article-flat.php?id=34558&group=comp.theory#34558

copy link Newsgroups: comp.theory comp.ai.philosophy sci.logic sci.math

Path: i2pn2.org!i2pn.org!weretis.net!feeder6.news.weretis.net!news.misty.com!border2.nntp.dca1.giganews.com!border1.nntp.dca1.giganews.com!nntp.giganews.com!peer03.iad!feed-me.highwinds-media.com!news.highwinds-media.com!fx39.iad.POSTED!not-for-mail
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:91.0)
Gecko/20100101 Thunderbird/91.10.0
Subject: Re: H(P,P)==0 as a pure function of its inputs is fully operational
Content-Language: en-US
Newsgroups: comp.theory,comp.ai.philosophy,sci.logic,sci.math
References: <l86dnSvJRcj4rjD_nZ2dnUU7_83NnZ2d@giganews.com>
<20220618142334.000029bd@reddwarf.jmc>
<AqCdnRVT97k7STD_nZ2dnUU7_81g4p2d@giganews.com>
<20220618145325.0000368e@reddwarf.jmc>
<t8udnTpiCtbbRzD_nZ2dnUU7_81g4p2d@giganews.com>
From: Rich...@Damon-Family.org (Richard Damon)
In-Reply-To: <t8udnTpiCtbbRzD_nZ2dnUU7_81g4p2d@giganews.com>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Lines: 184
Message-ID: <q5lrK.1704$vd2.903@fx39.iad>
X-Complaints-To: abuse@easynews.com
Organization: Forte - www.forteinc.com
X-Complaints-Info: Please be sure to forward a copy of ALL headers otherwise we will be unable to process your complaint properly.
Date: Sat, 18 Jun 2022 10:14:46 -0400
X-Received-Bytes: 9266
X-Original-Bytes: 9133

by: Richard Damon - Sat, 18 Jun 2022 14:14 UTC

On 6/18/22 9:59 AM, olcott wrote:
> On 6/18/2022 8:53 AM, Mr Flibble wrote:
>> On Sat, 18 Jun 2022 08:35:36 -0500
>> olcott <NoOne@NoWhere.com> wrote:
>>
>>> On 6/18/2022 8:23 AM, Mr Flibble wrote:
>>>> On Fri, 17 Jun 2022 21:07:31 -0500
>>>> olcott <NoOne@NoWhere.com> wrote:
>>>>> 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
>>>>> the final state of this input that all [these] inputs (including
>>>>> pathological inputs) are decided correctly.
>>>>>
>>>>> *computation that halts* … the Turing machine will halt whenever it
>>>>> enters a final state. (Linz:1990:234)
>>>>>
>>>>> Linz, Peter 1990. An Introduction to Formal Languages and Automata.
>>>>> Lexington/Toronto: D. C. Heath and Company. (317-320)
>>>>>
>>>>> void P(u32 x)
>>>>> {
>>>>>      if (H(x, x))
>>>>>        HERE: goto HERE;
>>>>>      return;
>>>>> }
>>>>>
>>>>> int main()
>>>>> {
>>>>>      Output("Input_Halts = ", H((u32)P, (u32)P));
>>>>> }
>>>>>
>>>>> _P()
>>>>> [0000127e](01) 55              push ebp
>>>>> [0000127f](02) 8bec            mov ebp,esp
>>>>> [00001281](03) 8b4508          mov eax,[ebp+08]
>>>>> [00001284](01) 50              push eax
>>>>> [00001285](03) 8b4d08          mov ecx,[ebp+08]
>>>>> [00001288](01) 51              push ecx
>>>>> [00001289](05) e820feffff      call 000010ae
>>>>> [0000128e](03) 83c408          add esp,+08
>>>>> [00001291](02) 85c0            test eax,eax
>>>>> [00001293](02) 7402            jz 00001297
>>>>> [00001295](02) ebfe            jmp 00001295
>>>>> [00001297](01) 5d              pop ebp
>>>>> [00001298](01) c3              ret
>>>>> Size in bytes:(0027) [00001298]
>>>>>
>>>>> _main()
>>>>> [0000129e](01) 55              push ebp
>>>>> [0000129f](02) 8bec            mov ebp,esp
>>>>> [000012a1](05) 687e120000      push 0000127e
>>>>> [000012a6](05) 687e120000      push 0000127e
>>>>> [000012ab](05) e8fefdffff      call 000010ae
>>>>> [000012b0](03) 83c408          add esp,+08
>>>>> [000012b3](01) 50              push eax
>>>>> [000012b4](05) 680f040000      push 0000040f
>>>>> [000012b9](05) e8a0f1ffff      call 0000045e
>>>>> [000012be](03) 83c408          add esp,+08
>>>>> [000012c1](02) 33c0            xor eax,eax
>>>>> [000012c3](01) 5d              pop ebp
>>>>> [000012c4](01) c3              ret
>>>>> Size in bytes:(0039) [000012c4]
>>>>>
>>>>>        machine   stack     stack     machine    assembly
>>>>>        address   address   data      code       language
>>>>>        ======== ======== ======== ========= =============
>>>>> ...[0000129e][0010201f][00000000] 55         push ebp
>>>>> ...[0000129f][0010201f][00000000] 8bec       mov ebp,esp
>>>>> ...[000012a1][0010201b][0000127e] 687e120000 push 0000127e // push
>>>>> P ...[000012a6][00102017][0000127e] 687e120000 push 0000127e //
>>>>> push P ...[000012ab][00102013][000012b0] e8fefdffff call 000010ae
>>>>> // call H
>>>>>
>>>>> *Begin Local Halt Decider Simulation*   Execution Trace Stored
>>>>> at:2120d3 ...[0000127e][002120bf][002120c3] 55         push ebp
>>>>> ...[0000127f][002120bf][002120c3] 8bec       mov ebp,esp
>>>>> ...[00001281][002120bf][002120c3] 8b4508     mov eax,[ebp+08]
>>>>> ...[00001284][002120bb][0000127e] 50         push eax      // push
>>>>> P ...[00001285][002120bb][0000127e] 8b4d08     mov ecx,[ebp+08]
>>>>> ...[00001288][002120b7][0000127e] 51         push ecx      // push
>>>>> P ...[00001289][002120b3][0000128e] e820feffff call 000010ae //
>>>>> call H *Infinitely Recursive Simulation Detected Simulation
>>>>> Stopped*
>>>>>
>>>>> H knows its own machine address and on this basis
>>>>> H recognizes that P is calling H with its same arguments that it
>>>>> was called with and there are no instructions preceding this call
>>>>> that could possibly escape infinitely recursive emulation so H
>>>>> aborts its emulation of P before P even makes its first call to H.
>>>>>
>>>>> ...[000012b0][0010201f][00000000] 83c408     add esp,+08
>>>>> ...[000012b3][0010201b][00000000] 50         push eax
>>>>> ...[000012b4][00102017][0000040f] 680f040000 push 0000040f
>>>>> ---[000012b9][00102017][0000040f] e8a0f1ffff call 0000045e
>>>>> Input_Halts = 0
>>>>> ...[000012be][0010201f][00000000] 83c408     add esp,+08
>>>>> ...[000012c1][0010201f][00000000] 33c0       xor eax,eax
>>>>> ...[000012c3][00102023][00100000] 5d         pop ebp
>>>>> ...[000012c4][00102027][00000004] c3         ret
>>>>> Number of Instructions Executed(1134) == 17 pages
>>>>>
>>>>>
>>>>>
>>>>> Halting problem undecidability and infinitely nested simulation
>>>>> (V5)
>>>>>
>>>>> https://www.researchgate.net/publication/359984584_Halting_problem_undecidability_and_infinitely_nested_simulation_V5
>>>>>
>>>>
>>>> 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
>>>
>>> (X) H(P,P) correctly determines (in a finite number of steps) that
>>> the correct and complete x86 emulation of its input would never reach
>>> the "ret" instruction (AKA final state) of this input.
>>>
>>> (Y) computation that halts … the Turing machine will halt whenever it
>>> enters a final state. (Linz:1990:234)
>>>
>>> (Z) H(P,P) has correctly determined that its input is non-halting.
>>>
>>> When we know that X & Y proves Z and we know X & Y then Z is proved.
>>> *Failing to agree with this last line is sufficient evidence of
>>> dishonesty*
>>>
>>>
>>>
>>> Linz, Peter 1990. An Introduction to Formal Languages and Automata.
>>> Lexington/Toronto: D. C. Heath and Company. (317-320)
>>
>> It gets the answer wrong, i.e. input has not been decided correctly.
>> QED.
>>
>> /Flibble
>>
>
> When we know that X & Y proves Z and we know X & Y then Z is proved.
> *Failing to agree with this last line is sufficient evidence of dishonesty*
>
> Sufficient evidence of dishonesty!
>
>

Click here to read the complete article

Re: H(P,P)==0 as a pure function of its inputs is fully operational [ 131K zipped VS project ]

<eIadnWfewpBx9DL_nZ2dnUU7_83NnZ2d@giganews.com>

copy mid

https://www.novabbs.com/devel/article-flat.php?id=34593&group=comp.theory#34593

copy link Newsgroups: comp.theory comp.ai.philosophy sci.logic sci.math

Path: i2pn2.org!i2pn.org!usenet.blueworldhosting.com!feed1.usenet.blueworldhosting.com!peer01.iad!feed-me.highwinds-media.com!news.highwinds-media.com!border1.nntp.dca1.giganews.com!nntp.giganews.com!buffer1.nntp.dca1.giganews.com!news.giganews.com.POSTED!not-for-mail
NNTP-Posting-Date: Sun, 19 Jun 2022 13:24:43 -0500
Date: Sun, 19 Jun 2022 13:24:44 -0500
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:91.0) Gecko/20100101
Thunderbird/91.10.0
Subject: Re: H(P,P)==0 as a pure function of its inputs is fully operational [
131K zipped VS project ]
Content-Language: en-US
Newsgroups: comp.theory,comp.ai.philosophy,sci.logic,sci.math
References: <l86dnSvJRcj4rjD_nZ2dnUU7_83NnZ2d@giganews.com>
From: NoO...@NoWhere.com (olcott)
In-Reply-To: <l86dnSvJRcj4rjD_nZ2dnUU7_83NnZ2d@giganews.com>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Message-ID: <eIadnWfewpBx9DL_nZ2dnUU7_83NnZ2d@giganews.com>
Lines: 128
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-wRaOnk0zUkrLuBuuXB+5HTt9lOlXOBtxxDf2mOw5viTXhOAi09dVne9dpyYGwzS91aUns6vkYzTyuHW!6HIxNN0Of8YYMMss4mi/+SQaZgzC5K0bHZhKtgkvMvOzyRS0flcka9y8MhFxUI8Jt6NEo3RkxETF
X-Complaints-To: abuse@giganews.com
X-DMCA-Notifications: http://www.giganews.com/info/dmca.html
X-Abuse-and-DMCA-Info: Please be sure to forward a copy of ALL headers
X-Abuse-and-DMCA-Info: Otherwise we will be unable to process your complaint properly
X-Postfilter: 1.3.40
X-Original-Bytes: 7156
X-Received-Bytes: 7247

by: olcott - Sun, 19 Jun 2022 18:24 UTC

All of the code including several halt deciders that use different
methods for pathological inputs and take 0,1,2 arguments, along with the
complete x86 emulator fits in a 131K zip file and is configured as a
visual studio project. *I just got this done right now*

The prior pathological input decider required static local data that was
stored directly in the function body. it construed infinitely nested
simulation as infinite recursion.

The current pathological input decider is a pure function of its inputs.
The infinite loop and infinite recursion deciders remain the same.

This is the the design of the pathological input decider :

H knows its own machine address and on this basis:
(a) H recognizes that P is calling H with the same arguments that H was
called with.
(b) There are no instructions in P that could possibly escape this
infinitely recursive emulation.
(c) H aborts its emulation of P before P its call to H is invoked.

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

Re: H(P,P)==0 as a pure function of its inputs is fully operational [ 131K zipped VS project ]

<_0KrK.302938$zgr9.295984@fx13.iad>

copy mid

https://www.novabbs.com/devel/article-flat.php?id=34595&group=comp.theory#34595

copy link Newsgroups: comp.theory comp.ai.philosophy sci.logic sci.math

Path: i2pn2.org!i2pn.org!weretis.net!feeder8.news.weretis.net!news.uzoreto.com!tr2.eu1.usenetexpress.com!feeder.usenetexpress.com!tr2.iad1.usenetexpress.com!peer03.iad!feed-me.highwinds-media.com!news.highwinds-media.com!fx13.iad.POSTED!not-for-mail
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:91.0) Gecko/20100101 Thunderbird/91.10.0
Subject: Re: H(P,P)==0 as a pure function of its inputs is fully operational [ 131K zipped VS project ]
Content-Language: en-US
Newsgroups: comp.theory,comp.ai.philosophy,sci.logic,sci.math
References: <l86dnSvJRcj4rjD_nZ2dnUU7_83NnZ2d@giganews.com> <eIadnWfewpBx9DL_nZ2dnUU7_83NnZ2d@giganews.com>
From: Rich...@Damon-Family.org (Richard Damon)
In-Reply-To: <eIadnWfewpBx9DL_nZ2dnUU7_83NnZ2d@giganews.com>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Lines: 151
Message-ID: <_0KrK.302938$zgr9.295984@fx13.iad>
X-Complaints-To: abuse@easynews.com
Organization: Forte - www.forteinc.com
X-Complaints-Info: Please be sure to forward a copy of ALL headers otherwise we will be unable to process your complaint properly.
Date: Sun, 19 Jun 2022 14:36:40 -0400
X-Received-Bytes: 8112

by: Richard Damon - Sun, 19 Jun 2022 18:36 UTC

On 6/19/22 2:24 PM, olcott wrote:
> On 6/17/2022 9:07 PM, olcott wrote:
>> 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 the
>> final state of this input that all [these] inputs (including
>> pathological inputs) are decided correctly.
>>
>> *computation that halts* … the Turing machine will halt whenever it
>> enters a final state. (Linz:1990:234)
>>
>> Linz, Peter 1990. An Introduction to Formal Languages and Automata.
>> Lexington/Toronto: D. C. Heath and Company. (317-320)
>>
>> void P(u32 x)
>> {
>>    if (H(x, x))
>>      HERE: goto HERE;
>>    return;
>> }
>>
>> int main()
>> {
>>    Output("Input_Halts = ", H((u32)P, (u32)P));
>> }
>>
>> _P()
>> [0000127e](01) 55              push ebp
>> [0000127f](02) 8bec            mov ebp,esp
>> [00001281](03) 8b4508          mov eax,[ebp+08]
>> [00001284](01) 50              push eax
>> [00001285](03) 8b4d08          mov ecx,[ebp+08]
>> [00001288](01) 51              push ecx
>> [00001289](05) e820feffff      call 000010ae
>> [0000128e](03) 83c408          add esp,+08
>> [00001291](02) 85c0            test eax,eax
>> [00001293](02) 7402            jz 00001297
>> [00001295](02) ebfe            jmp 00001295
>> [00001297](01) 5d              pop ebp
>> [00001298](01) c3              ret
>> Size in bytes:(0027) [00001298]
>>
>> _main()
>> [0000129e](01) 55              push ebp
>> [0000129f](02) 8bec            mov ebp,esp
>> [000012a1](05) 687e120000      push 0000127e
>> [000012a6](05) 687e120000      push 0000127e
>> [000012ab](05) e8fefdffff      call 000010ae
>> [000012b0](03) 83c408          add esp,+08
>> [000012b3](01) 50              push eax
>> [000012b4](05) 680f040000      push 0000040f
>> [000012b9](05) e8a0f1ffff      call 0000045e
>> [000012be](03) 83c408          add esp,+08
>> [000012c1](02) 33c0            xor eax,eax
>> [000012c3](01) 5d              pop ebp
>> [000012c4](01) c3              ret
>> Size in bytes:(0039) [000012c4]
>>
>>      machine   stack     stack     machine    assembly
>>      address   address   data      code       language
>>      ======== ======== ======== ========= =============
>> ...[0000129e][0010201f][00000000] 55         push ebp
>> ...[0000129f][0010201f][00000000] 8bec       mov ebp,esp
>> ...[000012a1][0010201b][0000127e] 687e120000 push 0000127e // push P
>> ...[000012a6][00102017][0000127e] 687e120000 push 0000127e // push P
>> ...[000012ab][00102013][000012b0] e8fefdffff call 000010ae // call H
>>
>> *Begin Local Halt Decider Simulation*   Execution Trace Stored at:2120d3
>> ...[0000127e][002120bf][002120c3] 55         push ebp
>> ...[0000127f][002120bf][002120c3] 8bec       mov ebp,esp
>> ...[00001281][002120bf][002120c3] 8b4508     mov eax,[ebp+08]
>> ...[00001284][002120bb][0000127e] 50         push eax      // push P
>> ...[00001285][002120bb][0000127e] 8b4d08     mov ecx,[ebp+08]
>> ...[00001288][002120b7][0000127e] 51         push ecx      // push P
>> ...[00001289][002120b3][0000128e] e820feffff call 000010ae // call H
>> *Infinitely Recursive Simulation Detected Simulation Stopped*
>>
>> H knows its own machine address and on this basis
>> H recognizes that P is calling H with its same arguments that it
>> was called with and there are no instructions preceding this call that
>> could possibly escape infinitely recursive emulation so H aborts its
>> emulation of P before P even makes its first call to H.
>>
>> ...[000012b0][0010201f][00000000] 83c408     add esp,+08
>> ...[000012b3][0010201b][00000000] 50         push eax
>> ...[000012b4][00102017][0000040f] 680f040000 push 0000040f
>> ---[000012b9][00102017][0000040f] e8a0f1ffff call 0000045e
>> Input_Halts = 0
>> ...[000012be][0010201f][00000000] 83c408     add esp,+08
>> ...[000012c1][0010201f][00000000] 33c0       xor eax,eax
>> ...[000012c3][00102023][00100000] 5d         pop ebp
>> ...[000012c4][00102027][00000004] c3         ret
>> Number of Instructions Executed(1134) == 17 pages
>>
>>
>>
>> Halting problem undecidability and infinitely nested simulation (V5)
>>
>> https://www.researchgate.net/publication/359984584_Halting_problem_undecidability_and_infinitely_nested_simulation_V5
>>
>
> All of the code including several halt deciders that use different
> methods for pathological inputs and take 0,1,2 arguments, along with the
> complete x86 emulator fits in a 131K zip file and is configured as a
> visual studio project. *I just got this done right now*
>
> The prior pathological input decider required static local data that was
> stored directly in the function body. it construed infinitely nested
> simulation as infinite recursion.
>
> The current pathological input decider is a pure function of its inputs.
> The infinite loop and infinite recursion deciders remain the same.
>
> This is the the design of the pathological input decider :
>
> H knows its own machine address and on this basis:
> (a) H recognizes that P is calling H with the same arguments that H was
> called with.
> (b) There are no instructions in P that could possibly escape this
> infinitely recursive emulation.
> (c) H aborts its emulation of P before P its call to H is invoked.
>
>

The problem is your rule is incorrect, P doesn't need an instruction in
the code in P before the call to H to terminate the recurssion, because
the instruction to terminate the recursion exists in H,

If H aborts its simulation and returns the 0 to P, then P halts, and
thus H was wrong to decide its input was non-halting.

In all the cases, P is asking H to decide on what it will itself with
the input it was given, and it does the opposite.

The parameters given to H don't actually ask that question, then you
formed P incorrectly, so your "proof" is invalid.

If you CAN'T ask H that question, then H fails to even pretend to be a
universal halt decider, not even being able to be asked the key question
that shows that a universal halt decider can't exist.

Thus, your proof doesn't actually show what you claim, because you are
using an incorrect criteria.

The ONLY valid criteria is will the computation represented by the input
Halt when run as an unfettered computation, and P (your name for H^)
makes sure that H doesn't give the right answer. Alternate criteria can
be used, but only if they exactly agree with the actual definition.
Since yours doesn't, you can't use it.

FAIL.

Re: H(P,P)==0 as a pure function of its inputs is fully operational

<5e8bff2a-873b-4a99-9962-3bbc8a152056n@googlegroups.com>

copy mid

https://www.novabbs.com/devel/article-flat.php?id=34651&group=comp.theory#34651

copy link Newsgroups: comp.theory

X-Received: by 2002:a05:600c:1410:b0:39c:6fef:4b4c with SMTP id g16-20020a05600c141000b0039c6fef4b4cmr31859873wmi.124.1655688392129;
Sun, 19 Jun 2022 18:26:32 -0700 (PDT)
X-Received: by 2002:a81:2594:0:b0:310:6b:47b0 with SMTP id l142-20020a812594000000b00310006b47b0mr25240867ywl.14.1655688391679;
Sun, 19 Jun 2022 18:26:31 -0700 (PDT)
Path: i2pn2.org!i2pn.org!weretis.net!feeder8.news.weretis.net!proxad.net!feeder1-2.proxad.net!209.85.128.88.MISMATCH!news-out.google.com!nntp.google.com!postnews.google.com!google-groups.googlegroups.com!not-for-mail
Newsgroups: comp.theory
Date: Sun, 19 Jun 2022 18:26:31 -0700 (PDT)
In-Reply-To: <l86dnSvJRcj4rjD_nZ2dnUU7_83NnZ2d@giganews.com>
Injection-Info: google-groups.googlegroups.com; posting-host=124.218.76.41; posting-account=A1PyIwoAAACCahK0CVYFlDZG8JWzz_Go
NNTP-Posting-Host: 124.218.76.41
References: <l86dnSvJRcj4rjD_nZ2dnUU7_83NnZ2d@giganews.com>
User-Agent: G2/1.0
MIME-Version: 1.0
Message-ID: <5e8bff2a-873b-4a99-9962-3bbc8a152056n@googlegroups.com>
Subject: Re: H(P,P)==0 as a pure function of its inputs is fully operational
From: wynii...@gmail.com (wij)
Injection-Date: Mon, 20 Jun 2022 01:26:32 +0000
Content-Type: text/plain; charset="UTF-8"
Content-Transfer-Encoding: quoted-printable

by: wij - Mon, 20 Jun 2022 01:26 UTC

GUR is REPEATEDLY proved by POOH: Halting decider cannot exist.

No matter how he tried, olcott has repeatedly shown he cannot provide a real
halting decider except a verbal (or fake) one.

"You tweachewous miscweant!" -- Elmer Fudd

devel / comp.theory / Re: H(P,P)==0 as a pure function of its inputs is fully operational

Subject	Author
H(P,P)==0 as a pure function of its inputs is fully operational	olcott
H(P,P)==0 as a pure function of its inputs is fully operational	olcott
H(P,P)==0 as a pure function of its inputs is fully operational	olcott
H(P,P)==0 as a pure function of its inputs is fully operational	olcott
H(P,P)==0 as a pure function of its inputs is fully operational	Richard Damon
H(P,P)==0 as a pure function of its inputs is fully operational	Mr Flibble
H(P,P)==0 as a pure function of its inputs is fully operational	olcott
H(P,P)==0 as a pure function of its inputs is fully operational	Mr Flibble
H(P,P)==0 as a pure function of its inputs is fully operational	olcott
H(P,P)==0 as a pure function of its inputs is fully operational	Python
H(P,P)==0 as a pure function of its inputs is fully operational	Richard Damon
H(P,P)==0 as a pure function of its inputs is fully operational	wij
H(P,P)==0 as a pure function of its inputs is fully operational [	olcott
H(P,P)==0 as a pure function of its inputs is fully operational [ 131K zipped VS	Richard Damon
H(P,P)==0 as a pure function of its inputs is fully operational	wij