Rocksolid Light

Welcome to novaBBS (click a section below)

mail  files  register  newsreader  groups  login

Message-ID:  

My apologies if I sound angry. I feel like I'm talking to a void. -- Avery Pennarun


devel / comp.theory / Re: Proof that H(P,P)==0 is correct [ refuting the halting problem proofs ](V2)

SubjectAuthor
* Proof that H(P,P)==0 is correct [ refuting the halting problem proofsolcott
+* Proof that H(P,P)==0 is correct [ refuting the halting problemMr Flibble
|`* Proof that H(P,P)==0 is correct [ refuting the halting problemolcott
| +- Proof that H(P,P)==0 is correct [ refuting the halting problemRichard Damon
| +* Proof that H(P,P)==0 is correct [ refuting the halting problem proofs ](V2)Mr Flibble
| |`- Proof that H(P,P)==0 is correct [ refuting the halting problemolcott
| `* Proof that H(P,P)==0 is correct [ refuting the halting problemMr Flibble
|  `* Proof that H(P,P)==0 is correct [ refuting the halting problemolcott
|   +* Proof that H(P,P)==0 is correct [ refuting the halting problem proofs ](V2)Mr Flibble
|   |`* Proof that H(P,P)==0 is correct [ refuting the halting problemolcott
|   | +* Proof that H(P,P)==0 is correct [ refuting the halting problemMr Flibble
|   | |`* Proof that H(P,P)==0 is correct [ refuting the halting problemolcott
|   | | +- Proof that H(P,P)==0 is correct [ refuting the halting problemMr Flibble
|   | | +* Proof that H(P,P)==0 is correct [ refuting the halting problem proofs ](V2)Ben
|   | | |`* Proof that H(P,P)==0 is correct [ refuting the halting problemolcott
|   | | | +* Proof that H(P,P)==0 is correct [ refuting the halting problem proofs ](V2)Ben
|   | | | |`* Proof that H(P,P)==0 is correct [ refuting the halting problemolcott
|   | | | | +* Proof that H(P,P)==0 is correct [ refuting the halting problem proofs ](V2)Ben
|   | | | | |`* Proof that H(P,P)==0 is correct [ refuting the halting problemolcott
|   | | | | | +- Proof that H(P,P)==0 is correct [ refuting the halting problemRichard Damon
|   | | | | | `- Proof that H(P,P)==0 is correct [ refuting the halting problem proofs ](V2)Ben
|   | | | | `- Proof that H(P,P)==0 is correct [ refuting the halting problemRichard Damon
|   | | | `- Proof that H(P,P)==0 is correct [ refuting the halting problemRichard Damon
|   | | `- Proof that H(P,P)==0 is correct [ refuting the halting problemRichard Damon
|   | `- Proof that H(P,P)==0 is correct [ refuting the halting problemRichard Damon
|   `- Proof that H(P,P)==0 is correct [ refuting the halting problemRichard Damon
+- Proof that H(P,P)==0 is correct [ refuting the halting problemRichard Damon
+* Proof that H(P,P)==0 is correct [ refuting the halting problem proofs ](V2)Ben
|`* Proof that H(P,P)==0 is correct [ refuting the halting problemolcott
| +- Proof that H(P,P)==0 is correct [ refuting the halting problemRichard Damon
| `* Proof that H(P,P)==0 is correct [ refuting the halting problem proofs ](V2)Ben
|  `* Proof that H(P,P)==0 is correct [ refuting the halting problemolcott
|   +- Proof that H(P,P)==0 is correct [ refuting the halting problemRichard Damon
|   `* Proof that H(P,P)==0 is correct [ refuting the halting problem proofs ](V2)Ben
|    `* Proof that H(P,P)==0 is correct [ refuting the halting problemolcott
|     +* Proof that H(P,P)==0 is correct [ refuting the halting problemMr Flibble
|     |`- Proof that H(P,P)==0 is correct [ refuting the halting problemolcott
|     +* Proof that H(P,P)==0 is correct [ refuting the halting problem proofs ](V2)Ben
|     |`* Proof that H(P,P)==0 is correct [ foundation of truth itself ]olcott
|     | +- Proof that H(P,P)==0 is correct [ foundation of truth itself ]Richard Damon
|     | +* Proof that H(P,P)==0 is correct [ foundation of truth itself ]Ben
|     | |`* Proof that H(P,P)==0 is correct [ foundation of truth itself ]olcott
|     | | `* Proof that H(P,P)==0 is correct [ foundation of truth itself ]Ben
|     | |  `* Proof that H(P,P)==0 is correct [ foundation of truth itself ]olcott
|     | |   +* Proof that H(P,P)==0 is correct [ foundation of truth itself ]Richard Damon
|     | |   |`* Proof that H(P,P)==0 is correct [ foundation of truth itself ]olcott
|     | |   | +* Proof that H(P,P)==0 is correct [ foundation of truth itself ]Dennis Bush
|     | |   | |`* Proof that H(P,P)==0 is correct [ foundation of truth itself ]olcott
|     | |   | | `- Proof that H(P,P)==0 is correct [ foundation of truth itself ]Mr Flibble
|     | |   | +- Proof that H(P,P)==0 is correct [ foundation of truth itself ]wij
|     | |   | `* Proof that H(P,P)==0 is correct [ foundation of truth itself ]Richard Damon
|     | |   |  `* Proof that H(P,P)==0 is correct [ foundation of truth itself ]olcott
|     | |   |   `* Proof that H(P,P)==0 is correct [ foundation of truth itself ]Richard Damon
|     | |   |    `* Proof that H(P,P)==0 is correct [ foundation of truth itself ]olcott
|     | |   |     `* Proof that H(P,P)==0 is correct [ foundation of truth itself ]Richard Damon
|     | |   |      `* Proof that H(P,P)==0 is correct [ foundation of truth itself ]olcott
|     | |   |       `* Proof that H(P,P)==0 is correct [ foundation of truth itself ]Richard Damon
|     | |   |        `* Proof that H(P,P)==0 is correct [ foundation of truth itself ]olcott
|     | |   |         `* Proof that H(P,P)==0 is correct [ foundation of truth itself ]Richard Damon
|     | |   |          `* Proof that H(P,P)==0 is correct [ foundation of truth itself ]olcott
|     | |   |           +- Proof that H(P,P)==0 is correct [ foundation of truth itself ]Richard Damon
|     | |   |           `* Proof that H(P,P)==0 is correct [ foundation of truth itself ]André G. Isaak
|     | |   |            +- Proof that H(P,P)==0 is correct [ foundation of truth itself ]Richard Damon
|     | |   |            `- Proof that H(P,P)==0 is correct [ foundation of truth itself ]olcott
|     | |   `* Proof that H(P,P)==0 is correct [ foundation of truth itself ]Ben
|     | |    `* Proof that H(P,P)==0 is correct [ foundation of truth itself ]olcott
|     | |     +* Proof that H(P,P)==0 is correct [ foundation of truth itself ]Richard Damon
|     | |     |`* Proof that H(P,P)==0 is correct [ foundation of truth itself ]olcott
|     | |     | `- Proof that H(P,P)==0 is correct [ foundation of truth itself ]Richard Damon
|     | |     +* Proof that H(P,P)==0 is correct [ foundation of truth itself ]Ben
|     | |     |`* Proof that H(P,P)==0 is correct [ foundation of truth itself ]olcott
|     | |     | `* Proof that H(P,P)==0 is correct [ foundation of truth itself ]Ben
|     | |     |  `* Proof that H(P,P)==0 is correct [ foundation of truth itself ]olcott
|     | |     |   `- Proof that H(P,P)==0 is correct [ foundation of truth itself ]Ben
|     | |     `* Proof that H(P,P)==0 is correct [ foundation of truth itself ]Mikko
|     | |      `* Proof that H(P,P)==0 is correct [ foundation of truth itself ]olcott
|     | |       `* Proof that H(P,P)==0 is correct [ foundation of truth itself ]Mikko
|     | |        `* Proof that H(P,P)==0 is correct [ foundation of truth itself ]olcott
|     | |         `- Proof that H(P,P)==0 is correct [ foundation of truth itself ]Mikko
|     | `* Proof that H(P,P)==0 is correct [ foundation of truth itself ]Mikko
|     |  `* Proof that H(P,P)==0 is correct [ foundation of truth itself ]olcott
|     |   `- Proof that H(P,P)==0 is correct [ foundation of truth itself ]Mikko
|     `- Proof that H(P,P)==0 is correct [ refuting the halting problemRichard Damon
+- Proof that H(P,P)==0 is correct [ refuting the halting problem proofs ](V2)Mikko
`- Proof that H(P,P)==0 is correct [ refuting the halting problemwij

Pages:1234
Proof that H(P,P)==0 is correct [ refuting the halting problem proofs ](V2)

<2pSdnR25lqHLZub_nZ2dnUU7_8zNnZ2d@giganews.com>

 copy mid

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

 copy link   Newsgroups: comp.theory comp.ai.philosophy sci.logic
Followup: comp.theory
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: Wed, 11 May 2022 13:07:18 -0500
Date: Wed, 11 May 2022 13:07:16 -0500
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:91.0) Gecko/20100101
Thunderbird/91.9.0
Newsgroups: comp.theory,comp.ai.philosophy,sci.logic
Content-Language: en-US
Followup-To: comp.theory
From: NoO...@NoWhere.com (olcott)
Subject: Proof that H(P,P)==0 is correct [ refuting the halting problem proofs
](V2)
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 7bit
Message-ID: <2pSdnR25lqHLZub_nZ2dnUU7_8zNnZ2d@giganews.com>
Lines: 136
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-LwukSJT5xQPew/avCyZ2QIZvdrU5J+DT6xQUpKn/lwDAIQtRSbKlKp/BgIU7uRhwOGhJg1PP7usfFTF!UTtVU44snP0IQP9Xwl7qjs3DOpuw0nKxUMih9L8EYfL68Zh6FqNOKRvtSJbdGUPBIKX4KhhEJsE=
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: 6929
 by: olcott - Wed, 11 May 2022 18:07 UTC

Proof that H(P,P)==0 is correct [ refuting the halting problem proofs ]

The x86utm operating system was created so that every detail of the
conventional halting problem counter example could be fully specified in
C/x86.

In computability theory, the halting problem is the
problem of determining, from a description of an
arbitrary computer program and an input, whether the
program will finish running, or continue to run forever...

For any program f that might determine if programs halt,
a "pathological" program g, called with some input, can
pass its own source and its input to f and then specifically
do the opposite of what f predicts g will do. No f can exist
that handles this case. https://en.wikipedia.org/wiki/Halting_problem

This exact same relationship of f(g,g) was created as H(P,P), shown below.

This is the overview of the method for proving that this analysis is
correct:
(a) Verify that the execution trace of P by H is correct by comparing
this execution trace to the ax86 source-code of P.

(b) Verify that this execution trace shows that P is stuck in infinitely
nested simulation (a non-halting behavior).

This proof can only be understood only by those having sufficient
technical competence in:
(a) software engineering (recognizing infinite recursion in C and x86 code)
(b) the x86 programming language
(c) the C programming language and
(d) the details of how C is translated into x86 by the Microsoft C
compilers.

#include <stdint.h>
#define u32 uint32_t

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

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

_P()
[00001352](01) 55 push ebp
[00001353](02) 8bec mov ebp,esp
[00001355](03) 8b4508 mov eax,[ebp+08]
[00001358](01) 50 push eax
[00001359](03) 8b4d08 mov ecx,[ebp+08]
[0000135c](01) 51 push ecx
[0000135d](05) e840feffff call 000011a2 // call H
[00001362](03) 83c408 add esp,+08
[00001365](02) 85c0 test eax,eax
[00001367](02) 7402 jz 0000136b
[00001369](02) ebfe jmp 00001369
[0000136b](01) 5d pop ebp
[0000136c](01) c3 ret
Size in bytes:(0027) [0000136c]

_main()
[00001372](01) 55 push ebp
[00001373](02) 8bec mov ebp,esp
[00001375](05) 6852130000 push 00001352 // push P
[0000137a](05) 6852130000 push 00001352 // push P
[0000137f](05) e81efeffff call 000011a2 // call H
[00001384](03) 83c408 add esp,+08
[00001387](01) 50 push eax
[00001388](05) 6823040000 push 00000423 // "Input_Halts = "
[0000138d](05) e8e0f0ffff call 00000472 // call Output
[00001392](03) 83c408 add esp,+08
[00001395](02) 33c0 xor eax,eax
[00001397](01) 5d pop ebp
[00001398](01) c3 ret
Size in bytes:(0039) [00001398]

machine stack stack machine assembly
address address data code language
======== ======== ======== ========= =============
....[00001372][0010229e][00000000] 55 push ebp
....[00001373][0010229e][00000000] 8bec mov ebp,esp
....[00001375][0010229a][00001352] 6852130000 push 00001352 // push P
....[0000137a][00102296][00001352] 6852130000 push 00001352 // push P
....[0000137f][00102292][00001384] e81efeffff call 000011a2 // call H

Begin Local Halt Decider Simulation Execution Trace Stored at:212352
....[00001352][0021233e][00212342] 55 push ebp // enter P
....[00001353][0021233e][00212342] 8bec mov ebp,esp
....[00001355][0021233e][00212342] 8b4508 mov eax,[ebp+08]
....[00001358][0021233a][00001352] 50 push eax // push P
....[00001359][0021233a][00001352] 8b4d08 mov ecx,[ebp+08]
....[0000135c][00212336][00001352] 51 push ecx // push P
....[0000135d][00212332][00001362] e840feffff call 000011a2 // call H
....[00001352][0025cd66][0025cd6a] 55 push ebp // enter P
....[00001353][0025cd66][0025cd6a] 8bec mov ebp,esp
....[00001355][0025cd66][0025cd6a] 8b4508 mov eax,[ebp+08]
....[00001358][0025cd62][00001352] 50 push eax // push P
....[00001359][0025cd62][00001352] 8b4d08 mov ecx,[ebp+08]
....[0000135c][0025cd5e][00001352] 51 push ecx // push P
....[0000135d][0025cd5a][00001362] e840feffff call 000011a2 // call H
Local Halt Decider: Infinite Recursion Detected Simulation Stopped

H sees that P is calling the same function from the same machine address
with identical parameters, twice in sequence. This is the infinite
recursion (infinitely nested simulation) non-halting behavior pattern.

....[00001384][0010229e][00000000] 83c408 add esp,+08
....[00001387][0010229a][00000000] 50 push eax
....[00001388][00102296][00000423] 6823040000 push 00000423 //
"Input_Halts = "
---[0000138d][00102296][00000423] e8e0f0ffff call 00000472 // call Output
Input_Halts = 0
....[00001392][0010229e][00000000] 83c408 add esp,+08
....[00001395][0010229e][00000000] 33c0 xor eax,eax
....[00001397][001022a2][00100000] 5d pop ebp
....[00001398][001022a6][00000004] c3 ret
Number of Instructions Executed(15892) lines = 237 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: Proof that H(P,P)==0 is correct [ refuting the halting problem proofs ](V2)

<20220511201154.00002147@reddwarf.jmc>

 copy mid

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

 copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!aioe.org!feeder1.feed.usenet.farm!feed.usenet.farm!peer01.ams4!peer.am4.highwinds-media.com!news.highwinds-media.com!fx03.ams4.POSTED!not-for-mail
From: flib...@reddwarf.jmc (Mr Flibble)
Newsgroups: comp.theory
Subject: Re: Proof that H(P,P)==0 is correct [ refuting the halting problem
proofs ](V2)
Message-ID: <20220511201154.00002147@reddwarf.jmc>
References: <2pSdnR25lqHLZub_nZ2dnUU7_8zNnZ2d@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=US-ASCII
Content-Transfer-Encoding: 7bit
Lines: 151
X-Complaints-To: abuse@eweka.nl
NNTP-Posting-Date: Wed, 11 May 2022 19:11:52 UTC
Date: Wed, 11 May 2022 20:11:54 +0100
X-Received-Bytes: 7157
 by: Mr Flibble - Wed, 11 May 2022 19:11 UTC

On Wed, 11 May 2022 13:07:16 -0500
olcott <NoOne@NoWhere.com> wrote:

> Proof that H(P,P)==0 is correct [ refuting the halting problem proofs
> ]
>
> The x86utm operating system was created so that every detail of the
> conventional halting problem counter example could be fully specified
> in C/x86.
>
> In computability theory, the halting problem is the
> problem of determining, from a description of an
> arbitrary computer program and an input, whether the
> program will finish running, or continue to run forever...
>
> For any program f that might determine if programs halt,
> a "pathological" program g, called with some input, can
> pass its own source and its input to f and then specifically
> do the opposite of what f predicts g will do. No f can exist
> that handles this case.
> https://en.wikipedia.org/wiki/Halting_problem
>
> This exact same relationship of f(g,g) was created as H(P,P), shown
> below.
>
> This is the overview of the method for proving that this analysis is
> correct:
> (a) Verify that the execution trace of P by H is correct by comparing
> this execution trace to the ax86 source-code of P.
>
> (b) Verify that this execution trace shows that P is stuck in
> infinitely nested simulation (a non-halting behavior).
>
> This proof can only be understood only by those having sufficient
> technical competence in:
> (a) software engineering (recognizing infinite recursion in C and x86
> code) (b) the x86 programming language
> (c) the C programming language and
> (d) the details of how C is translated into x86 by the Microsoft C
> compilers.
>
> #include <stdint.h>
> #define u32 uint32_t
>
> void P(u32 x)
> {
> if (H(x, x))
> HERE: goto HERE;
> return;
> }
>
> int main()
> {
> Output("Input_Halts = ", H((u32)P, (u32)P));
> }
>
> _P()
> [00001352](01) 55 push ebp
> [00001353](02) 8bec mov ebp,esp
> [00001355](03) 8b4508 mov eax,[ebp+08]
> [00001358](01) 50 push eax
> [00001359](03) 8b4d08 mov ecx,[ebp+08]
> [0000135c](01) 51 push ecx
> [0000135d](05) e840feffff call 000011a2 // call H
> [00001362](03) 83c408 add esp,+08
> [00001365](02) 85c0 test eax,eax
> [00001367](02) 7402 jz 0000136b
> [00001369](02) ebfe jmp 00001369
> [0000136b](01) 5d pop ebp
> [0000136c](01) c3 ret
> Size in bytes:(0027) [0000136c]
>
> _main()
> [00001372](01) 55 push ebp
> [00001373](02) 8bec mov ebp,esp
> [00001375](05) 6852130000 push 00001352 // push P
> [0000137a](05) 6852130000 push 00001352 // push P
> [0000137f](05) e81efeffff call 000011a2 // call H
> [00001384](03) 83c408 add esp,+08
> [00001387](01) 50 push eax
> [00001388](05) 6823040000 push 00000423 // "Input_Halts = "
> [0000138d](05) e8e0f0ffff call 00000472 // call Output
> [00001392](03) 83c408 add esp,+08
> [00001395](02) 33c0 xor eax,eax
> [00001397](01) 5d pop ebp
> [00001398](01) c3 ret
> Size in bytes:(0039) [00001398]
>
> machine stack stack machine assembly
> address address data code language
> ======== ======== ======== ========= =============
> ...[00001372][0010229e][00000000] 55 push ebp
> ...[00001373][0010229e][00000000] 8bec mov ebp,esp
> ...[00001375][0010229a][00001352] 6852130000 push 00001352 // push P
> ...[0000137a][00102296][00001352] 6852130000 push 00001352 // push P
> ...[0000137f][00102292][00001384] e81efeffff call 000011a2 // call H
>
> Begin Local Halt Decider Simulation Execution Trace Stored at:212352
> ...[00001352][0021233e][00212342] 55 push ebp // enter P
> ...[00001353][0021233e][00212342] 8bec mov ebp,esp
> ...[00001355][0021233e][00212342] 8b4508 mov eax,[ebp+08]
> ...[00001358][0021233a][00001352] 50 push eax // push P
> ...[00001359][0021233a][00001352] 8b4d08 mov ecx,[ebp+08]
> ...[0000135c][00212336][00001352] 51 push ecx // push P
> ...[0000135d][00212332][00001362] e840feffff call 000011a2 // call H
> ...[00001352][0025cd66][0025cd6a] 55 push ebp // enter P
> ...[00001353][0025cd66][0025cd6a] 8bec mov ebp,esp
> ...[00001355][0025cd66][0025cd6a] 8b4508 mov eax,[ebp+08]
> ...[00001358][0025cd62][00001352] 50 push eax // push P
> ...[00001359][0025cd62][00001352] 8b4d08 mov ecx,[ebp+08]
> ...[0000135c][0025cd5e][00001352] 51 push ecx // push P
> ...[0000135d][0025cd5a][00001362] e840feffff call 000011a2 // call H
> Local Halt Decider: Infinite Recursion Detected Simulation Stopped
>
> H sees that P is calling the same function from the same machine
> address with identical parameters, twice in sequence. This is the
> infinite recursion (infinitely nested simulation) non-halting
> behavior pattern.
>
> ...[00001384][0010229e][00000000] 83c408 add esp,+08
> ...[00001387][0010229a][00000000] 50 push eax
> ...[00001388][00102296][00000423] 6823040000 push 00000423 //
> "Input_Halts = "
> ---[0000138d][00102296][00000423] e8e0f0ffff call 00000472 // call
> Output Input_Halts = 0
> ...[00001392][0010229e][00000000] 83c408 add esp,+08
> ...[00001395][0010229e][00000000] 33c0 xor eax,eax
> ...[00001397][001022a2][00100000] 5d pop ebp
> ...[00001398][001022a6][00000004] c3 ret
> Number of Instructions Executed(15892) lines = 237 pages
>
>
> Halting problem undecidability and infinitely nested simulation (V5)
>
> https://www.researchgate.net/publication/359984584_Halting_problem_undecidability_and_infinitely_nested_simulation_V5

Your simulation approach is erroneous as there is no infinite
recursion; the key to understanding this is by realizing the
implication of the words "pass its own source" in the following:

For any program f that might determine if programs halt,
a "pathological" program g, called with some input, can
pass its own source and its input to f and then specifically
do the opposite of what f predicts g will do. No f can exist
that handles this case.

"pass its own source" is NOT the same as compiling and running its own
source as part of a simulation.

/Flibble

Re: Proof that H(P,P)==0 is correct [ refuting the halting problem proofs ](V2)

<8RXeK.52$C7G6.1@fx46.iad>

 copy mid

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

 copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!weretis.net!feeder6.news.weretis.net!usenet.blueworldhosting.com!feed1.usenet.blueworldhosting.com!peer03.iad!feed-me.highwinds-media.com!news.highwinds-media.com!fx46.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.9.0
Subject: Re: Proof that H(P,P)==0 is correct [ refuting the halting problem
proofs ](V2)
Content-Language: en-US
Newsgroups: comp.theory
References: <2pSdnR25lqHLZub_nZ2dnUU7_8zNnZ2d@giganews.com>
From: Rich...@Damon-Family.org (Richard Damon)
In-Reply-To: <2pSdnR25lqHLZub_nZ2dnUU7_8zNnZ2d@giganews.com>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Lines: 159
Message-ID: <8RXeK.52$C7G6.1@fx46.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: Wed, 11 May 2022 19:41:57 -0400
X-Received-Bytes: 7811
 by: Richard Damon - Wed, 11 May 2022 23:41 UTC

On 5/11/22 2:07 PM, olcott wrote:
> Proof that H(P,P)==0 is correct [ refuting the halting problem proofs ]
>
> The x86utm operating system was created so that every detail of the
> conventional halting problem counter example could be fully specified in
> C/x86.
>
>    In computability theory, the halting problem is the
>    problem of determining, from a description of an
>    arbitrary computer program and an input, whether the
>    program will finish running, or continue to run forever...
>
>    For any program f that might determine if programs halt,
>    a "pathological" program g, called with some input, can
>    pass its own source and its input to f and then specifically
>    do the opposite of what f predicts g will do. No f can exist
>    that handles this case. https://en.wikipedia.org/wiki/Halting_problem
>
> This exact same relationship of f(g,g) was created as H(P,P), shown below.
>
> This is the overview of the method for proving that this analysis is
> correct:
> (a) Verify that the execution trace of P by H is correct by comparing
> this execution trace to the ax86 source-code of P.

Except that this fails!!

The x86 code shows that P calls H.

The simulation doesn't but seems to act like a call to H is just a call
to P.

Even if you edit out the 'setup' code in H, unless H just calls P (and
not simulates it) the trace is incorrect, but should be showing H
actually simulating P.

>
> (b) Verify that this execution trace shows that P is stuck in infinitely
> nested simulation (a non-halting behavior).

Since the trace is incorrect, the logic is UNSOUND.

>
> This proof can only be understood only by those having sufficient
> technical competence in:
> (a) software engineering (recognizing infinite recursion in C and x86 code)
> (b) the x86 programming language
> (c) the C programming language and
> (d) the details of how C is translated into x86 by the Microsoft C
> compilers.

Which you seem to lack, as you seem to think that a call to H is a call
to P.

FAIL.

>
> #include <stdint.h>
> #define u32 uint32_t
>
> void P(u32 x)
> {
>   if (H(x, x))
>     HERE: goto HERE;
>   return;
> }
>
> int main()
> {
>   Output("Input_Halts = ", H((u32)P, (u32)P));
> }
>
> _P()
> [00001352](01)  55              push ebp
> [00001353](02)  8bec            mov ebp,esp
> [00001355](03)  8b4508          mov eax,[ebp+08]
> [00001358](01)  50              push eax
> [00001359](03)  8b4d08          mov ecx,[ebp+08]
> [0000135c](01)  51              push ecx
> [0000135d](05)  e840feffff      call 000011a2 // call H
> [00001362](03)  83c408          add esp,+08
> [00001365](02)  85c0            test eax,eax
> [00001367](02)  7402            jz 0000136b
> [00001369](02)  ebfe            jmp 00001369
> [0000136b](01)  5d              pop ebp
> [0000136c](01)  c3              ret
> Size in bytes:(0027) [0000136c]
>
> _main()
> [00001372](01)  55              push ebp
> [00001373](02)  8bec            mov ebp,esp
> [00001375](05)  6852130000      push 00001352 // push P
> [0000137a](05)  6852130000      push 00001352 // push P
> [0000137f](05)  e81efeffff      call 000011a2 // call H
> [00001384](03)  83c408          add esp,+08
> [00001387](01)  50              push eax
> [00001388](05)  6823040000      push 00000423 // "Input_Halts = "
> [0000138d](05)  e8e0f0ffff      call 00000472 // call Output
> [00001392](03)  83c408          add esp,+08
> [00001395](02)  33c0            xor eax,eax
> [00001397](01)  5d              pop ebp
> [00001398](01)  c3              ret
> Size in bytes:(0039) [00001398]
>
>     machine   stack     stack     machine    assembly
>     address   address   data      code       language
>     ========  ========  ========  =========  =============
> ...[00001372][0010229e][00000000] 55         push ebp
> ...[00001373][0010229e][00000000] 8bec       mov ebp,esp
> ...[00001375][0010229a][00001352] 6852130000 push 00001352 // push P
> ...[0000137a][00102296][00001352] 6852130000 push 00001352 // push P
> ...[0000137f][00102292][00001384] e81efeffff call 000011a2 // call H
>
> Begin Local Halt Decider Simulation   Execution Trace Stored at:212352
> ...[00001352][0021233e][00212342] 55         push ebp      // enter P
> ...[00001353][0021233e][00212342] 8bec       mov ebp,esp
> ...[00001355][0021233e][00212342] 8b4508     mov eax,[ebp+08]
> ...[00001358][0021233a][00001352] 50         push eax      // push P
> ...[00001359][0021233a][00001352] 8b4d08     mov ecx,[ebp+08]
> ...[0000135c][00212336][00001352] 51         push ecx      // push P
> ...[0000135d][00212332][00001362] e840feffff call 000011a2 // call H

Error begins here.

> ...[00001352][0025cd66][0025cd6a] 55         push ebp      // enter P
> ...[00001353][0025cd66][0025cd6a] 8bec       mov ebp,esp
> ...[00001355][0025cd66][0025cd6a] 8b4508     mov eax,[ebp+08]
> ...[00001358][0025cd62][00001352] 50         push eax      // push P
> ...[00001359][0025cd62][00001352] 8b4d08     mov ecx,[ebp+08]
> ...[0000135c][0025cd5e][00001352] 51         push ecx      // push P
> ...[0000135d][0025cd5a][00001362] e840feffff call 000011a2 // call H
> Local Halt Decider: Infinite Recursion Detected Simulation Stopped
>
> H sees that P is calling the same function from the same machine address
> with identical parameters, twice in sequence. This is the infinite
> recursion (infinitely nested simulation) non-halting behavior pattern.

Nope, logic is ignoring the behavior of H.

>
> ...[00001384][0010229e][00000000] 83c408     add esp,+08
> ...[00001387][0010229a][00000000] 50         push eax
> ...[00001388][00102296][00000423] 6823040000 push 00000423 //
> "Input_Halts = "
> ---[0000138d][00102296][00000423] e8e0f0ffff call 00000472 // call Output
> Input_Halts = 0
> ...[00001392][0010229e][00000000] 83c408     add esp,+08
> ...[00001395][0010229e][00000000] 33c0       xor eax,eax
> ...[00001397][001022a2][00100000] 5d         pop ebp
> ...[00001398][001022a6][00000004] c3         ret
> Number of Instructions Executed(15892) lines = 237 pages
>
>
> Halting problem undecidability and infinitely nested simulation (V5)
>
> https://www.researchgate.net/publication/359984584_Halting_problem_undecidability_and_infinitely_nested_simulation_V5
>
>

Re: Proof that H(P,P)==0 is correct [ refuting the halting problem proofs ](V2)

<875ymb7gg2.fsf@bsb.me.uk>

 copy mid

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

 copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!eternal-september.org!reader02.eternal-september.org!.POSTED!not-for-mail
From: ben.use...@bsb.me.uk (Ben)
Newsgroups: comp.theory
Subject: Re: Proof that H(P,P)==0 is correct [ refuting the halting problem proofs ](V2)
Date: Thu, 12 May 2022 01:17:01 +0100
Organization: A noiseless patient Spider
Lines: 12
Message-ID: <875ymb7gg2.fsf@bsb.me.uk>
References: <2pSdnR25lqHLZub_nZ2dnUU7_8zNnZ2d@giganews.com>
MIME-Version: 1.0
Content-Type: text/plain; charset=utf-8
Content-Transfer-Encoding: 8bit
Injection-Info: reader02.eternal-september.org; posting-host="b918120b717b1a0036d52ef1ce111b9c";
logging-data="7798"; mail-complaints-to="abuse@eternal-september.org"; posting-account="U2FsdGVkX1/tGvgSdJkRMaKNQgVBmZXiwsMn+3BXm4g="
Cancel-Lock: sha1:8HEtEGqB2gczp+mKhmvXi389Fsc=
sha1:c7raK3tS7pzGuHBLRRYWeino/0A=
X-BSB-Auth: 1.0bce82843c3979f24557.20220512011701BST.875ymb7gg2.fsf@bsb.me.uk
 by: Ben - Thu, 12 May 2022 00:17 UTC

olcott <NoOne@NoWhere.com> writes:

> Proof that H(P,P)==0 is correct [ refuting the halting problem proofs ]

There are no arguments that can be passed to H so that H can correctly
report on the halting of the function call P(P). H falls at the first
hurdle: being able to decide the halting of specific function calls.

--
Ben.
"le génie humain a des limites, quand la bêtise humaine n’en a pas"
Alexandre Dumas (fils)

Re: Proof that H(P,P)==0 is correct [ refuting the halting problem proofs ](V2)

<lYydndd8nf4JzuH_nZ2dnUU7_83NnZ2d@giganews.com>

 copy mid

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

 copy link   Newsgroups: comp.theory
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: Wed, 11 May 2022 19:23:48 -0500
Date: Wed, 11 May 2022 19:23:45 -0500
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:91.0) Gecko/20100101
Thunderbird/91.9.0
Subject: Re: Proof that H(P,P)==0 is correct [ refuting the halting problem
proofs ](V2)
Content-Language: en-US
Newsgroups: comp.theory
References: <2pSdnR25lqHLZub_nZ2dnUU7_8zNnZ2d@giganews.com>
<20220511201154.00002147@reddwarf.jmc>
From: NoO...@NoWhere.com (olcott)
In-Reply-To: <20220511201154.00002147@reddwarf.jmc>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 7bit
Message-ID: <lYydndd8nf4JzuH_nZ2dnUU7_83NnZ2d@giganews.com>
Lines: 175
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-OIN/BMOvelMYSwIG35tjsETphvQZ/qHMgJWdgwL8l/KVm6abYxahisxfShGWuJIGhcO6LWf9+PUx5id!QkTmjMTIKtP7Nm+gZbdxeoyRS0M5daEorc5ahCZZi6KyAF/VzmKOcSLx2wYqrJwp98GtKiK/1yI=
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: 8560
 by: olcott - Thu, 12 May 2022 00:23 UTC

On 5/11/2022 2:11 PM, Mr Flibble wrote:
> On Wed, 11 May 2022 13:07:16 -0500
> olcott <NoOne@NoWhere.com> wrote:
>
>> Proof that H(P,P)==0 is correct [ refuting the halting problem proofs
>> ]
>>
>> The x86utm operating system was created so that every detail of the
>> conventional halting problem counter example could be fully specified
>> in C/x86.
>>
>> In computability theory, the halting problem is the
>> problem of determining, from a description of an
>> arbitrary computer program and an input, whether the
>> program will finish running, or continue to run forever...
>>
>> For any program f that might determine if programs halt,
>> a "pathological" program g, called with some input, can
>> pass its own source and its input to f and then specifically
>> do the opposite of what f predicts g will do. No f can exist
>> that handles this case.
>> https://en.wikipedia.org/wiki/Halting_problem
>>
>> This exact same relationship of f(g,g) was created as H(P,P), shown
>> below.
>>
>> This is the overview of the method for proving that this analysis is
>> correct:
>> (a) Verify that the execution trace of P by H is correct by comparing
>> this execution trace to the ax86 source-code of P.
>>
>> (b) Verify that this execution trace shows that P is stuck in
>> infinitely nested simulation (a non-halting behavior).
>>
>> This proof can only be understood only by those having sufficient
>> technical competence in:
>> (a) software engineering (recognizing infinite recursion in C and x86
>> code) (b) the x86 programming language
>> (c) the C programming language and
>> (d) the details of how C is translated into x86 by the Microsoft C
>> compilers.
>>
>> #include <stdint.h>
>> #define u32 uint32_t
>>
>> void P(u32 x)
>> {
>> if (H(x, x))
>> HERE: goto HERE;
>> return;
>> }
>>
>> int main()
>> {
>> Output("Input_Halts = ", H((u32)P, (u32)P));
>> }
>>
>> _P()
>> [00001352](01) 55 push ebp
>> [00001353](02) 8bec mov ebp,esp
>> [00001355](03) 8b4508 mov eax,[ebp+08]
>> [00001358](01) 50 push eax
>> [00001359](03) 8b4d08 mov ecx,[ebp+08]
>> [0000135c](01) 51 push ecx
>> [0000135d](05) e840feffff call 000011a2 // call H
>> [00001362](03) 83c408 add esp,+08
>> [00001365](02) 85c0 test eax,eax
>> [00001367](02) 7402 jz 0000136b
>> [00001369](02) ebfe jmp 00001369
>> [0000136b](01) 5d pop ebp
>> [0000136c](01) c3 ret
>> Size in bytes:(0027) [0000136c]
>>
>> _main()
>> [00001372](01) 55 push ebp
>> [00001373](02) 8bec mov ebp,esp
>> [00001375](05) 6852130000 push 00001352 // push P
>> [0000137a](05) 6852130000 push 00001352 // push P
>> [0000137f](05) e81efeffff call 000011a2 // call H
>> [00001384](03) 83c408 add esp,+08
>> [00001387](01) 50 push eax
>> [00001388](05) 6823040000 push 00000423 // "Input_Halts = "
>> [0000138d](05) e8e0f0ffff call 00000472 // call Output
>> [00001392](03) 83c408 add esp,+08
>> [00001395](02) 33c0 xor eax,eax
>> [00001397](01) 5d pop ebp
>> [00001398](01) c3 ret
>> Size in bytes:(0039) [00001398]
>>
>> machine stack stack machine assembly
>> address address data code language
>> ======== ======== ======== ========= =============
>> ...[00001372][0010229e][00000000] 55 push ebp
>> ...[00001373][0010229e][00000000] 8bec mov ebp,esp
>> ...[00001375][0010229a][00001352] 6852130000 push 00001352 // push P
>> ...[0000137a][00102296][00001352] 6852130000 push 00001352 // push P
>> ...[0000137f][00102292][00001384] e81efeffff call 000011a2 // call H
>>
>> Begin Local Halt Decider Simulation Execution Trace Stored at:212352
>> ...[00001352][0021233e][00212342] 55 push ebp // enter P
>> ...[00001353][0021233e][00212342] 8bec mov ebp,esp
>> ...[00001355][0021233e][00212342] 8b4508 mov eax,[ebp+08]
>> ...[00001358][0021233a][00001352] 50 push eax // push P
>> ...[00001359][0021233a][00001352] 8b4d08 mov ecx,[ebp+08]
>> ...[0000135c][00212336][00001352] 51 push ecx // push P
>> ...[0000135d][00212332][00001362] e840feffff call 000011a2 // call H
>> ...[00001352][0025cd66][0025cd6a] 55 push ebp // enter P
>> ...[00001353][0025cd66][0025cd6a] 8bec mov ebp,esp
>> ...[00001355][0025cd66][0025cd6a] 8b4508 mov eax,[ebp+08]
>> ...[00001358][0025cd62][00001352] 50 push eax // push P
>> ...[00001359][0025cd62][00001352] 8b4d08 mov ecx,[ebp+08]
>> ...[0000135c][0025cd5e][00001352] 51 push ecx // push P
>> ...[0000135d][0025cd5a][00001362] e840feffff call 000011a2 // call H
>> Local Halt Decider: Infinite Recursion Detected Simulation Stopped
>>
>> H sees that P is calling the same function from the same machine
>> address with identical parameters, twice in sequence. This is the
>> infinite recursion (infinitely nested simulation) non-halting
>> behavior pattern.
>>
>> ...[00001384][0010229e][00000000] 83c408 add esp,+08
>> ...[00001387][0010229a][00000000] 50 push eax
>> ...[00001388][00102296][00000423] 6823040000 push 00000423 //
>> "Input_Halts ="
>> ---[0000138d][00102296][00000423] e8e0f0ffff call 00000472 // call
>> Output Input_Halts = 0
>> ...[00001392][0010229e][00000000] 83c408 add esp,+08
>> ...[00001395][0010229e][00000000] 33c0 xor eax,eax
>> ...[00001397][001022a2][00100000] 5d pop ebp
>> ...[00001398][001022a6][00000004] c3 ret
>> Number of Instructions Executed(15892) lines = 237 pages
>>
>>
>> Halting problem undecidability and infinitely nested simulation (V5)
>>
>> https://www.researchgate.net/publication/359984584_Halting_problem_undecidability_and_infinitely_nested_simulation_V5
>
> Your simulation approach is erroneous as there is no infinite
> recursion; the key to understanding this is by realizing the
> implication of the words "pass its own source" in the following:

YOU IGNORED THIS PART

This proof can only be understood only by those having sufficient
technical competence in:
(a) software engineering - recognizing infinite recursion in C/x86
(b) the x86 programming language
(c) the C programming language and
(d) the details of how C is translated into x86 by the Microsoft C
compilers.

> For any program f that might determine if programs halt,
> a "pathological" program g, called with some input, can
> pass its own source and its input to f and then specifically
> do the opposite of what f predicts g will do. No f can exist
> that handles this case.
>
> "pass its own source" is NOT the same as compiling and running its own
> source as part of a simulation.

Passing the finite string of its own machine code is equivalent to
passing its own source.

>
> /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

Re: Proof that H(P,P)==0 is correct [ refuting the halting problem proofs ](V2)

<66idnbnmOdNtyeH_nZ2dnUU7_83NnZ2d@giganews.com>

 copy mid

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

 copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!weretis.net!feeder6.news.weretis.net!usenet.blueworldhosting.com!feed1.usenet.blueworldhosting.com!peer03.iad!feed-me.highwinds-media.com!news.highwinds-media.com!border1.nntp.dca1.giganews.com!nntp.giganews.com!buffer1.nntp.dca1.giganews.com!buffer2.nntp.dca1.giganews.com!news.giganews.com.POSTED!not-for-mail
NNTP-Posting-Date: Wed, 11 May 2022 19:29:36 -0500
Date: Wed, 11 May 2022 19:29:33 -0500
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:91.0) Gecko/20100101
Thunderbird/91.9.0
Subject: Re: Proof that H(P,P)==0 is correct [ refuting the halting problem
proofs ](V2)
Content-Language: en-US
Newsgroups: comp.theory
References: <2pSdnR25lqHLZub_nZ2dnUU7_8zNnZ2d@giganews.com>
<875ymb7gg2.fsf@bsb.me.uk>
From: NoO...@NoWhere.com (olcott)
In-Reply-To: <875ymb7gg2.fsf@bsb.me.uk>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 7bit
Message-ID: <66idnbnmOdNtyeH_nZ2dnUU7_83NnZ2d@giganews.com>
Lines: 24
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-O0eV19PHmRAI34F8qfA+FyfHMS95CPPCxffrLVSYc+t68C3bPYsgWSC32cTxDQdT4mpvrQA2XZHsM5c!JwBVVkgfmQB6KRqBoaqE97lvs+XnlO0GaBd3NxdtbpbQH/kntsn5xBJofzBO6sgzYQbk9Z4Xy0w=
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: 2007
X-Received-Bytes: 2129
 by: olcott - Thu, 12 May 2022 00:29 UTC

On 5/11/2022 7:17 PM, Ben wrote:
> olcott <NoOne@NoWhere.com> writes:
>
>> Proof that H(P,P)==0 is correct [ refuting the halting problem proofs ]
>
> There are no arguments that can be passed to H so that H can correctly
> report on the halting of the function call P(P). H falls at the first
> hurdle: being able to decide the halting of specific function calls.
>

A halt decider must only correctly report on the halt status of its
inputs. H(P,P)==0 and H1(P,P)==1 both do that correctly.

The HP proof tries to show an input that H gets wrong.
The proof no longer works on my H.

--
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: Proof that H(P,P)==0 is correct [ refuting the halting problem proofs ](V2)

<2TYeK.54$C7G6.8@fx46.iad>

 copy mid

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

 copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!weretis.net!feeder6.news.weretis.net!usenet.blueworldhosting.com!feed1.usenet.blueworldhosting.com!peer01.iad!feed-me.highwinds-media.com!news.highwinds-media.com!fx46.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.9.0
Subject: Re: Proof that H(P,P)==0 is correct [ refuting the halting problem
proofs ](V2)
Content-Language: en-US
Newsgroups: comp.theory
References: <2pSdnR25lqHLZub_nZ2dnUU7_8zNnZ2d@giganews.com>
<875ymb7gg2.fsf@bsb.me.uk> <66idnbnmOdNtyeH_nZ2dnUU7_83NnZ2d@giganews.com>
From: Rich...@Damon-Family.org (Richard Damon)
In-Reply-To: <66idnbnmOdNtyeH_nZ2dnUU7_83NnZ2d@giganews.com>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Lines: 46
Message-ID: <2TYeK.54$C7G6.8@fx46.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: Wed, 11 May 2022 20:52:14 -0400
X-Received-Bytes: 2618
 by: Richard Damon - Thu, 12 May 2022 00:52 UTC

On 5/11/22 8:29 PM, olcott wrote:
> On 5/11/2022 7:17 PM, Ben wrote:
>> olcott <NoOne@NoWhere.com> writes:
>>
>>> Proof that H(P,P)==0 is correct [ refuting the halting problem proofs ]
>>
>> There are no arguments that can be passed to H so that H can correctly
>> report on the halting of the function call P(P).  H falls at the first
>> hurdle: being able to decide the halting of specific function calls.
>>
>
> A halt decider must only correctly report on the halt status of its
> inputs. H(P,P)==0 and H1(P,P)==1 both do that correctly.
>
> The HP proof tries to show an input that H gets wrong.
> The proof no longer works on my H.
>

Nope, a Halt Decider must report the Halting Status of the Machine the
input represents.

Thus P,P is ALWAYS the same computation for a Halting Decider.

The fact that your H and H1 give different answer just proves that they
aren't Halt Deciders.

Rmebmer xxx decider(foo) needs to give the mapping of xxx(foo) based on
the definition of xxx.

Halting(P,P) is defined as the halting of the computation P(P).

Thus anything that claims to be a Halting decider need to give the
answer of Halting(P,P) for H(P,P)

If you claim this isn't possbile because it isn't an input, just proves
that you can't make a Halting Decider.

This is like if we want to make an 'even decider' as a Turing Machine,
we can't give a Turing Machine an actual 'Number' but some
representation of a number.

In the same way the Halt Decider isn't given an ACTUAL program, but a
representation of it. (and it needs to be a representation of the ENTIRE
program, or it isn't decidable).

Re: Proof that H(P,P)==0 is correct [ refuting the halting problem proofs ](V2)

<b0ZeK.1833$6y5f.1474@fx40.iad>

 copy mid

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

 copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!weretis.net!feeder6.news.weretis.net!news.misty.com!border2.nntp.dca1.giganews.com!nntp.giganews.com!peer01.iad!feed-me.highwinds-media.com!news.highwinds-media.com!fx40.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.9.0
Subject: Re: Proof that H(P,P)==0 is correct [ refuting the halting problem
proofs ](V2)
Content-Language: en-US
Newsgroups: comp.theory
References: <2pSdnR25lqHLZub_nZ2dnUU7_8zNnZ2d@giganews.com>
<20220511201154.00002147@reddwarf.jmc>
<lYydndd8nf4JzuH_nZ2dnUU7_83NnZ2d@giganews.com>
From: Rich...@Damon-Family.org (Richard Damon)
In-Reply-To: <lYydndd8nf4JzuH_nZ2dnUU7_83NnZ2d@giganews.com>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Lines: 184
Message-ID: <b0ZeK.1833$6y5f.1474@fx40.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: Wed, 11 May 2022 21:02:00 -0400
X-Received-Bytes: 9208
X-Original-Bytes: 9075
 by: Richard Damon - Thu, 12 May 2022 01:02 UTC

On 5/11/22 8:23 PM, olcott wrote:
> On 5/11/2022 2:11 PM, Mr Flibble wrote:
>> On Wed, 11 May 2022 13:07:16 -0500
>> olcott <NoOne@NoWhere.com> wrote:
>>
>>> Proof that H(P,P)==0 is correct [ refuting the halting problem proofs
>>> ]
>>>
>>> The x86utm operating system was created so that every detail of the
>>> conventional halting problem counter example could be fully specified
>>> in C/x86.
>>>
>>>      In computability theory, the halting problem is the
>>>      problem of determining, from a description of an
>>>      arbitrary computer program and an input, whether the
>>>      program will finish running, or continue to run forever...
>>>
>>>      For any program f that might determine if programs halt,
>>>      a "pathological" program g, called with some input, can
>>>      pass its own source and its input to f and then specifically
>>>      do the opposite of what f predicts g will do. No f can exist
>>>      that handles this case.
>>> https://en.wikipedia.org/wiki/Halting_problem
>>>
>>> This exact same relationship of f(g,g) was created as H(P,P), shown
>>> below.
>>>
>>> This is the overview of the method for proving that this analysis is
>>> correct:
>>> (a) Verify that the execution trace of P by H is correct by comparing
>>> this execution trace to the ax86 source-code of P.
>>>
>>> (b) Verify that this execution trace shows that P is stuck in
>>> infinitely nested simulation (a non-halting behavior).
>>>
>>> This proof can only be understood only by those having sufficient
>>> technical competence in:
>>> (a) software engineering (recognizing infinite recursion in C and x86
>>> code) (b) the x86 programming language
>>> (c) the C programming language and
>>> (d) the details of how C is translated into x86 by the Microsoft C
>>> compilers.
>>>
>>> #include <stdint.h>
>>> #define u32 uint32_t
>>>
>>> void P(u32 x)
>>> {
>>>     if (H(x, x))
>>>       HERE: goto HERE;
>>>     return;
>>> }
>>>
>>> int main()
>>> {
>>>     Output("Input_Halts = ", H((u32)P, (u32)P));
>>> }
>>>
>>> _P()
>>> [00001352](01)  55              push ebp
>>> [00001353](02)  8bec            mov ebp,esp
>>> [00001355](03)  8b4508          mov eax,[ebp+08]
>>> [00001358](01)  50              push eax
>>> [00001359](03)  8b4d08          mov ecx,[ebp+08]
>>> [0000135c](01)  51              push ecx
>>> [0000135d](05)  e840feffff      call 000011a2 // call H
>>> [00001362](03)  83c408          add esp,+08
>>> [00001365](02)  85c0            test eax,eax
>>> [00001367](02)  7402            jz 0000136b
>>> [00001369](02)  ebfe            jmp 00001369
>>> [0000136b](01)  5d              pop ebp
>>> [0000136c](01)  c3              ret
>>> Size in bytes:(0027) [0000136c]
>>>
>>> _main()
>>> [00001372](01)  55              push ebp
>>> [00001373](02)  8bec            mov ebp,esp
>>> [00001375](05)  6852130000      push 00001352 // push P
>>> [0000137a](05)  6852130000      push 00001352 // push P
>>> [0000137f](05)  e81efeffff      call 000011a2 // call H
>>> [00001384](03)  83c408          add esp,+08
>>> [00001387](01)  50              push eax
>>> [00001388](05)  6823040000      push 00000423 // "Input_Halts = "
>>> [0000138d](05)  e8e0f0ffff      call 00000472 // call Output
>>> [00001392](03)  83c408          add esp,+08
>>> [00001395](02)  33c0            xor eax,eax
>>> [00001397](01)  5d              pop ebp
>>> [00001398](01)  c3              ret
>>> Size in bytes:(0039) [00001398]
>>>
>>>       machine   stack     stack     machine    assembly
>>>       address   address   data      code       language
>>>       ========  ========  ========  =========  =============
>>> ...[00001372][0010229e][00000000] 55         push ebp
>>> ...[00001373][0010229e][00000000] 8bec       mov ebp,esp
>>> ...[00001375][0010229a][00001352] 6852130000 push 00001352 // push P
>>> ...[0000137a][00102296][00001352] 6852130000 push 00001352 // push P
>>> ...[0000137f][00102292][00001384] e81efeffff call 000011a2 // call H
>>>
>>> Begin Local Halt Decider Simulation   Execution Trace Stored at:212352
>>> ...[00001352][0021233e][00212342] 55         push ebp      // enter P
>>> ...[00001353][0021233e][00212342] 8bec       mov ebp,esp
>>> ...[00001355][0021233e][00212342] 8b4508     mov eax,[ebp+08]
>>> ...[00001358][0021233a][00001352] 50         push eax      // push P
>>> ...[00001359][0021233a][00001352] 8b4d08     mov ecx,[ebp+08]
>>> ...[0000135c][00212336][00001352] 51         push ecx      // push P
>>> ...[0000135d][00212332][00001362] e840feffff call 000011a2 // call H
>>> ...[00001352][0025cd66][0025cd6a] 55         push ebp      // enter P
>>> ...[00001353][0025cd66][0025cd6a] 8bec       mov ebp,esp
>>> ...[00001355][0025cd66][0025cd6a] 8b4508     mov eax,[ebp+08]
>>> ...[00001358][0025cd62][00001352] 50         push eax      // push P
>>> ...[00001359][0025cd62][00001352] 8b4d08     mov ecx,[ebp+08]
>>> ...[0000135c][0025cd5e][00001352] 51         push ecx      // push P
>>> ...[0000135d][0025cd5a][00001362] e840feffff call 000011a2 // call H
>>> Local Halt Decider: Infinite Recursion Detected Simulation Stopped
>>>
>>> H sees that P is calling the same function from the same machine
>>> address with identical parameters, twice in sequence. This is the
>>> infinite recursion (infinitely nested simulation) non-halting
>>> behavior pattern.
>>>
>>> ...[00001384][0010229e][00000000] 83c408     add esp,+08
>>> ...[00001387][0010229a][00000000] 50         push eax
>>> ...[00001388][00102296][00000423] 6823040000 push 00000423 //
>>> "Input_Halts ="
>>> ---[0000138d][00102296][00000423] e8e0f0ffff call 00000472 // call
>>> Output Input_Halts = 0
>>> ...[00001392][0010229e][00000000] 83c408     add esp,+08
>>> ...[00001395][0010229e][00000000] 33c0       xor eax,eax
>>> ...[00001397][001022a2][00100000] 5d         pop ebp
>>> ...[00001398][001022a6][00000004] c3         ret
>>> Number of Instructions Executed(15892) lines = 237 pages
>>>
>>>
>>> Halting problem undecidability and infinitely nested simulation (V5)
>>>
>>> https://www.researchgate.net/publication/359984584_Halting_problem_undecidability_and_infinitely_nested_simulation_V5
>>>
>>
>> Your simulation approach is erroneous as there is no infinite
>> recursion; the key to understanding this is by realizing the
>> implication of the words "pass its own source" in the following:
>
>
> YOU IGNORED THIS PART
>
> This proof can only be understood only by those having sufficient
> technical competence in:
> (a) software engineering - recognizing infinite recursion in C/x86
> (b) the x86 programming language
> (c) the C programming language and
> (d) the details of how C is translated into x86 by the Microsoft C
> compilers.

And those that are see it to be the lie that it is.

I really don't think YOU understand the material to the level you claim
is needed.

>
>> For any program f that might determine if programs halt,
>> a "pathological" program g, called with some input, can
>> pass its own source and its input to f and then specifically
>> do the opposite of what f predicts g will do. No f can exist
>> that handles this case.
>>
>> "pass its own source" is NOT the same as compiling and running its own
>> source as part of a simulation.
>
> Passing the finite string of its own machine code is equivalent to
> passing its own source.


Click here to read the complete article
Re: Proof that H(P,P)==0 is correct [ refuting the halting problem proofs ](V2)

<87fslf5ze1.fsf@bsb.me.uk>

 copy mid

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

 copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!eternal-september.org!reader02.eternal-september.org!.POSTED!not-for-mail
From: ben.use...@bsb.me.uk (Ben)
Newsgroups: comp.theory
Subject: Re: Proof that H(P,P)==0 is correct [ refuting the halting problem proofs ](V2)
Date: Thu, 12 May 2022 02:10:46 +0100
Organization: A noiseless patient Spider
Lines: 29
Message-ID: <87fslf5ze1.fsf@bsb.me.uk>
References: <2pSdnR25lqHLZub_nZ2dnUU7_8zNnZ2d@giganews.com>
<875ymb7gg2.fsf@bsb.me.uk>
<66idnbnmOdNtyeH_nZ2dnUU7_83NnZ2d@giganews.com>
MIME-Version: 1.0
Content-Type: text/plain; charset=utf-8
Content-Transfer-Encoding: 8bit
Injection-Info: reader02.eternal-september.org; posting-host="b918120b717b1a0036d52ef1ce111b9c";
logging-data="24581"; mail-complaints-to="abuse@eternal-september.org"; posting-account="U2FsdGVkX18Ppcg4byIuuIWEsuZUBkbEN4KgruLzJCM="
Cancel-Lock: sha1:ldCC5WB8C42kYjEx2TMFntqTlGo=
sha1:KfYW4bTbKkDh0WBPp3xTVbGhgG4=
X-BSB-Auth: 1.f8444ac3f4a56bc480b7.20220512021046BST.87fslf5ze1.fsf@bsb.me.uk
 by: Ben - Thu, 12 May 2022 01:10 UTC

olcott <NoOne@NoWhere.com> writes:

> On 5/11/2022 7:17 PM, Ben wrote:
>> olcott <NoOne@NoWhere.com> writes:
>>
>>> Proof that H(P,P)==0 is correct [ refuting the halting problem proofs ]
>> There are no arguments that can be passed to H so that H can correctly
>> report on the halting of the function call P(P). H falls at the first
>> hurdle: being able to decide the halting of specific function calls.
>
> A halt decider must only correctly report on the halt status of its
> inputs. H(P,P)==0 and H1(P,P)==1 both do that correctly.

The "inputs" to H are two pointers. They have no halt status. What
H(X,Y) must correctly report on is the halting or otherwise of the
function call X(Y). Your H does not do the job it is supposed to do.

> The HP proof tries to show an input that H gets wrong.
> The proof no longer works on my H.

You are correct that the proof does not apply to your H. The proof is
about supposed halt deciders D such that D(X,Y) == true if and only if
X(Y) halts and false otherwise. Your H is not such a function -- you
can make it do what you like.

--
Ben.
"le génie humain a des limites, quand la bêtise humaine n’en a pas"
Alexandre Dumas (fils)

Re: Proof that H(P,P)==0 is correct [ refuting the halting problem proofs ](V2)

<dbudnSEVKLqG7OH_nZ2dnUU7_83NnZ2d@giganews.com>

 copy mid

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

 copy link   Newsgroups: comp.theory
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: Wed, 11 May 2022 21:29:47 -0500
Date: Wed, 11 May 2022 21:29:44 -0500
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:91.0) Gecko/20100101
Thunderbird/91.9.0
Subject: Re: Proof that H(P,P)==0 is correct [ refuting the halting problem
proofs ](V2)
Content-Language: en-US
Newsgroups: comp.theory
References: <2pSdnR25lqHLZub_nZ2dnUU7_8zNnZ2d@giganews.com>
<875ymb7gg2.fsf@bsb.me.uk> <66idnbnmOdNtyeH_nZ2dnUU7_83NnZ2d@giganews.com>
<87fslf5ze1.fsf@bsb.me.uk>
From: NoO...@NoWhere.com (olcott)
In-Reply-To: <87fslf5ze1.fsf@bsb.me.uk>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 7bit
Message-ID: <dbudnSEVKLqG7OH_nZ2dnUU7_83NnZ2d@giganews.com>
Lines: 67
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-jlJ7xe+fBhseoYUNyw7AXecKwzmE9OwSOyGvsaMzUE0oyAIYjsVZLiMVbrn3XwWnaNuQvsImtZvLLvo!tRkebaWZCW85b0vzvPtZTX4jkxyFxR0zPM571c6ABWJgSzhJneS+YS4mEJzjd+L2ZMQBdbiWHPY=
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: 3591
 by: olcott - Thu, 12 May 2022 02:29 UTC

On 5/11/2022 8:10 PM, Ben wrote:
> olcott <NoOne@NoWhere.com> writes:
>
>> On 5/11/2022 7:17 PM, Ben wrote:
>>> olcott <NoOne@NoWhere.com> writes:
>>>
>>>> Proof that H(P,P)==0 is correct [ refuting the halting problem proofs ]
>>> There are no arguments that can be passed to H so that H can correctly
>>> report on the halting of the function call P(P). H falls at the first
>>> hurdle: being able to decide the halting of specific function calls.
>>
>> A halt decider must only correctly report on the halt status of its
>> inputs. H(P,P)==0 and H1(P,P)==1 both do that correctly.
>
> The "inputs" to H are two pointers. They have no halt status.

This is such a nutty thing to say when you already know that strings are
always passed in C as char* pointers.

I am passing strings of machine code as pointers, this is the normal
correct way to do this.

> What
> H(X,Y) must correctly report on is the halting or otherwise of the
> function call X(Y). Your H does not do the job it is supposed to do.
>

int sim(int N, int M)
{ return (N+M);
}

It turns out that this requirement is the same as requiring that
sum(3,4) must report on sum(5,6), thus making the requirement itself
incorrect.

The correct way of viewing the HP proof (and it is often stated this
way) is that there exists some inputs such that H cannot correctly
report their halt status.

>> The HP proof tries to show an input that H gets wrong.
>> The proof no longer works on my H.
>
> You are correct that the proof does not apply to your H. The proof is
> about supposed halt deciders D such that D(X,Y) == true if and only if
> X(Y) halts and false otherwise.

That is an incoherent requirement for some cases, thus incorrect for
these cases.

That incoherent requirement is based on the false assumption that the
behavior that the input to H(P,P) specifies is the always that exact
same behavior as P(P).

No one ever noticed that there are rare exceptions where this is not true.

> Your H is not such a function -- you
> can make it do what you like.
>

--
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: Proof that H(P,P)==0 is correct [ refuting the halting problem proofs ](V2)

<DN_eK.1185$j0D5.979@fx09.iad>

 copy mid

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

 copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!weretis.net!feeder6.news.weretis.net!usenet.blueworldhosting.com!feed1.usenet.blueworldhosting.com!peer01.iad!feed-me.highwinds-media.com!news.highwinds-media.com!fx09.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.9.0
Subject: Re: Proof that H(P,P)==0 is correct [ refuting the halting problem
proofs ](V2)
Content-Language: en-US
Newsgroups: comp.theory
References: <2pSdnR25lqHLZub_nZ2dnUU7_8zNnZ2d@giganews.com>
<875ymb7gg2.fsf@bsb.me.uk> <66idnbnmOdNtyeH_nZ2dnUU7_83NnZ2d@giganews.com>
<87fslf5ze1.fsf@bsb.me.uk> <dbudnSEVKLqG7OH_nZ2dnUU7_83NnZ2d@giganews.com>
From: Rich...@Damon-Family.org (Richard Damon)
In-Reply-To: <dbudnSEVKLqG7OH_nZ2dnUU7_83NnZ2d@giganews.com>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Lines: 115
Message-ID: <DN_eK.1185$j0D5.979@fx09.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: Wed, 11 May 2022 23:02:59 -0400
X-Received-Bytes: 4719
 by: Richard Damon - Thu, 12 May 2022 03:02 UTC

On 5/11/22 10:29 PM, olcott wrote:
> On 5/11/2022 8:10 PM, Ben wrote:
>> olcott <NoOne@NoWhere.com> writes:
>>
>>> On 5/11/2022 7:17 PM, Ben wrote:
>>>> olcott <NoOne@NoWhere.com> writes:
>>>>
>>>>> Proof that H(P,P)==0 is correct [ refuting the halting problem
>>>>> proofs ]
>>>> There are no arguments that can be passed to H so that H can correctly
>>>> report on the halting of the function call P(P).  H falls at the first
>>>> hurdle: being able to decide the halting of specific function calls.
>>>
>>> A halt decider must only correctly report on the halt status of its
>>> inputs. H(P,P)==0 and H1(P,P)==1 both do that correctly.
>>
>> The "inputs" to H are two pointers.  They have no halt status.
>
> This is such a nutty thing to say when you already know that strings are
> always passed in C as char* pointers.
>
> I am passing strings of machine code as pointers, this is the normal
> correct way to do this.

But you violate the "bounds" of that string when you follow the call H
instruction.

>
>> What
>> H(X,Y) must correctly report on is the halting or otherwise of the
>> function call X(Y).  Your H does not do the job it is supposed to do.
>>
>
> int sim(int N, int M)
> {
>   return (N+M);
> }
>
> It turns out that this requirement is the same as requiring that
> sum(3,4) must report on sum(5,6), thus making the requirement itself
> incorrect.

Nope. UNSOUND Logic.

Sum is DEFINED to return the sum of the numbers given as its input.

H,(P,P) if it is a Halt Decider, is DEFINED to return and indication
about whether P(P) will Halt, read the DEFINITION.

If you disagree with the definition, you have a problem, because you
aren't allowed to change it, and still work on that same problem.

>
> The correct way of viewing the HP proof (and it is often stated this
> way) is that there exists some inputs such that H cannot correctly
> report their halt status.

Yes, which mean that NO H exist that can correctly report the correct
answer for ALL inputs.

>
>>> The HP proof tries to show an input that H gets wrong.
>>> The proof no longer works on my H.
>>
>> You are correct that the proof does not apply to your H.  The proof is
>> about supposed halt deciders D such that D(X,Y) == true if and only if
>> X(Y) halts and false otherwise.
>
> That is an incoherent requirement for some cases, thus incorrect for
> these cases.

No such thing as a incorrect requirement. Requirements ARE requirements.

What you actually mean is that some requirements are intrinsicly not
obtainable,

>
> That incoherent requirement is based on the false assumption that the
> behavior that the input to H(P,P) specifies is the always that exact
> same behavior as P(P).

Nope. You have the problem backwards.

xxx Deciders START with a defined mapping, and need to define how to
present that to the code to decide it.

Halting is about a Turing Machine and an Input to that machine.

A Halt Decider needs to define how to provide a computable
representation fpr that machine and input and have an algorithm to give
the right answer.

If there are machines/inputs that can't be properly expresses, that just
shows that the mapping is not computable, and no such decider exists.

IF we can't ask your H if P(P) will halt, then H fails to be a Halting
Decider,

>
> No one ever noticed that there are rare exceptions where this is not true.

Nope, there are no exceptions, you just don't understand what an xxx
decider is.

>
>> Your H is not such a function -- you
>> can make it do what you like.
>>
>
>

Re: Proof that H(P,P)==0 is correct [ refuting the halting problem proofs ](V2)

<20220512183107.00007721@reddwarf.jmc>

 copy mid

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

 copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!aioe.org!news.uzoreto.com!feeder.usenetexpress.com!tr2.eu1.usenetexpress.com!feeder1.feed.usenet.farm!feed.usenet.farm!peer02.ams4!peer.am4.highwinds-media.com!news.highwinds-media.com!fx08.ams4.POSTED!not-for-mail
From: flib...@reddwarf.jmc (Mr Flibble)
Newsgroups: comp.theory
Subject: Re: Proof that H(P,P)==0 is correct [ refuting the halting problem proofs ](V2)
Message-ID: <20220512183107.00007721@reddwarf.jmc>
References: <2pSdnR25lqHLZub_nZ2dnUU7_8zNnZ2d@giganews.com> <20220511201154.00002147@reddwarf.jmc> <lYydndd8nf4JzuH_nZ2dnUU7_83NnZ2d@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=US-ASCII
Content-Transfer-Encoding: 7bit
Lines: 183
X-Complaints-To: abuse@eweka.nl
NNTP-Posting-Date: Thu, 12 May 2022 17:31:07 UTC
Date: Thu, 12 May 2022 18:31:07 +0100
X-Received-Bytes: 8679
 by: Mr Flibble - Thu, 12 May 2022 17:31 UTC

On Wed, 11 May 2022 19:23:45 -0500
olcott <NoOne@NoWhere.com> wrote:

> On 5/11/2022 2:11 PM, Mr Flibble wrote:
> > On Wed, 11 May 2022 13:07:16 -0500
> > olcott <NoOne@NoWhere.com> wrote:
> >
> >> Proof that H(P,P)==0 is correct [ refuting the halting problem
> >> proofs ]
> >>
> >> The x86utm operating system was created so that every detail of the
> >> conventional halting problem counter example could be fully
> >> specified in C/x86.
> >>
> >> In computability theory, the halting problem is the
> >> problem of determining, from a description of an
> >> arbitrary computer program and an input, whether the
> >> program will finish running, or continue to run forever...
> >>
> >> For any program f that might determine if programs halt,
> >> a "pathological" program g, called with some input, can
> >> pass its own source and its input to f and then specifically
> >> do the opposite of what f predicts g will do. No f can exist
> >> that handles this case.
> >> https://en.wikipedia.org/wiki/Halting_problem
> >>
> >> This exact same relationship of f(g,g) was created as H(P,P), shown
> >> below.
> >>
> >> This is the overview of the method for proving that this analysis
> >> is correct:
> >> (a) Verify that the execution trace of P by H is correct by
> >> comparing this execution trace to the ax86 source-code of P.
> >>
> >> (b) Verify that this execution trace shows that P is stuck in
> >> infinitely nested simulation (a non-halting behavior).
> >>
> >> This proof can only be understood only by those having sufficient
> >> technical competence in:
> >> (a) software engineering (recognizing infinite recursion in C and
> >> x86 code) (b) the x86 programming language
> >> (c) the C programming language and
> >> (d) the details of how C is translated into x86 by the Microsoft C
> >> compilers.
> >>
> >> #include <stdint.h>
> >> #define u32 uint32_t
> >>
> >> void P(u32 x)
> >> {
> >> if (H(x, x))
> >> HERE: goto HERE;
> >> return;
> >> }
> >>
> >> int main()
> >> {
> >> Output("Input_Halts = ", H((u32)P, (u32)P));
> >> }
> >>
> >> _P()
> >> [00001352](01) 55 push ebp
> >> [00001353](02) 8bec mov ebp,esp
> >> [00001355](03) 8b4508 mov eax,[ebp+08]
> >> [00001358](01) 50 push eax
> >> [00001359](03) 8b4d08 mov ecx,[ebp+08]
> >> [0000135c](01) 51 push ecx
> >> [0000135d](05) e840feffff call 000011a2 // call H
> >> [00001362](03) 83c408 add esp,+08
> >> [00001365](02) 85c0 test eax,eax
> >> [00001367](02) 7402 jz 0000136b
> >> [00001369](02) ebfe jmp 00001369
> >> [0000136b](01) 5d pop ebp
> >> [0000136c](01) c3 ret
> >> Size in bytes:(0027) [0000136c]
> >>
> >> _main()
> >> [00001372](01) 55 push ebp
> >> [00001373](02) 8bec mov ebp,esp
> >> [00001375](05) 6852130000 push 00001352 // push P
> >> [0000137a](05) 6852130000 push 00001352 // push P
> >> [0000137f](05) e81efeffff call 000011a2 // call H
> >> [00001384](03) 83c408 add esp,+08
> >> [00001387](01) 50 push eax
> >> [00001388](05) 6823040000 push 00000423 // "Input_Halts = "
> >> [0000138d](05) e8e0f0ffff call 00000472 // call Output
> >> [00001392](03) 83c408 add esp,+08
> >> [00001395](02) 33c0 xor eax,eax
> >> [00001397](01) 5d pop ebp
> >> [00001398](01) c3 ret
> >> Size in bytes:(0039) [00001398]
> >>
> >> machine stack stack machine assembly
> >> address address data code language
> >> ======== ======== ======== ========= =============
> >> ...[00001372][0010229e][00000000] 55 push ebp
> >> ...[00001373][0010229e][00000000] 8bec mov ebp,esp
> >> ...[00001375][0010229a][00001352] 6852130000 push 00001352 // push
> >> P ...[0000137a][00102296][00001352] 6852130000 push 00001352 //
> >> push P ...[0000137f][00102292][00001384] e81efeffff call 000011a2
> >> // call H
> >>
> >> Begin Local Halt Decider Simulation Execution Trace Stored
> >> at:212352 ...[00001352][0021233e][00212342] 55 push ebp
> >> // enter P ...[00001353][0021233e][00212342] 8bec mov
> >> ebp,esp ...[00001355][0021233e][00212342] 8b4508 mov
> >> eax,[ebp+08] ...[00001358][0021233a][00001352] 50 push eax
> >> // push P ...[00001359][0021233a][00001352] 8b4d08 mov
> >> ecx,[ebp+08] ...[0000135c][00212336][00001352] 51 push ecx
> >> // push P ...[0000135d][00212332][00001362] e840feffff call
> >> 000011a2 // call H ...[00001352][0025cd66][0025cd6a] 55
> >> push ebp // enter P ...[00001353][0025cd66][0025cd6a] 8bec
> >> mov ebp,esp ...[00001355][0025cd66][0025cd6a] 8b4508 mov
> >> eax,[ebp+08] ...[00001358][0025cd62][00001352] 50 push eax
> >> // push P ...[00001359][0025cd62][00001352] 8b4d08 mov
> >> ecx,[ebp+08] ...[0000135c][0025cd5e][00001352] 51 push ecx
> >> // push P ...[0000135d][0025cd5a][00001362] e840feffff call
> >> 000011a2 // call H Local Halt Decider: Infinite Recursion Detected
> >> Simulation Stopped
> >>
> >> H sees that P is calling the same function from the same machine
> >> address with identical parameters, twice in sequence. This is the
> >> infinite recursion (infinitely nested simulation) non-halting
> >> behavior pattern.
> >>
> >> ...[00001384][0010229e][00000000] 83c408 add esp,+08
> >> ...[00001387][0010229a][00000000] 50 push eax
> >> ...[00001388][00102296][00000423] 6823040000 push 00000423 //
> >> "Input_Halts ="
> >> ---[0000138d][00102296][00000423] e8e0f0ffff call 00000472 // call
> >> Output Input_Halts = 0
> >> ...[00001392][0010229e][00000000] 83c408 add esp,+08
> >> ...[00001395][0010229e][00000000] 33c0 xor eax,eax
> >> ...[00001397][001022a2][00100000] 5d pop ebp
> >> ...[00001398][001022a6][00000004] c3 ret
> >> Number of Instructions Executed(15892) lines = 237 pages
> >>
> >>
> >> Halting problem undecidability and infinitely nested simulation
> >> (V5)
> >>
> >> https://www.researchgate.net/publication/359984584_Halting_problem_undecidability_and_infinitely_nested_simulation_V5
> >>
> >
> > Your simulation approach is erroneous as there is no infinite
> > recursion; the key to understanding this is by realizing the
> > implication of the words "pass its own source" in the following:
>
>
> YOU IGNORED THIS PART
>
> This proof can only be understood only by those having sufficient
> technical competence in:
> (a) software engineering - recognizing infinite recursion in C/x86
> (b) the x86 programming language
> (c) the C programming language and
> (d) the details of how C is translated into x86 by the Microsoft C
> compilers.
>
> > For any program f that might determine if programs halt,
> > a "pathological" program g, called with some input, can
> > pass its own source and its input to f and then specifically
> > do the opposite of what f predicts g will do. No f can exist
> > that handles this case.
> >
> > "pass its own source" is NOT the same as compiling and running its
> > own source as part of a simulation.
>
> Passing the finite string of its own machine code is equivalent to
> passing its own source.

Indeed its own machine code is a representation of its own source code
so is valid to pass to a decider HOWEVER you ignored the second part
of my assertion:

"pass its own source" is NOT the same as compiling *AND RUNNING* its
own source as part of a simulation.

"AND RUNNING" means you cannot execute that machine code as part of a
simulation to correctly decide anything.


Click here to read the complete article
Re: Proof that H(P,P)==0 is correct [ refuting the halting problem proofs ](V2)

<20220512184323.000078f7@reddwarf.jmc>

 copy mid

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

 copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!weretis.net!feeder8.news.weretis.net!news.roellig-ltd.de!open-news-network.org!peer02.ams4!peer.am4.highwinds-media.com!news.highwinds-media.com!fx08.ams4.POSTED!not-for-mail
From: flib...@reddwarf.jmc (Mr Flibble)
Newsgroups: comp.theory
Subject: Re: Proof that H(P,P)==0 is correct [ refuting the halting problem
proofs ](V2)
Message-ID: <20220512184323.000078f7@reddwarf.jmc>
References: <2pSdnR25lqHLZub_nZ2dnUU7_8zNnZ2d@giganews.com>
<20220511201154.00002147@reddwarf.jmc>
<lYydndd8nf4JzuH_nZ2dnUU7_83NnZ2d@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=US-ASCII
Content-Transfer-Encoding: 7bit
Lines: 169
X-Complaints-To: abuse@eweka.nl
NNTP-Posting-Date: Thu, 12 May 2022 17:43:23 UTC
Date: Thu, 12 May 2022 18:43:23 +0100
X-Received-Bytes: 8155
 by: Mr Flibble - Thu, 12 May 2022 17:43 UTC

On Wed, 11 May 2022 19:23:45 -0500
olcott <NoOne@NoWhere.com> wrote:

> On 5/11/2022 2:11 PM, Mr Flibble wrote:
> > On Wed, 11 May 2022 13:07:16 -0500
> > olcott <NoOne@NoWhere.com> wrote:
> >
> >> Proof that H(P,P)==0 is correct [ refuting the halting problem
> >> proofs ]
> >>
> >> The x86utm operating system was created so that every detail of the
> >> conventional halting problem counter example could be fully
> >> specified in C/x86.
> >>
> >> In computability theory, the halting problem is the
> >> problem of determining, from a description of an
> >> arbitrary computer program and an input, whether the
> >> program will finish running, or continue to run forever...
> >>
> >> For any program f that might determine if programs halt,
> >> a "pathological" program g, called with some input, can
> >> pass its own source and its input to f and then specifically
> >> do the opposite of what f predicts g will do. No f can exist
> >> that handles this case.
> >> https://en.wikipedia.org/wiki/Halting_problem
> >>
> >> This exact same relationship of f(g,g) was created as H(P,P), shown
> >> below.
> >>
> >> This is the overview of the method for proving that this analysis
> >> is correct:
> >> (a) Verify that the execution trace of P by H is correct by
> >> comparing this execution trace to the ax86 source-code of P.
> >>
> >> (b) Verify that this execution trace shows that P is stuck in
> >> infinitely nested simulation (a non-halting behavior).
> >>
> >> This proof can only be understood only by those having sufficient
> >> technical competence in:
> >> (a) software engineering (recognizing infinite recursion in C and
> >> x86 code) (b) the x86 programming language
> >> (c) the C programming language and
> >> (d) the details of how C is translated into x86 by the Microsoft C
> >> compilers.
> >>
> >> #include <stdint.h>
> >> #define u32 uint32_t
> >>
> >> void P(u32 x)
> >> {
> >> if (H(x, x))
> >> HERE: goto HERE;
> >> return;
> >> }
> >>
> >> int main()
> >> {
> >> Output("Input_Halts = ", H((u32)P, (u32)P));
> >> }
> >>
> >> _P()
> >> [00001352](01) 55 push ebp
> >> [00001353](02) 8bec mov ebp,esp
> >> [00001355](03) 8b4508 mov eax,[ebp+08]
> >> [00001358](01) 50 push eax
> >> [00001359](03) 8b4d08 mov ecx,[ebp+08]
> >> [0000135c](01) 51 push ecx
> >> [0000135d](05) e840feffff call 000011a2 // call H
> >> [00001362](03) 83c408 add esp,+08
> >> [00001365](02) 85c0 test eax,eax
> >> [00001367](02) 7402 jz 0000136b
> >> [00001369](02) ebfe jmp 00001369
> >> [0000136b](01) 5d pop ebp
> >> [0000136c](01) c3 ret
> >> Size in bytes:(0027) [0000136c]
> >>
> >> _main()
> >> [00001372](01) 55 push ebp
> >> [00001373](02) 8bec mov ebp,esp
> >> [00001375](05) 6852130000 push 00001352 // push P
> >> [0000137a](05) 6852130000 push 00001352 // push P
> >> [0000137f](05) e81efeffff call 000011a2 // call H
> >> [00001384](03) 83c408 add esp,+08
> >> [00001387](01) 50 push eax
> >> [00001388](05) 6823040000 push 00000423 // "Input_Halts = "
> >> [0000138d](05) e8e0f0ffff call 00000472 // call Output
> >> [00001392](03) 83c408 add esp,+08
> >> [00001395](02) 33c0 xor eax,eax
> >> [00001397](01) 5d pop ebp
> >> [00001398](01) c3 ret
> >> Size in bytes:(0039) [00001398]
> >>
> >> machine stack stack machine assembly
> >> address address data code language
> >> ======== ======== ======== ========= =============
> >> ...[00001372][0010229e][00000000] 55 push ebp
> >> ...[00001373][0010229e][00000000] 8bec mov ebp,esp
> >> ...[00001375][0010229a][00001352] 6852130000 push 00001352 // push
> >> P ...[0000137a][00102296][00001352] 6852130000 push 00001352 //
> >> push P ...[0000137f][00102292][00001384] e81efeffff call 000011a2
> >> // call H
> >>
> >> Begin Local Halt Decider Simulation Execution Trace Stored
> >> at:212352 ...[00001352][0021233e][00212342] 55 push ebp
> >> // enter P ...[00001353][0021233e][00212342] 8bec mov
> >> ebp,esp ...[00001355][0021233e][00212342] 8b4508 mov
> >> eax,[ebp+08] ...[00001358][0021233a][00001352] 50 push eax
> >> // push P ...[00001359][0021233a][00001352] 8b4d08 mov
> >> ecx,[ebp+08] ...[0000135c][00212336][00001352] 51 push ecx
> >> // push P ...[0000135d][00212332][00001362] e840feffff call
> >> 000011a2 // call H ...[00001352][0025cd66][0025cd6a] 55
> >> push ebp // enter P ...[00001353][0025cd66][0025cd6a] 8bec
> >> mov ebp,esp ...[00001355][0025cd66][0025cd6a] 8b4508 mov
> >> eax,[ebp+08] ...[00001358][0025cd62][00001352] 50 push eax
> >> // push P ...[00001359][0025cd62][00001352] 8b4d08 mov
> >> ecx,[ebp+08] ...[0000135c][0025cd5e][00001352] 51 push ecx
> >> // push P ...[0000135d][0025cd5a][00001362] e840feffff call
> >> 000011a2 // call H Local Halt Decider: Infinite Recursion Detected
> >> Simulation Stopped
> >>
> >> H sees that P is calling the same function from the same machine
> >> address with identical parameters, twice in sequence. This is the
> >> infinite recursion (infinitely nested simulation) non-halting
> >> behavior pattern.
> >>
> >> ...[00001384][0010229e][00000000] 83c408 add esp,+08
> >> ...[00001387][0010229a][00000000] 50 push eax
> >> ...[00001388][00102296][00000423] 6823040000 push 00000423 //
> >> "Input_Halts ="
> >> ---[0000138d][00102296][00000423] e8e0f0ffff call 00000472 // call
> >> Output Input_Halts = 0
> >> ...[00001392][0010229e][00000000] 83c408 add esp,+08
> >> ...[00001395][0010229e][00000000] 33c0 xor eax,eax
> >> ...[00001397][001022a2][00100000] 5d pop ebp
> >> ...[00001398][001022a6][00000004] c3 ret
> >> Number of Instructions Executed(15892) lines = 237 pages
> >>
> >>
> >> Halting problem undecidability and infinitely nested simulation
> >> (V5)
> >>
> >> https://www.researchgate.net/publication/359984584_Halting_problem_undecidability_and_infinitely_nested_simulation_V5
> >>
> >
> > Your simulation approach is erroneous as there is no infinite
> > recursion; the key to understanding this is by realizing the
> > implication of the words "pass its own source" in the following:
>
>
> YOU IGNORED THIS PART
>
> This proof can only be understood only by those having sufficient
> technical competence in:
> (a) software engineering - recognizing infinite recursion in C/x86
> (b) the x86 programming language
> (c) the C programming language and
> (d) the details of how C is translated into x86 by the Microsoft C
> compilers.

(a) I have been a software developer/engineer since 1993 and am able to
recognize infinite recursion and additionally, and more importantly, a
lack of infinite recursion.
(b) I have been familiar with x86 assembly since before 1993
(c) I understand and have competence in both C and C++ (having used the
latter since 1993)
(d) I have written a compiler, have you?

/Flibble

Re: Proof that H(P,P)==0 is correct [ refuting the halting problem proofs ](V2)

<YrydnRkeEcug2uD_nZ2dnUU7_81g4p2d@giganews.com>

 copy mid

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

 copy link   Newsgroups: comp.theory
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: Thu, 12 May 2022 12:43:25 -0500
Date: Thu, 12 May 2022 12:43:24 -0500
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:91.0) Gecko/20100101
Thunderbird/91.9.0
Subject: Re: Proof that H(P,P)==0 is correct [ refuting the halting problem
proofs ](V2)
Content-Language: en-US
Newsgroups: comp.theory
References: <2pSdnR25lqHLZub_nZ2dnUU7_8zNnZ2d@giganews.com>
<20220511201154.00002147@reddwarf.jmc>
<lYydndd8nf4JzuH_nZ2dnUU7_83NnZ2d@giganews.com>
<20220512183107.00007721@reddwarf.jmc>
From: NoO...@NoWhere.com (olcott)
In-Reply-To: <20220512183107.00007721@reddwarf.jmc>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 7bit
Message-ID: <YrydnRkeEcug2uD_nZ2dnUU7_81g4p2d@giganews.com>
Lines: 196
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-3PuYd/v/b8KhJ1HPtm9ZiAXlaThg5bVaRV13p3ehHJ77R20kYxdn+ZUQReNhnr5qDApA9VFMMHVRX4S!MNgytVcDuGzomQsLRAeLOidHcHwduvdukrHp+lwaptjCyrVWLw6PI7iGWHhZq9BK8y7golsWbYM=
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: 9676
 by: olcott - Thu, 12 May 2022 17:43 UTC

On 5/12/2022 12:31 PM, Mr Flibble wrote:
> On Wed, 11 May 2022 19:23:45 -0500
> olcott <NoOne@NoWhere.com> wrote:
>
>> On 5/11/2022 2:11 PM, Mr Flibble wrote:
>>> On Wed, 11 May 2022 13:07:16 -0500
>>> olcott <NoOne@NoWhere.com> wrote:
>>>
>>>> Proof that H(P,P)==0 is correct [ refuting the halting problem
>>>> proofs ]
>>>>
>>>> The x86utm operating system was created so that every detail of the
>>>> conventional halting problem counter example could be fully
>>>> specified in C/x86.
>>>>
>>>> In computability theory, the halting problem is the
>>>> problem of determining, from a description of an
>>>> arbitrary computer program and an input, whether the
>>>> program will finish running, or continue to run forever...
>>>>
>>>> For any program f that might determine if programs halt,
>>>> a "pathological" program g, called with some input, can
>>>> pass its own source and its input to f and then specifically
>>>> do the opposite of what f predicts g will do. No f can exist
>>>> that handles this case.
>>>> https://en.wikipedia.org/wiki/Halting_problem
>>>>
>>>> This exact same relationship of f(g,g) was created as H(P,P), shown
>>>> below.
>>>>
>>>> This is the overview of the method for proving that this analysis
>>>> is correct:
>>>> (a) Verify that the execution trace of P by H is correct by
>>>> comparing this execution trace to the ax86 source-code of P.
>>>>
>>>> (b) Verify that this execution trace shows that P is stuck in
>>>> infinitely nested simulation (a non-halting behavior).
>>>>
>>>> This proof can only be understood only by those having sufficient
>>>> technical competence in:
>>>> (a) software engineering (recognizing infinite recursion in C and
>>>> x86 code) (b) the x86 programming language
>>>> (c) the C programming language and
>>>> (d) the details of how C is translated into x86 by the Microsoft C
>>>> compilers.
>>>>
>>>> #include <stdint.h>
>>>> #define u32 uint32_t
>>>>
>>>> void P(u32 x)
>>>> {
>>>> if (H(x, x))
>>>> HERE: goto HERE;
>>>> return;
>>>> }
>>>>
>>>> int main()
>>>> {
>>>> Output("Input_Halts = ", H((u32)P, (u32)P));
>>>> }
>>>>
>>>> _P()
>>>> [00001352](01) 55 push ebp
>>>> [00001353](02) 8bec mov ebp,esp
>>>> [00001355](03) 8b4508 mov eax,[ebp+08]
>>>> [00001358](01) 50 push eax
>>>> [00001359](03) 8b4d08 mov ecx,[ebp+08]
>>>> [0000135c](01) 51 push ecx
>>>> [0000135d](05) e840feffff call 000011a2 // call H
>>>> [00001362](03) 83c408 add esp,+08
>>>> [00001365](02) 85c0 test eax,eax
>>>> [00001367](02) 7402 jz 0000136b
>>>> [00001369](02) ebfe jmp 00001369
>>>> [0000136b](01) 5d pop ebp
>>>> [0000136c](01) c3 ret
>>>> Size in bytes:(0027) [0000136c]
>>>>
>>>> _main()
>>>> [00001372](01) 55 push ebp
>>>> [00001373](02) 8bec mov ebp,esp
>>>> [00001375](05) 6852130000 push 00001352 // push P
>>>> [0000137a](05) 6852130000 push 00001352 // push P
>>>> [0000137f](05) e81efeffff call 000011a2 // call H
>>>> [00001384](03) 83c408 add esp,+08
>>>> [00001387](01) 50 push eax
>>>> [00001388](05) 6823040000 push 00000423 // "Input_Halts = "
>>>> [0000138d](05) e8e0f0ffff call 00000472 // call Output
>>>> [00001392](03) 83c408 add esp,+08
>>>> [00001395](02) 33c0 xor eax,eax
>>>> [00001397](01) 5d pop ebp
>>>> [00001398](01) c3 ret
>>>> Size in bytes:(0039) [00001398]
>>>>
>>>> machine stack stack machine assembly
>>>> address address data code language
>>>> ======== ======== ======== ========= =============
>>>> ...[00001372][0010229e][00000000] 55 push ebp
>>>> ...[00001373][0010229e][00000000] 8bec mov ebp,esp
>>>> ...[00001375][0010229a][00001352] 6852130000 push 00001352 // push
>>>> P ...[0000137a][00102296][00001352] 6852130000 push 00001352 //
>>>> push P ...[0000137f][00102292][00001384] e81efeffff call 000011a2
>>>> // call H
>>>>
>>>> Begin Local Halt Decider Simulation Execution Trace Stored
>>>> at:212352 ...[00001352][0021233e][00212342] 55 push ebp
>>>> // enter P ...[00001353][0021233e][00212342] 8bec mov
>>>> ebp,esp ...[00001355][0021233e][00212342] 8b4508 mov
>>>> eax,[ebp+08] ...[00001358][0021233a][00001352] 50 push eax
>>>> // push P ...[00001359][0021233a][00001352] 8b4d08 mov
>>>> ecx,[ebp+08] ...[0000135c][00212336][00001352] 51 push ecx
>>>> // push P ...[0000135d][00212332][00001362] e840feffff call
>>>> 000011a2 // call H ...[00001352][0025cd66][0025cd6a] 55
>>>> push ebp // enter P ...[00001353][0025cd66][0025cd6a] 8bec
>>>> mov ebp,esp ...[00001355][0025cd66][0025cd6a] 8b4508 mov
>>>> eax,[ebp+08] ...[00001358][0025cd62][00001352] 50 push eax
>>>> // push P ...[00001359][0025cd62][00001352] 8b4d08 mov
>>>> ecx,[ebp+08] ...[0000135c][0025cd5e][00001352] 51 push ecx
>>>> // push P ...[0000135d][0025cd5a][00001362] e840feffff call
>>>> 000011a2 // call H Local Halt Decider: Infinite Recursion Detected
>>>> Simulation Stopped
>>>>
>>>> H sees that P is calling the same function from the same machine
>>>> address with identical parameters, twice in sequence. This is the
>>>> infinite recursion (infinitely nested simulation) non-halting
>>>> behavior pattern.
>>>>
>>>> ...[00001384][0010229e][00000000] 83c408 add esp,+08
>>>> ...[00001387][0010229a][00000000] 50 push eax
>>>> ...[00001388][00102296][00000423] 6823040000 push 00000423 //
>>>> "Input_Halts ="
>>>> ---[0000138d][00102296][00000423] e8e0f0ffff call 00000472 // call
>>>> Output Input_Halts = 0
>>>> ...[00001392][0010229e][00000000] 83c408 add esp,+08
>>>> ...[00001395][0010229e][00000000] 33c0 xor eax,eax
>>>> ...[00001397][001022a2][00100000] 5d pop ebp
>>>> ...[00001398][001022a6][00000004] c3 ret
>>>> Number of Instructions Executed(15892) lines = 237 pages
>>>>
>>>>
>>>> Halting problem undecidability and infinitely nested simulation
>>>> (V5)
>>>>
>>>> https://www.researchgate.net/publication/359984584_Halting_problem_undecidability_and_infinitely_nested_simulation_V5
>>>>
>>>
>>> Your simulation approach is erroneous as there is no infinite
>>> recursion; the key to understanding this is by realizing the
>>> implication of the words "pass its own source" in the following:
>>
>>
>> YOU IGNORED THIS PART
>>
>> This proof can only be understood only by those having sufficient
>> technical competence in:
>> (a) software engineering - recognizing infinite recursion in C/x86
>> (b) the x86 programming language
>> (c) the C programming language and
>> (d) the details of how C is translated into x86 by the Microsoft C
>> compilers.
>>
>>> For any program f that might determine if programs halt,
>>> a "pathological" program g, called with some input, can
>>> pass its own source and its input to f and then specifically
>>> do the opposite of what f predicts g will do. No f can exist
>>> that handles this case.
>>>
>>> "pass its own source" is NOT the same as compiling and running its
>>> own source as part of a simulation.
>>
>> Passing the finite string of its own machine code is equivalent to
>> passing its own source.
>
> Indeed its own machine code is a representation of its own source code
> so is valid to pass to a decider HOWEVER you ignored the second part
> of my assertion:
>
> "pass its own source" is NOT the same as compiling *AND RUNNING* its
> own source as part of a simulation.
>


Click here to read the complete article
Re: Proof that H(P,P)==0 is correct [ refuting the halting problem proofs ](V2)

<YrydnRgeEcs22uD_nZ2dnUU7_81g4p2d@giganews.com>

 copy mid

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

 copy link   Newsgroups: comp.theory
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: Thu, 12 May 2022 12:45:15 -0500
Date: Thu, 12 May 2022 12:45:15 -0500
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:91.0) Gecko/20100101
Thunderbird/91.9.0
Subject: Re: Proof that H(P,P)==0 is correct [ refuting the halting problem
proofs ](V2)
Content-Language: en-US
Newsgroups: comp.theory
References: <2pSdnR25lqHLZub_nZ2dnUU7_8zNnZ2d@giganews.com>
<20220511201154.00002147@reddwarf.jmc>
<lYydndd8nf4JzuH_nZ2dnUU7_83NnZ2d@giganews.com>
<20220512184323.000078f7@reddwarf.jmc>
From: NoO...@NoWhere.com (olcott)
In-Reply-To: <20220512184323.000078f7@reddwarf.jmc>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 7bit
Message-ID: <YrydnRgeEcs22uD_nZ2dnUU7_81g4p2d@giganews.com>
Lines: 188
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-QQkmiB9A4VwC3FqtJGm3QXAbCSBRsOOoZdodSQgSbKY0CyWasH+ZPYkg2MMETgozyB5mO6cMvXrrewg!Jm35zfeuhNv8+pPnLfZs4umI+PYYM9JTxJq46y2jJPgtKBPKO0iTjfmOYjPCHiUgDXGRR31vK7I=
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: 9326
 by: olcott - Thu, 12 May 2022 17:45 UTC

On 5/12/2022 12:43 PM, Mr Flibble wrote:
> On Wed, 11 May 2022 19:23:45 -0500
> olcott <NoOne@NoWhere.com> wrote:
>
>> On 5/11/2022 2:11 PM, Mr Flibble wrote:
>>> On Wed, 11 May 2022 13:07:16 -0500
>>> olcott <NoOne@NoWhere.com> wrote:
>>>
>>>> Proof that H(P,P)==0 is correct [ refuting the halting problem
>>>> proofs ]
>>>>
>>>> The x86utm operating system was created so that every detail of the
>>>> conventional halting problem counter example could be fully
>>>> specified in C/x86.
>>>>
>>>> In computability theory, the halting problem is the
>>>> problem of determining, from a description of an
>>>> arbitrary computer program and an input, whether the
>>>> program will finish running, or continue to run forever...
>>>>
>>>> For any program f that might determine if programs halt,
>>>> a "pathological" program g, called with some input, can
>>>> pass its own source and its input to f and then specifically
>>>> do the opposite of what f predicts g will do. No f can exist
>>>> that handles this case.
>>>> https://en.wikipedia.org/wiki/Halting_problem
>>>>
>>>> This exact same relationship of f(g,g) was created as H(P,P), shown
>>>> below.
>>>>
>>>> This is the overview of the method for proving that this analysis
>>>> is correct:
>>>> (a) Verify that the execution trace of P by H is correct by
>>>> comparing this execution trace to the ax86 source-code of P.
>>>>
>>>> (b) Verify that this execution trace shows that P is stuck in
>>>> infinitely nested simulation (a non-halting behavior).
>>>>
>>>> This proof can only be understood only by those having sufficient
>>>> technical competence in:
>>>> (a) software engineering (recognizing infinite recursion in C and
>>>> x86 code) (b) the x86 programming language
>>>> (c) the C programming language and
>>>> (d) the details of how C is translated into x86 by the Microsoft C
>>>> compilers.
>>>>
>>>> #include <stdint.h>
>>>> #define u32 uint32_t
>>>>
>>>> void P(u32 x)
>>>> {
>>>> if (H(x, x))
>>>> HERE: goto HERE;
>>>> return;
>>>> }
>>>>
>>>> int main()
>>>> {
>>>> Output("Input_Halts = ", H((u32)P, (u32)P));
>>>> }
>>>>
>>>> _P()
>>>> [00001352](01) 55 push ebp
>>>> [00001353](02) 8bec mov ebp,esp
>>>> [00001355](03) 8b4508 mov eax,[ebp+08]
>>>> [00001358](01) 50 push eax
>>>> [00001359](03) 8b4d08 mov ecx,[ebp+08]
>>>> [0000135c](01) 51 push ecx
>>>> [0000135d](05) e840feffff call 000011a2 // call H
>>>> [00001362](03) 83c408 add esp,+08
>>>> [00001365](02) 85c0 test eax,eax
>>>> [00001367](02) 7402 jz 0000136b
>>>> [00001369](02) ebfe jmp 00001369
>>>> [0000136b](01) 5d pop ebp
>>>> [0000136c](01) c3 ret
>>>> Size in bytes:(0027) [0000136c]
>>>>
>>>> _main()
>>>> [00001372](01) 55 push ebp
>>>> [00001373](02) 8bec mov ebp,esp
>>>> [00001375](05) 6852130000 push 00001352 // push P
>>>> [0000137a](05) 6852130000 push 00001352 // push P
>>>> [0000137f](05) e81efeffff call 000011a2 // call H
>>>> [00001384](03) 83c408 add esp,+08
>>>> [00001387](01) 50 push eax
>>>> [00001388](05) 6823040000 push 00000423 // "Input_Halts = "
>>>> [0000138d](05) e8e0f0ffff call 00000472 // call Output
>>>> [00001392](03) 83c408 add esp,+08
>>>> [00001395](02) 33c0 xor eax,eax
>>>> [00001397](01) 5d pop ebp
>>>> [00001398](01) c3 ret
>>>> Size in bytes:(0039) [00001398]
>>>>
>>>> machine stack stack machine assembly
>>>> address address data code language
>>>> ======== ======== ======== ========= =============
>>>> ...[00001372][0010229e][00000000] 55 push ebp
>>>> ...[00001373][0010229e][00000000] 8bec mov ebp,esp
>>>> ...[00001375][0010229a][00001352] 6852130000 push 00001352 // push
>>>> P ...[0000137a][00102296][00001352] 6852130000 push 00001352 //
>>>> push P ...[0000137f][00102292][00001384] e81efeffff call 000011a2
>>>> // call H
>>>>
>>>> Begin Local Halt Decider Simulation Execution Trace Stored
>>>> at:212352 ...[00001352][0021233e][00212342] 55 push ebp
>>>> // enter P ...[00001353][0021233e][00212342] 8bec mov
>>>> ebp,esp ...[00001355][0021233e][00212342] 8b4508 mov
>>>> eax,[ebp+08] ...[00001358][0021233a][00001352] 50 push eax
>>>> // push P ...[00001359][0021233a][00001352] 8b4d08 mov
>>>> ecx,[ebp+08] ...[0000135c][00212336][00001352] 51 push ecx
>>>> // push P ...[0000135d][00212332][00001362] e840feffff call
>>>> 000011a2 // call H ...[00001352][0025cd66][0025cd6a] 55
>>>> push ebp // enter P ...[00001353][0025cd66][0025cd6a] 8bec
>>>> mov ebp,esp ...[00001355][0025cd66][0025cd6a] 8b4508 mov
>>>> eax,[ebp+08] ...[00001358][0025cd62][00001352] 50 push eax
>>>> // push P ...[00001359][0025cd62][00001352] 8b4d08 mov
>>>> ecx,[ebp+08] ...[0000135c][0025cd5e][00001352] 51 push ecx
>>>> // push P ...[0000135d][0025cd5a][00001362] e840feffff call
>>>> 000011a2 // call H Local Halt Decider: Infinite Recursion Detected
>>>> Simulation Stopped
>>>>
>>>> H sees that P is calling the same function from the same machine
>>>> address with identical parameters, twice in sequence. This is the
>>>> infinite recursion (infinitely nested simulation) non-halting
>>>> behavior pattern.
>>>>
>>>> ...[00001384][0010229e][00000000] 83c408 add esp,+08
>>>> ...[00001387][0010229a][00000000] 50 push eax
>>>> ...[00001388][00102296][00000423] 6823040000 push 00000423 //
>>>> "Input_Halts ="
>>>> ---[0000138d][00102296][00000423] e8e0f0ffff call 00000472 // call
>>>> Output Input_Halts = 0
>>>> ...[00001392][0010229e][00000000] 83c408 add esp,+08
>>>> ...[00001395][0010229e][00000000] 33c0 xor eax,eax
>>>> ...[00001397][001022a2][00100000] 5d pop ebp
>>>> ...[00001398][001022a6][00000004] c3 ret
>>>> Number of Instructions Executed(15892) lines = 237 pages
>>>>
>>>>
>>>> Halting problem undecidability and infinitely nested simulation
>>>> (V5)
>>>>
>>>> https://www.researchgate.net/publication/359984584_Halting_problem_undecidability_and_infinitely_nested_simulation_V5
>>>>
>>>
>>> Your simulation approach is erroneous as there is no infinite
>>> recursion; the key to understanding this is by realizing the
>>> implication of the words "pass its own source" in the following:
>>
>>
>> YOU IGNORED THIS PART
>>
>> This proof can only be understood only by those having sufficient
>> technical competence in:
>> (a) software engineering - recognizing infinite recursion in C/x86
>> (b) the x86 programming language
>> (c) the C programming language and
>> (d) the details of how C is translated into x86 by the Microsoft C
>> compilers.
>
> (a) I have been a software developer/engineer since 1993 and am able to
> recognize infinite recursion and additionally, and more importantly, a
> lack of infinite recursion.

This has been disproven in that you did not see this:

>>>> H sees that P is calling the same function from the same machine
>>>> address with identical parameters, twice in sequence. This is the
>>>> infinite recursion (infinitely nested simulation) non-halting
>>>> behavior pattern.


Click here to read the complete article
Re: Proof that H(P,P)==0 is correct [ refuting the halting problem proofs ](V2)

<20220512184716.00007086@reddwarf.jmc>

 copy mid

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

 copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!aioe.org!news.uzoreto.com!feeder.usenetexpress.com!tr1.eu1.usenetexpress.com!81.171.65.13.MISMATCH!peer01.ams4!peer.am4.highwinds-media.com!news.highwinds-media.com!fx08.ams4.POSTED!not-for-mail
From: flib...@reddwarf.jmc (Mr Flibble)
Newsgroups: comp.theory
Subject: Re: Proof that H(P,P)==0 is correct [ refuting the halting problem proofs ](V2)
Message-ID: <20220512184716.00007086@reddwarf.jmc>
References: <2pSdnR25lqHLZub_nZ2dnUU7_8zNnZ2d@giganews.com> <20220511201154.00002147@reddwarf.jmc> <lYydndd8nf4JzuH_nZ2dnUU7_83NnZ2d@giganews.com> <20220512184323.000078f7@reddwarf.jmc> <YrydnRgeEcs22uD_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=US-ASCII
Content-Transfer-Encoding: 7bit
Lines: 180
X-Complaints-To: abuse@eweka.nl
NNTP-Posting-Date: Thu, 12 May 2022 17:47:16 UTC
Date: Thu, 12 May 2022 18:47:16 +0100
X-Received-Bytes: 8994
 by: Mr Flibble - Thu, 12 May 2022 17:47 UTC

On Thu, 12 May 2022 12:45:15 -0500
olcott <NoOne@NoWhere.com> wrote:

> On 5/12/2022 12:43 PM, Mr Flibble wrote:
> > On Wed, 11 May 2022 19:23:45 -0500
> > olcott <NoOne@NoWhere.com> wrote:
> >
> >> On 5/11/2022 2:11 PM, Mr Flibble wrote:
> >>> On Wed, 11 May 2022 13:07:16 -0500
> >>> olcott <NoOne@NoWhere.com> wrote:
> >>>
> >>>> Proof that H(P,P)==0 is correct [ refuting the halting problem
> >>>> proofs ]
> >>>>
> >>>> The x86utm operating system was created so that every detail of
> >>>> the conventional halting problem counter example could be fully
> >>>> specified in C/x86.
> >>>>
> >>>> In computability theory, the halting problem is the
> >>>> problem of determining, from a description of an
> >>>> arbitrary computer program and an input, whether the
> >>>> program will finish running, or continue to run forever...
> >>>>
> >>>> For any program f that might determine if programs halt,
> >>>> a "pathological" program g, called with some input, can
> >>>> pass its own source and its input to f and then
> >>>> specifically do the opposite of what f predicts g will do. No f
> >>>> can exist that handles this case.
> >>>> https://en.wikipedia.org/wiki/Halting_problem
> >>>>
> >>>> This exact same relationship of f(g,g) was created as H(P,P),
> >>>> shown below.
> >>>>
> >>>> This is the overview of the method for proving that this analysis
> >>>> is correct:
> >>>> (a) Verify that the execution trace of P by H is correct by
> >>>> comparing this execution trace to the ax86 source-code of P.
> >>>>
> >>>> (b) Verify that this execution trace shows that P is stuck in
> >>>> infinitely nested simulation (a non-halting behavior).
> >>>>
> >>>> This proof can only be understood only by those having sufficient
> >>>> technical competence in:
> >>>> (a) software engineering (recognizing infinite recursion in C and
> >>>> x86 code) (b) the x86 programming language
> >>>> (c) the C programming language and
> >>>> (d) the details of how C is translated into x86 by the Microsoft
> >>>> C compilers.
> >>>>
> >>>> #include <stdint.h>
> >>>> #define u32 uint32_t
> >>>>
> >>>> void P(u32 x)
> >>>> {
> >>>> if (H(x, x))
> >>>> HERE: goto HERE;
> >>>> return;
> >>>> }
> >>>>
> >>>> int main()
> >>>> {
> >>>> Output("Input_Halts = ", H((u32)P, (u32)P));
> >>>> }
> >>>>
> >>>> _P()
> >>>> [00001352](01) 55 push ebp
> >>>> [00001353](02) 8bec mov ebp,esp
> >>>> [00001355](03) 8b4508 mov eax,[ebp+08]
> >>>> [00001358](01) 50 push eax
> >>>> [00001359](03) 8b4d08 mov ecx,[ebp+08]
> >>>> [0000135c](01) 51 push ecx
> >>>> [0000135d](05) e840feffff call 000011a2 // call H
> >>>> [00001362](03) 83c408 add esp,+08
> >>>> [00001365](02) 85c0 test eax,eax
> >>>> [00001367](02) 7402 jz 0000136b
> >>>> [00001369](02) ebfe jmp 00001369
> >>>> [0000136b](01) 5d pop ebp
> >>>> [0000136c](01) c3 ret
> >>>> Size in bytes:(0027) [0000136c]
> >>>>
> >>>> _main()
> >>>> [00001372](01) 55 push ebp
> >>>> [00001373](02) 8bec mov ebp,esp
> >>>> [00001375](05) 6852130000 push 00001352 // push P
> >>>> [0000137a](05) 6852130000 push 00001352 // push P
> >>>> [0000137f](05) e81efeffff call 000011a2 // call H
> >>>> [00001384](03) 83c408 add esp,+08
> >>>> [00001387](01) 50 push eax
> >>>> [00001388](05) 6823040000 push 00000423 // "Input_Halts = "
> >>>> [0000138d](05) e8e0f0ffff call 00000472 // call Output
> >>>> [00001392](03) 83c408 add esp,+08
> >>>> [00001395](02) 33c0 xor eax,eax
> >>>> [00001397](01) 5d pop ebp
> >>>> [00001398](01) c3 ret
> >>>> Size in bytes:(0039) [00001398]
> >>>>
> >>>> machine stack stack machine assembly
> >>>> address address data code language
> >>>> ======== ======== ======== ========= =============
> >>>> ...[00001372][0010229e][00000000] 55 push ebp
> >>>> ...[00001373][0010229e][00000000] 8bec mov ebp,esp
> >>>> ...[00001375][0010229a][00001352] 6852130000 push 00001352 //
> >>>> push P ...[0000137a][00102296][00001352] 6852130000 push
> >>>> 00001352 // push P ...[0000137f][00102292][00001384] e81efeffff
> >>>> call 000011a2 // call H
> >>>>
> >>>> Begin Local Halt Decider Simulation Execution Trace Stored
> >>>> at:212352 ...[00001352][0021233e][00212342] 55 push ebp
> >>>> // enter P ...[00001353][0021233e][00212342] 8bec mov
> >>>> ebp,esp ...[00001355][0021233e][00212342] 8b4508 mov
> >>>> eax,[ebp+08] ...[00001358][0021233a][00001352] 50 push
> >>>> eax // push P ...[00001359][0021233a][00001352] 8b4d08 mov
> >>>> ecx,[ebp+08] ...[0000135c][00212336][00001352] 51 push
> >>>> ecx // push P ...[0000135d][00212332][00001362] e840feffff call
> >>>> 000011a2 // call H ...[00001352][0025cd66][0025cd6a] 55
> >>>> push ebp // enter P ...[00001353][0025cd66][0025cd6a] 8bec
> >>>> mov ebp,esp ...[00001355][0025cd66][0025cd6a] 8b4508 mov
> >>>> eax,[ebp+08] ...[00001358][0025cd62][00001352] 50 push
> >>>> eax // push P ...[00001359][0025cd62][00001352] 8b4d08 mov
> >>>> ecx,[ebp+08] ...[0000135c][0025cd5e][00001352] 51 push
> >>>> ecx // push P ...[0000135d][0025cd5a][00001362] e840feffff call
> >>>> 000011a2 // call H Local Halt Decider: Infinite Recursion
> >>>> Detected Simulation Stopped
> >>>>
> >>>> H sees that P is calling the same function from the same machine
> >>>> address with identical parameters, twice in sequence. This is the
> >>>> infinite recursion (infinitely nested simulation) non-halting
> >>>> behavior pattern.
> >>>>
> >>>> ...[00001384][0010229e][00000000] 83c408 add esp,+08
> >>>> ...[00001387][0010229a][00000000] 50 push eax
> >>>> ...[00001388][00102296][00000423] 6823040000 push 00000423 //
> >>>> "Input_Halts ="
> >>>> ---[0000138d][00102296][00000423] e8e0f0ffff call 00000472 //
> >>>> call Output Input_Halts = 0
> >>>> ...[00001392][0010229e][00000000] 83c408 add esp,+08
> >>>> ...[00001395][0010229e][00000000] 33c0 xor eax,eax
> >>>> ...[00001397][001022a2][00100000] 5d pop ebp
> >>>> ...[00001398][001022a6][00000004] c3 ret
> >>>> Number of Instructions Executed(15892) lines = 237 pages
> >>>>
> >>>>
> >>>> Halting problem undecidability and infinitely nested simulation
> >>>> (V5)
> >>>>
> >>>> https://www.researchgate.net/publication/359984584_Halting_problem_undecidability_and_infinitely_nested_simulation_V5
> >>>>
> >>>
> >>> Your simulation approach is erroneous as there is no infinite
> >>> recursion; the key to understanding this is by realizing the
> >>> implication of the words "pass its own source" in the following:
> >>
> >>
> >> YOU IGNORED THIS PART
> >>
> >> This proof can only be understood only by those having sufficient
> >> technical competence in:
> >> (a) software engineering - recognizing infinite recursion in C/x86
> >> (b) the x86 programming language
> >> (c) the C programming language and
> >> (d) the details of how C is translated into x86 by the Microsoft C
> >> compilers.
> >
> > (a) I have been a software developer/engineer since 1993 and am
> > able to recognize infinite recursion and additionally, and more
> > importantly, a lack of infinite recursion.
>
> This has been disproven in that you did not see this:
>
> >>>> H sees that P is calling the same function from the same machine
> >>>> address with identical parameters, twice in sequence. This is
> >>>> the infinite recursion (infinitely nested simulation)
> >>>> non-halting behavior pattern.

Click here to read the complete article

Re: Proof that H(P,P)==0 is correct [ refuting the halting problem proofs ](V2)

<28Odnb4QI9a91OD_nZ2dnUU7_81g4p2d@giganews.com>

 copy mid

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

 copy link   Newsgroups: comp.theory
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: Thu, 12 May 2022 12:51:28 -0500
Date: Thu, 12 May 2022 12:51:27 -0500
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:91.0) Gecko/20100101
Thunderbird/91.9.0
Subject: Re: Proof that H(P,P)==0 is correct [ refuting the halting problem
proofs ](V2)
Content-Language: en-US
Newsgroups: comp.theory
References: <2pSdnR25lqHLZub_nZ2dnUU7_8zNnZ2d@giganews.com>
<20220511201154.00002147@reddwarf.jmc>
<lYydndd8nf4JzuH_nZ2dnUU7_83NnZ2d@giganews.com>
<20220512184323.000078f7@reddwarf.jmc>
<YrydnRgeEcs22uD_nZ2dnUU7_81g4p2d@giganews.com>
<20220512184716.00007086@reddwarf.jmc>
From: NoO...@NoWhere.com (olcott)
In-Reply-To: <20220512184716.00007086@reddwarf.jmc>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 7bit
Message-ID: <28Odnb4QI9a91OD_nZ2dnUU7_81g4p2d@giganews.com>
Lines: 191
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-46YNikZ0GA/cNDvIm/0X1FoFQCNZLjnmBur3ydZnQzIC0+RYVn1AZts0FkjKMA/xP0CPe06cTi6J3vS!B7wpajkxEhL5hrzFeUd02zYn4bJ+0KKNELIYiQM2enQkEM/R8+CTkwiIGUZboftZjm3EO3d7tSg=
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: 9930
 by: olcott - Thu, 12 May 2022 17:51 UTC

On 5/12/2022 12:47 PM, Mr Flibble wrote:
> On Thu, 12 May 2022 12:45:15 -0500
> olcott <NoOne@NoWhere.com> wrote:
>
>> On 5/12/2022 12:43 PM, Mr Flibble wrote:
>>> On Wed, 11 May 2022 19:23:45 -0500
>>> olcott <NoOne@NoWhere.com> wrote:
>>>
>>>> On 5/11/2022 2:11 PM, Mr Flibble wrote:
>>>>> On Wed, 11 May 2022 13:07:16 -0500
>>>>> olcott <NoOne@NoWhere.com> wrote:
>>>>>
>>>>>> Proof that H(P,P)==0 is correct [ refuting the halting problem
>>>>>> proofs ]
>>>>>>
>>>>>> The x86utm operating system was created so that every detail of
>>>>>> the conventional halting problem counter example could be fully
>>>>>> specified in C/x86.
>>>>>>
>>>>>> In computability theory, the halting problem is the
>>>>>> problem of determining, from a description of an
>>>>>> arbitrary computer program and an input, whether the
>>>>>> program will finish running, or continue to run forever...
>>>>>>
>>>>>> For any program f that might determine if programs halt,
>>>>>> a "pathological" program g, called with some input, can
>>>>>> pass its own source and its input to f and then
>>>>>> specifically do the opposite of what f predicts g will do. No f
>>>>>> can exist that handles this case.
>>>>>> https://en.wikipedia.org/wiki/Halting_problem
>>>>>>
>>>>>> This exact same relationship of f(g,g) was created as H(P,P),
>>>>>> shown below.
>>>>>>
>>>>>> This is the overview of the method for proving that this analysis
>>>>>> is correct:
>>>>>> (a) Verify that the execution trace of P by H is correct by
>>>>>> comparing this execution trace to the ax86 source-code of P.
>>>>>>
>>>>>> (b) Verify that this execution trace shows that P is stuck in
>>>>>> infinitely nested simulation (a non-halting behavior).
>>>>>>
>>>>>> This proof can only be understood only by those having sufficient
>>>>>> technical competence in:
>>>>>> (a) software engineering (recognizing infinite recursion in C and
>>>>>> x86 code) (b) the x86 programming language
>>>>>> (c) the C programming language and
>>>>>> (d) the details of how C is translated into x86 by the Microsoft
>>>>>> C compilers.
>>>>>>
>>>>>> #include <stdint.h>
>>>>>> #define u32 uint32_t
>>>>>>
>>>>>> void P(u32 x)
>>>>>> {
>>>>>> if (H(x, x))
>>>>>> HERE: goto HERE;
>>>>>> return;
>>>>>> }
>>>>>>
>>>>>> int main()
>>>>>> {
>>>>>> Output("Input_Halts = ", H((u32)P, (u32)P));
>>>>>> }
>>>>>>
>>>>>> _P()
>>>>>> [00001352](01) 55 push ebp
>>>>>> [00001353](02) 8bec mov ebp,esp
>>>>>> [00001355](03) 8b4508 mov eax,[ebp+08]
>>>>>> [00001358](01) 50 push eax
>>>>>> [00001359](03) 8b4d08 mov ecx,[ebp+08]
>>>>>> [0000135c](01) 51 push ecx
>>>>>> [0000135d](05) e840feffff call 000011a2 // call H
>>>>>> [00001362](03) 83c408 add esp,+08
>>>>>> [00001365](02) 85c0 test eax,eax
>>>>>> [00001367](02) 7402 jz 0000136b
>>>>>> [00001369](02) ebfe jmp 00001369
>>>>>> [0000136b](01) 5d pop ebp
>>>>>> [0000136c](01) c3 ret
>>>>>> Size in bytes:(0027) [0000136c]
>>>>>>
>>>>>> _main()
>>>>>> [00001372](01) 55 push ebp
>>>>>> [00001373](02) 8bec mov ebp,esp
>>>>>> [00001375](05) 6852130000 push 00001352 // push P
>>>>>> [0000137a](05) 6852130000 push 00001352 // push P
>>>>>> [0000137f](05) e81efeffff call 000011a2 // call H
>>>>>> [00001384](03) 83c408 add esp,+08
>>>>>> [00001387](01) 50 push eax
>>>>>> [00001388](05) 6823040000 push 00000423 // "Input_Halts = "
>>>>>> [0000138d](05) e8e0f0ffff call 00000472 // call Output
>>>>>> [00001392](03) 83c408 add esp,+08
>>>>>> [00001395](02) 33c0 xor eax,eax
>>>>>> [00001397](01) 5d pop ebp
>>>>>> [00001398](01) c3 ret
>>>>>> Size in bytes:(0039) [00001398]
>>>>>>
>>>>>> machine stack stack machine assembly
>>>>>> address address data code language
>>>>>> ======== ======== ======== ========= =============
>>>>>> ...[00001372][0010229e][00000000] 55 push ebp
>>>>>> ...[00001373][0010229e][00000000] 8bec mov ebp,esp
>>>>>> ...[00001375][0010229a][00001352] 6852130000 push 00001352 //
>>>>>> push P ...[0000137a][00102296][00001352] 6852130000 push
>>>>>> 00001352 // push P ...[0000137f][00102292][00001384] e81efeffff
>>>>>> call 000011a2 // call H
>>>>>>
>>>>>> Begin Local Halt Decider Simulation Execution Trace Stored
>>>>>> at:212352 ...[00001352][0021233e][00212342] 55 push ebp
>>>>>> // enter P ...[00001353][0021233e][00212342] 8bec mov
>>>>>> ebp,esp ...[00001355][0021233e][00212342] 8b4508 mov
>>>>>> eax,[ebp+08] ...[00001358][0021233a][00001352] 50 push
>>>>>> eax // push P ...[00001359][0021233a][00001352] 8b4d08 mov
>>>>>> ecx,[ebp+08] ...[0000135c][00212336][00001352] 51 push
>>>>>> ecx // push P ...[0000135d][00212332][00001362] e840feffff call
>>>>>> 000011a2 // call H ...[00001352][0025cd66][0025cd6a] 55
>>>>>> push ebp // enter P ...[00001353][0025cd66][0025cd6a] 8bec
>>>>>> mov ebp,esp ...[00001355][0025cd66][0025cd6a] 8b4508 mov
>>>>>> eax,[ebp+08] ...[00001358][0025cd62][00001352] 50 push
>>>>>> eax // push P ...[00001359][0025cd62][00001352] 8b4d08 mov
>>>>>> ecx,[ebp+08] ...[0000135c][0025cd5e][00001352] 51 push
>>>>>> ecx // push P ...[0000135d][0025cd5a][00001362] e840feffff call
>>>>>> 000011a2 // call H Local Halt Decider: Infinite Recursion
>>>>>> Detected Simulation Stopped
>>>>>>
>>>>>> H sees that P is calling the same function from the same machine
>>>>>> address with identical parameters, twice in sequence. This is the
>>>>>> infinite recursion (infinitely nested simulation) non-halting
>>>>>> behavior pattern.
>>>>>>
>>>>>> ...[00001384][0010229e][00000000] 83c408 add esp,+08
>>>>>> ...[00001387][0010229a][00000000] 50 push eax
>>>>>> ...[00001388][00102296][00000423] 6823040000 push 00000423 //
>>>>>> "Input_Halts ="
>>>>>> ---[0000138d][00102296][00000423] e8e0f0ffff call 00000472 //
>>>>>> call Output Input_Halts = 0
>>>>>> ...[00001392][0010229e][00000000] 83c408 add esp,+08
>>>>>> ...[00001395][0010229e][00000000] 33c0 xor eax,eax
>>>>>> ...[00001397][001022a2][00100000] 5d pop ebp
>>>>>> ...[00001398][001022a6][00000004] c3 ret
>>>>>> Number of Instructions Executed(15892) lines = 237 pages
>>>>>>
>>>>>>
>>>>>> Halting problem undecidability and infinitely nested simulation
>>>>>> (V5)
>>>>>>
>>>>>> https://www.researchgate.net/publication/359984584_Halting_problem_undecidability_and_infinitely_nested_simulation_V5
>>>>>>
>>>>>
>>>>> Your simulation approach is erroneous as there is no infinite
>>>>> recursion; the key to understanding this is by realizing the
>>>>> implication of the words "pass its own source" in the following:
>>>>
>>>>
>>>> YOU IGNORED THIS PART
>>>>
>>>> This proof can only be understood only by those having sufficient
>>>> technical competence in:
>>>> (a) software engineering - recognizing infinite recursion in C/x86
>>>> (b) the x86 programming language
>>>> (c) the C programming language and
>>>> (d) the details of how C is translated into x86 by the Microsoft C
>>>> compilers.
>>>
>>> (a) I have been a software developer/engineer since 1993 and am
>>> able to recognize infinite recursion and additionally, and more
>>> importantly, a lack of infinite recursion.
>>
>> This has been disproven in that you did not see this:
>>
>> >>>> H sees that P is calling the same function from the same machine
>> >>>> address with identical parameters, twice in sequence. This is
>> >>>> the infinite recursion (infinitely nested simulation)
>> >>>> non-halting behavior pattern.
>
> I am not talking about your braindead simulation, I am talking about
> the halting problem proofs you are trying to refute: THEY DO NOT HAVE
> AN INFINITE RECURSION.
>
> /Flibble
>


Click here to read the complete article
Re: Proof that H(P,P)==0 is correct [ refuting the halting problem proofs ](V2)

<20220512190002.00001651@reddwarf.jmc>

 copy mid

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

 copy link   Newsgroups: comp.theory
Path: i2pn2.org!rocksolid2!i2pn.org!news.neodome.net!news.uzoreto.com!feeder1.feed.usenet.farm!feed.usenet.farm!peer01.ams4!peer.am4.highwinds-media.com!news.highwinds-media.com!fx08.ams4.POSTED!not-for-mail
From: flib...@reddwarf.jmc (Mr Flibble)
Newsgroups: comp.theory
Subject: Re: Proof that H(P,P)==0 is correct [ refuting the halting problem
proofs ](V2)
Message-ID: <20220512190002.00001651@reddwarf.jmc>
References: <2pSdnR25lqHLZub_nZ2dnUU7_8zNnZ2d@giganews.com>
<20220511201154.00002147@reddwarf.jmc>
<lYydndd8nf4JzuH_nZ2dnUU7_83NnZ2d@giganews.com>
<20220512184323.000078f7@reddwarf.jmc>
<YrydnRgeEcs22uD_nZ2dnUU7_81g4p2d@giganews.com>
<20220512184716.00007086@reddwarf.jmc>
<28Odnb4QI9a91OD_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=US-ASCII
Content-Transfer-Encoding: 7bit
Lines: 196
X-Complaints-To: abuse@eweka.nl
NNTP-Posting-Date: Thu, 12 May 2022 18:00:02 UTC
Date: Thu, 12 May 2022 19:00:02 +0100
X-Received-Bytes: 9902
 by: Mr Flibble - Thu, 12 May 2022 18:00 UTC

On Thu, 12 May 2022 12:51:27 -0500
olcott <NoOne@NoWhere.com> wrote:

> On 5/12/2022 12:47 PM, Mr Flibble wrote:
> > On Thu, 12 May 2022 12:45:15 -0500
> > olcott <NoOne@NoWhere.com> wrote:
> >
> >> On 5/12/2022 12:43 PM, Mr Flibble wrote:
> >>> On Wed, 11 May 2022 19:23:45 -0500
> >>> olcott <NoOne@NoWhere.com> wrote:
> >>>
> >>>> On 5/11/2022 2:11 PM, Mr Flibble wrote:
> >>>>> On Wed, 11 May 2022 13:07:16 -0500
> >>>>> olcott <NoOne@NoWhere.com> wrote:
> >>>>>
> >>>>>> Proof that H(P,P)==0 is correct [ refuting the halting problem
> >>>>>> proofs ]
> >>>>>>
> >>>>>> The x86utm operating system was created so that every detail of
> >>>>>> the conventional halting problem counter example could be fully
> >>>>>> specified in C/x86.
> >>>>>>
> >>>>>> In computability theory, the halting problem is the
> >>>>>> problem of determining, from a description of an
> >>>>>> arbitrary computer program and an input, whether the
> >>>>>> program will finish running, or continue to run
> >>>>>> forever...
> >>>>>>
> >>>>>> For any program f that might determine if programs halt,
> >>>>>> a "pathological" program g, called with some input, can
> >>>>>> pass its own source and its input to f and then
> >>>>>> specifically do the opposite of what f predicts g will do. No f
> >>>>>> can exist that handles this case.
> >>>>>> https://en.wikipedia.org/wiki/Halting_problem
> >>>>>>
> >>>>>> This exact same relationship of f(g,g) was created as H(P,P),
> >>>>>> shown below.
> >>>>>>
> >>>>>> This is the overview of the method for proving that this
> >>>>>> analysis is correct:
> >>>>>> (a) Verify that the execution trace of P by H is correct by
> >>>>>> comparing this execution trace to the ax86 source-code of P.
> >>>>>>
> >>>>>> (b) Verify that this execution trace shows that P is stuck in
> >>>>>> infinitely nested simulation (a non-halting behavior).
> >>>>>>
> >>>>>> This proof can only be understood only by those having
> >>>>>> sufficient technical competence in:
> >>>>>> (a) software engineering (recognizing infinite recursion in C
> >>>>>> and x86 code) (b) the x86 programming language
> >>>>>> (c) the C programming language and
> >>>>>> (d) the details of how C is translated into x86 by the
> >>>>>> Microsoft C compilers.
> >>>>>>
> >>>>>> #include <stdint.h>
> >>>>>> #define u32 uint32_t
> >>>>>>
> >>>>>> void P(u32 x)
> >>>>>> {
> >>>>>> if (H(x, x))
> >>>>>> HERE: goto HERE;
> >>>>>> return;
> >>>>>> }
> >>>>>>
> >>>>>> int main()
> >>>>>> {
> >>>>>> Output("Input_Halts = ", H((u32)P, (u32)P));
> >>>>>> }
> >>>>>>
> >>>>>> _P()
> >>>>>> [00001352](01) 55 push ebp
> >>>>>> [00001353](02) 8bec mov ebp,esp
> >>>>>> [00001355](03) 8b4508 mov eax,[ebp+08]
> >>>>>> [00001358](01) 50 push eax
> >>>>>> [00001359](03) 8b4d08 mov ecx,[ebp+08]
> >>>>>> [0000135c](01) 51 push ecx
> >>>>>> [0000135d](05) e840feffff call 000011a2 // call H
> >>>>>> [00001362](03) 83c408 add esp,+08
> >>>>>> [00001365](02) 85c0 test eax,eax
> >>>>>> [00001367](02) 7402 jz 0000136b
> >>>>>> [00001369](02) ebfe jmp 00001369
> >>>>>> [0000136b](01) 5d pop ebp
> >>>>>> [0000136c](01) c3 ret
> >>>>>> Size in bytes:(0027) [0000136c]
> >>>>>>
> >>>>>> _main()
> >>>>>> [00001372](01) 55 push ebp
> >>>>>> [00001373](02) 8bec mov ebp,esp
> >>>>>> [00001375](05) 6852130000 push 00001352 // push P
> >>>>>> [0000137a](05) 6852130000 push 00001352 // push P
> >>>>>> [0000137f](05) e81efeffff call 000011a2 // call H
> >>>>>> [00001384](03) 83c408 add esp,+08
> >>>>>> [00001387](01) 50 push eax
> >>>>>> [00001388](05) 6823040000 push 00000423 // "Input_Halts
> >>>>>> = " [0000138d](05) e8e0f0ffff call 00000472 // call
> >>>>>> Output [00001392](03) 83c408 add esp,+08
> >>>>>> [00001395](02) 33c0 xor eax,eax
> >>>>>> [00001397](01) 5d pop ebp
> >>>>>> [00001398](01) c3 ret
> >>>>>> Size in bytes:(0039) [00001398]
> >>>>>>
> >>>>>> machine stack stack machine assembly
> >>>>>> address address data code language
> >>>>>> ======== ======== ======== ========= =============
> >>>>>> ...[00001372][0010229e][00000000] 55 push ebp
> >>>>>> ...[00001373][0010229e][00000000] 8bec mov ebp,esp
> >>>>>> ...[00001375][0010229a][00001352] 6852130000 push 00001352 //
> >>>>>> push P ...[0000137a][00102296][00001352] 6852130000 push
> >>>>>> 00001352 // push P ...[0000137f][00102292][00001384] e81efeffff
> >>>>>> call 000011a2 // call H
> >>>>>>
> >>>>>> Begin Local Halt Decider Simulation Execution Trace Stored
> >>>>>> at:212352 ...[00001352][0021233e][00212342] 55 push ebp
> >>>>>> // enter P ...[00001353][0021233e][00212342] 8bec mov
> >>>>>> ebp,esp ...[00001355][0021233e][00212342] 8b4508 mov
> >>>>>> eax,[ebp+08] ...[00001358][0021233a][00001352] 50 push
> >>>>>> eax // push P ...[00001359][0021233a][00001352] 8b4d08 mov
> >>>>>> ecx,[ebp+08] ...[0000135c][00212336][00001352] 51 push
> >>>>>> ecx // push P ...[0000135d][00212332][00001362] e840feffff call
> >>>>>> 000011a2 // call H ...[00001352][0025cd66][0025cd6a] 55
> >>>>>> push ebp // enter P ...[00001353][0025cd66][0025cd6a] 8bec
> >>>>>> mov ebp,esp ...[00001355][0025cd66][0025cd6a] 8b4508
> >>>>>> mov eax,[ebp+08] ...[00001358][0025cd62][00001352] 50
> >>>>>> push eax // push P ...[00001359][0025cd62][00001352] 8b4d08
> >>>>>> mov ecx,[ebp+08] ...[0000135c][0025cd5e][00001352] 51
> >>>>>> push ecx // push P ...[0000135d][0025cd5a][00001362]
> >>>>>> e840feffff call 000011a2 // call H Local Halt Decider:
> >>>>>> Infinite Recursion Detected Simulation Stopped
> >>>>>>
> >>>>>> H sees that P is calling the same function from the same
> >>>>>> machine address with identical parameters, twice in sequence.
> >>>>>> This is the infinite recursion (infinitely nested simulation)
> >>>>>> non-halting behavior pattern.
> >>>>>>
> >>>>>> ...[00001384][0010229e][00000000] 83c408 add esp,+08
> >>>>>> ...[00001387][0010229a][00000000] 50 push eax
> >>>>>> ...[00001388][00102296][00000423] 6823040000 push 00000423 //
> >>>>>> "Input_Halts ="
> >>>>>> ---[0000138d][00102296][00000423] e8e0f0ffff call 00000472 //
> >>>>>> call Output Input_Halts = 0
> >>>>>> ...[00001392][0010229e][00000000] 83c408 add esp,+08
> >>>>>> ...[00001395][0010229e][00000000] 33c0 xor eax,eax
> >>>>>> ...[00001397][001022a2][00100000] 5d pop ebp
> >>>>>> ...[00001398][001022a6][00000004] c3 ret
> >>>>>> Number of Instructions Executed(15892) lines = 237 pages
> >>>>>>
> >>>>>>
> >>>>>> Halting problem undecidability and infinitely nested simulation
> >>>>>> (V5)
> >>>>>>
> >>>>>> https://www.researchgate.net/publication/359984584_Halting_problem_undecidability_and_infinitely_nested_simulation_V5
> >>>>>>
> >>>>>
> >>>>> Your simulation approach is erroneous as there is no infinite
> >>>>> recursion; the key to understanding this is by realizing the
> >>>>> implication of the words "pass its own source" in the
> >>>>> following:
> >>>>
> >>>>
> >>>> YOU IGNORED THIS PART
> >>>>
> >>>> This proof can only be understood only by those having sufficient
> >>>> technical competence in:
> >>>> (a) software engineering - recognizing infinite recursion in
> >>>> C/x86 (b) the x86 programming language
> >>>> (c) the C programming language and
> >>>> (d) the details of how C is translated into x86 by the Microsoft
> >>>> C compilers.
> >>>
> >>> (a) I have been a software developer/engineer since 1993 and am
> >>> able to recognize infinite recursion and additionally, and more
> >>> importantly, a lack of infinite recursion.
> >>
> >> This has been disproven in that you did not see this:
> >>
> >> >>>> H sees that P is calling the same function from the same
> >> >>>> machine address with identical parameters, twice in
> >> >>>> sequence. This is the infinite recursion (infinitely nested
> >> >>>> simulation) non-halting behavior pattern.
> >
> > I am not talking about your braindead simulation, I am talking about
> > the halting problem proofs you are trying to refute: THEY DO NOT
> > HAVE AN INFINITE RECURSION.
> >
> > /Flibble
> >
>
> My proofs prove that they do.
> That you fail to comprehend this is no rebuttal at all.

Click here to read the complete article

Re: Proof that H(P,P)==0 is correct [ refuting the halting problem proofs ](V2)

<nNSdnRSV0Zck0eD_nZ2dnUU7_83NnZ2d@giganews.com>

 copy mid

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

 copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!usenet.blueworldhosting.com!feed1.usenet.blueworldhosting.com!3.us.feeder.erje.net!feeder.erje.net!border1.nntp.dca1.giganews.com!nntp.giganews.com!buffer1.nntp.dca1.giganews.com!buffer2.nntp.dca1.giganews.com!news.giganews.com.POSTED!not-for-mail
NNTP-Posting-Date: Thu, 12 May 2022 13:06:49 -0500
Date: Thu, 12 May 2022 13:06:48 -0500
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:91.0) Gecko/20100101
Thunderbird/91.9.0
Subject: Re: Proof that H(P,P)==0 is correct [ refuting the halting problem
proofs ](V2)
Content-Language: en-US
Newsgroups: comp.theory
References: <2pSdnR25lqHLZub_nZ2dnUU7_8zNnZ2d@giganews.com>
<20220511201154.00002147@reddwarf.jmc>
<lYydndd8nf4JzuH_nZ2dnUU7_83NnZ2d@giganews.com>
<20220512184323.000078f7@reddwarf.jmc>
<YrydnRgeEcs22uD_nZ2dnUU7_81g4p2d@giganews.com>
<20220512184716.00007086@reddwarf.jmc>
<28Odnb4QI9a91OD_nZ2dnUU7_81g4p2d@giganews.com>
<20220512190002.00001651@reddwarf.jmc>
From: NoO...@NoWhere.com (olcott)
In-Reply-To: <20220512190002.00001651@reddwarf.jmc>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Message-ID: <nNSdnRSV0Zck0eD_nZ2dnUU7_83NnZ2d@giganews.com>
Lines: 242
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-7Mh83ORZbJV28yHa0aKYcNannE4QhS1SclGq5qCF+hJyI3b+iBXgYDyIOkvm+plUyJDSuhX2g2r3xSJ!YlMvLgQRcAIkybPIKlN6e57NwOzpRMUErj+xDZwTG79tKCwmmOPjJwlcnp2WODwz/1wNNeK4uVg=
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: 12538
 by: olcott - Thu, 12 May 2022 18:06 UTC

On 5/12/2022 1:00 PM, Mr Flibble wrote:
> On Thu, 12 May 2022 12:51:27 -0500
> olcott <NoOne@NoWhere.com> wrote:
>
>> On 5/12/2022 12:47 PM, Mr Flibble wrote:
>>> On Thu, 12 May 2022 12:45:15 -0500
>>> olcott <NoOne@NoWhere.com> wrote:
>>>
>>>> On 5/12/2022 12:43 PM, Mr Flibble wrote:
>>>>> On Wed, 11 May 2022 19:23:45 -0500
>>>>> olcott <NoOne@NoWhere.com> wrote:
>>>>>
>>>>>> On 5/11/2022 2:11 PM, Mr Flibble wrote:
>>>>>>> On Wed, 11 May 2022 13:07:16 -0500
>>>>>>> olcott <NoOne@NoWhere.com> wrote:
>>>>>>>
>>>>>>>> Proof that H(P,P)==0 is correct [ refuting the halting problem
>>>>>>>> proofs ]
>>>>>>>>
>>>>>>>> The x86utm operating system was created so that every detail of
>>>>>>>> the conventional halting problem counter example could be fully
>>>>>>>> specified in C/x86.
>>>>>>>>
>>>>>>>> In computability theory, the halting problem is the
>>>>>>>> problem of determining, from a description of an
>>>>>>>> arbitrary computer program and an input, whether the
>>>>>>>> program will finish running, or continue to run
>>>>>>>> forever...
>>>>>>>>
>>>>>>>> For any program f that might determine if programs halt,
>>>>>>>> a "pathological" program g, called with some input, can
>>>>>>>> pass its own source and its input to f and then
>>>>>>>> specifically do the opposite of what f predicts g will do. No f
>>>>>>>> can exist that handles this case.
>>>>>>>> https://en.wikipedia.org/wiki/Halting_problem
>>>>>>>>
>>>>>>>> This exact same relationship of f(g,g) was created as H(P,P),
>>>>>>>> shown below.
>>>>>>>>
>>>>>>>> This is the overview of the method for proving that this
>>>>>>>> analysis is correct:
>>>>>>>> (a) Verify that the execution trace of P by H is correct by
>>>>>>>> comparing this execution trace to the ax86 source-code of P.
>>>>>>>>
>>>>>>>> (b) Verify that this execution trace shows that P is stuck in
>>>>>>>> infinitely nested simulation (a non-halting behavior).
>>>>>>>>
>>>>>>>> This proof can only be understood only by those having
>>>>>>>> sufficient technical competence in:
>>>>>>>> (a) software engineering (recognizing infinite recursion in C
>>>>>>>> and x86 code) (b) the x86 programming language
>>>>>>>> (c) the C programming language and
>>>>>>>> (d) the details of how C is translated into x86 by the
>>>>>>>> Microsoft C compilers.
>>>>>>>>
>>>>>>>> #include <stdint.h>
>>>>>>>> #define u32 uint32_t
>>>>>>>>
>>>>>>>> void P(u32 x)
>>>>>>>> {
>>>>>>>> if (H(x, x))
>>>>>>>> HERE: goto HERE;
>>>>>>>> return;
>>>>>>>> }
>>>>>>>>
>>>>>>>> int main()
>>>>>>>> {
>>>>>>>> Output("Input_Halts = ", H((u32)P, (u32)P));
>>>>>>>> }
>>>>>>>>
>>>>>>>> _P()
>>>>>>>> [00001352](01) 55 push ebp
>>>>>>>> [00001353](02) 8bec mov ebp,esp
>>>>>>>> [00001355](03) 8b4508 mov eax,[ebp+08]
>>>>>>>> [00001358](01) 50 push eax
>>>>>>>> [00001359](03) 8b4d08 mov ecx,[ebp+08]
>>>>>>>> [0000135c](01) 51 push ecx
>>>>>>>> [0000135d](05) e840feffff call 000011a2 // call H
>>>>>>>> [00001362](03) 83c408 add esp,+08
>>>>>>>> [00001365](02) 85c0 test eax,eax
>>>>>>>> [00001367](02) 7402 jz 0000136b
>>>>>>>> [00001369](02) ebfe jmp 00001369
>>>>>>>> [0000136b](01) 5d pop ebp
>>>>>>>> [0000136c](01) c3 ret
>>>>>>>> Size in bytes:(0027) [0000136c]
>>>>>>>>
>>>>>>>> _main()
>>>>>>>> [00001372](01) 55 push ebp
>>>>>>>> [00001373](02) 8bec mov ebp,esp
>>>>>>>> [00001375](05) 6852130000 push 00001352 // push P
>>>>>>>> [0000137a](05) 6852130000 push 00001352 // push P
>>>>>>>> [0000137f](05) e81efeffff call 000011a2 // call H
>>>>>>>> [00001384](03) 83c408 add esp,+08
>>>>>>>> [00001387](01) 50 push eax
>>>>>>>> [00001388](05) 6823040000 push 00000423 // "Input_Halts
>>>>>>>> = " [0000138d](05) e8e0f0ffff call 00000472 // call
>>>>>>>> Output [00001392](03) 83c408 add esp,+08
>>>>>>>> [00001395](02) 33c0 xor eax,eax
>>>>>>>> [00001397](01) 5d pop ebp
>>>>>>>> [00001398](01) c3 ret
>>>>>>>> Size in bytes:(0039) [00001398]
>>>>>>>>
>>>>>>>> machine stack stack machine assembly
>>>>>>>> address address data code language
>>>>>>>> ======== ======== ======== ========= =============
>>>>>>>> ...[00001372][0010229e][00000000] 55 push ebp
>>>>>>>> ...[00001373][0010229e][00000000] 8bec mov ebp,esp
>>>>>>>> ...[00001375][0010229a][00001352] 6852130000 push 00001352 //
>>>>>>>> push P ...[0000137a][00102296][00001352] 6852130000 push
>>>>>>>> 00001352 // push P ...[0000137f][00102292][00001384] e81efeffff
>>>>>>>> call 000011a2 // call H
>>>>>>>>
>>>>>>>> Begin Local Halt Decider Simulation Execution Trace Stored
>>>>>>>> at:212352 ...[00001352][0021233e][00212342] 55 push ebp
>>>>>>>> // enter P ...[00001353][0021233e][00212342] 8bec mov
>>>>>>>> ebp,esp ...[00001355][0021233e][00212342] 8b4508 mov
>>>>>>>> eax,[ebp+08] ...[00001358][0021233a][00001352] 50 push
>>>>>>>> eax // push P ...[00001359][0021233a][00001352] 8b4d08 mov
>>>>>>>> ecx,[ebp+08] ...[0000135c][00212336][00001352] 51 push
>>>>>>>> ecx // push P ...[0000135d][00212332][00001362] e840feffff call
>>>>>>>> 000011a2 // call H ...[00001352][0025cd66][0025cd6a] 55
>>>>>>>> push ebp // enter P ...[00001353][0025cd66][0025cd6a] 8bec
>>>>>>>> mov ebp,esp ...[00001355][0025cd66][0025cd6a] 8b4508
>>>>>>>> mov eax,[ebp+08] ...[00001358][0025cd62][00001352] 50
>>>>>>>> push eax // push P ...[00001359][0025cd62][00001352] 8b4d08
>>>>>>>> mov ecx,[ebp+08] ...[0000135c][0025cd5e][00001352] 51
>>>>>>>> push ecx // push P ...[0000135d][0025cd5a][00001362]
>>>>>>>> e840feffff call 000011a2 // call H Local Halt Decider:
>>>>>>>> Infinite Recursion Detected Simulation Stopped
>>>>>>>>
>>>>>>>> H sees that P is calling the same function from the same
>>>>>>>> machine address with identical parameters, twice in sequence.
>>>>>>>> This is the infinite recursion (infinitely nested simulation)
>>>>>>>> non-halting behavior pattern.
>>>>>>>>
>>>>>>>> ...[00001384][0010229e][00000000] 83c408 add esp,+08
>>>>>>>> ...[00001387][0010229a][00000000] 50 push eax
>>>>>>>> ...[00001388][00102296][00000423] 6823040000 push 00000423 //
>>>>>>>> "Input_Halts ="
>>>>>>>> ---[0000138d][00102296][00000423] e8e0f0ffff call 00000472 //
>>>>>>>> call Output Input_Halts = 0
>>>>>>>> ...[00001392][0010229e][00000000] 83c408 add esp,+08
>>>>>>>> ...[00001395][0010229e][00000000] 33c0 xor eax,eax
>>>>>>>> ...[00001397][001022a2][00100000] 5d pop ebp
>>>>>>>> ...[00001398][001022a6][00000004] c3 ret
>>>>>>>> Number of Instructions Executed(15892) lines = 237 pages
>>>>>>>>
>>>>>>>>
>>>>>>>> Halting problem undecidability and infinitely nested simulation
>>>>>>>> (V5)
>>>>>>>>
>>>>>>>> https://www.researchgate.net/publication/359984584_Halting_problem_undecidability_and_infinitely_nested_simulation_V5
>>>>>>>>
>>>>>>>
>>>>>>> Your simulation approach is erroneous as there is no infinite
>>>>>>> recursion; the key to understanding this is by realizing the
>>>>>>> implication of the words "pass its own source" in the
>>>>>>> following:
>>>>>>
>>>>>>
>>>>>> YOU IGNORED THIS PART
>>>>>>
>>>>>> This proof can only be understood only by those having sufficient
>>>>>> technical competence in:
>>>>>> (a) software engineering - recognizing infinite recursion in
>>>>>> C/x86 (b) the x86 programming language
>>>>>> (c) the C programming language and
>>>>>> (d) the details of how C is translated into x86 by the Microsoft
>>>>>> C compilers.
>>>>>
>>>>> (a) I have been a software developer/engineer since 1993 and am
>>>>> able to recognize infinite recursion and additionally, and more
>>>>> importantly, a lack of infinite recursion.
>>>>
>>>> This has been disproven in that you did not see this:
>>>>
>>>> >>>> H sees that P is calling the same function from the same
>>>> >>>> machine address with identical parameters, twice in
>>>> >>>> sequence. This is the infinite recursion (infinitely nested
>>>> >>>> simulation) non-halting behavior pattern.
>>>
>>> I am not talking about your braindead simulation, I am talking about
>>> the halting problem proofs you are trying to refute: THEY DO NOT
>>> HAVE AN INFINITE RECURSION.
>>>
>>> /Flibble
>>>
>>
>> My proofs prove that they do.
>> That you fail to comprehend this is no rebuttal at all.
>
> Only your simulation contains an infinite recursion due to a category
> error ON YOUR PART. Your category error is proof that your
> simulation-based proof is in error.
>
> /Flibble
>


Click here to read the complete article
Re: Proof that H(P,P)==0 is correct [ refuting the halting problem proofs ](V2)

<20220512191355.000050d4@reddwarf.jmc>

 copy mid

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

 copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!aioe.org!news.uzoreto.com!peer03.ams4!peer.am4.highwinds-media.com!news.highwinds-media.com!fx08.ams4.POSTED!not-for-mail
From: flib...@reddwarf.jmc (Mr Flibble)
Newsgroups: comp.theory
Subject: Re: Proof that H(P,P)==0 is correct [ refuting the halting problem
proofs ](V2)
Message-ID: <20220512191355.000050d4@reddwarf.jmc>
References: <2pSdnR25lqHLZub_nZ2dnUU7_8zNnZ2d@giganews.com>
<20220511201154.00002147@reddwarf.jmc>
<lYydndd8nf4JzuH_nZ2dnUU7_83NnZ2d@giganews.com>
<20220512184323.000078f7@reddwarf.jmc>
<YrydnRgeEcs22uD_nZ2dnUU7_81g4p2d@giganews.com>
<20220512184716.00007086@reddwarf.jmc>
<28Odnb4QI9a91OD_nZ2dnUU7_81g4p2d@giganews.com>
<20220512190002.00001651@reddwarf.jmc>
<nNSdnRSV0Zck0eD_nZ2dnUU7_83NnZ2d@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=US-ASCII
Content-Transfer-Encoding: 7bit
Lines: 216
X-Complaints-To: abuse@eweka.nl
NNTP-Posting-Date: Thu, 12 May 2022 18:13:54 UTC
Date: Thu, 12 May 2022 19:13:55 +0100
X-Received-Bytes: 11143
 by: Mr Flibble - Thu, 12 May 2022 18:13 UTC

On Thu, 12 May 2022 13:06:48 -0500
olcott <NoOne@NoWhere.com> wrote:

> On 5/12/2022 1:00 PM, Mr Flibble wrote:
> > On Thu, 12 May 2022 12:51:27 -0500
> > olcott <NoOne@NoWhere.com> wrote:
> >
> >> On 5/12/2022 12:47 PM, Mr Flibble wrote:
> >>> On Thu, 12 May 2022 12:45:15 -0500
> >>> olcott <NoOne@NoWhere.com> wrote:
> >>>
> >>>> On 5/12/2022 12:43 PM, Mr Flibble wrote:
> >>>>> On Wed, 11 May 2022 19:23:45 -0500
> >>>>> olcott <NoOne@NoWhere.com> wrote:
> >>>>>
> >>>>>> On 5/11/2022 2:11 PM, Mr Flibble wrote:
> >>>>>>> On Wed, 11 May 2022 13:07:16 -0500
> >>>>>>> olcott <NoOne@NoWhere.com> wrote:
> >>>>>>>
> >>>>>>>> Proof that H(P,P)==0 is correct [ refuting the halting
> >>>>>>>> problem proofs ]
> >>>>>>>>
> >>>>>>>> The x86utm operating system was created so that every detail
> >>>>>>>> of the conventional halting problem counter example could be
> >>>>>>>> fully specified in C/x86.
> >>>>>>>>
> >>>>>>>> In computability theory, the halting problem is the
> >>>>>>>> problem of determining, from a description of an
> >>>>>>>> arbitrary computer program and an input, whether the
> >>>>>>>> program will finish running, or continue to run
> >>>>>>>> forever...
> >>>>>>>>
> >>>>>>>> For any program f that might determine if programs
> >>>>>>>> halt, a "pathological" program g, called with some input, can
> >>>>>>>> pass its own source and its input to f and then
> >>>>>>>> specifically do the opposite of what f predicts g will do.
> >>>>>>>> No f can exist that handles this case.
> >>>>>>>> https://en.wikipedia.org/wiki/Halting_problem
> >>>>>>>>
> >>>>>>>> This exact same relationship of f(g,g) was created as H(P,P),
> >>>>>>>> shown below.
> >>>>>>>>
> >>>>>>>> This is the overview of the method for proving that this
> >>>>>>>> analysis is correct:
> >>>>>>>> (a) Verify that the execution trace of P by H is correct by
> >>>>>>>> comparing this execution trace to the ax86 source-code of P.
> >>>>>>>>
> >>>>>>>> (b) Verify that this execution trace shows that P is stuck in
> >>>>>>>> infinitely nested simulation (a non-halting behavior).
> >>>>>>>>
> >>>>>>>> This proof can only be understood only by those having
> >>>>>>>> sufficient technical competence in:
> >>>>>>>> (a) software engineering (recognizing infinite recursion in C
> >>>>>>>> and x86 code) (b) the x86 programming language
> >>>>>>>> (c) the C programming language and
> >>>>>>>> (d) the details of how C is translated into x86 by the
> >>>>>>>> Microsoft C compilers.
> >>>>>>>>
> >>>>>>>> #include <stdint.h>
> >>>>>>>> #define u32 uint32_t
> >>>>>>>>
> >>>>>>>> void P(u32 x)
> >>>>>>>> {
> >>>>>>>> if (H(x, x))
> >>>>>>>> HERE: goto HERE;
> >>>>>>>> return;
> >>>>>>>> }
> >>>>>>>>
> >>>>>>>> int main()
> >>>>>>>> {
> >>>>>>>> Output("Input_Halts = ", H((u32)P, (u32)P));
> >>>>>>>> }
> >>>>>>>>
> >>>>>>>> _P()
> >>>>>>>> [00001352](01) 55 push ebp
> >>>>>>>> [00001353](02) 8bec mov ebp,esp
> >>>>>>>> [00001355](03) 8b4508 mov eax,[ebp+08]
> >>>>>>>> [00001358](01) 50 push eax
> >>>>>>>> [00001359](03) 8b4d08 mov ecx,[ebp+08]
> >>>>>>>> [0000135c](01) 51 push ecx
> >>>>>>>> [0000135d](05) e840feffff call 000011a2 // call H
> >>>>>>>> [00001362](03) 83c408 add esp,+08
> >>>>>>>> [00001365](02) 85c0 test eax,eax
> >>>>>>>> [00001367](02) 7402 jz 0000136b
> >>>>>>>> [00001369](02) ebfe jmp 00001369
> >>>>>>>> [0000136b](01) 5d pop ebp
> >>>>>>>> [0000136c](01) c3 ret
> >>>>>>>> Size in bytes:(0027) [0000136c]
> >>>>>>>>
> >>>>>>>> _main()
> >>>>>>>> [00001372](01) 55 push ebp
> >>>>>>>> [00001373](02) 8bec mov ebp,esp
> >>>>>>>> [00001375](05) 6852130000 push 00001352 // push P
> >>>>>>>> [0000137a](05) 6852130000 push 00001352 // push P
> >>>>>>>> [0000137f](05) e81efeffff call 000011a2 // call H
> >>>>>>>> [00001384](03) 83c408 add esp,+08
> >>>>>>>> [00001387](01) 50 push eax
> >>>>>>>> [00001388](05) 6823040000 push 00000423 // "Input_Halts
> >>>>>>>> = " [0000138d](05) e8e0f0ffff call 00000472 // call
> >>>>>>>> Output [00001392](03) 83c408 add esp,+08
> >>>>>>>> [00001395](02) 33c0 xor eax,eax
> >>>>>>>> [00001397](01) 5d pop ebp
> >>>>>>>> [00001398](01) c3 ret
> >>>>>>>> Size in bytes:(0039) [00001398]
> >>>>>>>>
> >>>>>>>> machine stack stack machine assembly
> >>>>>>>> address address data code language
> >>>>>>>> ======== ======== ======== =========
> >>>>>>>> ============= ...[00001372][0010229e][00000000] 55
> >>>>>>>> push ebp ...[00001373][0010229e][00000000] 8bec mov
> >>>>>>>> ebp,esp ...[00001375][0010229a][00001352] 6852130000 push
> >>>>>>>> 00001352 // push P ...[0000137a][00102296][00001352]
> >>>>>>>> 6852130000 push 00001352 // push P
> >>>>>>>> ...[0000137f][00102292][00001384] e81efeffff call 000011a2
> >>>>>>>> // call H
> >>>>>>>>
> >>>>>>>> Begin Local Halt Decider Simulation Execution Trace Stored
> >>>>>>>> at:212352 ...[00001352][0021233e][00212342] 55 push
> >>>>>>>> ebp // enter P ...[00001353][0021233e][00212342] 8bec
> >>>>>>>> mov ebp,esp ...[00001355][0021233e][00212342] 8b4508 mov
> >>>>>>>> eax,[ebp+08] ...[00001358][0021233a][00001352] 50
> >>>>>>>> push eax // push P ...[00001359][0021233a][00001352] 8b4d08
> >>>>>>>> mov ecx,[ebp+08] ...[0000135c][00212336][00001352] 51
> >>>>>>>> push ecx // push P ...[0000135d][00212332][00001362]
> >>>>>>>> e840feffff call 000011a2 // call H
> >>>>>>>> ...[00001352][0025cd66][0025cd6a] 55 push ebp // enter
> >>>>>>>> P ...[00001353][0025cd66][0025cd6a] 8bec mov ebp,esp
> >>>>>>>> ...[00001355][0025cd66][0025cd6a] 8b4508 mov eax,[ebp+08]
> >>>>>>>> ...[00001358][0025cd62][00001352] 50 push eax // push P
> >>>>>>>> ...[00001359][0025cd62][00001352] 8b4d08 mov ecx,[ebp+08]
> >>>>>>>> ...[0000135c][0025cd5e][00001352] 51 push ecx // push P
> >>>>>>>> ...[0000135d][0025cd5a][00001362] e840feffff call 000011a2
> >>>>>>>> // call H Local Halt Decider: Infinite Recursion Detected
> >>>>>>>> Simulation Stopped
> >>>>>>>>
> >>>>>>>> H sees that P is calling the same function from the same
> >>>>>>>> machine address with identical parameters, twice in sequence.
> >>>>>>>> This is the infinite recursion (infinitely nested simulation)
> >>>>>>>> non-halting behavior pattern.
> >>>>>>>>
> >>>>>>>> ...[00001384][0010229e][00000000] 83c408 add esp,+08
> >>>>>>>> ...[00001387][0010229a][00000000] 50 push eax
> >>>>>>>> ...[00001388][00102296][00000423] 6823040000 push 00000423 //
> >>>>>>>> "Input_Halts ="
> >>>>>>>> ---[0000138d][00102296][00000423] e8e0f0ffff call 00000472 //
> >>>>>>>> call Output Input_Halts = 0
> >>>>>>>> ...[00001392][0010229e][00000000] 83c408 add esp,+08
> >>>>>>>> ...[00001395][0010229e][00000000] 33c0 xor eax,eax
> >>>>>>>> ...[00001397][001022a2][00100000] 5d pop ebp
> >>>>>>>> ...[00001398][001022a6][00000004] c3 ret
> >>>>>>>> Number of Instructions Executed(15892) lines = 237 pages
> >>>>>>>>
> >>>>>>>>
> >>>>>>>> Halting problem undecidability and infinitely nested
> >>>>>>>> simulation (V5)
> >>>>>>>>
> >>>>>>>> https://www.researchgate.net/publication/359984584_Halting_problem_undecidability_and_infinitely_nested_simulation_V5
> >>>>>>>>
> >>>>>>>
> >>>>>>> Your simulation approach is erroneous as there is no infinite
> >>>>>>> recursion; the key to understanding this is by realizing the
> >>>>>>> implication of the words "pass its own source" in the
> >>>>>>> following:
> >>>>>>
> >>>>>>
> >>>>>> YOU IGNORED THIS PART
> >>>>>>
> >>>>>> This proof can only be understood only by those having
> >>>>>> sufficient technical competence in:
> >>>>>> (a) software engineering - recognizing infinite recursion in
> >>>>>> C/x86 (b) the x86 programming language
> >>>>>> (c) the C programming language and
> >>>>>> (d) the details of how C is translated into x86 by the
> >>>>>> Microsoft C compilers.
> >>>>>
> >>>>> (a) I have been a software developer/engineer since 1993 and am
> >>>>> able to recognize infinite recursion and additionally, and more
> >>>>> importantly, a lack of infinite recursion.
> >>>>
> >>>> This has been disproven in that you did not see this:
> >>>>
> >>>> >>>> H sees that P is calling the same function from the same
> >>>> >>>> machine address with identical parameters, twice in
> >>>> >>>> sequence. This is the infinite recursion (infinitely
> >>>> >>>> nested simulation) non-halting behavior pattern.
> >>>
> >>> I am not talking about your braindead simulation, I am talking
> >>> about the halting problem proofs you are trying to refute: THEY
> >>> DO NOT HAVE AN INFINITE RECURSION.
> >>>
> >>> /Flibble
> >>>
> >>
> >> My proofs prove that they do.
> >> That you fail to comprehend this is no rebuttal at all.
> >
> > Only your simulation contains an infinite recursion due to a
> > category error ON YOUR PART. Your category error is proof that your
> > simulation-based proof is in error.
> >
> > /Flibble
> >
>
> > PO's idea is to have a simulator with an infinite cycle detector.
> > You would achieve this by modifying a UTM, so describing it as
> > a "modified UTM", or "acts like a UTM until it detects an infinite
> > cycle", is reasonable. And such a machine is a fairly powerful
> > halt decider. Even if the infinite cycle detector isn't very
> > sophisticated, it will still catch a large subset of non-halting
> > machines.


Click here to read the complete article
Re: Proof that H(P,P)==0 is correct [ refuting the halting problem proofs ](V2)

<87bkw24ij5.fsf@bsb.me.uk>

 copy mid

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

 copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!eternal-september.org!reader02.eternal-september.org!.POSTED!not-for-mail
From: ben.use...@bsb.me.uk (Ben)
Newsgroups: comp.theory
Subject: Re: Proof that H(P,P)==0 is correct [ refuting the halting problem proofs ](V2)
Date: Thu, 12 May 2022 21:12:30 +0100
Organization: A noiseless patient Spider
Lines: 54
Message-ID: <87bkw24ij5.fsf@bsb.me.uk>
References: <2pSdnR25lqHLZub_nZ2dnUU7_8zNnZ2d@giganews.com>
<20220511201154.00002147@reddwarf.jmc>
<lYydndd8nf4JzuH_nZ2dnUU7_83NnZ2d@giganews.com>
<20220512184323.000078f7@reddwarf.jmc>
<YrydnRgeEcs22uD_nZ2dnUU7_81g4p2d@giganews.com>
<20220512184716.00007086@reddwarf.jmc>
<28Odnb4QI9a91OD_nZ2dnUU7_81g4p2d@giganews.com>
<20220512190002.00001651@reddwarf.jmc>
<nNSdnRSV0Zck0eD_nZ2dnUU7_83NnZ2d@giganews.com>
MIME-Version: 1.0
Content-Type: text/plain; charset=utf-8
Content-Transfer-Encoding: 8bit
Injection-Info: reader02.eternal-september.org; posting-host="b918120b717b1a0036d52ef1ce111b9c";
logging-data="27725"; mail-complaints-to="abuse@eternal-september.org"; posting-account="U2FsdGVkX18z2nOaxWrVPZf5fYcOH3mWI5gEnuKV8tg="
Cancel-Lock: sha1:0KdHQQAJ/SLzMW5LxLCwpLXXieI=
sha1:R9SZf1n5zQ1SIShdT+BuswY+ZVw=
X-BSB-Auth: 1.53e9fb26207dd44cac97.20220512211230BST.87bkw24ij5.fsf@bsb.me.uk
 by: Ben - Thu, 12 May 2022 20:12 UTC

olcott <NoOne@NoWhere.com> writes:

> The halting criteria has been adapted so that

H is no longer a halt decider.

> it applies to a
> simulating halt decider (SHD).
>
> Ĥ.q0 ⟨Ĥ⟩ ⊢* H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* H.qy
> If the correctly simulated input ⟨Ĥ⟩ ⟨Ĥ⟩ to H would reach its own
> final state of ⟨Ĥ.qy⟩ or ⟨Ĥ.qn⟩.

This not Linz's Ĥ. Linz's H leads to a contradiction because of how H
and the "hat" construction are defined. Using a different "hat"
construction, and an "adapted" halt criterion, means you are not
addressing Linz's (or anyone's) proof. Why do you think anyone will
take any claims about your bogus seriously?

> Ĥ.q0 ⟨Ĥ⟩ ⊢* H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* H.qn
> If the correctly simulated input ⟨Ĥ⟩ ⟨Ĥ⟩ to H would never reach its
> own final state of ⟨Ĥ.qy⟩ or ⟨Ĥ.qn⟩.

A halt decider would have this simple behaviour:

J ⟨M⟩ s ⊢* J.qy if M applied to s halts, and
J ⟨M⟩ s ⊢* J.qn if M applied to s does not halt.

(I've changed the name because you are abusing H and Ĥ to refer to TMs
that do not meet Linz's specifications.)

Which, with the correct "hat" construction applied, results in

Ĵ.q0 ⟨Ĵ⟩ ⊢* J ⟨Ĵ⟩ ⟨Ĵ⟩ ⊢* J.qy ⊢* oo if J applied to ⟨Ĵ⟩ ⟨Ĵ⟩ halts, and
Ĵ.q0 ⟨Ĵ⟩ ⊢* J ⟨Ĵ⟩ ⟨Ĵ⟩ ⊢* J.qn if J applied to ⟨Ĵ⟩ ⟨Ĵ⟩ does not halt

which, as Linz says, is clearly nonsense. No TM can behave as Ĵ was
assumed to behave.

I bring this up only for the benefit of anyone who is still interested
in how the proof works. You stopped talking about the halting problem
and it's proofs some while ago, having failed to persuade anyone that
the wrong answer is the right one.

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

Bit of a nerve to cite Linz when you are ignoring his specification and
his proof!

--
Ben.
"le génie humain a des limites, quand la bêtise humaine n’en a pas"
Alexandre Dumas (fils)

Re: Proof that H(P,P)==0 is correct [ refuting the halting problem proofs ](V2)

<L-ydnag1-YUx9uD_nZ2dnUU7_8xh4p2d@giganews.com>

 copy mid

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

 copy link   Newsgroups: comp.theory
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: Thu, 12 May 2022 15:18:52 -0500
Date: Thu, 12 May 2022 15:18:51 -0500
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:91.0) Gecko/20100101
Thunderbird/91.9.0
Subject: Re: Proof that H(P,P)==0 is correct [ refuting the halting problem
proofs ](V2)
Content-Language: en-US
Newsgroups: comp.theory
References: <2pSdnR25lqHLZub_nZ2dnUU7_8zNnZ2d@giganews.com>
<20220511201154.00002147@reddwarf.jmc>
<lYydndd8nf4JzuH_nZ2dnUU7_83NnZ2d@giganews.com>
<20220512184323.000078f7@reddwarf.jmc>
<YrydnRgeEcs22uD_nZ2dnUU7_81g4p2d@giganews.com>
<20220512184716.00007086@reddwarf.jmc>
<28Odnb4QI9a91OD_nZ2dnUU7_81g4p2d@giganews.com>
<20220512190002.00001651@reddwarf.jmc>
<nNSdnRSV0Zck0eD_nZ2dnUU7_83NnZ2d@giganews.com> <87bkw24ij5.fsf@bsb.me.uk>
From: NoO...@NoWhere.com (olcott)
In-Reply-To: <87bkw24ij5.fsf@bsb.me.uk>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Message-ID: <L-ydnag1-YUx9uD_nZ2dnUU7_8xh4p2d@giganews.com>
Lines: 62
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-BeTTzEamqK8DpT26n9HCOwceMkXCMmDWMM0nQyZtZuAZn+N3tJaWtyWLLPDDAVbjJyODd6mSN2yYcs7!Z9c3P2t2LP9ztfALKBtZYqfcytHNo6Xob+rmj4TnLXavHRjwoMb6PIA2HJUAAG+tAJUkibr9/E4=
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: 4092
 by: olcott - Thu, 12 May 2022 20:18 UTC

On 5/12/2022 3:12 PM, Ben wrote:
> olcott <NoOne@NoWhere.com> writes:
>
>> The halting criteria has been adapted so that
>
> H is no longer a halt decider.
>
>> it applies to a
>> simulating halt decider (SHD).
>>
>> Ĥ.q0 ⟨Ĥ⟩ ⊢* H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* H.qy
>> If the correctly simulated input ⟨Ĥ⟩ ⟨Ĥ⟩ to H would reach its own
>> final state of ⟨Ĥ.qy⟩ or ⟨Ĥ.qn⟩.
>
> This not Linz's Ĥ. Linz's H leads to a contradiction because of how H
> and the "hat" construction are defined. Using a different "hat"
> construction, and an "adapted" halt criterion, means you are not
> addressing Linz's (or anyone's) proof. Why do you think anyone will
> take any claims about your bogus seriously?
>
>> Ĥ.q0 ⟨Ĥ⟩ ⊢* H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* H.qn
>> If the correctly simulated input ⟨Ĥ⟩ ⟨Ĥ⟩ to H would never reach its
>> own final state of ⟨Ĥ.qy⟩ or ⟨Ĥ.qn⟩.
>
> A halt decider would have this simple behaviour:
>
> J ⟨M⟩ s ⊢* J.qy if M applied to s halts, and
> J ⟨M⟩ s ⊢* J.qn if M applied to s does not halt.
>
> (I've changed the name because you are abusing H and Ĥ to refer to TMs
> that do not meet Linz's specifications.)
>
> Which, with the correct "hat" construction applied, results in
>
> Ĵ.q0 ⟨Ĵ⟩ ⊢* J ⟨Ĵ⟩ ⟨Ĵ⟩ ⊢* J.qy ⊢* oo if J applied to ⟨Ĵ⟩ ⟨Ĵ⟩ halts, and
> Ĵ.q0 ⟨Ĵ⟩ ⊢* J ⟨Ĵ⟩ ⟨Ĵ⟩ ⊢* J.qn if J applied to ⟨Ĵ⟩ ⟨Ĵ⟩ does not halt
>
> which, as Linz says, is clearly nonsense. No TM can behave as Ĵ was
> assumed to behave.
>
> I bring this up only for the benefit of anyone who is still interested
> in how the proof works. You stopped talking about the halting problem
> and it's proofs some while ago, having failed to persuade anyone that
> the wrong answer is the right one.
>
>> Linz, Peter 1990. An Introduction to Formal Languages and
>> Automata. Lexington/Toronto: D. C. Heath and Company. (317-320)
>
> Bit of a nerve to cite Linz when you are ignoring his specification and
> his proof!
>

My only point is that the input to embedded_H does specifies infinitely
nested simulation contradicting Flibble's claim that it does not, thus
my H(P,P) is equivalent to embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩.

--
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: Proof that H(P,P)==0 is correct [ refuting the halting problem proofs ](V2)

<y6gfK.1282$j0D5.111@fx09.iad>

 copy mid

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

 copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!weretis.net!feeder8.news.weretis.net!feeder1.feed.usenet.farm!feed.usenet.farm!peer03.ams4!peer.am4.highwinds-media.com!peer03.iad!feed-me.highwinds-media.com!news.highwinds-media.com!fx09.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.9.0
Subject: Re: Proof that H(P,P)==0 is correct [ refuting the halting problem
proofs ](V2)
Content-Language: en-US
Newsgroups: comp.theory
References: <2pSdnR25lqHLZub_nZ2dnUU7_8zNnZ2d@giganews.com>
<20220511201154.00002147@reddwarf.jmc>
<lYydndd8nf4JzuH_nZ2dnUU7_83NnZ2d@giganews.com>
<20220512184323.000078f7@reddwarf.jmc>
<YrydnRgeEcs22uD_nZ2dnUU7_81g4p2d@giganews.com>
From: Rich...@Damon-Family.org (Richard Damon)
In-Reply-To: <YrydnRgeEcs22uD_nZ2dnUU7_81g4p2d@giganews.com>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Lines: 193
Message-ID: <y6gfK.1282$j0D5.111@fx09.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: Thu, 12 May 2022 18:45:52 -0400
X-Received-Bytes: 10148
 by: Richard Damon - Thu, 12 May 2022 22:45 UTC

On 5/12/22 1:45 PM, olcott wrote:
> On 5/12/2022 12:43 PM, Mr Flibble wrote:
>> On Wed, 11 May 2022 19:23:45 -0500
>> olcott <NoOne@NoWhere.com> wrote:
>>
>>> On 5/11/2022 2:11 PM, Mr Flibble wrote:
>>>> On Wed, 11 May 2022 13:07:16 -0500
>>>> olcott <NoOne@NoWhere.com> wrote:
>>>>> Proof that H(P,P)==0 is correct [ refuting the halting problem
>>>>> proofs ]
>>>>>
>>>>> The x86utm operating system was created so that every detail of the
>>>>> conventional halting problem counter example could be fully
>>>>> specified in C/x86.
>>>>>
>>>>>       In computability theory, the halting problem is the
>>>>>       problem of determining, from a description of an
>>>>>       arbitrary computer program and an input, whether the
>>>>>       program will finish running, or continue to run forever...
>>>>>
>>>>>       For any program f that might determine if programs halt,
>>>>>       a "pathological" program g, called with some input, can
>>>>>       pass its own source and its input to f and then specifically
>>>>>       do the opposite of what f predicts g will do. No f can exist
>>>>>       that handles this case.
>>>>> https://en.wikipedia.org/wiki/Halting_problem
>>>>>
>>>>> This exact same relationship of f(g,g) was created as H(P,P), shown
>>>>> below.
>>>>>
>>>>> This is the overview of the method for proving that this analysis
>>>>> is correct:
>>>>> (a) Verify that the execution trace of P by H is correct by
>>>>> comparing this execution trace to the ax86 source-code of P.
>>>>>
>>>>> (b) Verify that this execution trace shows that P is stuck in
>>>>> infinitely nested simulation (a non-halting behavior).
>>>>>
>>>>> This proof can only be understood only by those having sufficient
>>>>> technical competence in:
>>>>> (a) software engineering (recognizing infinite recursion in C and
>>>>> x86 code) (b) the x86 programming language
>>>>> (c) the C programming language and
>>>>> (d) the details of how C is translated into x86 by the Microsoft C
>>>>> compilers.
>>>>>
>>>>> #include <stdint.h>
>>>>> #define u32 uint32_t
>>>>>
>>>>> void P(u32 x)
>>>>> {
>>>>>      if (H(x, x))
>>>>>        HERE: goto HERE;
>>>>>      return;
>>>>> }
>>>>>
>>>>> int main()
>>>>> {
>>>>>      Output("Input_Halts = ", H((u32)P, (u32)P));
>>>>> }
>>>>>
>>>>> _P()
>>>>> [00001352](01)  55              push ebp
>>>>> [00001353](02)  8bec            mov ebp,esp
>>>>> [00001355](03)  8b4508          mov eax,[ebp+08]
>>>>> [00001358](01)  50              push eax
>>>>> [00001359](03)  8b4d08          mov ecx,[ebp+08]
>>>>> [0000135c](01)  51              push ecx
>>>>> [0000135d](05)  e840feffff      call 000011a2 // call H
>>>>> [00001362](03)  83c408          add esp,+08
>>>>> [00001365](02)  85c0            test eax,eax
>>>>> [00001367](02)  7402            jz 0000136b
>>>>> [00001369](02)  ebfe            jmp 00001369
>>>>> [0000136b](01)  5d              pop ebp
>>>>> [0000136c](01)  c3              ret
>>>>> Size in bytes:(0027) [0000136c]
>>>>>
>>>>> _main()
>>>>> [00001372](01)  55              push ebp
>>>>> [00001373](02)  8bec            mov ebp,esp
>>>>> [00001375](05)  6852130000      push 00001352 // push P
>>>>> [0000137a](05)  6852130000      push 00001352 // push P
>>>>> [0000137f](05)  e81efeffff      call 000011a2 // call H
>>>>> [00001384](03)  83c408          add esp,+08
>>>>> [00001387](01)  50              push eax
>>>>> [00001388](05)  6823040000      push 00000423 // "Input_Halts = "
>>>>> [0000138d](05)  e8e0f0ffff      call 00000472 // call Output
>>>>> [00001392](03)  83c408          add esp,+08
>>>>> [00001395](02)  33c0            xor eax,eax
>>>>> [00001397](01)  5d              pop ebp
>>>>> [00001398](01)  c3              ret
>>>>> Size in bytes:(0039) [00001398]
>>>>>
>>>>>        machine   stack     stack     machine    assembly
>>>>>        address   address   data      code       language
>>>>>        ========  ========  ========  =========  =============
>>>>> ...[00001372][0010229e][00000000] 55         push ebp
>>>>> ...[00001373][0010229e][00000000] 8bec       mov ebp,esp
>>>>> ...[00001375][0010229a][00001352] 6852130000 push 00001352 // push
>>>>> P ...[0000137a][00102296][00001352] 6852130000 push 00001352 //
>>>>> push P ...[0000137f][00102292][00001384] e81efeffff call 000011a2
>>>>> // call H
>>>>>
>>>>> Begin Local Halt Decider Simulation   Execution Trace Stored
>>>>> at:212352 ...[00001352][0021233e][00212342] 55         push ebp
>>>>>    // enter P ...[00001353][0021233e][00212342] 8bec       mov
>>>>> ebp,esp ...[00001355][0021233e][00212342] 8b4508     mov
>>>>> eax,[ebp+08] ...[00001358][0021233a][00001352] 50         push eax
>>>>>       // push P ...[00001359][0021233a][00001352] 8b4d08     mov
>>>>> ecx,[ebp+08] ...[0000135c][00212336][00001352] 51         push ecx
>>>>>       // push P ...[0000135d][00212332][00001362] e840feffff call
>>>>> 000011a2 // call H ...[00001352][0025cd66][0025cd6a] 55
>>>>> push ebp      // enter P ...[00001353][0025cd66][0025cd6a] 8bec
>>>>>     mov ebp,esp ...[00001355][0025cd66][0025cd6a] 8b4508     mov
>>>>> eax,[ebp+08] ...[00001358][0025cd62][00001352] 50         push eax
>>>>>       // push P ...[00001359][0025cd62][00001352] 8b4d08     mov
>>>>> ecx,[ebp+08] ...[0000135c][0025cd5e][00001352] 51         push ecx
>>>>>       // push P ...[0000135d][0025cd5a][00001362] e840feffff call
>>>>> 000011a2 // call H Local Halt Decider: Infinite Recursion Detected
>>>>> Simulation Stopped
>>>>>
>>>>> H sees that P is calling the same function from the same machine
>>>>> address with identical parameters, twice in sequence. This is the
>>>>> infinite recursion (infinitely nested simulation) non-halting
>>>>> behavior pattern.
>>>>>
>>>>> ...[00001384][0010229e][00000000] 83c408     add esp,+08
>>>>> ...[00001387][0010229a][00000000] 50         push eax
>>>>> ...[00001388][00102296][00000423] 6823040000 push 00000423 //
>>>>> "Input_Halts ="
>>>>> ---[0000138d][00102296][00000423] e8e0f0ffff call 00000472 // call
>>>>> Output Input_Halts = 0
>>>>> ...[00001392][0010229e][00000000] 83c408     add esp,+08
>>>>> ...[00001395][0010229e][00000000] 33c0       xor eax,eax
>>>>> ...[00001397][001022a2][00100000] 5d         pop ebp
>>>>> ...[00001398][001022a6][00000004] c3         ret
>>>>> Number of Instructions Executed(15892) lines = 237 pages
>>>>>
>>>>>
>>>>> Halting problem undecidability and infinitely nested simulation
>>>>> (V5)
>>>>>
>>>>> https://www.researchgate.net/publication/359984584_Halting_problem_undecidability_and_infinitely_nested_simulation_V5
>>>>>
>>>>
>>>> Your simulation approach is erroneous as there is no infinite
>>>> recursion; the key to understanding this is by realizing the
>>>> implication of the words "pass its own source" in the following:
>>>
>>>
>>> YOU IGNORED THIS PART
>>>
>>> This proof can only be understood only by those having sufficient
>>> technical competence in:
>>> (a) software engineering - recognizing infinite recursion in C/x86
>>> (b) the x86 programming language
>>> (c) the C programming language and
>>> (d) the details of how C is translated into x86 by the Microsoft C
>>> compilers.
>>
>> (a) I have been a software developer/engineer since 1993 and am able to
>> recognize infinite recursion and additionally, and more importantly, a
>> lack of infinite recursion.
>
> This has been disproven in that you did not see this:
>
> >>>> H sees that P is calling the same function from the same machine
> >>>> address with identical parameters, twice in sequence. This is the
> >>>> infinite recursion (infinitely nested simulation) non-halting
> >>>> behavior pattern.


Click here to read the complete article
Re: Proof that H(P,P)==0 is correct [ refuting the halting problem proofs ](V2)

<c7gfK.1283$j0D5.340@fx09.iad>

 copy mid

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

 copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!weretis.net!feeder8.news.weretis.net!ecngs!feeder2.ecngs.de!178.20.174.213.MISMATCH!feeder1.feed.usenet.farm!feed.usenet.farm!peer02.ams4!peer.am4.highwinds-media.com!peer02.iad!feed-me.highwinds-media.com!news.highwinds-media.com!fx09.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.9.0
Subject: Re: Proof that H(P,P)==0 is correct [ refuting the halting problem
proofs ](V2)
Content-Language: en-US
Newsgroups: comp.theory
References: <2pSdnR25lqHLZub_nZ2dnUU7_8zNnZ2d@giganews.com>
<20220511201154.00002147@reddwarf.jmc>
<lYydndd8nf4JzuH_nZ2dnUU7_83NnZ2d@giganews.com>
<20220512184323.000078f7@reddwarf.jmc>
<YrydnRgeEcs22uD_nZ2dnUU7_81g4p2d@giganews.com>
<20220512184716.00007086@reddwarf.jmc>
<28Odnb4QI9a91OD_nZ2dnUU7_81g4p2d@giganews.com>
From: Rich...@Damon-Family.org (Richard Damon)
In-Reply-To: <28Odnb4QI9a91OD_nZ2dnUU7_81g4p2d@giganews.com>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Lines: 184
Message-ID: <c7gfK.1283$j0D5.340@fx09.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: Thu, 12 May 2022 18:46:35 -0400
X-Received-Bytes: 10347
 by: Richard Damon - Thu, 12 May 2022 22:46 UTC

On 5/12/22 1:51 PM, olcott wrote:
> On 5/12/2022 12:47 PM, Mr Flibble wrote:
>> On Thu, 12 May 2022 12:45:15 -0500
>> olcott <NoOne@NoWhere.com> wrote:
>>
>>> On 5/12/2022 12:43 PM, Mr Flibble wrote:
>>>> On Wed, 11 May 2022 19:23:45 -0500
>>>> olcott <NoOne@NoWhere.com> wrote:
>>>>> On 5/11/2022 2:11 PM, Mr Flibble wrote:
>>>>>> On Wed, 11 May 2022 13:07:16 -0500
>>>>>> olcott <NoOne@NoWhere.com> wrote:
>>>>>>> Proof that H(P,P)==0 is correct [ refuting the halting problem
>>>>>>> proofs ]
>>>>>>>
>>>>>>> The x86utm operating system was created so that every detail of
>>>>>>> the conventional halting problem counter example could be fully
>>>>>>> specified in C/x86.
>>>>>>>
>>>>>>>        In computability theory, the halting problem is the
>>>>>>>        problem of determining, from a description of an
>>>>>>>        arbitrary computer program and an input, whether the
>>>>>>>        program will finish running, or continue to run forever...
>>>>>>>
>>>>>>>        For any program f that might determine if programs halt,
>>>>>>>        a "pathological" program g, called with some input, can
>>>>>>>        pass its own source and its input to f and then
>>>>>>> specifically do the opposite of what f predicts g will do. No f
>>>>>>> can exist that handles this case.
>>>>>>> https://en.wikipedia.org/wiki/Halting_problem
>>>>>>>
>>>>>>> This exact same relationship of f(g,g) was created as H(P,P),
>>>>>>> shown below.
>>>>>>>
>>>>>>> This is the overview of the method for proving that this analysis
>>>>>>> is correct:
>>>>>>> (a) Verify that the execution trace of P by H is correct by
>>>>>>> comparing this execution trace to the ax86 source-code of P.
>>>>>>>
>>>>>>> (b) Verify that this execution trace shows that P is stuck in
>>>>>>> infinitely nested simulation (a non-halting behavior).
>>>>>>>
>>>>>>> This proof can only be understood only by those having sufficient
>>>>>>> technical competence in:
>>>>>>> (a) software engineering (recognizing infinite recursion in C and
>>>>>>> x86 code) (b) the x86 programming language
>>>>>>> (c) the C programming language and
>>>>>>> (d) the details of how C is translated into x86 by the Microsoft
>>>>>>> C compilers.
>>>>>>>
>>>>>>> #include <stdint.h>
>>>>>>> #define u32 uint32_t
>>>>>>>
>>>>>>> void P(u32 x)
>>>>>>> {
>>>>>>>       if (H(x, x))
>>>>>>>         HERE: goto HERE;
>>>>>>>       return;
>>>>>>> }
>>>>>>>
>>>>>>> int main()
>>>>>>> {
>>>>>>>       Output("Input_Halts = ", H((u32)P, (u32)P));
>>>>>>> }
>>>>>>>
>>>>>>> _P()
>>>>>>> [00001352](01)  55              push ebp
>>>>>>> [00001353](02)  8bec            mov ebp,esp
>>>>>>> [00001355](03)  8b4508          mov eax,[ebp+08]
>>>>>>> [00001358](01)  50              push eax
>>>>>>> [00001359](03)  8b4d08          mov ecx,[ebp+08]
>>>>>>> [0000135c](01)  51              push ecx
>>>>>>> [0000135d](05)  e840feffff      call 000011a2 // call H
>>>>>>> [00001362](03)  83c408          add esp,+08
>>>>>>> [00001365](02)  85c0            test eax,eax
>>>>>>> [00001367](02)  7402            jz 0000136b
>>>>>>> [00001369](02)  ebfe            jmp 00001369
>>>>>>> [0000136b](01)  5d              pop ebp
>>>>>>> [0000136c](01)  c3              ret
>>>>>>> Size in bytes:(0027) [0000136c]
>>>>>>>
>>>>>>> _main()
>>>>>>> [00001372](01)  55              push ebp
>>>>>>> [00001373](02)  8bec            mov ebp,esp
>>>>>>> [00001375](05)  6852130000      push 00001352 // push P
>>>>>>> [0000137a](05)  6852130000      push 00001352 // push P
>>>>>>> [0000137f](05)  e81efeffff      call 000011a2 // call H
>>>>>>> [00001384](03)  83c408          add esp,+08
>>>>>>> [00001387](01)  50              push eax
>>>>>>> [00001388](05)  6823040000      push 00000423 // "Input_Halts = "
>>>>>>> [0000138d](05)  e8e0f0ffff      call 00000472 // call Output
>>>>>>> [00001392](03)  83c408          add esp,+08
>>>>>>> [00001395](02)  33c0            xor eax,eax
>>>>>>> [00001397](01)  5d              pop ebp
>>>>>>> [00001398](01)  c3              ret
>>>>>>> Size in bytes:(0039) [00001398]
>>>>>>>
>>>>>>>         machine   stack     stack     machine    assembly
>>>>>>>         address   address   data      code       language
>>>>>>>         ========  ========  ========  =========  =============
>>>>>>> ...[00001372][0010229e][00000000] 55         push ebp
>>>>>>> ...[00001373][0010229e][00000000] 8bec       mov ebp,esp
>>>>>>> ...[00001375][0010229a][00001352] 6852130000 push 00001352 //
>>>>>>> push P ...[0000137a][00102296][00001352] 6852130000 push
>>>>>>> 00001352 // push P ...[0000137f][00102292][00001384] e81efeffff
>>>>>>> call 000011a2 // call H
>>>>>>>
>>>>>>> Begin Local Halt Decider Simulation   Execution Trace Stored
>>>>>>> at:212352 ...[00001352][0021233e][00212342] 55         push ebp
>>>>>>>     // enter P ...[00001353][0021233e][00212342] 8bec       mov
>>>>>>> ebp,esp ...[00001355][0021233e][00212342] 8b4508     mov
>>>>>>> eax,[ebp+08] ...[00001358][0021233a][00001352] 50         push
>>>>>>> eax // push P ...[00001359][0021233a][00001352] 8b4d08     mov
>>>>>>> ecx,[ebp+08] ...[0000135c][00212336][00001352] 51         push
>>>>>>> ecx // push P ...[0000135d][00212332][00001362] e840feffff call
>>>>>>> 000011a2 // call H ...[00001352][0025cd66][0025cd6a] 55
>>>>>>> push ebp      // enter P ...[00001353][0025cd66][0025cd6a] 8bec
>>>>>>>      mov ebp,esp ...[00001355][0025cd66][0025cd6a] 8b4508     mov
>>>>>>> eax,[ebp+08] ...[00001358][0025cd62][00001352] 50         push
>>>>>>> eax // push P ...[00001359][0025cd62][00001352] 8b4d08     mov
>>>>>>> ecx,[ebp+08] ...[0000135c][0025cd5e][00001352] 51         push
>>>>>>> ecx // push P ...[0000135d][0025cd5a][00001362] e840feffff call
>>>>>>> 000011a2 // call H Local Halt Decider: Infinite Recursion
>>>>>>> Detected Simulation Stopped
>>>>>>>
>>>>>>> H sees that P is calling the same function from the same machine
>>>>>>> address with identical parameters, twice in sequence. This is the
>>>>>>> infinite recursion (infinitely nested simulation) non-halting
>>>>>>> behavior pattern.
>>>>>>>
>>>>>>> ...[00001384][0010229e][00000000] 83c408     add esp,+08
>>>>>>> ...[00001387][0010229a][00000000] 50         push eax
>>>>>>> ...[00001388][00102296][00000423] 6823040000 push 00000423 //
>>>>>>> "Input_Halts ="
>>>>>>> ---[0000138d][00102296][00000423] e8e0f0ffff call 00000472 //
>>>>>>> call Output Input_Halts = 0
>>>>>>> ...[00001392][0010229e][00000000] 83c408     add esp,+08
>>>>>>> ...[00001395][0010229e][00000000] 33c0       xor eax,eax
>>>>>>> ...[00001397][001022a2][00100000] 5d         pop ebp
>>>>>>> ...[00001398][001022a6][00000004] c3         ret
>>>>>>> Number of Instructions Executed(15892) lines = 237 pages
>>>>>>>
>>>>>>>
>>>>>>> Halting problem undecidability and infinitely nested simulation
>>>>>>> (V5)
>>>>>>>
>>>>>>> https://www.researchgate.net/publication/359984584_Halting_problem_undecidability_and_infinitely_nested_simulation_V5
>>>>>>>
>>>>>>
>>>>>> Your simulation approach is erroneous as there is no infinite
>>>>>> recursion; the key to understanding this is by realizing the
>>>>>> implication of the words "pass its own source" in the following:
>>>>>
>>>>>
>>>>> YOU IGNORED THIS PART
>>>>>
>>>>> This proof can only be understood only by those having sufficient
>>>>> technical competence in:
>>>>> (a) software engineering - recognizing infinite recursion in C/x86
>>>>> (b) the x86 programming language
>>>>> (c) the C programming language and
>>>>> (d) the details of how C is translated into x86 by the Microsoft C
>>>>> compilers.
>>>>
>>>> (a) I have been a software developer/engineer since 1993 and am
>>>> able to recognize infinite recursion and additionally, and more
>>>> importantly, a lack of infinite recursion.
>>>
>>> This has been disproven in that you did not see this:
>>>
>>>   >>>> H sees that P is calling the same function from the same machine
>>>   >>>> address with identical parameters, twice in sequence. This is
>>>   >>>> the infinite recursion (infinitely nested simulation)
>>>   >>>> non-halting behavior pattern.
>> I am not talking about your braindead simulation, I am talking about
>> the halting problem proofs you are trying to refute: THEY DO NOT HAVE
>> AN INFINITE RECURSION.
>>
>> /Flibble
>>
>
> My proofs prove that they do.
> That you fail to comprehend this is no rebuttal at all.
>
You proofs are incorrect, and unsound, just as YOU are.


Click here to read the complete article
Re: Proof that H(P,P)==0 is correct [ refuting the halting problem proofs ](V2)

<GagfK.1284$j0D5.190@fx09.iad>

 copy mid

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

 copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!aioe.org!feeder1.feed.usenet.farm!feed.usenet.farm!peer02.ams4!peer.am4.highwinds-media.com!peer02.iad!feed-me.highwinds-media.com!news.highwinds-media.com!fx09.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.9.0
Subject: Re: Proof that H(P,P)==0 is correct [ refuting the halting problem
proofs ](V2)
Content-Language: en-US
Newsgroups: comp.theory
References: <2pSdnR25lqHLZub_nZ2dnUU7_8zNnZ2d@giganews.com>
<20220511201154.00002147@reddwarf.jmc>
<lYydndd8nf4JzuH_nZ2dnUU7_83NnZ2d@giganews.com>
<20220512184323.000078f7@reddwarf.jmc>
<YrydnRgeEcs22uD_nZ2dnUU7_81g4p2d@giganews.com>
<20220512184716.00007086@reddwarf.jmc>
<28Odnb4QI9a91OD_nZ2dnUU7_81g4p2d@giganews.com>
<20220512190002.00001651@reddwarf.jmc>
<nNSdnRSV0Zck0eD_nZ2dnUU7_83NnZ2d@giganews.com>
From: Rich...@Damon-Family.org (Richard Damon)
In-Reply-To: <nNSdnRSV0Zck0eD_nZ2dnUU7_83NnZ2d@giganews.com>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Lines: 245
Message-ID: <GagfK.1284$j0D5.190@fx09.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: Thu, 12 May 2022 18:50:16 -0400
X-Received-Bytes: 13592
 by: Richard Damon - Thu, 12 May 2022 22:50 UTC

On 5/12/22 2:06 PM, olcott wrote:
> On 5/12/2022 1:00 PM, Mr Flibble wrote:
>> On Thu, 12 May 2022 12:51:27 -0500
>> olcott <NoOne@NoWhere.com> wrote:
>>
>>> On 5/12/2022 12:47 PM, Mr Flibble wrote:
>>>> On Thu, 12 May 2022 12:45:15 -0500
>>>> olcott <NoOne@NoWhere.com> wrote:
>>>>> On 5/12/2022 12:43 PM, Mr Flibble wrote:
>>>>>> On Wed, 11 May 2022 19:23:45 -0500
>>>>>> olcott <NoOne@NoWhere.com> wrote:
>>>>>>> On 5/11/2022 2:11 PM, Mr Flibble wrote:
>>>>>>>> On Wed, 11 May 2022 13:07:16 -0500
>>>>>>>> olcott <NoOne@NoWhere.com> wrote:
>>>>>>>>> Proof that H(P,P)==0 is correct [ refuting the halting problem
>>>>>>>>> proofs ]
>>>>>>>>>
>>>>>>>>> The x86utm operating system was created so that every detail of
>>>>>>>>> the conventional halting problem counter example could be fully
>>>>>>>>> specified in C/x86.
>>>>>>>>>
>>>>>>>>>         In computability theory, the halting problem is the
>>>>>>>>>         problem of determining, from a description of an
>>>>>>>>>         arbitrary computer program and an input, whether the
>>>>>>>>>         program will finish running, or continue to run
>>>>>>>>> forever...
>>>>>>>>>
>>>>>>>>>         For any program f that might determine if programs halt,
>>>>>>>>>         a "pathological" program g, called with some input, can
>>>>>>>>>         pass its own source and its input to f and then
>>>>>>>>> specifically do the opposite of what f predicts g will do. No f
>>>>>>>>> can exist that handles this case.
>>>>>>>>> https://en.wikipedia.org/wiki/Halting_problem
>>>>>>>>>
>>>>>>>>> This exact same relationship of f(g,g) was created as H(P,P),
>>>>>>>>> shown below.
>>>>>>>>>
>>>>>>>>> This is the overview of the method for proving that this
>>>>>>>>> analysis is correct:
>>>>>>>>> (a) Verify that the execution trace of P by H is correct by
>>>>>>>>> comparing this execution trace to the ax86 source-code of P.
>>>>>>>>>
>>>>>>>>> (b) Verify that this execution trace shows that P is stuck in
>>>>>>>>> infinitely nested simulation (a non-halting behavior).
>>>>>>>>>
>>>>>>>>> This proof can only be understood only by those having
>>>>>>>>> sufficient technical competence in:
>>>>>>>>> (a) software engineering (recognizing infinite recursion in C
>>>>>>>>> and x86 code) (b) the x86 programming language
>>>>>>>>> (c) the C programming language and
>>>>>>>>> (d) the details of how C is translated into x86 by the
>>>>>>>>> Microsoft C compilers.
>>>>>>>>>
>>>>>>>>> #include <stdint.h>
>>>>>>>>> #define u32 uint32_t
>>>>>>>>>
>>>>>>>>> void P(u32 x)
>>>>>>>>> {
>>>>>>>>>        if (H(x, x))
>>>>>>>>>          HERE: goto HERE;
>>>>>>>>>        return;
>>>>>>>>> }
>>>>>>>>>
>>>>>>>>> int main()
>>>>>>>>> {
>>>>>>>>>        Output("Input_Halts = ", H((u32)P, (u32)P));
>>>>>>>>> }
>>>>>>>>>
>>>>>>>>> _P()
>>>>>>>>> [00001352](01)  55              push ebp
>>>>>>>>> [00001353](02)  8bec            mov ebp,esp
>>>>>>>>> [00001355](03)  8b4508          mov eax,[ebp+08]
>>>>>>>>> [00001358](01)  50              push eax
>>>>>>>>> [00001359](03)  8b4d08          mov ecx,[ebp+08]
>>>>>>>>> [0000135c](01)  51              push ecx
>>>>>>>>> [0000135d](05)  e840feffff      call 000011a2 // call H
>>>>>>>>> [00001362](03)  83c408          add esp,+08
>>>>>>>>> [00001365](02)  85c0            test eax,eax
>>>>>>>>> [00001367](02)  7402            jz 0000136b
>>>>>>>>> [00001369](02)  ebfe            jmp 00001369
>>>>>>>>> [0000136b](01)  5d              pop ebp
>>>>>>>>> [0000136c](01)  c3              ret
>>>>>>>>> Size in bytes:(0027) [0000136c]
>>>>>>>>>
>>>>>>>>> _main()
>>>>>>>>> [00001372](01)  55              push ebp
>>>>>>>>> [00001373](02)  8bec            mov ebp,esp
>>>>>>>>> [00001375](05)  6852130000      push 00001352 // push P
>>>>>>>>> [0000137a](05)  6852130000      push 00001352 // push P
>>>>>>>>> [0000137f](05)  e81efeffff      call 000011a2 // call H
>>>>>>>>> [00001384](03)  83c408          add esp,+08
>>>>>>>>> [00001387](01)  50              push eax
>>>>>>>>> [00001388](05)  6823040000      push 00000423 // "Input_Halts
>>>>>>>>> = " [0000138d](05)  e8e0f0ffff      call 00000472 // call
>>>>>>>>> Output [00001392](03)  83c408          add esp,+08
>>>>>>>>> [00001395](02)  33c0            xor eax,eax
>>>>>>>>> [00001397](01)  5d              pop ebp
>>>>>>>>> [00001398](01)  c3              ret
>>>>>>>>> Size in bytes:(0039) [00001398]
>>>>>>>>>
>>>>>>>>>          machine   stack     stack     machine    assembly
>>>>>>>>>          address   address   data      code       language
>>>>>>>>>          ========  ========  ========  =========  =============
>>>>>>>>> ...[00001372][0010229e][00000000] 55         push ebp
>>>>>>>>> ...[00001373][0010229e][00000000] 8bec       mov ebp,esp
>>>>>>>>> ...[00001375][0010229a][00001352] 6852130000 push 00001352 //
>>>>>>>>> push P ...[0000137a][00102296][00001352] 6852130000 push
>>>>>>>>> 00001352 // push P ...[0000137f][00102292][00001384] e81efeffff
>>>>>>>>> call 000011a2 // call H
>>>>>>>>>
>>>>>>>>> Begin Local Halt Decider Simulation   Execution Trace Stored
>>>>>>>>> at:212352 ...[00001352][0021233e][00212342] 55         push ebp
>>>>>>>>>      // enter P ...[00001353][0021233e][00212342] 8bec       mov
>>>>>>>>> ebp,esp ...[00001355][0021233e][00212342] 8b4508     mov
>>>>>>>>> eax,[ebp+08] ...[00001358][0021233a][00001352] 50         push
>>>>>>>>> eax // push P ...[00001359][0021233a][00001352] 8b4d08     mov
>>>>>>>>> ecx,[ebp+08] ...[0000135c][00212336][00001352] 51         push
>>>>>>>>> ecx // push P ...[0000135d][00212332][00001362] e840feffff call
>>>>>>>>> 000011a2 // call H ...[00001352][0025cd66][0025cd6a] 55
>>>>>>>>> push ebp      // enter P ...[00001353][0025cd66][0025cd6a] 8bec
>>>>>>>>>       mov ebp,esp ...[00001355][0025cd66][0025cd6a] 8b4508
>>>>>>>>> mov eax,[ebp+08] ...[00001358][0025cd62][00001352] 50
>>>>>>>>> push eax // push P ...[00001359][0025cd62][00001352] 8b4d08
>>>>>>>>>   mov ecx,[ebp+08] ...[0000135c][0025cd5e][00001352] 51
>>>>>>>>> push ecx // push P ...[0000135d][0025cd5a][00001362]
>>>>>>>>> e840feffff call 000011a2 // call H Local Halt Decider:
>>>>>>>>> Infinite Recursion Detected Simulation Stopped
>>>>>>>>>
>>>>>>>>> H sees that P is calling the same function from the same
>>>>>>>>> machine address with identical parameters, twice in sequence.
>>>>>>>>> This is the infinite recursion (infinitely nested simulation)
>>>>>>>>> non-halting behavior pattern.
>>>>>>>>>
>>>>>>>>> ...[00001384][0010229e][00000000] 83c408     add esp,+08
>>>>>>>>> ...[00001387][0010229a][00000000] 50         push eax
>>>>>>>>> ...[00001388][00102296][00000423] 6823040000 push 00000423 //
>>>>>>>>> "Input_Halts ="
>>>>>>>>> ---[0000138d][00102296][00000423] e8e0f0ffff call 00000472 //
>>>>>>>>> call Output Input_Halts = 0
>>>>>>>>> ...[00001392][0010229e][00000000] 83c408     add esp,+08
>>>>>>>>> ...[00001395][0010229e][00000000] 33c0       xor eax,eax
>>>>>>>>> ...[00001397][001022a2][00100000] 5d         pop ebp
>>>>>>>>> ...[00001398][001022a6][00000004] c3         ret
>>>>>>>>> Number of Instructions Executed(15892) lines = 237 pages
>>>>>>>>>
>>>>>>>>>
>>>>>>>>> Halting problem undecidability and infinitely nested simulation
>>>>>>>>> (V5)
>>>>>>>>>
>>>>>>>>> https://www.researchgate.net/publication/359984584_Halting_problem_undecidability_and_infinitely_nested_simulation_V5
>>>>>>>>>
>>>>>>>>
>>>>>>>> Your simulation approach is erroneous as there is no infinite
>>>>>>>> recursion; the key to understanding this is by realizing the
>>>>>>>> implication of the words "pass its own source" in the
>>>>>>>> following:
>>>>>>>
>>>>>>>
>>>>>>> YOU IGNORED THIS PART
>>>>>>>
>>>>>>> This proof can only be understood only by those having sufficient
>>>>>>> technical competence in:
>>>>>>> (a) software engineering - recognizing infinite recursion in
>>>>>>> C/x86 (b) the x86 programming language
>>>>>>> (c) the C programming language and
>>>>>>> (d) the details of how C is translated into x86 by the Microsoft
>>>>>>> C compilers.
>>>>>>
>>>>>> (a) I have been a software developer/engineer since 1993 and am
>>>>>> able to recognize infinite recursion and additionally, and more
>>>>>> importantly, a lack of infinite recursion.
>>>>>
>>>>> This has been disproven in that you did not see this:
>>>>>    >>>> H sees that P is calling the same function from the same
>>>>>    >>>> machine address with identical parameters, twice in
>>>>>    >>>> sequence. This is the infinite recursion (infinitely nested
>>>>>    >>>> simulation) non-halting behavior pattern.
>>>> I am not talking about your braindead simulation, I am talking about
>>>> the halting problem proofs you are trying to refute: THEY DO NOT
>>>> HAVE AN INFINITE RECURSION.
>>>>
>>>> /Flibble
>>>
>>> My proofs prove that they do.
>>> That you fail to comprehend this is no rebuttal at all.
>> Only your simulation contains an infinite recursion due to a category
>> error ON YOUR PART. Your category error is proof that your
>> simulation-based proof is in error.
>>
>> /Flibble
>>
>
> > PO's idea is to have a simulator with an infinite cycle detector.
> > You would achieve this by modifying a UTM, so describing it as
> > a "modified UTM", or "acts like a UTM until it detects an infinite
> > cycle", is reasonable. And such a machine is a fairly powerful
> > halt decider. Even if the infinite cycle detector isn't very
> > sophisticated, it will still catch a large subset of non-halting
> > machines.
>
> The following simplifies the syntax for the definition of the Linz
> Turing machine Ĥ.
> There is no need for the infinite loop after H.qy because it is never
> reached. The halting criteria has been adapted so that it applies to a
> simulating halt decider (SHD).
>
> Ĥ.q0 ⟨Ĥ⟩ ⊢* H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* H.qy
> If the correctly simulated input ⟨Ĥ⟩ ⟨Ĥ⟩ to H would reach its own final
> state of ⟨Ĥ.qy⟩ or ⟨Ĥ.qn⟩.
>
> Ĥ.q0 ⟨Ĥ⟩ ⊢* H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* H.qn
> If the correctly simulated input ⟨Ĥ⟩ ⟨Ĥ⟩ to H would never reach its own
> final state of ⟨Ĥ.qy⟩ or ⟨Ĥ.qn⟩.
>
> When Ĥ is applied to ⟨Ĥ⟩
> Ĥ copies its input ⟨Ĥ0⟩ to ⟨Ĥ1⟩ then H simulates ⟨Ĥ0⟩ ⟨Ĥ1⟩
>
> Then these steps would keep repeating: (unless their simulation is aborted)
> Ĥ0 copies its input ⟨Ĥ1⟩ to ⟨Ĥ2⟩ then H0 simulates ⟨Ĥ1⟩ ⟨Ĥ2⟩
> Ĥ1 copies its input ⟨Ĥ2⟩ to ⟨Ĥ3⟩ then H1 simulates ⟨Ĥ2⟩ ⟨Ĥ3⟩
> Ĥ2 copies its input ⟨Ĥ3⟩ to ⟨Ĥ4⟩ then H2 simulates ⟨Ĥ3⟩ ⟨Ĥ4⟩...
>
> Since we can see that the simulated input: ⟨Ĥ0⟩ to H would never reach
> its own final state of ⟨Ĥ0.qy⟩ or ⟨Ĥ0.qn⟩ we know that it is non-halting.
>
> Linz, Peter 1990. An Introduction to Formal Languages and Automata.
> Lexington/Toronto: D. C. Heath and Company. (317-320)
>
>
>


Click here to read the complete article
Pages:1234
server_pubkey.txt

rocksolid light 0.9.7
clearnet tor