Rocksolid Light

Welcome to novaBBS (click a section below)

mail  files  register  newsreader  groups  login

Message-ID:  

"Cogito ergo I'm right and you're wrong." -- Blair Houghton


devel / comp.theory / Re: All my reviewers expect a halt decider to have psychic power

SubjectAuthor
* All my reviewers expect a halt decider to have psychic powerolcott
`* All my reviewers expect a halt decider to have psychic powerwij
 `* All my reviewers expect a halt decider to have psychic powerolcott
  +* All my reviewers expect a halt decider to have psychic powerwij
  |`* All my reviewers expect a halt decider to have psychic powerolcott
  | `* All my reviewers expect a halt decider to have psychic powerwij
  |  `* All my reviewers expect a halt decider to have psychic powerolcott
  |   +- All my reviewers expect a halt decider to have psychic powerRichard Damon
  |   `* All my reviewers expect a halt decider to have psychic powerwij
  |    `* All my reviewers expect a halt decider to have psychic powerolcott
  |     +* All my reviewers expect a halt decider to have psychic powerwij
  |     |+* All my reviewers expect a halt decider to have psychic powerolcott
  |     ||+* All my reviewers expect a halt decider to have psychic powerwij
  |     |||`* All my reviewers expect a halt decider to have psychic powerolcott
  |     ||| +* All my reviewers expect a halt decider to have psychic powerMalcolm McLean
  |     ||| |`* All my reviewers expect a halt decider to have psychic powerolcott
  |     ||| | `* All my reviewers expect a halt decider to have psychic powerMalcolm McLean
  |     ||| |  `* All my reviewers expect a halt decider to have psychic powerolcott
  |     ||| |   `- All my reviewers expect a halt decider to have psychic powerRichard Damon
  |     ||| `- All my reviewers expect a halt decider to have psychic powerRichard Damon
  |     ||`- All my reviewers expect a halt decider to have psychic powerRichard Damon
  |     |`* All my reviewers expect a halt decider to have psychic powerolcott
  |     | +* All my reviewers expect a halt decider to have psychic powerwij
  |     | |`- All my reviewers expect a halt decider to have psychic powerolcott
  |     | `* All my reviewers expect a halt decider to have psychic powerBen
  |     |  +- All my reviewers expect a halt decider to have psychic powerMr Flibble
  |     |  `* All my reviewers expect a halt decider to have psychic powerolcott
  |     |   +- All my reviewers expect a halt decider to have psychic powerBen
  |     |   `- All my reviewers expect a halt decider to have psychic powerRichard Damon
  |     `- All my reviewers expect a halt decider to have psychic powerRichard Damon
  `- All my reviewers expect a halt decider to have psychic powerRichard Damon

Pages:12
All my reviewers expect a halt decider to have psychic power

<9sudne4_G7qNj_n_nZ2dnUU7_83NnZ2d@giganews.com>

 copy mid

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

 copy link   Newsgroups: comp.theory comp.ai.philosophy sci.logic sci.math
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: Sat, 23 Apr 2022 09:49:52 -0500
Date: Sat, 23 Apr 2022 09:49:51 -0500
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:91.0) Gecko/20100101
Thunderbird/91.8.1
Newsgroups: comp.theory,comp.ai.philosophy,sci.logic,sci.math
Content-Language: en-US
Followup-To: comp.theory
From: NoO...@NoWhere.com (olcott)
Subject: All my reviewers expect a halt decider to have psychic power
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 7bit
Message-ID: <9sudne4_G7qNj_n_nZ2dnUU7_83NnZ2d@giganews.com>
Lines: 98
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-zoq87pf9/hkCgBxOTRF1B3L6uZOjB2lmYZ1IGT659TqtpR1aLyGP4xW1X/w8/4vbnhrEJrJ83QyZn+K!4aasDHJ1K0Y7ZBkpSegjHsh4807bsLmMKPKJTIoqtDD5rDMWxhaKoK4oebywYyOeBRaLFu0tq+Ib
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: 5117
 by: olcott - Sat, 23 Apr 2022 14:49 UTC

All of my reviewers expect H(P,P) to compute the halt status of P(P),
yet the behavior specified by the input to H(P,P) is not the same as the
behavior specified by P(P).

Anyone that is an expert in the C programming language, the x86
programming language, exactly how C translates into x86 and what an x86
processor emulator is can easily verify that the correctly simulated
input to H(P,P) by H specifies a non-halting sequence of configurations.

Since my reviewers expect the halt decider to compute the halt status of
P(P) yet the input to H(P,P) specifies a different halt status my
reviewers expect H to read their mind so that it can compute different
behavior than the behavior that the input actually specifies.

The function named H continues to simulate its input using an x86
emulator until this input either halts on its own or H detects that it
would never halt. If its input halts H returns 1. If H detects that its
input would never halt H returns 0.

#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()
[000009d6](01) 55 push ebp
[000009d7](02) 8bec mov ebp,esp
[000009d9](03) 8b4508 mov eax,[ebp+08]
[000009dc](01) 50 push eax // push P
[000009dd](03) 8b4d08 mov ecx,[ebp+08]
[000009e0](01) 51 push ecx // push P
[000009e1](05) e840feffff call 00000826 // call H
[000009e6](03) 83c408 add esp,+08
[000009e9](02) 85c0 test eax,eax
[000009eb](02) 7402 jz 000009ef
[000009ed](02) ebfe jmp 000009ed
[000009ef](01) 5d pop ebp
[000009f0](01) c3 ret // Final state
Size in bytes:(0027) [000009f0]

The simulated input to H(P,P) cannot possibly reach its own final state
of [000009f0] it keeps repeating [000009d6] to [000009e1] until aborted.

Begin Local Halt Decider Simulation

machine stack stack machine assembly
address address data code language
======== ======== ======== ========= =============
....[000009d6][00211368][0021136c] 55 push ebp // enter P
....[000009d7][00211368][0021136c] 8bec mov ebp,esp
....[000009d9][00211368][0021136c] 8b4508 mov eax,[ebp+08]
....[000009dc][00211364][000009d6] 50 push eax // Push P
....[000009dd][00211364][000009d6] 8b4d08 mov ecx,[ebp+08]
....[000009e0][00211360][000009d6] 51 push ecx // Push P
....[000009e1][0021135c][000009e6] e840feffff call 00000826 // Call H
....[000009d6][0025bd90][0025bd94] 55 push ebp // enter P
....[000009d7][0025bd90][0025bd94] 8bec mov ebp,esp
....[000009d9][0025bd90][0025bd94] 8b4508 mov eax,[ebp+08]
....[000009dc][0025bd8c][000009d6] 50 push eax // Push P
....[000009dd][0025bd8c][000009d6] 8b4d08 mov ecx,[ebp+08]
....[000009e0][0025bd88][000009d6] 51 push ecx // Push P
....[000009e1][0025bd84][000009e6] e840feffff call 00000826 // Call H
Local Halt Decider: Infinite Recursion Detected Simulation Stopped

Because the correctly simulated input to H(P,P) cannot possibly reach
its own final state at [000009f0] it is necessarily correct for H to
reject this input as non-halting.

The correctly simulated 27 bytes of machine code at [000009d6] would
never reach its own final state at [000009f0] when correctly simulated
by the simulating halt decider (SHD) at machine address [00000826].

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: All my reviewers expect a halt decider to have psychic power

<a9db8e82-955f-48d1-98c9-a4a529b64e56n@googlegroups.com>

 copy mid

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

 copy link   Newsgroups: comp.theory
X-Received: by 2002:a05:620a:74b:b0:69b:db1d:f91e with SMTP id i11-20020a05620a074b00b0069bdb1df91emr5868383qki.286.1650729504786;
Sat, 23 Apr 2022 08:58:24 -0700 (PDT)
X-Received: by 2002:a25:20a:0:b0:645:74e4:8cc9 with SMTP id
10-20020a25020a000000b0064574e48cc9mr9260131ybc.518.1650729504552; Sat, 23
Apr 2022 08:58:24 -0700 (PDT)
Path: i2pn2.org!i2pn.org!weretis.net!feeder6.news.weretis.net!news.misty.com!border2.nntp.dca1.giganews.com!nntp.giganews.com!news-out.google.com!nntp.google.com!postnews.google.com!google-groups.googlegroups.com!not-for-mail
Newsgroups: comp.theory
Date: Sat, 23 Apr 2022 08:58:24 -0700 (PDT)
In-Reply-To: <9sudne4_G7qNj_n_nZ2dnUU7_83NnZ2d@giganews.com>
Injection-Info: google-groups.googlegroups.com; posting-host=58.115.187.102; posting-account=QJ9iEwoAAACyjkKjQAWQOwSEULNvZZkc
NNTP-Posting-Host: 58.115.187.102
References: <9sudne4_G7qNj_n_nZ2dnUU7_83NnZ2d@giganews.com>
User-Agent: G2/1.0
MIME-Version: 1.0
Message-ID: <a9db8e82-955f-48d1-98c9-a4a529b64e56n@googlegroups.com>
Subject: Re: All my reviewers expect a halt decider to have psychic power
From: wyni...@gmail.com (wij)
Injection-Date: Sat, 23 Apr 2022 15:58:24 +0000
Content-Type: text/plain; charset="UTF-8"
Lines: 107
 by: wij - Sat, 23 Apr 2022 15:58 UTC

On Saturday, 23 April 2022 at 22:49:59 UTC+8, olcott wrote:
> All of my reviewers expect H(P,P) to compute the halt status of P(P),
> yet the behavior specified by the input to H(P,P) is not the same as the
> behavior specified by P(P).

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
https://en.wikipedia.org/wiki/Halting_problem

If using this common concept, the halting decider H, when given an argument P
(or P P), is supposed to answer whether P(P) will halt or not. This is a very
simple, easy idea to understand even for teenager students.

> Anyone that is an expert in the C programming language, the x86
> programming language, exactly how C translates into x86 and what an x86
> processor emulator is can easily verify that the correctly simulated
> input to H(P,P) by H specifies a non-halting sequence of configurations.
>
> Since my reviewers expect the halt decider to compute the halt status of
> P(P) yet the input to H(P,P) specifies a different halt status my
> reviewers expect H to read their mind so that it can compute different
> behavior than the behavior that the input actually specifies.
>
>
>
> The function named H continues to simulate its input using an x86
> emulator until this input either halts on its own or H detects that it
> would never halt. If its input halts H returns 1. If H detects that its
> input would never halt H returns 0.
>
> #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()
> [000009d6](01) 55 push ebp
> [000009d7](02) 8bec mov ebp,esp
> [000009d9](03) 8b4508 mov eax,[ebp+08]
> [000009dc](01) 50 push eax // push P
> [000009dd](03) 8b4d08 mov ecx,[ebp+08]
> [000009e0](01) 51 push ecx // push P
> [000009e1](05) e840feffff call 00000826 // call H
> [000009e6](03) 83c408 add esp,+08
> [000009e9](02) 85c0 test eax,eax
> [000009eb](02) 7402 jz 000009ef
> [000009ed](02) ebfe jmp 000009ed
> [000009ef](01) 5d pop ebp
> [000009f0](01) c3 ret // Final state
> Size in bytes:(0027) [000009f0]
>
> The simulated input to H(P,P) cannot possibly reach its own final state
> of [000009f0] it keeps repeating [000009d6] to [000009e1] until aborted.
>
> Begin Local Halt Decider Simulation
>
> machine stack stack machine assembly
> address address data code language
> ======== ======== ======== ========= =============
> ...[000009d6][00211368][0021136c] 55 push ebp // enter P
> ...[000009d7][00211368][0021136c] 8bec mov ebp,esp
> ...[000009d9][00211368][0021136c] 8b4508 mov eax,[ebp+08]
> ...[000009dc][00211364][000009d6] 50 push eax // Push P
> ...[000009dd][00211364][000009d6] 8b4d08 mov ecx,[ebp+08]
> ...[000009e0][00211360][000009d6] 51 push ecx // Push P
> ...[000009e1][0021135c][000009e6] e840feffff call 00000826 // Call H
> ...[000009d6][0025bd90][0025bd94] 55 push ebp // enter P
> ...[000009d7][0025bd90][0025bd94] 8bec mov ebp,esp
> ...[000009d9][0025bd90][0025bd94] 8b4508 mov eax,[ebp+08]
> ...[000009dc][0025bd8c][000009d6] 50 push eax // Push P
> ...[000009dd][0025bd8c][000009d6] 8b4d08 mov ecx,[ebp+08]
> ...[000009e0][0025bd88][000009d6] 51 push ecx // Push P
> ...[000009e1][0025bd84][000009e6] e840feffff call 00000826 // Call H
> Local Halt Decider: Infinite Recursion Detected Simulation Stopped
>
> Because the correctly simulated input to H(P,P) cannot possibly reach
> its own final state at [000009f0] it is necessarily correct for H to
> reject this input as non-halting.
>
> The correctly simulated 27 bytes of machine code at [000009d6] would
> never reach its own final state at [000009f0] when correctly simulated
> by the simulating halt decider (SHD) at machine address [00000826].
>
>
>
>
> 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

These are POOP's

Re: All my reviewers expect a halt decider to have psychic power

<7emdnUtkBq8lvvn_nZ2dnUU7_8zNnZ2d@giganews.com>

 copy mid

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

 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: Sat, 23 Apr 2022 11:05:12 -0500
Date: Sat, 23 Apr 2022 11:05:11 -0500
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:91.0) Gecko/20100101
Thunderbird/91.8.1
Subject: Re: All my reviewers expect a halt decider to have psychic power
Content-Language: en-US
Newsgroups: comp.theory
References: <9sudne4_G7qNj_n_nZ2dnUU7_83NnZ2d@giganews.com>
<a9db8e82-955f-48d1-98c9-a4a529b64e56n@googlegroups.com>
From: NoO...@NoWhere.com (olcott)
In-Reply-To: <a9db8e82-955f-48d1-98c9-a4a529b64e56n@googlegroups.com>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 7bit
Message-ID: <7emdnUtkBq8lvvn_nZ2dnUU7_8zNnZ2d@giganews.com>
Lines: 123
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-eU5YJAOfEVZIwsfz3f7VlpmVF0FiMGb5FAkVmv1bOCU96jcAIoabA6sh/8947dXch945wUe2jZ8QLj+!YYIUDO+yGtlZ2XBSoHVouyObKzyJHMIKuQFHCuKgwOZ1qyQtEC07KkXCJngLAlnChtrqzboL4sZ5
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: 6203
 by: olcott - Sat, 23 Apr 2022 16:05 UTC

On 4/23/2022 10:58 AM, wij wrote:
> On Saturday, 23 April 2022 at 22:49:59 UTC+8, olcott wrote:
>> All of my reviewers expect H(P,P) to compute the halt status of P(P),
>> yet the behavior specified by the input to H(P,P) is not the same as the
>> behavior specified by P(P).
>
> 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
> https://en.wikipedia.org/wiki/Halting_problem
>
> If using this common concept, the halting decider H, when given an argument P
> (or P P), is supposed to answer whether P(P) will halt or not. This is a very
> simple, easy idea to understand even for teenager students.
>

When this very simple idea is very rigorously examined (as it is in my
paper) one sees that this requires the halt decider to be a mind reader
and compute the halt status other than the actual halt status specified
by its actual input.

>> Anyone that is an expert in the C programming language, the x86
>> programming language, exactly how C translates into x86 and what an x86
>> processor emulator is can easily verify that the correctly simulated
>> input to H(P,P) by H specifies a non-halting sequence of configurations.
>>
>> Since my reviewers expect the halt decider to compute the halt status of
>> P(P) yet the input to H(P,P) specifies a different halt status my
>> reviewers expect H to read their mind so that it can compute different
>> behavior than the behavior that the input actually specifies.
>>
>>
>>
>> The function named H continues to simulate its input using an x86
>> emulator until this input either halts on its own or H detects that it
>> would never halt. If its input halts H returns 1. If H detects that its
>> input would never halt H returns 0.
>>
>> #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()
>> [000009d6](01) 55 push ebp
>> [000009d7](02) 8bec mov ebp,esp
>> [000009d9](03) 8b4508 mov eax,[ebp+08]
>> [000009dc](01) 50 push eax // push P
>> [000009dd](03) 8b4d08 mov ecx,[ebp+08]
>> [000009e0](01) 51 push ecx // push P
>> [000009e1](05) e840feffff call 00000826 // call H
>> [000009e6](03) 83c408 add esp,+08
>> [000009e9](02) 85c0 test eax,eax
>> [000009eb](02) 7402 jz 000009ef
>> [000009ed](02) ebfe jmp 000009ed
>> [000009ef](01) 5d pop ebp
>> [000009f0](01) c3 ret // Final state
>> Size in bytes:(0027) [000009f0]
>>
>> The simulated input to H(P,P) cannot possibly reach its own final state
>> of [000009f0] it keeps repeating [000009d6] to [000009e1] until aborted.
>>
>> Begin Local Halt Decider Simulation
>>
>> machine stack stack machine assembly
>> address address data code language
>> ======== ======== ======== ========= =============
>> ...[000009d6][00211368][0021136c] 55 push ebp // enter P
>> ...[000009d7][00211368][0021136c] 8bec mov ebp,esp
>> ...[000009d9][00211368][0021136c] 8b4508 mov eax,[ebp+08]
>> ...[000009dc][00211364][000009d6] 50 push eax // Push P
>> ...[000009dd][00211364][000009d6] 8b4d08 mov ecx,[ebp+08]
>> ...[000009e0][00211360][000009d6] 51 push ecx // Push P
>> ...[000009e1][0021135c][000009e6] e840feffff call 00000826 // Call H
>> ...[000009d6][0025bd90][0025bd94] 55 push ebp // enter P
>> ...[000009d7][0025bd90][0025bd94] 8bec mov ebp,esp
>> ...[000009d9][0025bd90][0025bd94] 8b4508 mov eax,[ebp+08]
>> ...[000009dc][0025bd8c][000009d6] 50 push eax // Push P
>> ...[000009dd][0025bd8c][000009d6] 8b4d08 mov ecx,[ebp+08]
>> ...[000009e0][0025bd88][000009d6] 51 push ecx // Push P
>> ...[000009e1][0025bd84][000009e6] e840feffff call 00000826 // Call H
>> Local Halt Decider: Infinite Recursion Detected Simulation Stopped
>>
>> Because the correctly simulated input to H(P,P) cannot possibly reach
>> its own final state at [000009f0] it is necessarily correct for H to
>> reject this input as non-halting.
>>
>> The correctly simulated 27 bytes of machine code at [000009d6] would
>> never reach its own final state at [000009f0] when correctly simulated
>> by the simulating halt decider (SHD) at machine address [00000826].
>>
>>
>>
>>
>> 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
>
> These are POOP's

--
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: All my reviewers expect a halt decider to have psychic power

<ae21ba1f-e4e2-432b-a274-2d6319af57bdn@googlegroups.com>

 copy mid

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

 copy link   Newsgroups: comp.theory
X-Received: by 2002:a0c:d7cb:0:b0:444:2b27:80d3 with SMTP id g11-20020a0cd7cb000000b004442b2780d3mr7545985qvj.57.1650731363218;
Sat, 23 Apr 2022 09:29:23 -0700 (PDT)
X-Received: by 2002:a25:d785:0:b0:641:cbcd:4a2d with SMTP id
o127-20020a25d785000000b00641cbcd4a2dmr9253551ybg.251.1650731362988; Sat, 23
Apr 2022 09:29:22 -0700 (PDT)
Path: i2pn2.org!i2pn.org!weretis.net!feeder6.news.weretis.net!news.misty.com!border2.nntp.dca1.giganews.com!nntp.giganews.com!news-out.google.com!nntp.google.com!postnews.google.com!google-groups.googlegroups.com!not-for-mail
Newsgroups: comp.theory
Date: Sat, 23 Apr 2022 09:29:22 -0700 (PDT)
In-Reply-To: <7emdnUtkBq8lvvn_nZ2dnUU7_8zNnZ2d@giganews.com>
Injection-Info: google-groups.googlegroups.com; posting-host=58.115.187.102; posting-account=QJ9iEwoAAACyjkKjQAWQOwSEULNvZZkc
NNTP-Posting-Host: 58.115.187.102
References: <9sudne4_G7qNj_n_nZ2dnUU7_83NnZ2d@giganews.com>
<a9db8e82-955f-48d1-98c9-a4a529b64e56n@googlegroups.com> <7emdnUtkBq8lvvn_nZ2dnUU7_8zNnZ2d@giganews.com>
User-Agent: G2/1.0
MIME-Version: 1.0
Message-ID: <ae21ba1f-e4e2-432b-a274-2d6319af57bdn@googlegroups.com>
Subject: Re: All my reviewers expect a halt decider to have psychic power
From: wyni...@gmail.com (wij)
Injection-Date: Sat, 23 Apr 2022 16:29:23 +0000
Content-Type: text/plain; charset="UTF-8"
Lines: 25
 by: wij - Sat, 23 Apr 2022 16:29 UTC

On Sunday, 24 April 2022 at 00:05:19 UTC+8, olcott wrote:
> On 4/23/2022 10:58 AM, wij wrote:
> > On Saturday, 23 April 2022 at 22:49:59 UTC+8, olcott wrote:
> >> All of my reviewers expect H(P,P) to compute the halt status of P(P),
> >> yet the behavior specified by the input to H(P,P) is not the same as the
> >> behavior specified by P(P).
> >
> > 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
> > https://en.wikipedia.org/wiki/Halting_problem
> >
> > If using this common concept, the halting decider H, when given an argument P
> > (or P P), is supposed to answer whether P(P) will halt or not. This is a very
> > simple, easy idea to understand even for teenager students.
> >
> When this very simple idea is very rigorously examined (as it is in my
> paper) one sees that this requires the halt decider to be a mind reader
> and compute the halt status other than the actual halt status specified
> by its actual input.

Your wording/interpretations/paper change all the time. No idea what this new
excuse 'mind reader' might mean. As said, the Halting Problem is very simple
and intuitive.
H should be a decider that computes the actual halt status of P(P). P is the
H's actual argument input.
I expect you might try to find some bugs of those descriptions to rephrasing it
in your favor. But, what would be the point? What is the usefulness of POOP?

Re: All my reviewers expect a halt decider to have psychic power

<mfmdnYqt3Ys1t_n_nZ2dnUU7_83NnZ2d@giganews.com>

 copy mid

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

 copy link   Newsgroups: comp.theory comp.ai.philosophy sci.math sci.logic
Followup: sci.logic
Path: i2pn2.org!i2pn.org!weretis.net!feeder6.news.weretis.net!news.misty.com!border2.nntp.dca1.giganews.com!nntp.giganews.com!buffer2.nntp.dca1.giganews.com!buffer1.nntp.dca1.giganews.com!news.giganews.com.POSTED!not-for-mail
NNTP-Posting-Date: Sat, 23 Apr 2022 11:34:48 -0500
Date: Sat, 23 Apr 2022 11:34:47 -0500
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:91.0) Gecko/20100101
Thunderbird/91.8.1
Subject: Re: All my reviewers expect a halt decider to have psychic power
Content-Language: en-US
Newsgroups: comp.theory,comp.ai.philosophy,sci.math,sci.logic
References: <9sudne4_G7qNj_n_nZ2dnUU7_83NnZ2d@giganews.com>
<a9db8e82-955f-48d1-98c9-a4a529b64e56n@googlegroups.com>
<7emdnUtkBq8lvvn_nZ2dnUU7_8zNnZ2d@giganews.com>
<ae21ba1f-e4e2-432b-a274-2d6319af57bdn@googlegroups.com>
Followup-To: sci.logic
From: NoO...@NoWhere.com (olcott)
In-Reply-To: <ae21ba1f-e4e2-432b-a274-2d6319af57bdn@googlegroups.com>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 7bit
Message-ID: <mfmdnYqt3Ys1t_n_nZ2dnUU7_83NnZ2d@giganews.com>
Lines: 50
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-6rUTwGQ+Y2re5h7KR25d5uDdDhBFPuPJFcSCnDOejsYqqOxfXGrFU7xLHbSB/N1B+BG/n+352WuxE6d!F5bAhyeUFh2mFNeYDhBsiAhaNGdZdsJ2vgnChqyI+hbfNthl5+r+5tKmYkYBhs57pEe98cUE+Vze
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: 3849
 by: olcott - Sat, 23 Apr 2022 16:34 UTC

On 4/23/2022 11:29 AM, wij wrote:
> On Sunday, 24 April 2022 at 00:05:19 UTC+8, olcott wrote:
>> On 4/23/2022 10:58 AM, wij wrote:
>>> On Saturday, 23 April 2022 at 22:49:59 UTC+8, olcott wrote:
>>>> All of my reviewers expect H(P,P) to compute the halt status of P(P),
>>>> yet the behavior specified by the input to H(P,P) is not the same as the
>>>> behavior specified by P(P).
>>>
>>> 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
>>> https://en.wikipedia.org/wiki/Halting_problem
>>>
>>> If using this common concept, the halting decider H, when given an argument P
>>> (or P P), is supposed to answer whether P(P) will halt or not. This is a very
>>> simple, easy idea to understand even for teenager students.
>>>
>> When this very simple idea is very rigorously examined (as it is in my
>> paper) one sees that this requires the halt decider to be a mind reader
>> and compute the halt status other than the actual halt status specified
>> by its actual input.
>
> Your wording/interpretations/paper change all the time. No idea what this new
> excuse 'mind reader' might mean. As said, the Halting Problem is very simple
> and intuitive.
> H should be a decider that computes the actual halt status of P(P). P is the
> H's actual argument input.
> I expect you might try to find some bugs of those descriptions to rephrasing it
> in your favor. But, what would be the point? What is the usefulness of POOP?

Yet when you carefully examine my paper:

Anyone that is an expert in the C programming language, the x86
programming language, exactly how C translates into x86 and what an x86
processor emulator is can easily verify that the correctly simulated
input to H(P,P) by H specifies a non-halting sequence of configurations.

Halting problem undecidability and infinitely nested simulation (V5)

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

Simply ignoring the verified facts is a ridiculously foolish was to form
any actual rebuttal.

--
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: All my reviewers expect a halt decider to have psychic power

<90544d3f-8d36-4d70-8951-45342b939a06n@googlegroups.com>

 copy mid

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

 copy link   Newsgroups: comp.theory
X-Received: by 2002:ac8:578c:0:b0:2f1:ed92:39a9 with SMTP id v12-20020ac8578c000000b002f1ed9239a9mr7064035qta.300.1650732232458;
Sat, 23 Apr 2022 09:43:52 -0700 (PDT)
X-Received: by 2002:a05:6902:12c6:b0:644:d4fd:f149 with SMTP id
j6-20020a05690212c600b00644d4fdf149mr9908020ybu.347.1650732232196; Sat, 23
Apr 2022 09:43:52 -0700 (PDT)
Path: i2pn2.org!i2pn.org!weretis.net!feeder6.news.weretis.net!news.misty.com!border2.nntp.dca1.giganews.com!nntp.giganews.com!news-out.google.com!nntp.google.com!postnews.google.com!google-groups.googlegroups.com!not-for-mail
Newsgroups: comp.theory
Date: Sat, 23 Apr 2022 09:43:51 -0700 (PDT)
In-Reply-To: <mfmdnYqt3Ys1t_n_nZ2dnUU7_83NnZ2d@giganews.com>
Injection-Info: google-groups.googlegroups.com; posting-host=58.115.187.102; posting-account=QJ9iEwoAAACyjkKjQAWQOwSEULNvZZkc
NNTP-Posting-Host: 58.115.187.102
References: <9sudne4_G7qNj_n_nZ2dnUU7_83NnZ2d@giganews.com>
<a9db8e82-955f-48d1-98c9-a4a529b64e56n@googlegroups.com> <7emdnUtkBq8lvvn_nZ2dnUU7_8zNnZ2d@giganews.com>
<ae21ba1f-e4e2-432b-a274-2d6319af57bdn@googlegroups.com> <mfmdnYqt3Ys1t_n_nZ2dnUU7_83NnZ2d@giganews.com>
User-Agent: G2/1.0
MIME-Version: 1.0
Message-ID: <90544d3f-8d36-4d70-8951-45342b939a06n@googlegroups.com>
Subject: Re: All my reviewers expect a halt decider to have psychic power
From: wyni...@gmail.com (wij)
Injection-Date: Sat, 23 Apr 2022 16:43:52 +0000
Content-Type: text/plain; charset="UTF-8"
Lines: 46
 by: wij - Sat, 23 Apr 2022 16:43 UTC

On Sunday, 24 April 2022 at 00:34:55 UTC+8, olcott wrote:
> On 4/23/2022 11:29 AM, wij wrote:
> > On Sunday, 24 April 2022 at 00:05:19 UTC+8, olcott wrote:
> >> On 4/23/2022 10:58 AM, wij wrote:
> >>> On Saturday, 23 April 2022 at 22:49:59 UTC+8, olcott wrote:
> >>>> All of my reviewers expect H(P,P) to compute the halt status of P(P),
> >>>> yet the behavior specified by the input to H(P,P) is not the same as the
> >>>> behavior specified by P(P).
> >>>
> >>> 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
> >>> https://en.wikipedia.org/wiki/Halting_problem
> >>>
> >>> If using this common concept, the halting decider H, when given an argument P
> >>> (or P P), is supposed to answer whether P(P) will halt or not. This is a very
> >>> simple, easy idea to understand even for teenager students.
> >>>
> >> When this very simple idea is very rigorously examined (as it is in my
> >> paper) one sees that this requires the halt decider to be a mind reader
> >> and compute the halt status other than the actual halt status specified
> >> by its actual input.
> >
> > Your wording/interpretations/paper change all the time. No idea what this new
> > excuse 'mind reader' might mean. As said, the Halting Problem is very simple
> > and intuitive.
> > H should be a decider that computes the actual halt status of P(P). P is the
> > H's actual argument input.
> > I expect you might try to find some bugs of those descriptions to rephrasing it
> > in your favor. But, what would be the point? What is the usefulness of POOP?
> Yet when you carefully examine my paper:
> Anyone that is an expert in the C programming language, the x86
> programming language, exactly how C translates into x86 and what an x86
> processor emulator is can easily verify that the correctly simulated
> input to H(P,P) by H specifies a non-halting sequence of configurations.
> Halting problem undecidability and infinitely nested simulation (V5)
>
> https://www.researchgate.net/publication/359984584_Halting_problem_undecidability_and_infinitely_nested_simulation_V5
> Simply ignoring the verified facts is a ridiculously foolish was to form
> any actual rebuttal.
> --
> Copyright 2022 Pete Olcott
>
> "Talent hits a target no one else can hit;
> Genius hits a target no one else can see."
> Arthur Schopenhauer

You already verified the fact that H(P,P) will be in an infinite recursive call
(thus, undecidable). Why you say H(P,P)==false (or true)?

Re: All my reviewers expect a halt decider to have psychic power

<JY2dndGxr5I0s_n_nZ2dnUU7_83NnZ2d@giganews.com>

 copy mid

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

 copy link   Newsgroups: comp.theory comp.ai.philosophy sci.logic sci.math
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!news.giganews.com.POSTED!not-for-mail
NNTP-Posting-Date: Sat, 23 Apr 2022 11:51:53 -0500
Date: Sat, 23 Apr 2022 11:51:52 -0500
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:91.0) Gecko/20100101
Thunderbird/91.8.1
Subject: Re: All my reviewers expect a halt decider to have psychic power
Content-Language: en-US
Newsgroups: comp.theory,comp.ai.philosophy,sci.logic,sci.math
References: <9sudne4_G7qNj_n_nZ2dnUU7_83NnZ2d@giganews.com>
<a9db8e82-955f-48d1-98c9-a4a529b64e56n@googlegroups.com>
<7emdnUtkBq8lvvn_nZ2dnUU7_8zNnZ2d@giganews.com>
<ae21ba1f-e4e2-432b-a274-2d6319af57bdn@googlegroups.com>
<mfmdnYqt3Ys1t_n_nZ2dnUU7_83NnZ2d@giganews.com>
<90544d3f-8d36-4d70-8951-45342b939a06n@googlegroups.com>
Followup-To: comp.theory
From: NoO...@NoWhere.com (olcott)
In-Reply-To: <90544d3f-8d36-4d70-8951-45342b939a06n@googlegroups.com>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 7bit
Message-ID: <JY2dndGxr5I0s_n_nZ2dnUU7_83NnZ2d@giganews.com>
Lines: 89
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-g1JGn3cEqrtNyCaIvCxBxmF3wjw01pcJdGP4cJe68AJ3AtwqwGwojzQxzU6ELXGRvJUDfc5DKNgo8U3!7yTqwkfpmbjZLkRZS9KJ7mmXB2O4HOadwVU4l0Iq20TwidiC267F5MWuZYU8jMJXCB0e1oSszOLR
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: 6177
 by: olcott - Sat, 23 Apr 2022 16:51 UTC

On 4/23/2022 11:43 AM, wij wrote:
> On Sunday, 24 April 2022 at 00:34:55 UTC+8, olcott wrote:
>> On 4/23/2022 11:29 AM, wij wrote:
>>> On Sunday, 24 April 2022 at 00:05:19 UTC+8, olcott wrote:
>>>> On 4/23/2022 10:58 AM, wij wrote:
>>>>> On Saturday, 23 April 2022 at 22:49:59 UTC+8, olcott wrote:
>>>>>> All of my reviewers expect H(P,P) to compute the halt status of P(P),
>>>>>> yet the behavior specified by the input to H(P,P) is not the same as the
>>>>>> behavior specified by P(P).
>>>>>
>>>>> 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
>>>>> https://en.wikipedia.org/wiki/Halting_problem
>>>>>
>>>>> If using this common concept, the halting decider H, when given an argument P
>>>>> (or P P), is supposed to answer whether P(P) will halt or not. This is a very
>>>>> simple, easy idea to understand even for teenager students.
>>>>>
>>>> When this very simple idea is very rigorously examined (as it is in my
>>>> paper) one sees that this requires the halt decider to be a mind reader
>>>> and compute the halt status other than the actual halt status specified
>>>> by its actual input.
>>>
>>> Your wording/interpretations/paper change all the time. No idea what this new
>>> excuse 'mind reader' might mean. As said, the Halting Problem is very simple
>>> and intuitive.
>>> H should be a decider that computes the actual halt status of P(P). P is the
>>> H's actual argument input.
>>> I expect you might try to find some bugs of those descriptions to rephrasing it
>>> in your favor. But, what would be the point? What is the usefulness of POOP?
>> Yet when you carefully examine my paper:
>> Anyone that is an expert in the C programming language, the x86
>> programming language, exactly how C translates into x86 and what an x86
>> processor emulator is can easily verify that the correctly simulated
>> input to H(P,P) by H specifies a non-halting sequence of configurations.
>> Halting problem undecidability and infinitely nested simulation (V5)
>>
>> https://www.researchgate.net/publication/359984584_Halting_problem_undecidability_and_infinitely_nested_simulation_V5
>> Simply ignoring the verified facts is a ridiculously foolish was to form
>> any actual rebuttal.
>> --
>> Copyright 2022 Pete Olcott
>>
>> "Talent hits a target no one else can hit;
>> Genius hits a target no one else can see."
>> Arthur Schopenhauer
>
> You already verified the fact that H(P,P) will be in an infinite recursive call
> (thus, undecidable). Why you say H(P,P)==false (or true)?

You might make a wild guess like this if you make sure to hardly pay
attention. When you actually pay close attention and carefully study my
paper it is very easy to see that H sees the same infinitely repeating
pattern that we see, thus can abort its simulation and reject its input.

Begin Local Halt Decider Simulation

machine stack stack machine assembly
address address data code language
======== ======== ======== ========= =============
....[000009d6][00211368][0021136c] 55 push ebp // enter P
....[000009d7][00211368][0021136c] 8bec mov ebp,esp
....[000009d9][00211368][0021136c] 8b4508 mov eax,[ebp+08]
....[000009dc][00211364][000009d6] 50 push eax // Push P
....[000009dd][00211364][000009d6] 8b4d08 mov ecx,[ebp+08]
....[000009e0][00211360][000009d6] 51 push ecx // Push P
....[000009e1][0021135c][000009e6] e840feffff call 00000826 // Call H
....[000009d6][0025bd90][0025bd94] 55 push ebp // enter P
....[000009d7][0025bd90][0025bd94] 8bec mov ebp,esp
....[000009d9][0025bd90][0025bd94] 8b4508 mov eax,[ebp+08]
....[000009dc][0025bd8c][000009d6] 50 push eax // Push P
....[000009dd][0025bd8c][000009d6] 8b4d08 mov ecx,[ebp+08]
....[000009e0][0025bd88][000009d6] 51 push ecx // Push P
....[000009e1][0025bd84][000009e6] e840feffff call 00000826 // Call H
Local Halt Decider: Infinite Recursion Detected Simulation Stopped

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: All my reviewers expect a halt decider to have psychic power

<DjW8K.365490$Gojc.300811@fx99.iad>

 copy mid

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

 copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!weretis.net!feeder8.news.weretis.net!newsreader4.netcologne.de!news.netcologne.de!peer03.ams1!peer.ams1.xlned.com!news.xlned.com!peer03.iad!feed-me.highwinds-media.com!news.highwinds-media.com!fx99.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.8.1
Subject: Re: All my reviewers expect a halt decider to have psychic power
Content-Language: en-US
Newsgroups: comp.theory
References: <9sudne4_G7qNj_n_nZ2dnUU7_83NnZ2d@giganews.com>
<a9db8e82-955f-48d1-98c9-a4a529b64e56n@googlegroups.com>
<7emdnUtkBq8lvvn_nZ2dnUU7_8zNnZ2d@giganews.com>
From: Rich...@Damon-Family.org (Richard Damon)
In-Reply-To: <7emdnUtkBq8lvvn_nZ2dnUU7_8zNnZ2d@giganews.com>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 7bit
Lines: 48
Message-ID: <DjW8K.365490$Gojc.300811@fx99.iad>
X-Complaints-To: abuse@easynews.com
Organization: Forte - www.forteinc.com
X-Complaints-Info: Please be sure to forward a copy of ALL headers otherwise we will be unable to process your complaint properly.
Date: Sat, 23 Apr 2022 13:03:30 -0400
X-Received-Bytes: 3234
 by: Richard Damon - Sat, 23 Apr 2022 17:03 UTC

On 4/23/22 12:05 PM, olcott wrote:
> On 4/23/2022 10:58 AM, wij wrote:
>> On Saturday, 23 April 2022 at 22:49:59 UTC+8, olcott wrote:
>>> All of my reviewers expect H(P,P) to compute the halt status of P(P),
>>> yet the behavior specified by the input to H(P,P) is not the same as the
>>> behavior specified by P(P).
>>
>> 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
>> https://en.wikipedia.org/wiki/Halting_problem
>>
>> If using this common concept, the halting decider H, when given an
>> argument P
>> (or P P), is supposed to answer whether P(P) will halt or not. This is
>> a very
>> simple, easy idea to understand even for teenager students.
>>
>
> When this very simple idea is very rigorously examined (as it is in my
> paper) one sees that this requires the halt decider to be a mind reader
> and compute the halt status other than the actual halt status specified
> by its actual input.

So, you are admitting that the Halting Problem, as classically defined,
is actually impossible to solve, because it requires H to do something
that is impossible.

Thus, you are changing the definition of what you are calling the
Halting Problem to something that is solvable.

Fine, all that means is that you have defined some new property,
PO-Halting, and show that it might be possible to solve PO-Halting (at
least you can handle the Linz input).

Since this isn't actually dealing with what is classically called the
Halting Problem, and all classical uses of the Halting Problem are still
using the classical halting problem and classic halting property, and
that is still proved unsolvable.

Thus things like the proof that not all Truths are Provable still hold,
since that was based on ACTUAL-Halting, not PO=Halting.

Thus, your whole arguement FAILS to produce the results you claim.

You don't get to change the definition of the classical halting problem,
so by attempting it, you have invalidated your 'proof'

Re: All my reviewers expect a halt decider to have psychic power

<NkW8K.365491$Gojc.274515@fx99.iad>

 copy mid

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

 copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!usenet.goja.nl.eu.org!news.freedyn.de!newsreader4.netcologne.de!news.netcologne.de!peer03.ams1!peer.ams1.xlned.com!news.xlned.com!peer02.iad!feed-me.highwinds-media.com!news.highwinds-media.com!fx99.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.8.1
Subject: Re: All my reviewers expect a halt decider to have psychic power
Content-Language: en-US
Newsgroups: comp.theory
References: <9sudne4_G7qNj_n_nZ2dnUU7_83NnZ2d@giganews.com>
<a9db8e82-955f-48d1-98c9-a4a529b64e56n@googlegroups.com>
<7emdnUtkBq8lvvn_nZ2dnUU7_8zNnZ2d@giganews.com>
<ae21ba1f-e4e2-432b-a274-2d6319af57bdn@googlegroups.com>
<mfmdnYqt3Ys1t_n_nZ2dnUU7_83NnZ2d@giganews.com>
<90544d3f-8d36-4d70-8951-45342b939a06n@googlegroups.com>
<JY2dndGxr5I0s_n_nZ2dnUU7_83NnZ2d@giganews.com>
From: Rich...@Damon-Family.org (Richard Damon)
In-Reply-To: <JY2dndGxr5I0s_n_nZ2dnUU7_83NnZ2d@giganews.com>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Lines: 107
Message-ID: <NkW8K.365491$Gojc.274515@fx99.iad>
X-Complaints-To: abuse@easynews.com
Organization: Forte - www.forteinc.com
X-Complaints-Info: Please be sure to forward a copy of ALL headers otherwise we will be unable to process your complaint properly.
Date: Sat, 23 Apr 2022 13:04:45 -0400
X-Received-Bytes: 6330
 by: Richard Damon - Sat, 23 Apr 2022 17:04 UTC

On 4/23/22 12:51 PM, olcott wrote:
> On 4/23/2022 11:43 AM, wij wrote:
>> On Sunday, 24 April 2022 at 00:34:55 UTC+8, olcott wrote:
>>> On 4/23/2022 11:29 AM, wij wrote:
>>>> On Sunday, 24 April 2022 at 00:05:19 UTC+8, olcott wrote:
>>>>> On 4/23/2022 10:58 AM, wij wrote:
>>>>>> On Saturday, 23 April 2022 at 22:49:59 UTC+8, olcott wrote:
>>>>>>> All of my reviewers expect H(P,P) to compute the halt status of
>>>>>>> P(P),
>>>>>>> yet the behavior specified by the input to H(P,P) is not the same
>>>>>>> as the
>>>>>>> behavior specified by P(P).
>>>>>>
>>>>>> 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
>>>>>> https://en.wikipedia.org/wiki/Halting_problem
>>>>>>
>>>>>> If using this common concept, the halting decider H, when given an
>>>>>> argument P
>>>>>> (or P P), is supposed to answer whether P(P) will halt or not.
>>>>>> This is a very
>>>>>> simple, easy idea to understand even for teenager students.
>>>>>>
>>>>> When this very simple idea is very rigorously examined (as it is in my
>>>>> paper) one sees that this requires the halt decider to be a mind
>>>>> reader
>>>>> and compute the halt status other than the actual halt status
>>>>> specified
>>>>> by its actual input.
>>>>
>>>> Your wording/interpretations/paper change all the time. No idea what
>>>> this new
>>>> excuse 'mind reader' might mean. As said, the Halting Problem is
>>>> very simple
>>>> and intuitive.
>>>> H should be a decider that computes the actual halt status of P(P).
>>>> P is the
>>>> H's actual argument input.
>>>> I expect you might try to find some bugs of those descriptions to
>>>> rephrasing it
>>>> in your favor. But, what would be the point? What is the usefulness
>>>> of POOP?
>>> Yet when you carefully examine my paper:
>>> Anyone that is an expert in the C programming language, the x86
>>> programming language, exactly how C translates into x86 and what an x86
>>> processor emulator is can easily verify that the correctly simulated
>>> input to H(P,P) by H specifies a non-halting sequence of configurations.
>>> Halting problem undecidability and infinitely nested simulation (V5)
>>>
>>> https://www.researchgate.net/publication/359984584_Halting_problem_undecidability_and_infinitely_nested_simulation_V5
>>>
>>> Simply ignoring the verified facts is a ridiculously foolish was to form
>>> any actual rebuttal.
>>> --
>>> Copyright 2022 Pete Olcott
>>>
>>> "Talent hits a target no one else can hit;
>>> Genius hits a target no one else can see."
>>> Arthur Schopenhauer
>>
>> You already verified the fact that H(P,P) will be in an infinite
>> recursive call
>> (thus, undecidable). Why you say H(P,P)==false (or true)?
>
> You might make a wild guess like this if you make sure to hardly pay
> attention. When you actually pay close attention and carefully study my
> paper it is very easy to see that H sees the same infinitely repeating
> pattern that we see, thus can abort its simulation and reject its input.

Nope, H only sees the behavior when it ignores that the copy of H will
also see the behavior.

Thus H is either wrong or not a computation.

>
>
> Begin Local Halt Decider Simulation
>
>     machine   stack     stack     machine    assembly
>     address   address   data      code       language
>     ========  ========  ========  =========  =============
> ...[000009d6][00211368][0021136c] 55         push ebp         // enter P
> ...[000009d7][00211368][0021136c] 8bec       mov ebp,esp
> ...[000009d9][00211368][0021136c] 8b4508     mov eax,[ebp+08]
> ...[000009dc][00211364][000009d6] 50         push eax         // Push P
> ...[000009dd][00211364][000009d6] 8b4d08     mov ecx,[ebp+08]
> ...[000009e0][00211360][000009d6] 51         push ecx         // Push P
> ...[000009e1][0021135c][000009e6] e840feffff call 00000826    // Call H
> ...[000009d6][0025bd90][0025bd94] 55         push ebp         // enter P
> ...[000009d7][0025bd90][0025bd94] 8bec       mov ebp,esp
> ...[000009d9][0025bd90][0025bd94] 8b4508     mov eax,[ebp+08]
> ...[000009dc][0025bd8c][000009d6] 50         push eax         // Push P
> ...[000009dd][0025bd8c][000009d6] 8b4d08     mov ecx,[ebp+08]
> ...[000009e0][0025bd88][000009d6] 51         push ecx         // Push P
> ...[000009e1][0025bd84][000009e6] e840feffff call 00000826    // Call H
> Local Halt Decider: Infinite Recursion Detected Simulation Stopped
>
>
>
> Halting problem undecidability and infinitely nested simulation (V5)
>
> https://www.researchgate.net/publication/359984584_Halting_problem_undecidability_and_infinitely_nested_simulation_V5
>
>

Re: All my reviewers expect a halt decider to have psychic power

<5f5837f9-279a-4d02-8d54-18e604a8496an@googlegroups.com>

 copy mid

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

 copy link   Newsgroups: comp.theory
X-Received: by 2002:a05:620a:258e:b0:680:f33c:dbcd with SMTP id x14-20020a05620a258e00b00680f33cdbcdmr6222000qko.542.1650734123543;
Sat, 23 Apr 2022 10:15:23 -0700 (PDT)
X-Received: by 2002:a25:2c07:0:b0:648:4ab1:3f25 with SMTP id
s7-20020a252c07000000b006484ab13f25mr172298ybs.101.1650734123254; Sat, 23 Apr
2022 10:15:23 -0700 (PDT)
Path: i2pn2.org!i2pn.org!weretis.net!feeder6.news.weretis.net!news.misty.com!border2.nntp.dca1.giganews.com!nntp.giganews.com!news-out.google.com!nntp.google.com!postnews.google.com!google-groups.googlegroups.com!not-for-mail
Newsgroups: comp.theory
Date: Sat, 23 Apr 2022 10:15:22 -0700 (PDT)
In-Reply-To: <JY2dndGxr5I0s_n_nZ2dnUU7_83NnZ2d@giganews.com>
Injection-Info: google-groups.googlegroups.com; posting-host=58.115.187.102; posting-account=QJ9iEwoAAACyjkKjQAWQOwSEULNvZZkc
NNTP-Posting-Host: 58.115.187.102
References: <9sudne4_G7qNj_n_nZ2dnUU7_83NnZ2d@giganews.com>
<a9db8e82-955f-48d1-98c9-a4a529b64e56n@googlegroups.com> <7emdnUtkBq8lvvn_nZ2dnUU7_8zNnZ2d@giganews.com>
<ae21ba1f-e4e2-432b-a274-2d6319af57bdn@googlegroups.com> <mfmdnYqt3Ys1t_n_nZ2dnUU7_83NnZ2d@giganews.com>
<90544d3f-8d36-4d70-8951-45342b939a06n@googlegroups.com> <JY2dndGxr5I0s_n_nZ2dnUU7_83NnZ2d@giganews.com>
User-Agent: G2/1.0
MIME-Version: 1.0
Message-ID: <5f5837f9-279a-4d02-8d54-18e604a8496an@googlegroups.com>
Subject: Re: All my reviewers expect a halt decider to have psychic power
From: wyni...@gmail.com (wij)
Injection-Date: Sat, 23 Apr 2022 17:15:23 +0000
Content-Type: text/plain; charset="UTF-8"
Lines: 85
 by: wij - Sat, 23 Apr 2022 17:15 UTC

On Sunday, 24 April 2022 at 00:52:00 UTC+8, olcott wrote:
> On 4/23/2022 11:43 AM, wij wrote:
> > On Sunday, 24 April 2022 at 00:34:55 UTC+8, olcott wrote:
> >> On 4/23/2022 11:29 AM, wij wrote:
> >>> On Sunday, 24 April 2022 at 00:05:19 UTC+8, olcott wrote:
> >>>> On 4/23/2022 10:58 AM, wij wrote:
> >>>>> On Saturday, 23 April 2022 at 22:49:59 UTC+8, olcott wrote:
> >>>>>> All of my reviewers expect H(P,P) to compute the halt status of P(P),
> >>>>>> yet the behavior specified by the input to H(P,P) is not the same as the
> >>>>>> behavior specified by P(P).
> >>>>>
> >>>>> 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
> >>>>> https://en.wikipedia.org/wiki/Halting_problem
> >>>>>
> >>>>> If using this common concept, the halting decider H, when given an argument P
> >>>>> (or P P), is supposed to answer whether P(P) will halt or not. This is a very
> >>>>> simple, easy idea to understand even for teenager students.
> >>>>>
> >>>> When this very simple idea is very rigorously examined (as it is in my
> >>>> paper) one sees that this requires the halt decider to be a mind reader
> >>>> and compute the halt status other than the actual halt status specified
> >>>> by its actual input.
> >>>
> >>> Your wording/interpretations/paper change all the time. No idea what this new
> >>> excuse 'mind reader' might mean. As said, the Halting Problem is very simple
> >>> and intuitive.
> >>> H should be a decider that computes the actual halt status of P(P). P is the
> >>> H's actual argument input.
> >>> I expect you might try to find some bugs of those descriptions to rephrasing it
> >>> in your favor. But, what would be the point? What is the usefulness of POOP?
> >> Yet when you carefully examine my paper:
> >> Anyone that is an expert in the C programming language, the x86
> >> programming language, exactly how C translates into x86 and what an x86
> >> processor emulator is can easily verify that the correctly simulated
> >> input to H(P,P) by H specifies a non-halting sequence of configurations.
> >> Halting problem undecidability and infinitely nested simulation (V5)
> >>
> >> https://www.researchgate.net/publication/359984584_Halting_problem_undecidability_and_infinitely_nested_simulation_V5
> >> Simply ignoring the verified facts is a ridiculously foolish was to form
> >> any actual rebuttal.
> >> --
> >> Copyright 2022 Pete Olcott
> >>
> >> "Talent hits a target no one else can hit;
> >> Genius hits a target no one else can see."
> >> Arthur Schopenhauer
> >
> > You already verified the fact that H(P,P) will be in an infinite recursive call
> > (thus, undecidable). Why you say H(P,P)==false (or true)?
> You might make a wild guess like this if you make sure to hardly pay
> attention. When you actually pay close attention and carefully study my
> paper it is very easy to see that H sees the same infinitely repeating
> pattern that we see, thus can abort its simulation and reject its input.
> Begin Local Halt Decider Simulation
>
> machine stack stack machine assembly
> address address data code language
> ======== ======== ======== ========= =============
> ...[000009d6][00211368][0021136c] 55 push ebp // enter P
> ...[000009d7][00211368][0021136c] 8bec mov ebp,esp
> ...[000009d9][00211368][0021136c] 8b4508 mov eax,[ebp+08]
> ...[000009dc][00211364][000009d6] 50 push eax // Push P
> ...[000009dd][00211364][000009d6] 8b4d08 mov ecx,[ebp+08]
> ...[000009e0][00211360][000009d6] 51 push ecx // Push P
> ...[000009e1][0021135c][000009e6] e840feffff call 00000826 // Call H
> ...[000009d6][0025bd90][0025bd94] 55 push ebp // enter P
> ...[000009d7][0025bd90][0025bd94] 8bec mov ebp,esp
> ...[000009d9][0025bd90][0025bd94] 8b4508 mov eax,[ebp+08]
> ...[000009dc][0025bd8c][000009d6] 50 push eax // Push P
> ...[000009dd][0025bd8c][000009d6] 8b4d08 mov ecx,[ebp+08]
> ...[000009e0][0025bd88][000009d6] 51 push ecx // Push P
> ...[000009e1][0025bd84][000009e6] e840feffff call 00000826 // Call H
> Local Halt Decider: Infinite Recursion Detected Simulation Stopped
> 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

"Local Halt Decider: Infinite Recursion Detected Simulation Stopped" means
your x86utm emulator has encountered an infinite recursive call.
This is referred to as "undecidable". This is the fact.

Re: All my reviewers expect a halt decider to have psychic power

<3cWdnSN3ZITNqPn_nZ2dnUU7_8xh4p2d@giganews.com>

 copy mid

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

 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: Sat, 23 Apr 2022 12:20:16 -0500
Date: Sat, 23 Apr 2022 12:20:16 -0500
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:91.0) Gecko/20100101
Thunderbird/91.8.1
Subject: Re: All my reviewers expect a halt decider to have psychic power
Content-Language: en-US
Newsgroups: comp.theory
References: <9sudne4_G7qNj_n_nZ2dnUU7_83NnZ2d@giganews.com>
<a9db8e82-955f-48d1-98c9-a4a529b64e56n@googlegroups.com>
<7emdnUtkBq8lvvn_nZ2dnUU7_8zNnZ2d@giganews.com>
<ae21ba1f-e4e2-432b-a274-2d6319af57bdn@googlegroups.com>
<mfmdnYqt3Ys1t_n_nZ2dnUU7_83NnZ2d@giganews.com>
<90544d3f-8d36-4d70-8951-45342b939a06n@googlegroups.com>
<JY2dndGxr5I0s_n_nZ2dnUU7_83NnZ2d@giganews.com>
<5f5837f9-279a-4d02-8d54-18e604a8496an@googlegroups.com>
From: NoO...@NoWhere.com (olcott)
In-Reply-To: <5f5837f9-279a-4d02-8d54-18e604a8496an@googlegroups.com>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 7bit
Message-ID: <3cWdnSN3ZITNqPn_nZ2dnUU7_8xh4p2d@giganews.com>
Lines: 101
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-EzOGWlt1MeDAnfw45yAOcFBLopc0hfDJI/gL3PTghKoQEf5e2rq7TSQWQVSAwOFTsGVeDv1D/7TKNT7!Lmc2S0+2NhT5SEfK/akb+fkcSSChOWiDRK/jI0Kgjjdg8VHmBYSsvysy5BF17QJChlBXQyow+EcM
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: 6941
 by: olcott - Sat, 23 Apr 2022 17:20 UTC

On 4/23/2022 12:15 PM, wij wrote:
> On Sunday, 24 April 2022 at 00:52:00 UTC+8, olcott wrote:
>> On 4/23/2022 11:43 AM, wij wrote:
>>> On Sunday, 24 April 2022 at 00:34:55 UTC+8, olcott wrote:
>>>> On 4/23/2022 11:29 AM, wij wrote:
>>>>> On Sunday, 24 April 2022 at 00:05:19 UTC+8, olcott wrote:
>>>>>> On 4/23/2022 10:58 AM, wij wrote:
>>>>>>> On Saturday, 23 April 2022 at 22:49:59 UTC+8, olcott wrote:
>>>>>>>> All of my reviewers expect H(P,P) to compute the halt status of P(P),
>>>>>>>> yet the behavior specified by the input to H(P,P) is not the same as the
>>>>>>>> behavior specified by P(P).
>>>>>>>
>>>>>>> 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
>>>>>>> https://en.wikipedia.org/wiki/Halting_problem
>>>>>>>
>>>>>>> If using this common concept, the halting decider H, when given an argument P
>>>>>>> (or P P), is supposed to answer whether P(P) will halt or not. This is a very
>>>>>>> simple, easy idea to understand even for teenager students.
>>>>>>>
>>>>>> When this very simple idea is very rigorously examined (as it is in my
>>>>>> paper) one sees that this requires the halt decider to be a mind reader
>>>>>> and compute the halt status other than the actual halt status specified
>>>>>> by its actual input.
>>>>>
>>>>> Your wording/interpretations/paper change all the time. No idea what this new
>>>>> excuse 'mind reader' might mean. As said, the Halting Problem is very simple
>>>>> and intuitive.
>>>>> H should be a decider that computes the actual halt status of P(P). P is the
>>>>> H's actual argument input.
>>>>> I expect you might try to find some bugs of those descriptions to rephrasing it
>>>>> in your favor. But, what would be the point? What is the usefulness of POOP?
>>>> Yet when you carefully examine my paper:
>>>> Anyone that is an expert in the C programming language, the x86
>>>> programming language, exactly how C translates into x86 and what an x86
>>>> processor emulator is can easily verify that the correctly simulated
>>>> input to H(P,P) by H specifies a non-halting sequence of configurations.
>>>> Halting problem undecidability and infinitely nested simulation (V5)
>>>>
>>>> https://www.researchgate.net/publication/359984584_Halting_problem_undecidability_and_infinitely_nested_simulation_V5
>>>> Simply ignoring the verified facts is a ridiculously foolish was to form
>>>> any actual rebuttal.
>>>> --
>>>> Copyright 2022 Pete Olcott
>>>>
>>>> "Talent hits a target no one else can hit;
>>>> Genius hits a target no one else can see."
>>>> Arthur Schopenhauer
>>>
>>> You already verified the fact that H(P,P) will be in an infinite recursive call
>>> (thus, undecidable). Why you say H(P,P)==false (or true)?
>> You might make a wild guess like this if you make sure to hardly pay
>> attention. When you actually pay close attention and carefully study my
>> paper it is very easy to see that H sees the same infinitely repeating
>> pattern that we see, thus can abort its simulation and reject its input.
>> Begin Local Halt Decider Simulation
>>
>> machine stack stack machine assembly
>> address address data code language
>> ======== ======== ======== ========= =============
>> ...[000009d6][00211368][0021136c] 55 push ebp // enter P
>> ...[000009d7][00211368][0021136c] 8bec mov ebp,esp
>> ...[000009d9][00211368][0021136c] 8b4508 mov eax,[ebp+08]
>> ...[000009dc][00211364][000009d6] 50 push eax // Push P
>> ...[000009dd][00211364][000009d6] 8b4d08 mov ecx,[ebp+08]
>> ...[000009e0][00211360][000009d6] 51 push ecx // Push P
>> ...[000009e1][0021135c][000009e6] e840feffff call 00000826 // Call H
>> ...[000009d6][0025bd90][0025bd94] 55 push ebp // enter P
>> ...[000009d7][0025bd90][0025bd94] 8bec mov ebp,esp
>> ...[000009d9][0025bd90][0025bd94] 8b4508 mov eax,[ebp+08]
>> ...[000009dc][0025bd8c][000009d6] 50 push eax // Push P
>> ...[000009dd][0025bd8c][000009d6] 8b4d08 mov ecx,[ebp+08]
>> ...[000009e0][0025bd88][000009d6] 51 push ecx // Push P
>> ...[000009e1][0025bd84][000009e6] e840feffff call 00000826 // Call H
>> Local Halt Decider: Infinite Recursion Detected Simulation Stopped
>> 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
>
> "Local Halt Decider: Infinite Recursion Detected Simulation Stopped" means
> your x86utm emulator has encountered an infinite recursive call.
> This is referred to as "undecidable". This is the fact.

So you are saying that after H makes the correct halt status decision
that this correct halt status decision is impossible to make.

That is just like my example a smashing a Boston cream pie in your face
and while this pie drips from your face you deny that the pie exists.

--
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: All my reviewers expect a halt decider to have psychic power

<97d83870-8f3c-4e54-918c-dac850abce3cn@googlegroups.com>

 copy mid

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

 copy link   Newsgroups: comp.theory
X-Received: by 2002:a37:9ad5:0:b0:69e:8c03:7e0 with SMTP id c204-20020a379ad5000000b0069e8c0307e0mr5925612qke.747.1650734954611;
Sat, 23 Apr 2022 10:29:14 -0700 (PDT)
X-Received: by 2002:a05:6902:1101:b0:645:f11:c83f with SMTP id
o1-20020a056902110100b006450f11c83fmr10357555ybu.114.1650734954364; Sat, 23
Apr 2022 10:29:14 -0700 (PDT)
Path: i2pn2.org!i2pn.org!weretis.net!feeder6.news.weretis.net!news.misty.com!border2.nntp.dca1.giganews.com!nntp.giganews.com!news-out.google.com!nntp.google.com!postnews.google.com!google-groups.googlegroups.com!not-for-mail
Newsgroups: comp.theory
Date: Sat, 23 Apr 2022 10:29:14 -0700 (PDT)
In-Reply-To: <3cWdnSN3ZITNqPn_nZ2dnUU7_8xh4p2d@giganews.com>
Injection-Info: google-groups.googlegroups.com; posting-host=58.115.187.102; posting-account=QJ9iEwoAAACyjkKjQAWQOwSEULNvZZkc
NNTP-Posting-Host: 58.115.187.102
References: <9sudne4_G7qNj_n_nZ2dnUU7_83NnZ2d@giganews.com>
<a9db8e82-955f-48d1-98c9-a4a529b64e56n@googlegroups.com> <7emdnUtkBq8lvvn_nZ2dnUU7_8zNnZ2d@giganews.com>
<ae21ba1f-e4e2-432b-a274-2d6319af57bdn@googlegroups.com> <mfmdnYqt3Ys1t_n_nZ2dnUU7_83NnZ2d@giganews.com>
<90544d3f-8d36-4d70-8951-45342b939a06n@googlegroups.com> <JY2dndGxr5I0s_n_nZ2dnUU7_83NnZ2d@giganews.com>
<5f5837f9-279a-4d02-8d54-18e604a8496an@googlegroups.com> <3cWdnSN3ZITNqPn_nZ2dnUU7_8xh4p2d@giganews.com>
User-Agent: G2/1.0
MIME-Version: 1.0
Message-ID: <97d83870-8f3c-4e54-918c-dac850abce3cn@googlegroups.com>
Subject: Re: All my reviewers expect a halt decider to have psychic power
From: wyni...@gmail.com (wij)
Injection-Date: Sat, 23 Apr 2022 17:29:14 +0000
Content-Type: text/plain; charset="UTF-8"
Lines: 97
 by: wij - Sat, 23 Apr 2022 17:29 UTC

On Sunday, 24 April 2022 at 01:20:23 UTC+8, olcott wrote:
> On 4/23/2022 12:15 PM, wij wrote:
> > On Sunday, 24 April 2022 at 00:52:00 UTC+8, olcott wrote:
> >> On 4/23/2022 11:43 AM, wij wrote:
> >>> On Sunday, 24 April 2022 at 00:34:55 UTC+8, olcott wrote:
> >>>> On 4/23/2022 11:29 AM, wij wrote:
> >>>>> On Sunday, 24 April 2022 at 00:05:19 UTC+8, olcott wrote:
> >>>>>> On 4/23/2022 10:58 AM, wij wrote:
> >>>>>>> On Saturday, 23 April 2022 at 22:49:59 UTC+8, olcott wrote:
> >>>>>>>> All of my reviewers expect H(P,P) to compute the halt status of P(P),
> >>>>>>>> yet the behavior specified by the input to H(P,P) is not the same as the
> >>>>>>>> behavior specified by P(P).
> >>>>>>>
> >>>>>>> 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
> >>>>>>> https://en.wikipedia.org/wiki/Halting_problem
> >>>>>>>
> >>>>>>> If using this common concept, the halting decider H, when given an argument P
> >>>>>>> (or P P), is supposed to answer whether P(P) will halt or not. This is a very
> >>>>>>> simple, easy idea to understand even for teenager students.
> >>>>>>>
> >>>>>> When this very simple idea is very rigorously examined (as it is in my
> >>>>>> paper) one sees that this requires the halt decider to be a mind reader
> >>>>>> and compute the halt status other than the actual halt status specified
> >>>>>> by its actual input.
> >>>>>
> >>>>> Your wording/interpretations/paper change all the time. No idea what this new
> >>>>> excuse 'mind reader' might mean. As said, the Halting Problem is very simple
> >>>>> and intuitive.
> >>>>> H should be a decider that computes the actual halt status of P(P). P is the
> >>>>> H's actual argument input.
> >>>>> I expect you might try to find some bugs of those descriptions to rephrasing it
> >>>>> in your favor. But, what would be the point? What is the usefulness of POOP?
> >>>> Yet when you carefully examine my paper:
> >>>> Anyone that is an expert in the C programming language, the x86
> >>>> programming language, exactly how C translates into x86 and what an x86
> >>>> processor emulator is can easily verify that the correctly simulated
> >>>> input to H(P,P) by H specifies a non-halting sequence of configurations.
> >>>> Halting problem undecidability and infinitely nested simulation (V5)
> >>>>
> >>>> https://www.researchgate.net/publication/359984584_Halting_problem_undecidability_and_infinitely_nested_simulation_V5
> >>>> Simply ignoring the verified facts is a ridiculously foolish was to form
> >>>> any actual rebuttal.
> >>>> --
> >>>> Copyright 2022 Pete Olcott
> >>>>
> >>>> "Talent hits a target no one else can hit;
> >>>> Genius hits a target no one else can see."
> >>>> Arthur Schopenhauer
> >>>
> >>> You already verified the fact that H(P,P) will be in an infinite recursive call
> >>> (thus, undecidable). Why you say H(P,P)==false (or true)?
> >> You might make a wild guess like this if you make sure to hardly pay
> >> attention. When you actually pay close attention and carefully study my
> >> paper it is very easy to see that H sees the same infinitely repeating
> >> pattern that we see, thus can abort its simulation and reject its input.
> >> Begin Local Halt Decider Simulation
> >>
> >> machine stack stack machine assembly
> >> address address data code language
> >> ======== ======== ======== ========= =============
> >> ...[000009d6][00211368][0021136c] 55 push ebp // enter P
> >> ...[000009d7][00211368][0021136c] 8bec mov ebp,esp
> >> ...[000009d9][00211368][0021136c] 8b4508 mov eax,[ebp+08]
> >> ...[000009dc][00211364][000009d6] 50 push eax // Push P
> >> ...[000009dd][00211364][000009d6] 8b4d08 mov ecx,[ebp+08]
> >> ...[000009e0][00211360][000009d6] 51 push ecx // Push P
> >> ...[000009e1][0021135c][000009e6] e840feffff call 00000826 // Call H
> >> ...[000009d6][0025bd90][0025bd94] 55 push ebp // enter P
> >> ...[000009d7][0025bd90][0025bd94] 8bec mov ebp,esp
> >> ...[000009d9][0025bd90][0025bd94] 8b4508 mov eax,[ebp+08]
> >> ...[000009dc][0025bd8c][000009d6] 50 push eax // Push P
> >> ...[000009dd][0025bd8c][000009d6] 8b4d08 mov ecx,[ebp+08]
> >> ...[000009e0][0025bd88][000009d6] 51 push ecx // Push P
> >> ...[000009e1][0025bd84][000009e6] e840feffff call 00000826 // Call H
> >> Local Halt Decider: Infinite Recursion Detected Simulation Stopped
> >> 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
> >
> > "Local Halt Decider: Infinite Recursion Detected Simulation Stopped" means
> > your x86utm emulator has encountered an infinite recursive call.
> > This is referred to as "undecidable". This is the fact.
> So you are saying that after H makes the correct halt status decision
> that this correct halt status decision is impossible to make.
>
> That is just like my example a smashing a Boston cream pie in your face
> and while this pie drips from your face you deny that the pie exists.

Your H did not show 'correct decision' but 'unreachable' (exactly what the HP says).

This is like "0.999..." (or repeating decimal) problems: Infinite repeating
simply means INFINITE repeating. Please, respect what it is.

Re: All my reviewers expect a halt decider to have psychic power

<jJW8K.630304$LN2.454235@fx13.iad>

 copy mid

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

 copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!aioe.org!feeder1.feed.usenet.farm!feed.usenet.farm!peer03.ams4!peer.am4.highwinds-media.com!peer02.iad!feed-me.highwinds-media.com!news.highwinds-media.com!fx13.iad.POSTED!not-for-mail
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:91.0)
Gecko/20100101 Thunderbird/91.8.1
Subject: Re: All my reviewers expect a halt decider to have psychic power
Content-Language: en-US
Newsgroups: comp.theory
References: <9sudne4_G7qNj_n_nZ2dnUU7_83NnZ2d@giganews.com>
<a9db8e82-955f-48d1-98c9-a4a529b64e56n@googlegroups.com>
<7emdnUtkBq8lvvn_nZ2dnUU7_8zNnZ2d@giganews.com>
<ae21ba1f-e4e2-432b-a274-2d6319af57bdn@googlegroups.com>
<mfmdnYqt3Ys1t_n_nZ2dnUU7_83NnZ2d@giganews.com>
<90544d3f-8d36-4d70-8951-45342b939a06n@googlegroups.com>
<JY2dndGxr5I0s_n_nZ2dnUU7_83NnZ2d@giganews.com>
<5f5837f9-279a-4d02-8d54-18e604a8496an@googlegroups.com>
<3cWdnSN3ZITNqPn_nZ2dnUU7_8xh4p2d@giganews.com>
From: Rich...@Damon-Family.org (Richard Damon)
In-Reply-To: <3cWdnSN3ZITNqPn_nZ2dnUU7_8xh4p2d@giganews.com>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 7bit
Lines: 126
Message-ID: <jJW8K.630304$LN2.454235@fx13.iad>
X-Complaints-To: abuse@easynews.com
Organization: Forte - www.forteinc.com
X-Complaints-Info: Please be sure to forward a copy of ALL headers otherwise we will be unable to process your complaint properly.
Date: Sat, 23 Apr 2022 13:30:55 -0400
X-Received-Bytes: 7259
 by: Richard Damon - Sat, 23 Apr 2022 17:30 UTC

On 4/23/22 1:20 PM, olcott wrote:
> On 4/23/2022 12:15 PM, wij wrote:
>> On Sunday, 24 April 2022 at 00:52:00 UTC+8, olcott wrote:
>>> On 4/23/2022 11:43 AM, wij wrote:
>>>> On Sunday, 24 April 2022 at 00:34:55 UTC+8, olcott wrote:
>>>>> On 4/23/2022 11:29 AM, wij wrote:
>>>>>> On Sunday, 24 April 2022 at 00:05:19 UTC+8, olcott wrote:
>>>>>>> On 4/23/2022 10:58 AM, wij wrote:
>>>>>>>> On Saturday, 23 April 2022 at 22:49:59 UTC+8, olcott wrote:
>>>>>>>>> All of my reviewers expect H(P,P) to compute the halt status of
>>>>>>>>> P(P),
>>>>>>>>> yet the behavior specified by the input to H(P,P) is not the
>>>>>>>>> same as the
>>>>>>>>> behavior specified by P(P).
>>>>>>>>
>>>>>>>> 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
>>>>>>>> https://en.wikipedia.org/wiki/Halting_problem
>>>>>>>>
>>>>>>>> If using this common concept, the halting decider H, when given
>>>>>>>> an argument P
>>>>>>>> (or P P), is supposed to answer whether P(P) will halt or not.
>>>>>>>> This is a very
>>>>>>>> simple, easy idea to understand even for teenager students.
>>>>>>>>
>>>>>>> When this very simple idea is very rigorously examined (as it is
>>>>>>> in my
>>>>>>> paper) one sees that this requires the halt decider to be a mind
>>>>>>> reader
>>>>>>> and compute the halt status other than the actual halt status
>>>>>>> specified
>>>>>>> by its actual input.
>>>>>>
>>>>>> Your wording/interpretations/paper change all the time. No idea
>>>>>> what this new
>>>>>> excuse 'mind reader' might mean. As said, the Halting Problem is
>>>>>> very simple
>>>>>> and intuitive.
>>>>>> H should be a decider that computes the actual halt status of
>>>>>> P(P). P is the
>>>>>> H's actual argument input.
>>>>>> I expect you might try to find some bugs of those descriptions to
>>>>>> rephrasing it
>>>>>> in your favor. But, what would be the point? What is the
>>>>>> usefulness of POOP?
>>>>> Yet when you carefully examine my paper:
>>>>> Anyone that is an expert in the C programming language, the x86
>>>>> programming language, exactly how C translates into x86 and what an
>>>>> x86
>>>>> processor emulator is can easily verify that the correctly simulated
>>>>> input to H(P,P) by H specifies a non-halting sequence of
>>>>> configurations.
>>>>> Halting problem undecidability and infinitely nested simulation (V5)
>>>>>
>>>>> https://www.researchgate.net/publication/359984584_Halting_problem_undecidability_and_infinitely_nested_simulation_V5
>>>>>
>>>>> Simply ignoring the verified facts is a ridiculously foolish was to
>>>>> form
>>>>> any actual rebuttal.
>>>>> --
>>>>> Copyright 2022 Pete Olcott
>>>>>
>>>>> "Talent hits a target no one else can hit;
>>>>> Genius hits a target no one else can see."
>>>>> Arthur Schopenhauer
>>>>
>>>> You already verified the fact that H(P,P) will be in an infinite
>>>> recursive call
>>>> (thus, undecidable). Why you say H(P,P)==false (or true)?
>>> You might make a wild guess like this if you make sure to hardly pay
>>> attention. When you actually pay close attention and carefully study my
>>> paper it is very easy to see that H sees the same infinitely repeating
>>> pattern that we see, thus can abort its simulation and reject its input.
>>> Begin Local Halt Decider Simulation
>>>
>>> machine stack stack machine assembly
>>> address address data code language
>>> ======== ======== ======== ========= =============
>>> ...[000009d6][00211368][0021136c] 55 push ebp // enter P
>>> ...[000009d7][00211368][0021136c] 8bec mov ebp,esp
>>> ...[000009d9][00211368][0021136c] 8b4508 mov eax,[ebp+08]
>>> ...[000009dc][00211364][000009d6] 50 push eax // Push P
>>> ...[000009dd][00211364][000009d6] 8b4d08 mov ecx,[ebp+08]
>>> ...[000009e0][00211360][000009d6] 51 push ecx // Push P
>>> ...[000009e1][0021135c][000009e6] e840feffff call 00000826 // Call H
>>> ...[000009d6][0025bd90][0025bd94] 55 push ebp // enter P
>>> ...[000009d7][0025bd90][0025bd94] 8bec mov ebp,esp
>>> ...[000009d9][0025bd90][0025bd94] 8b4508 mov eax,[ebp+08]
>>> ...[000009dc][0025bd8c][000009d6] 50 push eax // Push P
>>> ...[000009dd][0025bd8c][000009d6] 8b4d08 mov ecx,[ebp+08]
>>> ...[000009e0][0025bd88][000009d6] 51 push ecx // Push P
>>> ...[000009e1][0025bd84][000009e6] e840feffff call 00000826 // Call H
>>> Local Halt Decider: Infinite Recursion Detected Simulation Stopped
>>> 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
>>
>> "Local Halt Decider: Infinite Recursion Detected Simulation Stopped"
>> means
>> your x86utm emulator has encountered an infinite recursive call.
>> This is referred to as "undecidable". This is the fact.
>
> So you are saying that after H makes the correct halt status decision
> that this correct halt status decision is impossible to make.
>
> That is just like my example a smashing a Boston cream pie in your face
> and while this pie drips from your face you deny that the pie exists.
>

Nope, it is just a fact that if H makes that decision that a CORRECT
simulation of the input shows that it will see the H in P return that
answer and that P will Halt, thus H was incorrect.

Only by INCORRECT using an INCORRECT simulation do you INCORRECTLY
determine that the input is INCORRECTLY non-halting, when it is IN FACT
Halting.

Re: All my reviewers expect a halt decider to have psychic power

<U-qdnTrGkI1xpfn_nZ2dnUU7_8xh4p2d@giganews.com>

 copy mid

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

 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: Sat, 23 Apr 2022 12:35:40 -0500
Date: Sat, 23 Apr 2022 12:35:40 -0500
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:91.0) Gecko/20100101
Thunderbird/91.8.1
Subject: Re: All my reviewers expect a halt decider to have psychic power
Content-Language: en-US
Newsgroups: comp.theory
References: <9sudne4_G7qNj_n_nZ2dnUU7_83NnZ2d@giganews.com>
<a9db8e82-955f-48d1-98c9-a4a529b64e56n@googlegroups.com>
<7emdnUtkBq8lvvn_nZ2dnUU7_8zNnZ2d@giganews.com>
<ae21ba1f-e4e2-432b-a274-2d6319af57bdn@googlegroups.com>
<mfmdnYqt3Ys1t_n_nZ2dnUU7_83NnZ2d@giganews.com>
<90544d3f-8d36-4d70-8951-45342b939a06n@googlegroups.com>
<JY2dndGxr5I0s_n_nZ2dnUU7_83NnZ2d@giganews.com>
<5f5837f9-279a-4d02-8d54-18e604a8496an@googlegroups.com>
<3cWdnSN3ZITNqPn_nZ2dnUU7_8xh4p2d@giganews.com>
<97d83870-8f3c-4e54-918c-dac850abce3cn@googlegroups.com>
From: NoO...@NoWhere.com (olcott)
In-Reply-To: <97d83870-8f3c-4e54-918c-dac850abce3cn@googlegroups.com>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 7bit
Message-ID: <U-qdnTrGkI1xpfn_nZ2dnUU7_8xh4p2d@giganews.com>
Lines: 111
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-55hHbLpDBFOi0PR/ACRnbPfvnPEuKxSkxRAMoLA9J7UM0AxWm2iA6mHqXajUrYKZvlGLHY4qaOSQNmt!24FVAuyFNkUl0O4ze5h9AbGD5dbaSjC1iepY7x/NDBZC1cHoGP3RxNhTVrVVQ4z3IyJEJ8wNvMzu
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: 7786
 by: olcott - Sat, 23 Apr 2022 17:35 UTC

On 4/23/2022 12:29 PM, wij wrote:
> On Sunday, 24 April 2022 at 01:20:23 UTC+8, olcott wrote:
>> On 4/23/2022 12:15 PM, wij wrote:
>>> On Sunday, 24 April 2022 at 00:52:00 UTC+8, olcott wrote:
>>>> On 4/23/2022 11:43 AM, wij wrote:
>>>>> On Sunday, 24 April 2022 at 00:34:55 UTC+8, olcott wrote:
>>>>>> On 4/23/2022 11:29 AM, wij wrote:
>>>>>>> On Sunday, 24 April 2022 at 00:05:19 UTC+8, olcott wrote:
>>>>>>>> On 4/23/2022 10:58 AM, wij wrote:
>>>>>>>>> On Saturday, 23 April 2022 at 22:49:59 UTC+8, olcott wrote:
>>>>>>>>>> All of my reviewers expect H(P,P) to compute the halt status of P(P),
>>>>>>>>>> yet the behavior specified by the input to H(P,P) is not the same as the
>>>>>>>>>> behavior specified by P(P).
>>>>>>>>>
>>>>>>>>> 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
>>>>>>>>> https://en.wikipedia.org/wiki/Halting_problem
>>>>>>>>>
>>>>>>>>> If using this common concept, the halting decider H, when given an argument P
>>>>>>>>> (or P P), is supposed to answer whether P(P) will halt or not. This is a very
>>>>>>>>> simple, easy idea to understand even for teenager students.
>>>>>>>>>
>>>>>>>> When this very simple idea is very rigorously examined (as it is in my
>>>>>>>> paper) one sees that this requires the halt decider to be a mind reader
>>>>>>>> and compute the halt status other than the actual halt status specified
>>>>>>>> by its actual input.
>>>>>>>
>>>>>>> Your wording/interpretations/paper change all the time. No idea what this new
>>>>>>> excuse 'mind reader' might mean. As said, the Halting Problem is very simple
>>>>>>> and intuitive.
>>>>>>> H should be a decider that computes the actual halt status of P(P). P is the
>>>>>>> H's actual argument input.
>>>>>>> I expect you might try to find some bugs of those descriptions to rephrasing it
>>>>>>> in your favor. But, what would be the point? What is the usefulness of POOP?
>>>>>> Yet when you carefully examine my paper:
>>>>>> Anyone that is an expert in the C programming language, the x86
>>>>>> programming language, exactly how C translates into x86 and what an x86
>>>>>> processor emulator is can easily verify that the correctly simulated
>>>>>> input to H(P,P) by H specifies a non-halting sequence of configurations.
>>>>>> Halting problem undecidability and infinitely nested simulation (V5)
>>>>>>
>>>>>> https://www.researchgate.net/publication/359984584_Halting_problem_undecidability_and_infinitely_nested_simulation_V5
>>>>>> Simply ignoring the verified facts is a ridiculously foolish was to form
>>>>>> any actual rebuttal.
>>>>>> --
>>>>>> Copyright 2022 Pete Olcott
>>>>>>
>>>>>> "Talent hits a target no one else can hit;
>>>>>> Genius hits a target no one else can see."
>>>>>> Arthur Schopenhauer
>>>>>
>>>>> You already verified the fact that H(P,P) will be in an infinite recursive call
>>>>> (thus, undecidable). Why you say H(P,P)==false (or true)?
>>>> You might make a wild guess like this if you make sure to hardly pay
>>>> attention. When you actually pay close attention and carefully study my
>>>> paper it is very easy to see that H sees the same infinitely repeating
>>>> pattern that we see, thus can abort its simulation and reject its input.
>>>> Begin Local Halt Decider Simulation
>>>>
>>>> machine stack stack machine assembly
>>>> address address data code language
>>>> ======== ======== ======== ========= =============
>>>> ...[000009d6][00211368][0021136c] 55 push ebp // enter P
>>>> ...[000009d7][00211368][0021136c] 8bec mov ebp,esp
>>>> ...[000009d9][00211368][0021136c] 8b4508 mov eax,[ebp+08]
>>>> ...[000009dc][00211364][000009d6] 50 push eax // Push P
>>>> ...[000009dd][00211364][000009d6] 8b4d08 mov ecx,[ebp+08]
>>>> ...[000009e0][00211360][000009d6] 51 push ecx // Push P
>>>> ...[000009e1][0021135c][000009e6] e840feffff call 00000826 // Call H
>>>> ...[000009d6][0025bd90][0025bd94] 55 push ebp // enter P
>>>> ...[000009d7][0025bd90][0025bd94] 8bec mov ebp,esp
>>>> ...[000009d9][0025bd90][0025bd94] 8b4508 mov eax,[ebp+08]
>>>> ...[000009dc][0025bd8c][000009d6] 50 push eax // Push P
>>>> ...[000009dd][0025bd8c][000009d6] 8b4d08 mov ecx,[ebp+08]
>>>> ...[000009e0][0025bd88][000009d6] 51 push ecx // Push P
>>>> ...[000009e1][0025bd84][000009e6] e840feffff call 00000826 // Call H
>>>> Local Halt Decider: Infinite Recursion Detected Simulation Stopped
>>>> 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
>>>
>>> "Local Halt Decider: Infinite Recursion Detected Simulation Stopped" means
>>> your x86utm emulator has encountered an infinite recursive call.
>>> This is referred to as "undecidable". This is the fact.
>> So you are saying that after H makes the correct halt status decision
>> that this correct halt status decision is impossible to make.
>>
>> That is just like my example a smashing a Boston cream pie in your face
>> and while this pie drips from your face you deny that the pie exists.
>
> Your H did not show 'correct decision' but 'unreachable' (exactly what the HP says).
>
> This is like "0.999..." (or repeating decimal) problems: Infinite repeating
> simply means INFINITE repeating. Please, respect what it is.

H simulates its input one x86 instruction at a time using an x86
emulator. As soon as H(P,P) detects the same infinitely repeating
pattern (that we can all see), it aborts its simulation and rejects its
input.

--
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: All my reviewers expect a halt decider to have psychic power

<70970a80-11a1-4481-a082-6fcea2555162n@googlegroups.com>

 copy mid

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

 copy link   Newsgroups: comp.theory
X-Received: by 2002:ac8:6ce:0:b0:2f0:29dd:bbc5 with SMTP id j14-20020ac806ce000000b002f029ddbbc5mr7371200qth.216.1650735744253;
Sat, 23 Apr 2022 10:42:24 -0700 (PDT)
X-Received: by 2002:a5b:6c1:0:b0:633:b5c7:b9b7 with SMTP id
r1-20020a5b06c1000000b00633b5c7b9b7mr9494311ybq.67.1650735743975; Sat, 23 Apr
2022 10:42:23 -0700 (PDT)
Path: i2pn2.org!i2pn.org!weretis.net!feeder6.news.weretis.net!news.misty.com!border2.nntp.dca1.giganews.com!nntp.giganews.com!news-out.google.com!nntp.google.com!postnews.google.com!google-groups.googlegroups.com!not-for-mail
Newsgroups: comp.theory
Date: Sat, 23 Apr 2022 10:42:23 -0700 (PDT)
In-Reply-To: <U-qdnTrGkI1xpfn_nZ2dnUU7_8xh4p2d@giganews.com>
Injection-Info: google-groups.googlegroups.com; posting-host=58.115.187.102; posting-account=QJ9iEwoAAACyjkKjQAWQOwSEULNvZZkc
NNTP-Posting-Host: 58.115.187.102
References: <9sudne4_G7qNj_n_nZ2dnUU7_83NnZ2d@giganews.com>
<a9db8e82-955f-48d1-98c9-a4a529b64e56n@googlegroups.com> <7emdnUtkBq8lvvn_nZ2dnUU7_8zNnZ2d@giganews.com>
<ae21ba1f-e4e2-432b-a274-2d6319af57bdn@googlegroups.com> <mfmdnYqt3Ys1t_n_nZ2dnUU7_83NnZ2d@giganews.com>
<90544d3f-8d36-4d70-8951-45342b939a06n@googlegroups.com> <JY2dndGxr5I0s_n_nZ2dnUU7_83NnZ2d@giganews.com>
<5f5837f9-279a-4d02-8d54-18e604a8496an@googlegroups.com> <3cWdnSN3ZITNqPn_nZ2dnUU7_8xh4p2d@giganews.com>
<97d83870-8f3c-4e54-918c-dac850abce3cn@googlegroups.com> <U-qdnTrGkI1xpfn_nZ2dnUU7_8xh4p2d@giganews.com>
User-Agent: G2/1.0
MIME-Version: 1.0
Message-ID: <70970a80-11a1-4481-a082-6fcea2555162n@googlegroups.com>
Subject: Re: All my reviewers expect a halt decider to have psychic power
From: wyni...@gmail.com (wij)
Injection-Date: Sat, 23 Apr 2022 17:42:24 +0000
Content-Type: text/plain; charset="UTF-8"
Lines: 111
 by: wij - Sat, 23 Apr 2022 17:42 UTC

On Sunday, 24 April 2022 at 01:35:47 UTC+8, olcott wrote:
> On 4/23/2022 12:29 PM, wij wrote:
> > On Sunday, 24 April 2022 at 01:20:23 UTC+8, olcott wrote:
> >> On 4/23/2022 12:15 PM, wij wrote:
> >>> On Sunday, 24 April 2022 at 00:52:00 UTC+8, olcott wrote:
> >>>> On 4/23/2022 11:43 AM, wij wrote:
> >>>>> On Sunday, 24 April 2022 at 00:34:55 UTC+8, olcott wrote:
> >>>>>> On 4/23/2022 11:29 AM, wij wrote:
> >>>>>>> On Sunday, 24 April 2022 at 00:05:19 UTC+8, olcott wrote:
> >>>>>>>> On 4/23/2022 10:58 AM, wij wrote:
> >>>>>>>>> On Saturday, 23 April 2022 at 22:49:59 UTC+8, olcott wrote:
> >>>>>>>>>> All of my reviewers expect H(P,P) to compute the halt status of P(P),
> >>>>>>>>>> yet the behavior specified by the input to H(P,P) is not the same as the
> >>>>>>>>>> behavior specified by P(P).
> >>>>>>>>>
> >>>>>>>>> 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
> >>>>>>>>> https://en.wikipedia.org/wiki/Halting_problem
> >>>>>>>>>
> >>>>>>>>> If using this common concept, the halting decider H, when given an argument P
> >>>>>>>>> (or P P), is supposed to answer whether P(P) will halt or not. This is a very
> >>>>>>>>> simple, easy idea to understand even for teenager students.
> >>>>>>>>>
> >>>>>>>> When this very simple idea is very rigorously examined (as it is in my
> >>>>>>>> paper) one sees that this requires the halt decider to be a mind reader
> >>>>>>>> and compute the halt status other than the actual halt status specified
> >>>>>>>> by its actual input.
> >>>>>>>
> >>>>>>> Your wording/interpretations/paper change all the time. No idea what this new
> >>>>>>> excuse 'mind reader' might mean. As said, the Halting Problem is very simple
> >>>>>>> and intuitive.
> >>>>>>> H should be a decider that computes the actual halt status of P(P). P is the
> >>>>>>> H's actual argument input.
> >>>>>>> I expect you might try to find some bugs of those descriptions to rephrasing it
> >>>>>>> in your favor. But, what would be the point? What is the usefulness of POOP?
> >>>>>> Yet when you carefully examine my paper:
> >>>>>> Anyone that is an expert in the C programming language, the x86
> >>>>>> programming language, exactly how C translates into x86 and what an x86
> >>>>>> processor emulator is can easily verify that the correctly simulated
> >>>>>> input to H(P,P) by H specifies a non-halting sequence of configurations.
> >>>>>> Halting problem undecidability and infinitely nested simulation (V5)
> >>>>>>
> >>>>>> https://www.researchgate.net/publication/359984584_Halting_problem_undecidability_and_infinitely_nested_simulation_V5
> >>>>>> Simply ignoring the verified facts is a ridiculously foolish was to form
> >>>>>> any actual rebuttal.
> >>>>>> --
> >>>>>> Copyright 2022 Pete Olcott
> >>>>>>
> >>>>>> "Talent hits a target no one else can hit;
> >>>>>> Genius hits a target no one else can see."
> >>>>>> Arthur Schopenhauer
> >>>>>
> >>>>> You already verified the fact that H(P,P) will be in an infinite recursive call
> >>>>> (thus, undecidable). Why you say H(P,P)==false (or true)?
> >>>> You might make a wild guess like this if you make sure to hardly pay
> >>>> attention. When you actually pay close attention and carefully study my
> >>>> paper it is very easy to see that H sees the same infinitely repeating
> >>>> pattern that we see, thus can abort its simulation and reject its input.
> >>>> Begin Local Halt Decider Simulation
> >>>>
> >>>> machine stack stack machine assembly
> >>>> address address data code language
> >>>> ======== ======== ======== ========= =============
> >>>> ...[000009d6][00211368][0021136c] 55 push ebp // enter P
> >>>> ...[000009d7][00211368][0021136c] 8bec mov ebp,esp
> >>>> ...[000009d9][00211368][0021136c] 8b4508 mov eax,[ebp+08]
> >>>> ...[000009dc][00211364][000009d6] 50 push eax // Push P
> >>>> ...[000009dd][00211364][000009d6] 8b4d08 mov ecx,[ebp+08]
> >>>> ...[000009e0][00211360][000009d6] 51 push ecx // Push P
> >>>> ...[000009e1][0021135c][000009e6] e840feffff call 00000826 // Call H
> >>>> ...[000009d6][0025bd90][0025bd94] 55 push ebp // enter P
> >>>> ...[000009d7][0025bd90][0025bd94] 8bec mov ebp,esp
> >>>> ...[000009d9][0025bd90][0025bd94] 8b4508 mov eax,[ebp+08]
> >>>> ...[000009dc][0025bd8c][000009d6] 50 push eax // Push P
> >>>> ...[000009dd][0025bd8c][000009d6] 8b4d08 mov ecx,[ebp+08]
> >>>> ...[000009e0][0025bd88][000009d6] 51 push ecx // Push P
> >>>> ...[000009e1][0025bd84][000009e6] e840feffff call 00000826 // Call H
> >>>> Local Halt Decider: Infinite Recursion Detected Simulation Stopped
> >>>> 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
> >>>
> >>> "Local Halt Decider: Infinite Recursion Detected Simulation Stopped" means
> >>> your x86utm emulator has encountered an infinite recursive call.
> >>> This is referred to as "undecidable". This is the fact.
> >> So you are saying that after H makes the correct halt status decision
> >> that this correct halt status decision is impossible to make.
> >>
> >> That is just like my example a smashing a Boston cream pie in your face
> >> and while this pie drips from your face you deny that the pie exists.
> >
> > Your H did not show 'correct decision' but 'unreachable' (exactly what the HP says).
> >
> > This is like "0.999..." (or repeating decimal) problems: Infinite repeating
> > simply means INFINITE repeating. Please, respect what it is.
> H simulates its input one x86 instruction at a time using an x86
> emulator. As soon as H(P,P) detects the same infinitely repeating
> pattern (that we can all see), it aborts its simulation and rejects its
> input.
> --
> Copyright 2022 Pete Olcott
>
> "Talent hits a target no one else can hit;
> Genius hits a target no one else can see."
> Arthur Schopenhauer

Your H shows 'undecidable'. There is no branching codes shown.

Re: All my reviewers expect a halt decider to have psychic power

<a6ydnWoUeOt8oPn_nZ2dnUU7_81g4p2d@giganews.com>

 copy mid

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

 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: Sat, 23 Apr 2022 12:56:49 -0500
Date: Sat, 23 Apr 2022 12:56:48 -0500
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:91.0) Gecko/20100101
Thunderbird/91.8.1
Subject: Re: All my reviewers expect a halt decider to have psychic power
Content-Language: en-US
Newsgroups: comp.theory
References: <9sudne4_G7qNj_n_nZ2dnUU7_83NnZ2d@giganews.com>
<a9db8e82-955f-48d1-98c9-a4a529b64e56n@googlegroups.com>
<7emdnUtkBq8lvvn_nZ2dnUU7_8zNnZ2d@giganews.com>
<ae21ba1f-e4e2-432b-a274-2d6319af57bdn@googlegroups.com>
<mfmdnYqt3Ys1t_n_nZ2dnUU7_83NnZ2d@giganews.com>
<90544d3f-8d36-4d70-8951-45342b939a06n@googlegroups.com>
<JY2dndGxr5I0s_n_nZ2dnUU7_83NnZ2d@giganews.com>
<5f5837f9-279a-4d02-8d54-18e604a8496an@googlegroups.com>
<3cWdnSN3ZITNqPn_nZ2dnUU7_8xh4p2d@giganews.com>
<97d83870-8f3c-4e54-918c-dac850abce3cn@googlegroups.com>
<U-qdnTrGkI1xpfn_nZ2dnUU7_8xh4p2d@giganews.com>
<70970a80-11a1-4481-a082-6fcea2555162n@googlegroups.com>
From: NoO...@NoWhere.com (olcott)
In-Reply-To: <70970a80-11a1-4481-a082-6fcea2555162n@googlegroups.com>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 7bit
Message-ID: <a6ydnWoUeOt8oPn_nZ2dnUU7_81g4p2d@giganews.com>
Lines: 127
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-wV54eFRy3a08chDNCMTtg3ut5N+nE4YpvtbUTGzwPWZAZmQsWKr7qS6pabCjh4PFjoaqhS2Pc9S1oSE!zxA9m/xTcRFGlPu/4Y65MR9ZSW6RRPh5LotFRiwQeomplSvCGVyynqaa/G8IiTZ+ljFbeMiTb0Xi
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: 8730
 by: olcott - Sat, 23 Apr 2022 17:56 UTC

On 4/23/2022 12:42 PM, wij wrote:
> On Sunday, 24 April 2022 at 01:35:47 UTC+8, olcott wrote:
>> On 4/23/2022 12:29 PM, wij wrote:
>>> On Sunday, 24 April 2022 at 01:20:23 UTC+8, olcott wrote:
>>>> On 4/23/2022 12:15 PM, wij wrote:
>>>>> On Sunday, 24 April 2022 at 00:52:00 UTC+8, olcott wrote:
>>>>>> On 4/23/2022 11:43 AM, wij wrote:
>>>>>>> On Sunday, 24 April 2022 at 00:34:55 UTC+8, olcott wrote:
>>>>>>>> On 4/23/2022 11:29 AM, wij wrote:
>>>>>>>>> On Sunday, 24 April 2022 at 00:05:19 UTC+8, olcott wrote:
>>>>>>>>>> On 4/23/2022 10:58 AM, wij wrote:
>>>>>>>>>>> On Saturday, 23 April 2022 at 22:49:59 UTC+8, olcott wrote:
>>>>>>>>>>>> All of my reviewers expect H(P,P) to compute the halt status of P(P),
>>>>>>>>>>>> yet the behavior specified by the input to H(P,P) is not the same as the
>>>>>>>>>>>> behavior specified by P(P).
>>>>>>>>>>>
>>>>>>>>>>> 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
>>>>>>>>>>> https://en.wikipedia.org/wiki/Halting_problem
>>>>>>>>>>>
>>>>>>>>>>> If using this common concept, the halting decider H, when given an argument P
>>>>>>>>>>> (or P P), is supposed to answer whether P(P) will halt or not. This is a very
>>>>>>>>>>> simple, easy idea to understand even for teenager students.
>>>>>>>>>>>
>>>>>>>>>> When this very simple idea is very rigorously examined (as it is in my
>>>>>>>>>> paper) one sees that this requires the halt decider to be a mind reader
>>>>>>>>>> and compute the halt status other than the actual halt status specified
>>>>>>>>>> by its actual input.
>>>>>>>>>
>>>>>>>>> Your wording/interpretations/paper change all the time. No idea what this new
>>>>>>>>> excuse 'mind reader' might mean. As said, the Halting Problem is very simple
>>>>>>>>> and intuitive.
>>>>>>>>> H should be a decider that computes the actual halt status of P(P). P is the
>>>>>>>>> H's actual argument input.
>>>>>>>>> I expect you might try to find some bugs of those descriptions to rephrasing it
>>>>>>>>> in your favor. But, what would be the point? What is the usefulness of POOP?
>>>>>>>> Yet when you carefully examine my paper:
>>>>>>>> Anyone that is an expert in the C programming language, the x86
>>>>>>>> programming language, exactly how C translates into x86 and what an x86
>>>>>>>> processor emulator is can easily verify that the correctly simulated
>>>>>>>> input to H(P,P) by H specifies a non-halting sequence of configurations.
>>>>>>>> Halting problem undecidability and infinitely nested simulation (V5)
>>>>>>>>
>>>>>>>> https://www.researchgate.net/publication/359984584_Halting_problem_undecidability_and_infinitely_nested_simulation_V5
>>>>>>>> Simply ignoring the verified facts is a ridiculously foolish was to form
>>>>>>>> any actual rebuttal.
>>>>>>>> --
>>>>>>>> Copyright 2022 Pete Olcott
>>>>>>>>
>>>>>>>> "Talent hits a target no one else can hit;
>>>>>>>> Genius hits a target no one else can see."
>>>>>>>> Arthur Schopenhauer
>>>>>>>
>>>>>>> You already verified the fact that H(P,P) will be in an infinite recursive call
>>>>>>> (thus, undecidable). Why you say H(P,P)==false (or true)?
>>>>>> You might make a wild guess like this if you make sure to hardly pay
>>>>>> attention. When you actually pay close attention and carefully study my
>>>>>> paper it is very easy to see that H sees the same infinitely repeating
>>>>>> pattern that we see, thus can abort its simulation and reject its input.
>>>>>> Begin Local Halt Decider Simulation
>>>>>>
>>>>>> machine stack stack machine assembly
>>>>>> address address data code language
>>>>>> ======== ======== ======== ========= =============
>>>>>> ...[000009d6][00211368][0021136c] 55 push ebp // enter P
>>>>>> ...[000009d7][00211368][0021136c] 8bec mov ebp,esp
>>>>>> ...[000009d9][00211368][0021136c] 8b4508 mov eax,[ebp+08]
>>>>>> ...[000009dc][00211364][000009d6] 50 push eax // Push P
>>>>>> ...[000009dd][00211364][000009d6] 8b4d08 mov ecx,[ebp+08]
>>>>>> ...[000009e0][00211360][000009d6] 51 push ecx // Push P
>>>>>> ...[000009e1][0021135c][000009e6] e840feffff call 00000826 // Call H
>>>>>> ...[000009d6][0025bd90][0025bd94] 55 push ebp // enter P
>>>>>> ...[000009d7][0025bd90][0025bd94] 8bec mov ebp,esp
>>>>>> ...[000009d9][0025bd90][0025bd94] 8b4508 mov eax,[ebp+08]
>>>>>> ...[000009dc][0025bd8c][000009d6] 50 push eax // Push P
>>>>>> ...[000009dd][0025bd8c][000009d6] 8b4d08 mov ecx,[ebp+08]
>>>>>> ...[000009e0][0025bd88][000009d6] 51 push ecx // Push P
>>>>>> ...[000009e1][0025bd84][000009e6] e840feffff call 00000826 // Call H
>>>>>> Local Halt Decider: Infinite Recursion Detected Simulation Stopped
>>>>>> 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
>>>>>
>>>>> "Local Halt Decider: Infinite Recursion Detected Simulation Stopped" means
>>>>> your x86utm emulator has encountered an infinite recursive call.
>>>>> This is referred to as "undecidable". This is the fact.
>>>> So you are saying that after H makes the correct halt status decision
>>>> that this correct halt status decision is impossible to make.
>>>>
>>>> That is just like my example a smashing a Boston cream pie in your face
>>>> and while this pie drips from your face you deny that the pie exists.
>>>
>>> Your H did not show 'correct decision' but 'unreachable' (exactly what the HP says).
>>>
>>> This is like "0.999..." (or repeating decimal) problems: Infinite repeating
>>> simply means INFINITE repeating. Please, respect what it is.
>> H simulates its input one x86 instruction at a time using an x86
>> emulator. As soon as H(P,P) detects the same infinitely repeating
>> pattern (that we can all see), it aborts its simulation and rejects its
>> input.
>> --
>> Copyright 2022 Pete Olcott
>>
>> "Talent hits a target no one else can hit;
>> Genius hits a target no one else can see."
>> Arthur Schopenhauer
>
> Your H shows 'undecidable'. There is no branching codes shown.

Without seeing any of the details of the 264 pages of the execution
trace of H we can verify on the basis of the x86 source code for P and
the execution trace that H derives that H does correctly simulate its
input until it detects the same infinitely repeating pattern that we all
can see.

--
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: All my reviewers expect a halt decider to have psychic power

<5d7c8fbe-8899-4a46-9f0c-e5a11081458en@googlegroups.com>

 copy mid

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

 copy link   Newsgroups: comp.theory
X-Received: by 2002:ac8:7f4d:0:b0:2f1:f967:52bd with SMTP id g13-20020ac87f4d000000b002f1f96752bdmr7174380qtk.597.1650738904573;
Sat, 23 Apr 2022 11:35:04 -0700 (PDT)
X-Received: by 2002:a25:8206:0:b0:645:88b5:e464 with SMTP id
q6-20020a258206000000b0064588b5e464mr8405888ybk.341.1650738904334; Sat, 23
Apr 2022 11:35:04 -0700 (PDT)
Path: i2pn2.org!i2pn.org!weretis.net!feeder6.news.weretis.net!news.misty.com!border2.nntp.dca1.giganews.com!nntp.giganews.com!news-out.google.com!nntp.google.com!postnews.google.com!google-groups.googlegroups.com!not-for-mail
Newsgroups: comp.theory
Date: Sat, 23 Apr 2022 11:35:04 -0700 (PDT)
In-Reply-To: <a6ydnWoUeOt8oPn_nZ2dnUU7_81g4p2d@giganews.com>
Injection-Info: google-groups.googlegroups.com; posting-host=81.143.231.9; posting-account=Dz2zqgkAAADlK5MFu78bw3ab-BRFV4Qn
NNTP-Posting-Host: 81.143.231.9
References: <9sudne4_G7qNj_n_nZ2dnUU7_83NnZ2d@giganews.com>
<a9db8e82-955f-48d1-98c9-a4a529b64e56n@googlegroups.com> <7emdnUtkBq8lvvn_nZ2dnUU7_8zNnZ2d@giganews.com>
<ae21ba1f-e4e2-432b-a274-2d6319af57bdn@googlegroups.com> <mfmdnYqt3Ys1t_n_nZ2dnUU7_83NnZ2d@giganews.com>
<90544d3f-8d36-4d70-8951-45342b939a06n@googlegroups.com> <JY2dndGxr5I0s_n_nZ2dnUU7_83NnZ2d@giganews.com>
<5f5837f9-279a-4d02-8d54-18e604a8496an@googlegroups.com> <3cWdnSN3ZITNqPn_nZ2dnUU7_8xh4p2d@giganews.com>
<97d83870-8f3c-4e54-918c-dac850abce3cn@googlegroups.com> <U-qdnTrGkI1xpfn_nZ2dnUU7_8xh4p2d@giganews.com>
<70970a80-11a1-4481-a082-6fcea2555162n@googlegroups.com> <a6ydnWoUeOt8oPn_nZ2dnUU7_81g4p2d@giganews.com>
User-Agent: G2/1.0
MIME-Version: 1.0
Message-ID: <5d7c8fbe-8899-4a46-9f0c-e5a11081458en@googlegroups.com>
Subject: Re: All my reviewers expect a halt decider to have psychic power
From: malcolm....@gmail.com (Malcolm McLean)
Injection-Date: Sat, 23 Apr 2022 18:35:04 +0000
Content-Type: text/plain; charset="UTF-8"
Lines: 129
 by: Malcolm McLean - Sat, 23 Apr 2022 18:35 UTC

On Saturday, 23 April 2022 at 18:56:56 UTC+1, olcott wrote:
> On 4/23/2022 12:42 PM, wij wrote:
> > On Sunday, 24 April 2022 at 01:35:47 UTC+8, olcott wrote:
> >> On 4/23/2022 12:29 PM, wij wrote:
> >>> On Sunday, 24 April 2022 at 01:20:23 UTC+8, olcott wrote:
> >>>> On 4/23/2022 12:15 PM, wij wrote:
> >>>>> On Sunday, 24 April 2022 at 00:52:00 UTC+8, olcott wrote:
> >>>>>> On 4/23/2022 11:43 AM, wij wrote:
> >>>>>>> On Sunday, 24 April 2022 at 00:34:55 UTC+8, olcott wrote:
> >>>>>>>> On 4/23/2022 11:29 AM, wij wrote:
> >>>>>>>>> On Sunday, 24 April 2022 at 00:05:19 UTC+8, olcott wrote:
> >>>>>>>>>> On 4/23/2022 10:58 AM, wij wrote:
> >>>>>>>>>>> On Saturday, 23 April 2022 at 22:49:59 UTC+8, olcott wrote:
> >>>>>>>>>>>> All of my reviewers expect H(P,P) to compute the halt status of P(P),
> >>>>>>>>>>>> yet the behavior specified by the input to H(P,P) is not the same as the
> >>>>>>>>>>>> behavior specified by P(P).
> >>>>>>>>>>>
> >>>>>>>>>>> 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
> >>>>>>>>>>> https://en.wikipedia.org/wiki/Halting_problem
> >>>>>>>>>>>
> >>>>>>>>>>> If using this common concept, the halting decider H, when given an argument P
> >>>>>>>>>>> (or P P), is supposed to answer whether P(P) will halt or not. This is a very
> >>>>>>>>>>> simple, easy idea to understand even for teenager students.
> >>>>>>>>>>>
> >>>>>>>>>> When this very simple idea is very rigorously examined (as it is in my
> >>>>>>>>>> paper) one sees that this requires the halt decider to be a mind reader
> >>>>>>>>>> and compute the halt status other than the actual halt status specified
> >>>>>>>>>> by its actual input.
> >>>>>>>>>
> >>>>>>>>> Your wording/interpretations/paper change all the time. No idea what this new
> >>>>>>>>> excuse 'mind reader' might mean. As said, the Halting Problem is very simple
> >>>>>>>>> and intuitive.
> >>>>>>>>> H should be a decider that computes the actual halt status of P(P). P is the
> >>>>>>>>> H's actual argument input.
> >>>>>>>>> I expect you might try to find some bugs of those descriptions to rephrasing it
> >>>>>>>>> in your favor. But, what would be the point? What is the usefulness of POOP?
> >>>>>>>> Yet when you carefully examine my paper:
> >>>>>>>> Anyone that is an expert in the C programming language, the x86
> >>>>>>>> programming language, exactly how C translates into x86 and what an x86
> >>>>>>>> processor emulator is can easily verify that the correctly simulated
> >>>>>>>> input to H(P,P) by H specifies a non-halting sequence of configurations.
> >>>>>>>> Halting problem undecidability and infinitely nested simulation (V5)
> >>>>>>>>
> >>>>>>>> https://www.researchgate.net/publication/359984584_Halting_problem_undecidability_and_infinitely_nested_simulation_V5
> >>>>>>>> Simply ignoring the verified facts is a ridiculously foolish was to form
> >>>>>>>> any actual rebuttal.
> >>>>>>>> --
> >>>>>>>> Copyright 2022 Pete Olcott
> >>>>>>>>
> >>>>>>>> "Talent hits a target no one else can hit;
> >>>>>>>> Genius hits a target no one else can see."
> >>>>>>>> Arthur Schopenhauer
> >>>>>>>
> >>>>>>> You already verified the fact that H(P,P) will be in an infinite recursive call
> >>>>>>> (thus, undecidable). Why you say H(P,P)==false (or true)?
> >>>>>> You might make a wild guess like this if you make sure to hardly pay
> >>>>>> attention. When you actually pay close attention and carefully study my
> >>>>>> paper it is very easy to see that H sees the same infinitely repeating
> >>>>>> pattern that we see, thus can abort its simulation and reject its input.
> >>>>>> Begin Local Halt Decider Simulation
> >>>>>>
> >>>>>> machine stack stack machine assembly
> >>>>>> address address data code language
> >>>>>> ======== ======== ======== ========= =============
> >>>>>> ...[000009d6][00211368][0021136c] 55 push ebp // enter P
> >>>>>> ...[000009d7][00211368][0021136c] 8bec mov ebp,esp
> >>>>>> ...[000009d9][00211368][0021136c] 8b4508 mov eax,[ebp+08]
> >>>>>> ...[000009dc][00211364][000009d6] 50 push eax // Push P
> >>>>>> ...[000009dd][00211364][000009d6] 8b4d08 mov ecx,[ebp+08]
> >>>>>> ...[000009e0][00211360][000009d6] 51 push ecx // Push P
> >>>>>> ...[000009e1][0021135c][000009e6] e840feffff call 00000826 // Call H
> >>>>>> ...[000009d6][0025bd90][0025bd94] 55 push ebp // enter P
> >>>>>> ...[000009d7][0025bd90][0025bd94] 8bec mov ebp,esp
> >>>>>> ...[000009d9][0025bd90][0025bd94] 8b4508 mov eax,[ebp+08]
> >>>>>> ...[000009dc][0025bd8c][000009d6] 50 push eax // Push P
> >>>>>> ...[000009dd][0025bd8c][000009d6] 8b4d08 mov ecx,[ebp+08]
> >>>>>> ...[000009e0][0025bd88][000009d6] 51 push ecx // Push P
> >>>>>> ...[000009e1][0025bd84][000009e6] e840feffff call 00000826 // Call H
> >>>>>> Local Halt Decider: Infinite Recursion Detected Simulation Stopped
> >>>>>> 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
> >>>>>
> >>>>> "Local Halt Decider: Infinite Recursion Detected Simulation Stopped" means
> >>>>> your x86utm emulator has encountered an infinite recursive call.
> >>>>> This is referred to as "undecidable". This is the fact.
> >>>> So you are saying that after H makes the correct halt status decision
> >>>> that this correct halt status decision is impossible to make.
> >>>>
> >>>> That is just like my example a smashing a Boston cream pie in your face
> >>>> and while this pie drips from your face you deny that the pie exists.
> >>>
> >>> Your H did not show 'correct decision' but 'unreachable' (exactly what the HP says).
> >>>
> >>> This is like "0.999..." (or repeating decimal) problems: Infinite repeating
> >>> simply means INFINITE repeating. Please, respect what it is.
> >> H simulates its input one x86 instruction at a time using an x86
> >> emulator. As soon as H(P,P) detects the same infinitely repeating
> >> pattern (that we can all see), it aborts its simulation and rejects its
> >> input.
> >> --
> >> Copyright 2022 Pete Olcott
> >>
> >> "Talent hits a target no one else can hit;
> >> Genius hits a target no one else can see."
> >> Arthur Schopenhauer
> >
> > Your H shows 'undecidable'. There is no branching codes shown.
> Without seeing any of the details of the 264 pages of the execution
> trace of H we can verify on the basis of the x86 source code for P and
> the execution trace that H derives that H does correctly simulate its
> input until it detects the same infinitely repeating pattern that we all
> can see.
>
Ben believes that H is just a call to P(P), and that there are no nested
simulations (simulations of simulations), and that the infinite cycle
detection code is in the outer layer, not incorporated into H at all.


Click here to read the complete article
Re: All my reviewers expect a halt decider to have psychic power

<ScednYS3GK-j1fn_nZ2dnUU7_8zNnZ2d@giganews.com>

 copy mid

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

 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: Sat, 23 Apr 2022 13:41:02 -0500
Date: Sat, 23 Apr 2022 13:41:01 -0500
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:91.0) Gecko/20100101
Thunderbird/91.8.1
Subject: Re: All my reviewers expect a halt decider to have psychic power
Content-Language: en-US
Newsgroups: comp.theory
References: <9sudne4_G7qNj_n_nZ2dnUU7_83NnZ2d@giganews.com>
<a9db8e82-955f-48d1-98c9-a4a529b64e56n@googlegroups.com>
<7emdnUtkBq8lvvn_nZ2dnUU7_8zNnZ2d@giganews.com>
<ae21ba1f-e4e2-432b-a274-2d6319af57bdn@googlegroups.com>
<mfmdnYqt3Ys1t_n_nZ2dnUU7_83NnZ2d@giganews.com>
<90544d3f-8d36-4d70-8951-45342b939a06n@googlegroups.com>
<JY2dndGxr5I0s_n_nZ2dnUU7_83NnZ2d@giganews.com>
<5f5837f9-279a-4d02-8d54-18e604a8496an@googlegroups.com>
<3cWdnSN3ZITNqPn_nZ2dnUU7_8xh4p2d@giganews.com>
<97d83870-8f3c-4e54-918c-dac850abce3cn@googlegroups.com>
<U-qdnTrGkI1xpfn_nZ2dnUU7_8xh4p2d@giganews.com>
<70970a80-11a1-4481-a082-6fcea2555162n@googlegroups.com>
<a6ydnWoUeOt8oPn_nZ2dnUU7_81g4p2d@giganews.com>
<5d7c8fbe-8899-4a46-9f0c-e5a11081458en@googlegroups.com>
From: NoO...@NoWhere.com (olcott)
In-Reply-To: <5d7c8fbe-8899-4a46-9f0c-e5a11081458en@googlegroups.com>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 7bit
Message-ID: <ScednYS3GK-j1fn_nZ2dnUU7_8zNnZ2d@giganews.com>
Lines: 184
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-zXr+5Ffl7ngs1wqyYW7QaueRTZISZJy0DhUGAh2KXE1RWvupzsL3s9NQz4YlgI/Y27LkjE6N95s64KZ!1KDj4o1wgJrFUfMBHI9FTgeAyKfhqmylUe1qCCWTITOHPwIIMMU3NNNOWrks7Dx7hquP4m1pnfM3
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: 11914
 by: olcott - Sat, 23 Apr 2022 18:41 UTC

On 4/23/2022 1:35 PM, Malcolm McLean wrote:
> On Saturday, 23 April 2022 at 18:56:56 UTC+1, olcott wrote:
>> On 4/23/2022 12:42 PM, wij wrote:
>>> On Sunday, 24 April 2022 at 01:35:47 UTC+8, olcott wrote:
>>>> On 4/23/2022 12:29 PM, wij wrote:
>>>>> On Sunday, 24 April 2022 at 01:20:23 UTC+8, olcott wrote:
>>>>>> On 4/23/2022 12:15 PM, wij wrote:
>>>>>>> On Sunday, 24 April 2022 at 00:52:00 UTC+8, olcott wrote:
>>>>>>>> On 4/23/2022 11:43 AM, wij wrote:
>>>>>>>>> On Sunday, 24 April 2022 at 00:34:55 UTC+8, olcott wrote:
>>>>>>>>>> On 4/23/2022 11:29 AM, wij wrote:
>>>>>>>>>>> On Sunday, 24 April 2022 at 00:05:19 UTC+8, olcott wrote:
>>>>>>>>>>>> On 4/23/2022 10:58 AM, wij wrote:
>>>>>>>>>>>>> On Saturday, 23 April 2022 at 22:49:59 UTC+8, olcott wrote:
>>>>>>>>>>>>>> All of my reviewers expect H(P,P) to compute the halt status of P(P),
>>>>>>>>>>>>>> yet the behavior specified by the input to H(P,P) is not the same as the
>>>>>>>>>>>>>> behavior specified by P(P).
>>>>>>>>>>>>>
>>>>>>>>>>>>> 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
>>>>>>>>>>>>> https://en.wikipedia.org/wiki/Halting_problem
>>>>>>>>>>>>>
>>>>>>>>>>>>> If using this common concept, the halting decider H, when given an argument P
>>>>>>>>>>>>> (or P P), is supposed to answer whether P(P) will halt or not. This is a very
>>>>>>>>>>>>> simple, easy idea to understand even for teenager students.
>>>>>>>>>>>>>
>>>>>>>>>>>> When this very simple idea is very rigorously examined (as it is in my
>>>>>>>>>>>> paper) one sees that this requires the halt decider to be a mind reader
>>>>>>>>>>>> and compute the halt status other than the actual halt status specified
>>>>>>>>>>>> by its actual input.
>>>>>>>>>>>
>>>>>>>>>>> Your wording/interpretations/paper change all the time. No idea what this new
>>>>>>>>>>> excuse 'mind reader' might mean. As said, the Halting Problem is very simple
>>>>>>>>>>> and intuitive.
>>>>>>>>>>> H should be a decider that computes the actual halt status of P(P). P is the
>>>>>>>>>>> H's actual argument input.
>>>>>>>>>>> I expect you might try to find some bugs of those descriptions to rephrasing it
>>>>>>>>>>> in your favor. But, what would be the point? What is the usefulness of POOP?
>>>>>>>>>> Yet when you carefully examine my paper:
>>>>>>>>>> Anyone that is an expert in the C programming language, the x86
>>>>>>>>>> programming language, exactly how C translates into x86 and what an x86
>>>>>>>>>> processor emulator is can easily verify that the correctly simulated
>>>>>>>>>> input to H(P,P) by H specifies a non-halting sequence of configurations.
>>>>>>>>>> Halting problem undecidability and infinitely nested simulation (V5)
>>>>>>>>>>
>>>>>>>>>> https://www.researchgate.net/publication/359984584_Halting_problem_undecidability_and_infinitely_nested_simulation_V5
>>>>>>>>>> Simply ignoring the verified facts is a ridiculously foolish was to form
>>>>>>>>>> any actual rebuttal.
>>>>>>>>>> --
>>>>>>>>>> Copyright 2022 Pete Olcott
>>>>>>>>>>
>>>>>>>>>> "Talent hits a target no one else can hit;
>>>>>>>>>> Genius hits a target no one else can see."
>>>>>>>>>> Arthur Schopenhauer
>>>>>>>>>
>>>>>>>>> You already verified the fact that H(P,P) will be in an infinite recursive call
>>>>>>>>> (thus, undecidable). Why you say H(P,P)==false (or true)?
>>>>>>>> You might make a wild guess like this if you make sure to hardly pay
>>>>>>>> attention. When you actually pay close attention and carefully study my
>>>>>>>> paper it is very easy to see that H sees the same infinitely repeating
>>>>>>>> pattern that we see, thus can abort its simulation and reject its input.
>>>>>>>> Begin Local Halt Decider Simulation
>>>>>>>>
>>>>>>>> machine stack stack machine assembly
>>>>>>>> address address data code language
>>>>>>>> ======== ======== ======== ========= =============
>>>>>>>> ...[000009d6][00211368][0021136c] 55 push ebp // enter P
>>>>>>>> ...[000009d7][00211368][0021136c] 8bec mov ebp,esp
>>>>>>>> ...[000009d9][00211368][0021136c] 8b4508 mov eax,[ebp+08]
>>>>>>>> ...[000009dc][00211364][000009d6] 50 push eax // Push P
>>>>>>>> ...[000009dd][00211364][000009d6] 8b4d08 mov ecx,[ebp+08]
>>>>>>>> ...[000009e0][00211360][000009d6] 51 push ecx // Push P
>>>>>>>> ...[000009e1][0021135c][000009e6] e840feffff call 00000826 // Call H
>>>>>>>> ...[000009d6][0025bd90][0025bd94] 55 push ebp // enter P
>>>>>>>> ...[000009d7][0025bd90][0025bd94] 8bec mov ebp,esp
>>>>>>>> ...[000009d9][0025bd90][0025bd94] 8b4508 mov eax,[ebp+08]
>>>>>>>> ...[000009dc][0025bd8c][000009d6] 50 push eax // Push P
>>>>>>>> ...[000009dd][0025bd8c][000009d6] 8b4d08 mov ecx,[ebp+08]
>>>>>>>> ...[000009e0][0025bd88][000009d6] 51 push ecx // Push P
>>>>>>>> ...[000009e1][0025bd84][000009e6] e840feffff call 00000826 // Call H
>>>>>>>> Local Halt Decider: Infinite Recursion Detected Simulation Stopped
>>>>>>>> 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
>>>>>>>
>>>>>>> "Local Halt Decider: Infinite Recursion Detected Simulation Stopped" means
>>>>>>> your x86utm emulator has encountered an infinite recursive call.
>>>>>>> This is referred to as "undecidable". This is the fact.
>>>>>> So you are saying that after H makes the correct halt status decision
>>>>>> that this correct halt status decision is impossible to make.
>>>>>>
>>>>>> That is just like my example a smashing a Boston cream pie in your face
>>>>>> and while this pie drips from your face you deny that the pie exists.
>>>>>
>>>>> Your H did not show 'correct decision' but 'unreachable' (exactly what the HP says).
>>>>>
>>>>> This is like "0.999..." (or repeating decimal) problems: Infinite repeating
>>>>> simply means INFINITE repeating. Please, respect what it is.
>>>> H simulates its input one x86 instruction at a time using an x86
>>>> emulator. As soon as H(P,P) detects the same infinitely repeating
>>>> pattern (that we can all see), it aborts its simulation and rejects its
>>>> input.
>>>> --
>>>> Copyright 2022 Pete Olcott
>>>>
>>>> "Talent hits a target no one else can hit;
>>>> Genius hits a target no one else can see."
>>>> Arthur Schopenhauer
>>>
>>> Your H shows 'undecidable'. There is no branching codes shown.
>> Without seeing any of the details of the 264 pages of the execution
>> trace of H we can verify on the basis of the x86 source code for P and
>> the execution trace that H derives that H does correctly simulate its
>> input until it detects the same infinitely repeating pattern that we all
>> can see.
>>
> Ben believes that H is just a call to P(P), and that there are no nested
> simulations (simulations of simulations),


Click here to read the complete article
Re: All my reviewers expect a halt decider to have psychic power

<89b229fa-7657-45a3-9b27-407c23a86cf5n@googlegroups.com>

 copy mid

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

 copy link   Newsgroups: comp.theory
X-Received: by 2002:ac8:7f4a:0:b0:2f3:5736:58a9 with SMTP id g10-20020ac87f4a000000b002f3573658a9mr7429617qtk.635.1650747466717;
Sat, 23 Apr 2022 13:57:46 -0700 (PDT)
X-Received: by 2002:a81:c09:0:b0:2e5:728f:b0d4 with SMTP id
9-20020a810c09000000b002e5728fb0d4mr10443614ywm.230.1650747466475; Sat, 23
Apr 2022 13:57:46 -0700 (PDT)
Path: i2pn2.org!i2pn.org!weretis.net!feeder6.news.weretis.net!news.misty.com!border2.nntp.dca1.giganews.com!nntp.giganews.com!news-out.google.com!nntp.google.com!postnews.google.com!google-groups.googlegroups.com!not-for-mail
Newsgroups: comp.theory
Date: Sat, 23 Apr 2022 13:57:46 -0700 (PDT)
In-Reply-To: <ScednYS3GK-j1fn_nZ2dnUU7_8zNnZ2d@giganews.com>
Injection-Info: google-groups.googlegroups.com; posting-host=2a00:23a8:400a:5601:4083:4ba2:910e:9cdd;
posting-account=Dz2zqgkAAADlK5MFu78bw3ab-BRFV4Qn
NNTP-Posting-Host: 2a00:23a8:400a:5601:4083:4ba2:910e:9cdd
References: <9sudne4_G7qNj_n_nZ2dnUU7_83NnZ2d@giganews.com>
<a9db8e82-955f-48d1-98c9-a4a529b64e56n@googlegroups.com> <7emdnUtkBq8lvvn_nZ2dnUU7_8zNnZ2d@giganews.com>
<ae21ba1f-e4e2-432b-a274-2d6319af57bdn@googlegroups.com> <mfmdnYqt3Ys1t_n_nZ2dnUU7_83NnZ2d@giganews.com>
<90544d3f-8d36-4d70-8951-45342b939a06n@googlegroups.com> <JY2dndGxr5I0s_n_nZ2dnUU7_83NnZ2d@giganews.com>
<5f5837f9-279a-4d02-8d54-18e604a8496an@googlegroups.com> <3cWdnSN3ZITNqPn_nZ2dnUU7_8xh4p2d@giganews.com>
<97d83870-8f3c-4e54-918c-dac850abce3cn@googlegroups.com> <U-qdnTrGkI1xpfn_nZ2dnUU7_8xh4p2d@giganews.com>
<70970a80-11a1-4481-a082-6fcea2555162n@googlegroups.com> <a6ydnWoUeOt8oPn_nZ2dnUU7_81g4p2d@giganews.com>
<5d7c8fbe-8899-4a46-9f0c-e5a11081458en@googlegroups.com> <ScednYS3GK-j1fn_nZ2dnUU7_8zNnZ2d@giganews.com>
User-Agent: G2/1.0
MIME-Version: 1.0
Message-ID: <89b229fa-7657-45a3-9b27-407c23a86cf5n@googlegroups.com>
Subject: Re: All my reviewers expect a halt decider to have psychic power
From: malcolm....@gmail.com (Malcolm McLean)
Injection-Date: Sat, 23 Apr 2022 20:57:46 +0000
Content-Type: text/plain; charset="UTF-8"
Lines: 177
 by: Malcolm McLean - Sat, 23 Apr 2022 20:57 UTC

On Saturday, 23 April 2022 at 19:41:09 UTC+1, olcott wrote:
> On 4/23/2022 1:35 PM, Malcolm McLean wrote:
> > On Saturday, 23 April 2022 at 18:56:56 UTC+1, olcott wrote:
> >> On 4/23/2022 12:42 PM, wij wrote:
> >>> On Sunday, 24 April 2022 at 01:35:47 UTC+8, olcott wrote:
> >>>> On 4/23/2022 12:29 PM, wij wrote:
> >>>>> On Sunday, 24 April 2022 at 01:20:23 UTC+8, olcott wrote:
> >>>>>> On 4/23/2022 12:15 PM, wij wrote:
> >>>>>>> On Sunday, 24 April 2022 at 00:52:00 UTC+8, olcott wrote:
> >>>>>>>> On 4/23/2022 11:43 AM, wij wrote:
> >>>>>>>>> On Sunday, 24 April 2022 at 00:34:55 UTC+8, olcott wrote:
> >>>>>>>>>> On 4/23/2022 11:29 AM, wij wrote:
> >>>>>>>>>>> On Sunday, 24 April 2022 at 00:05:19 UTC+8, olcott wrote:
> >>>>>>>>>>>> On 4/23/2022 10:58 AM, wij wrote:
> >>>>>>>>>>>>> On Saturday, 23 April 2022 at 22:49:59 UTC+8, olcott wrote:
> >>>>>>>>>>>>>> All of my reviewers expect H(P,P) to compute the halt status of P(P),
> >>>>>>>>>>>>>> yet the behavior specified by the input to H(P,P) is not the same as the
> >>>>>>>>>>>>>> behavior specified by P(P).
> >>>>>>>>>>>>>
> >>>>>>>>>>>>> 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
> >>>>>>>>>>>>> https://en.wikipedia.org/wiki/Halting_problem
> >>>>>>>>>>>>>
> >>>>>>>>>>>>> If using this common concept, the halting decider H, when given an argument P
> >>>>>>>>>>>>> (or P P), is supposed to answer whether P(P) will halt or not. This is a very
> >>>>>>>>>>>>> simple, easy idea to understand even for teenager students.
> >>>>>>>>>>>>>
> >>>>>>>>>>>> When this very simple idea is very rigorously examined (as it is in my
> >>>>>>>>>>>> paper) one sees that this requires the halt decider to be a mind reader
> >>>>>>>>>>>> and compute the halt status other than the actual halt status specified
> >>>>>>>>>>>> by its actual input.
> >>>>>>>>>>>
> >>>>>>>>>>> Your wording/interpretations/paper change all the time. No idea what this new
> >>>>>>>>>>> excuse 'mind reader' might mean. As said, the Halting Problem is very simple
> >>>>>>>>>>> and intuitive.
> >>>>>>>>>>> H should be a decider that computes the actual halt status of P(P). P is the
> >>>>>>>>>>> H's actual argument input.
> >>>>>>>>>>> I expect you might try to find some bugs of those descriptions to rephrasing it
> >>>>>>>>>>> in your favor. But, what would be the point? What is the usefulness of POOP?
> >>>>>>>>>> Yet when you carefully examine my paper:
> >>>>>>>>>> Anyone that is an expert in the C programming language, the x86
> >>>>>>>>>> programming language, exactly how C translates into x86 and what an x86
> >>>>>>>>>> processor emulator is can easily verify that the correctly simulated
> >>>>>>>>>> input to H(P,P) by H specifies a non-halting sequence of configurations.
> >>>>>>>>>> Halting problem undecidability and infinitely nested simulation (V5)
> >>>>>>>>>>
> >>>>>>>>>> https://www.researchgate.net/publication/359984584_Halting_problem_undecidability_and_infinitely_nested_simulation_V5
> >>>>>>>>>> Simply ignoring the verified facts is a ridiculously foolish was to form
> >>>>>>>>>> any actual rebuttal.
> >>>>>>>>>> --
> >>>>>>>>>> Copyright 2022 Pete Olcott
> >>>>>>>>>>
> >>>>>>>>>> "Talent hits a target no one else can hit;
> >>>>>>>>>> Genius hits a target no one else can see."
> >>>>>>>>>> Arthur Schopenhauer
> >>>>>>>>>
> >>>>>>>>> You already verified the fact that H(P,P) will be in an infinite recursive call
> >>>>>>>>> (thus, undecidable). Why you say H(P,P)==false (or true)?
> >>>>>>>> You might make a wild guess like this if you make sure to hardly pay
> >>>>>>>> attention. When you actually pay close attention and carefully study my
> >>>>>>>> paper it is very easy to see that H sees the same infinitely repeating
> >>>>>>>> pattern that we see, thus can abort its simulation and reject its input.
> >>>>>>>> Begin Local Halt Decider Simulation
> >>>>>>>>
> >>>>>>>> machine stack stack machine assembly
> >>>>>>>> address address data code language
> >>>>>>>> ======== ======== ======== ========= =============
> >>>>>>>> ...[000009d6][00211368][0021136c] 55 push ebp // enter P
> >>>>>>>> ...[000009d7][00211368][0021136c] 8bec mov ebp,esp
> >>>>>>>> ...[000009d9][00211368][0021136c] 8b4508 mov eax,[ebp+08]
> >>>>>>>> ...[000009dc][00211364][000009d6] 50 push eax // Push P
> >>>>>>>> ...[000009dd][00211364][000009d6] 8b4d08 mov ecx,[ebp+08]
> >>>>>>>> ...[000009e0][00211360][000009d6] 51 push ecx // Push P
> >>>>>>>> ...[000009e1][0021135c][000009e6] e840feffff call 00000826 // Call H
> >>>>>>>> ...[000009d6][0025bd90][0025bd94] 55 push ebp // enter P
> >>>>>>>> ...[000009d7][0025bd90][0025bd94] 8bec mov ebp,esp
> >>>>>>>> ...[000009d9][0025bd90][0025bd94] 8b4508 mov eax,[ebp+08]
> >>>>>>>> ...[000009dc][0025bd8c][000009d6] 50 push eax // Push P
> >>>>>>>> ...[000009dd][0025bd8c][000009d6] 8b4d08 mov ecx,[ebp+08]
> >>>>>>>> ...[000009e0][0025bd88][000009d6] 51 push ecx // Push P
> >>>>>>>> ...[000009e1][0025bd84][000009e6] e840feffff call 00000826 // Call H
> >>>>>>>> Local Halt Decider: Infinite Recursion Detected Simulation Stopped
> >>>>>>>> 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
> >>>>>>>
> >>>>>>> "Local Halt Decider: Infinite Recursion Detected Simulation Stopped" means
> >>>>>>> your x86utm emulator has encountered an infinite recursive call.
> >>>>>>> This is referred to as "undecidable". This is the fact.
> >>>>>> So you are saying that after H makes the correct halt status decision
> >>>>>> that this correct halt status decision is impossible to make.
> >>>>>>
> >>>>>> That is just like my example a smashing a Boston cream pie in your face
> >>>>>> and while this pie drips from your face you deny that the pie exists.
> >>>>>
> >>>>> Your H did not show 'correct decision' but 'unreachable' (exactly what the HP says).
> >>>>>
> >>>>> This is like "0.999..." (or repeating decimal) problems: Infinite repeating
> >>>>> simply means INFINITE repeating. Please, respect what it is.
> >>>> H simulates its input one x86 instruction at a time using an x86
> >>>> emulator. As soon as H(P,P) detects the same infinitely repeating
> >>>> pattern (that we can all see), it aborts its simulation and rejects its
> >>>> input.
> >>>> --
> >>>> Copyright 2022 Pete Olcott
> >>>>
> >>>> "Talent hits a target no one else can hit;
> >>>> Genius hits a target no one else can see."
> >>>> Arthur Schopenhauer
> >>>
> >>> Your H shows 'undecidable'. There is no branching codes shown.
> >> Without seeing any of the details of the 264 pages of the execution
> >> trace of H we can verify on the basis of the x86 source code for P and
> >> the execution trace that H derives that H does correctly simulate its
> >> input until it detects the same infinitely repeating pattern that we all
> >> can see.
> >>
> > Ben believes that H is just a call to P(P), and that there are no nested
> > simulations (simulations of simulations),
> Since I explained "how" I made my simulator re-entrant:
> Each simulation has its own registers, RAM and stack,
> and this is what is required to make my simulator re-entrant and every
> post that I have provided for many months shows that each subsequent
> simulation does have its own 64K stack your guess has been refuted.
> Begin Local Halt Decider Simulation
>
> machine stack stack machine assembly
> address address data code language
> ======== ======== ======== ========= =============
> ...[000009d6][00211368][0021136c] 55 push ebp // enter P
> ...[000009d7][00211368][0021136c] 8bec mov ebp,esp
> ...[000009d9][00211368][0021136c] 8b4508 mov eax,[ebp+08]
> ...[000009dc][00211364][000009d6] 50 push eax // Push P
> ...[000009dd][00211364][000009d6] 8b4d08 mov ecx,[ebp+08]
> ...[000009e0][00211360][000009d6] 51 push ecx // Push P
> ...[000009e1][0021135c][000009e6] e840feffff call 00000826 // Call H
> ...[000009d6][0025bd90][0025bd94] 55 push ebp // enter P
> ...[000009d7][0025bd90][0025bd94] 8bec mov ebp,esp
> ...[000009d9][0025bd90][0025bd94] 8b4508 mov eax,[ebp+08]
> ...[000009dc][0025bd8c][000009d6] 50 push eax // Push P
> ...[000009dd][0025bd8c][000009d6] 8b4d08 mov ecx,[ebp+08]
> ...[000009e0][0025bd88][000009d6] 51 push ecx // Push P
> ...[000009e1][0025bd84][000009e6] e840feffff call 00000826 // Call H
> Local Halt Decider: Infinite Recursion Detected Simulation Stopped
> > and that the infinite cycle
> > detection code is in the outer layer, not incorporated into H at all.
> >
> Yes, Ben determines that I must be wrong entirely on the basis that he
> really believes that I am wrong. When we get down to actual verified
> facts, Ben has nothing and I have everything.
> > That would explain why the execution trace shows simuated instructions,
> > not the trace of the simulated simulator. it would also explain why you
> > are withholding H.
> >
> The outer-most H sees the infinite pattern first because it has seen
> more simulated steps than any of the inner simulations.
> > I'm reserving judgement. But it's impossible to verify whether a program
> > halts or not if portions of it are concealed.
> Anyone that is an expert in the C programming language, the x86
> programming language, exactly how C translates into x86 and what an x86
> processor emulator is can easily verify that the correctly simulated
> input to H(P,P) by H specifies a non-halting sequence of configurations.
>
Anyone who knows what an x86 emulator is knows that the execution trace
of the emulator looks nothing like the execution trace of the program it is
emulating. And anyone who knows even a small amount about x86 code
knows that you can't tell whether a call will return or not except by examining
the called code.
Then I'm very reluctant to accuse anyone of lying. But you could instantly show
that Ben is in the wrong to make this accusation by providing the source of H.
Since it is necessary to show H to make your case, since it would be very easy to
do so, and since it would force Ben to issue an apology, surely you must see
that people will conclude that Ben is in fact right?


Click here to read the complete article
Re: All my reviewers expect a halt decider to have psychic power

<0NOdnTFREJs_8fn_nZ2dnUU7_8zNnZ2d@giganews.com>

 copy mid

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

 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: Sat, 23 Apr 2022 16:16:18 -0500
Date: Sat, 23 Apr 2022 16:16:17 -0500
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:91.0) Gecko/20100101
Thunderbird/91.8.1
Subject: Re: All my reviewers expect a halt decider to have psychic power
Content-Language: en-US
Newsgroups: comp.theory
References: <9sudne4_G7qNj_n_nZ2dnUU7_83NnZ2d@giganews.com>
<a9db8e82-955f-48d1-98c9-a4a529b64e56n@googlegroups.com>
<7emdnUtkBq8lvvn_nZ2dnUU7_8zNnZ2d@giganews.com>
<ae21ba1f-e4e2-432b-a274-2d6319af57bdn@googlegroups.com>
<mfmdnYqt3Ys1t_n_nZ2dnUU7_83NnZ2d@giganews.com>
<90544d3f-8d36-4d70-8951-45342b939a06n@googlegroups.com>
<JY2dndGxr5I0s_n_nZ2dnUU7_83NnZ2d@giganews.com>
<5f5837f9-279a-4d02-8d54-18e604a8496an@googlegroups.com>
<3cWdnSN3ZITNqPn_nZ2dnUU7_8xh4p2d@giganews.com>
<97d83870-8f3c-4e54-918c-dac850abce3cn@googlegroups.com>
<U-qdnTrGkI1xpfn_nZ2dnUU7_8xh4p2d@giganews.com>
<70970a80-11a1-4481-a082-6fcea2555162n@googlegroups.com>
<a6ydnWoUeOt8oPn_nZ2dnUU7_81g4p2d@giganews.com>
<5d7c8fbe-8899-4a46-9f0c-e5a11081458en@googlegroups.com>
<ScednYS3GK-j1fn_nZ2dnUU7_8zNnZ2d@giganews.com>
<89b229fa-7657-45a3-9b27-407c23a86cf5n@googlegroups.com>
From: NoO...@NoWhere.com (olcott)
In-Reply-To: <89b229fa-7657-45a3-9b27-407c23a86cf5n@googlegroups.com>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 7bit
Message-ID: <0NOdnTFREJs_8fn_nZ2dnUU7_8zNnZ2d@giganews.com>
Lines: 211
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-V0S+fzuT65hiBbelW4MrJSj+KsySKVEgiXdLXkCcoJkq1UySHfOlb8oePUKaR85VN6CvJp0ByrgvR4X!XLESmm/IWioCZQqxSy2ARgPgh1vTc55w65A/RMTtKtCt0F08YpH4HZhAcGU5lSZopbnAQ7dC7EIR
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: 13815
 by: olcott - Sat, 23 Apr 2022 21:16 UTC

On 4/23/2022 3:57 PM, Malcolm McLean wrote:
> On Saturday, 23 April 2022 at 19:41:09 UTC+1, olcott wrote:
>> On 4/23/2022 1:35 PM, Malcolm McLean wrote:
>>> On Saturday, 23 April 2022 at 18:56:56 UTC+1, olcott wrote:
>>>> On 4/23/2022 12:42 PM, wij wrote:
>>>>> On Sunday, 24 April 2022 at 01:35:47 UTC+8, olcott wrote:
>>>>>> On 4/23/2022 12:29 PM, wij wrote:
>>>>>>> On Sunday, 24 April 2022 at 01:20:23 UTC+8, olcott wrote:
>>>>>>>> On 4/23/2022 12:15 PM, wij wrote:
>>>>>>>>> On Sunday, 24 April 2022 at 00:52:00 UTC+8, olcott wrote:
>>>>>>>>>> On 4/23/2022 11:43 AM, wij wrote:
>>>>>>>>>>> On Sunday, 24 April 2022 at 00:34:55 UTC+8, olcott wrote:
>>>>>>>>>>>> On 4/23/2022 11:29 AM, wij wrote:
>>>>>>>>>>>>> On Sunday, 24 April 2022 at 00:05:19 UTC+8, olcott wrote:
>>>>>>>>>>>>>> On 4/23/2022 10:58 AM, wij wrote:
>>>>>>>>>>>>>>> On Saturday, 23 April 2022 at 22:49:59 UTC+8, olcott wrote:
>>>>>>>>>>>>>>>> All of my reviewers expect H(P,P) to compute the halt status of P(P),
>>>>>>>>>>>>>>>> yet the behavior specified by the input to H(P,P) is not the same as the
>>>>>>>>>>>>>>>> behavior specified by P(P).
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> 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
>>>>>>>>>>>>>>> https://en.wikipedia.org/wiki/Halting_problem
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> If using this common concept, the halting decider H, when given an argument P
>>>>>>>>>>>>>>> (or P P), is supposed to answer whether P(P) will halt or not. This is a very
>>>>>>>>>>>>>>> simple, easy idea to understand even for teenager students.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>> When this very simple idea is very rigorously examined (as it is in my
>>>>>>>>>>>>>> paper) one sees that this requires the halt decider to be a mind reader
>>>>>>>>>>>>>> and compute the halt status other than the actual halt status specified
>>>>>>>>>>>>>> by its actual input.
>>>>>>>>>>>>>
>>>>>>>>>>>>> Your wording/interpretations/paper change all the time. No idea what this new
>>>>>>>>>>>>> excuse 'mind reader' might mean. As said, the Halting Problem is very simple
>>>>>>>>>>>>> and intuitive.
>>>>>>>>>>>>> H should be a decider that computes the actual halt status of P(P). P is the
>>>>>>>>>>>>> H's actual argument input.
>>>>>>>>>>>>> I expect you might try to find some bugs of those descriptions to rephrasing it
>>>>>>>>>>>>> in your favor. But, what would be the point? What is the usefulness of POOP?
>>>>>>>>>>>> Yet when you carefully examine my paper:
>>>>>>>>>>>> Anyone that is an expert in the C programming language, the x86
>>>>>>>>>>>> programming language, exactly how C translates into x86 and what an x86
>>>>>>>>>>>> processor emulator is can easily verify that the correctly simulated
>>>>>>>>>>>> input to H(P,P) by H specifies a non-halting sequence of configurations.
>>>>>>>>>>>> Halting problem undecidability and infinitely nested simulation (V5)
>>>>>>>>>>>>
>>>>>>>>>>>> https://www.researchgate.net/publication/359984584_Halting_problem_undecidability_and_infinitely_nested_simulation_V5
>>>>>>>>>>>> Simply ignoring the verified facts is a ridiculously foolish was to form
>>>>>>>>>>>> any actual rebuttal.
>>>>>>>>>>>> --
>>>>>>>>>>>> Copyright 2022 Pete Olcott
>>>>>>>>>>>>
>>>>>>>>>>>> "Talent hits a target no one else can hit;
>>>>>>>>>>>> Genius hits a target no one else can see."
>>>>>>>>>>>> Arthur Schopenhauer
>>>>>>>>>>>
>>>>>>>>>>> You already verified the fact that H(P,P) will be in an infinite recursive call
>>>>>>>>>>> (thus, undecidable). Why you say H(P,P)==false (or true)?
>>>>>>>>>> You might make a wild guess like this if you make sure to hardly pay
>>>>>>>>>> attention. When you actually pay close attention and carefully study my
>>>>>>>>>> paper it is very easy to see that H sees the same infinitely repeating
>>>>>>>>>> pattern that we see, thus can abort its simulation and reject its input.
>>>>>>>>>> Begin Local Halt Decider Simulation
>>>>>>>>>>
>>>>>>>>>> machine stack stack machine assembly
>>>>>>>>>> address address data code language
>>>>>>>>>> ======== ======== ======== ========= =============
>>>>>>>>>> ...[000009d6][00211368][0021136c] 55 push ebp // enter P
>>>>>>>>>> ...[000009d7][00211368][0021136c] 8bec mov ebp,esp
>>>>>>>>>> ...[000009d9][00211368][0021136c] 8b4508 mov eax,[ebp+08]
>>>>>>>>>> ...[000009dc][00211364][000009d6] 50 push eax // Push P
>>>>>>>>>> ...[000009dd][00211364][000009d6] 8b4d08 mov ecx,[ebp+08]
>>>>>>>>>> ...[000009e0][00211360][000009d6] 51 push ecx // Push P
>>>>>>>>>> ...[000009e1][0021135c][000009e6] e840feffff call 00000826 // Call H
>>>>>>>>>> ...[000009d6][0025bd90][0025bd94] 55 push ebp // enter P
>>>>>>>>>> ...[000009d7][0025bd90][0025bd94] 8bec mov ebp,esp
>>>>>>>>>> ...[000009d9][0025bd90][0025bd94] 8b4508 mov eax,[ebp+08]
>>>>>>>>>> ...[000009dc][0025bd8c][000009d6] 50 push eax // Push P
>>>>>>>>>> ...[000009dd][0025bd8c][000009d6] 8b4d08 mov ecx,[ebp+08]
>>>>>>>>>> ...[000009e0][0025bd88][000009d6] 51 push ecx // Push P
>>>>>>>>>> ...[000009e1][0025bd84][000009e6] e840feffff call 00000826 // Call H
>>>>>>>>>> Local Halt Decider: Infinite Recursion Detected Simulation Stopped
>>>>>>>>>> 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
>>>>>>>>>
>>>>>>>>> "Local Halt Decider: Infinite Recursion Detected Simulation Stopped" means
>>>>>>>>> your x86utm emulator has encountered an infinite recursive call.
>>>>>>>>> This is referred to as "undecidable". This is the fact.
>>>>>>>> So you are saying that after H makes the correct halt status decision
>>>>>>>> that this correct halt status decision is impossible to make.
>>>>>>>>
>>>>>>>> That is just like my example a smashing a Boston cream pie in your face
>>>>>>>> and while this pie drips from your face you deny that the pie exists.
>>>>>>>
>>>>>>> Your H did not show 'correct decision' but 'unreachable' (exactly what the HP says).
>>>>>>>
>>>>>>> This is like "0.999..." (or repeating decimal) problems: Infinite repeating
>>>>>>> simply means INFINITE repeating. Please, respect what it is.
>>>>>> H simulates its input one x86 instruction at a time using an x86
>>>>>> emulator. As soon as H(P,P) detects the same infinitely repeating
>>>>>> pattern (that we can all see), it aborts its simulation and rejects its
>>>>>> input.
>>>>>> --
>>>>>> Copyright 2022 Pete Olcott
>>>>>>
>>>>>> "Talent hits a target no one else can hit;
>>>>>> Genius hits a target no one else can see."
>>>>>> Arthur Schopenhauer
>>>>>
>>>>> Your H shows 'undecidable'. There is no branching codes shown.
>>>> Without seeing any of the details of the 264 pages of the execution
>>>> trace of H we can verify on the basis of the x86 source code for P and
>>>> the execution trace that H derives that H does correctly simulate its
>>>> input until it detects the same infinitely repeating pattern that we all
>>>> can see.
>>>>
>>> Ben believes that H is just a call to P(P), and that there are no nested
>>> simulations (simulations of simulations),
>> Since I explained "how" I made my simulator re-entrant:
>> Each simulation has its own registers, RAM and stack,
>> and this is what is required to make my simulator re-entrant and every
>> post that I have provided for many months shows that each subsequent
>> simulation does have its own 64K stack your guess has been refuted.
>> Begin Local Halt Decider Simulation
>>
>> machine stack stack machine assembly
>> address address data code language
>> ======== ======== ======== ========= =============
>> ...[000009d6][00211368][0021136c] 55 push ebp // enter P
>> ...[000009d7][00211368][0021136c] 8bec mov ebp,esp
>> ...[000009d9][00211368][0021136c] 8b4508 mov eax,[ebp+08]
>> ...[000009dc][00211364][000009d6] 50 push eax // Push P
>> ...[000009dd][00211364][000009d6] 8b4d08 mov ecx,[ebp+08]
>> ...[000009e0][00211360][000009d6] 51 push ecx // Push P
>> ...[000009e1][0021135c][000009e6] e840feffff call 00000826 // Call H
>> ...[000009d6][0025bd90][0025bd94] 55 push ebp // enter P
>> ...[000009d7][0025bd90][0025bd94] 8bec mov ebp,esp
>> ...[000009d9][0025bd90][0025bd94] 8b4508 mov eax,[ebp+08]
>> ...[000009dc][0025bd8c][000009d6] 50 push eax // Push P
>> ...[000009dd][0025bd8c][000009d6] 8b4d08 mov ecx,[ebp+08]
>> ...[000009e0][0025bd88][000009d6] 51 push ecx // Push P
>> ...[000009e1][0025bd84][000009e6] e840feffff call 00000826 // Call H
>> Local Halt Decider: Infinite Recursion Detected Simulation Stopped
>>> and that the infinite cycle
>>> detection code is in the outer layer, not incorporated into H at all.
>>>
>> Yes, Ben determines that I must be wrong entirely on the basis that he
>> really believes that I am wrong. When we get down to actual verified
>> facts, Ben has nothing and I have everything.
>>> That would explain why the execution trace shows simuated instructions,
>>> not the trace of the simulated simulator. it would also explain why you
>>> are withholding H.
>>>
>> The outer-most H sees the infinite pattern first because it has seen
>> more simulated steps than any of the inner simulations.
>>> I'm reserving judgement. But it's impossible to verify whether a program
>>> halts or not if portions of it are concealed.
>> Anyone that is an expert in the C programming language, the x86
>> programming language, exactly how C translates into x86 and what an x86
>> processor emulator is can easily verify that the correctly simulated
>> input to H(P,P) by H specifies a non-halting sequence of configurations.
>>
> Anyone who knows what an x86 emulator is knows that the execution trace
> of the emulator looks nothing like the execution trace of the program it is
> emulating.


Click here to read the complete article
Re: All my reviewers expect a halt decider to have psychic power

<Cg_8K.2326$VwRc.2142@fx01.iad>

 copy mid

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

 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!peer01.iad!feed-me.highwinds-media.com!news.highwinds-media.com!fx01.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.8.1
Subject: Re: All my reviewers expect a halt decider to have psychic power
Content-Language: en-US
Newsgroups: comp.theory
References: <9sudne4_G7qNj_n_nZ2dnUU7_83NnZ2d@giganews.com>
<a9db8e82-955f-48d1-98c9-a4a529b64e56n@googlegroups.com>
<7emdnUtkBq8lvvn_nZ2dnUU7_8zNnZ2d@giganews.com>
<ae21ba1f-e4e2-432b-a274-2d6319af57bdn@googlegroups.com>
<mfmdnYqt3Ys1t_n_nZ2dnUU7_83NnZ2d@giganews.com>
<90544d3f-8d36-4d70-8951-45342b939a06n@googlegroups.com>
<JY2dndGxr5I0s_n_nZ2dnUU7_83NnZ2d@giganews.com>
<5f5837f9-279a-4d02-8d54-18e604a8496an@googlegroups.com>
<3cWdnSN3ZITNqPn_nZ2dnUU7_8xh4p2d@giganews.com>
<97d83870-8f3c-4e54-918c-dac850abce3cn@googlegroups.com>
<U-qdnTrGkI1xpfn_nZ2dnUU7_8xh4p2d@giganews.com>
<70970a80-11a1-4481-a082-6fcea2555162n@googlegroups.com>
<a6ydnWoUeOt8oPn_nZ2dnUU7_81g4p2d@giganews.com>
From: Rich...@Damon-Family.org (Richard Damon)
In-Reply-To: <a6ydnWoUeOt8oPn_nZ2dnUU7_81g4p2d@giganews.com>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 7bit
Lines: 160
Message-ID: <Cg_8K.2326$VwRc.2142@fx01.iad>
X-Complaints-To: abuse@easynews.com
Organization: Forte - www.forteinc.com
X-Complaints-Info: Please be sure to forward a copy of ALL headers otherwise we will be unable to process your complaint properly.
Date: Sat, 23 Apr 2022 17:33:22 -0400
X-Received-Bytes: 9087
 by: Richard Damon - Sat, 23 Apr 2022 21:33 UTC

On 4/23/22 1:56 PM, olcott wrote:
> On 4/23/2022 12:42 PM, wij wrote:
>> On Sunday, 24 April 2022 at 01:35:47 UTC+8, olcott wrote:
>>> On 4/23/2022 12:29 PM, wij wrote:
>>>> On Sunday, 24 April 2022 at 01:20:23 UTC+8, olcott wrote:
>>>>> On 4/23/2022 12:15 PM, wij wrote:
>>>>>> On Sunday, 24 April 2022 at 00:52:00 UTC+8, olcott wrote:
>>>>>>> On 4/23/2022 11:43 AM, wij wrote:
>>>>>>>> On Sunday, 24 April 2022 at 00:34:55 UTC+8, olcott wrote:
>>>>>>>>> On 4/23/2022 11:29 AM, wij wrote:
>>>>>>>>>> On Sunday, 24 April 2022 at 00:05:19 UTC+8, olcott wrote:
>>>>>>>>>>> On 4/23/2022 10:58 AM, wij wrote:
>>>>>>>>>>>> On Saturday, 23 April 2022 at 22:49:59 UTC+8, olcott wrote:
>>>>>>>>>>>>> All of my reviewers expect H(P,P) to compute the halt
>>>>>>>>>>>>> status of P(P),
>>>>>>>>>>>>> yet the behavior specified by the input to H(P,P) is not
>>>>>>>>>>>>> the same as the
>>>>>>>>>>>>> behavior specified by P(P).
>>>>>>>>>>>>
>>>>>>>>>>>> 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
>>>>>>>>>>>> https://en.wikipedia.org/wiki/Halting_problem
>>>>>>>>>>>>
>>>>>>>>>>>> If using this common concept, the halting decider H, when
>>>>>>>>>>>> given an argument P
>>>>>>>>>>>> (or P P), is supposed to answer whether P(P) will halt or
>>>>>>>>>>>> not. This is a very
>>>>>>>>>>>> simple, easy idea to understand even for teenager students.
>>>>>>>>>>>>
>>>>>>>>>>> When this very simple idea is very rigorously examined (as it
>>>>>>>>>>> is in my
>>>>>>>>>>> paper) one sees that this requires the halt decider to be a
>>>>>>>>>>> mind reader
>>>>>>>>>>> and compute the halt status other than the actual halt status
>>>>>>>>>>> specified
>>>>>>>>>>> by its actual input.
>>>>>>>>>>
>>>>>>>>>> Your wording/interpretations/paper change all the time. No
>>>>>>>>>> idea what this new
>>>>>>>>>> excuse 'mind reader' might mean. As said, the Halting Problem
>>>>>>>>>> is very simple
>>>>>>>>>> and intuitive.
>>>>>>>>>> H should be a decider that computes the actual halt status of
>>>>>>>>>> P(P). P is the
>>>>>>>>>> H's actual argument input.
>>>>>>>>>> I expect you might try to find some bugs of those descriptions
>>>>>>>>>> to rephrasing it
>>>>>>>>>> in your favor. But, what would be the point? What is the
>>>>>>>>>> usefulness of POOP?
>>>>>>>>> Yet when you carefully examine my paper:
>>>>>>>>> Anyone that is an expert in the C programming language, the x86
>>>>>>>>> programming language, exactly how C translates into x86 and
>>>>>>>>> what an x86
>>>>>>>>> processor emulator is can easily verify that the correctly
>>>>>>>>> simulated
>>>>>>>>> input to H(P,P) by H specifies a non-halting sequence of
>>>>>>>>> configurations.
>>>>>>>>> Halting problem undecidability and infinitely nested simulation
>>>>>>>>> (V5)
>>>>>>>>>
>>>>>>>>> https://www.researchgate.net/publication/359984584_Halting_problem_undecidability_and_infinitely_nested_simulation_V5
>>>>>>>>>
>>>>>>>>> Simply ignoring the verified facts is a ridiculously foolish
>>>>>>>>> was to form
>>>>>>>>> any actual rebuttal.
>>>>>>>>> --
>>>>>>>>> Copyright 2022 Pete Olcott
>>>>>>>>>
>>>>>>>>> "Talent hits a target no one else can hit;
>>>>>>>>> Genius hits a target no one else can see."
>>>>>>>>> Arthur Schopenhauer
>>>>>>>>
>>>>>>>> You already verified the fact that H(P,P) will be in an infinite
>>>>>>>> recursive call
>>>>>>>> (thus, undecidable). Why you say H(P,P)==false (or true)?
>>>>>>> You might make a wild guess like this if you make sure to hardly pay
>>>>>>> attention. When you actually pay close attention and carefully
>>>>>>> study my
>>>>>>> paper it is very easy to see that H sees the same infinitely
>>>>>>> repeating
>>>>>>> pattern that we see, thus can abort its simulation and reject its
>>>>>>> input.
>>>>>>> Begin Local Halt Decider Simulation
>>>>>>>
>>>>>>> machine stack stack machine assembly
>>>>>>> address address data code language
>>>>>>> ======== ======== ======== ========= =============
>>>>>>> ...[000009d6][00211368][0021136c] 55 push ebp // enter P
>>>>>>> ...[000009d7][00211368][0021136c] 8bec mov ebp,esp
>>>>>>> ...[000009d9][00211368][0021136c] 8b4508 mov eax,[ebp+08]
>>>>>>> ...[000009dc][00211364][000009d6] 50 push eax // Push P
>>>>>>> ...[000009dd][00211364][000009d6] 8b4d08 mov ecx,[ebp+08]
>>>>>>> ...[000009e0][00211360][000009d6] 51 push ecx // Push P
>>>>>>> ...[000009e1][0021135c][000009e6] e840feffff call 00000826 // Call H
>>>>>>> ...[000009d6][0025bd90][0025bd94] 55 push ebp // enter P
>>>>>>> ...[000009d7][0025bd90][0025bd94] 8bec mov ebp,esp
>>>>>>> ...[000009d9][0025bd90][0025bd94] 8b4508 mov eax,[ebp+08]
>>>>>>> ...[000009dc][0025bd8c][000009d6] 50 push eax // Push P
>>>>>>> ...[000009dd][0025bd8c][000009d6] 8b4d08 mov ecx,[ebp+08]
>>>>>>> ...[000009e0][0025bd88][000009d6] 51 push ecx // Push P
>>>>>>> ...[000009e1][0025bd84][000009e6] e840feffff call 00000826 // Call H
>>>>>>> Local Halt Decider: Infinite Recursion Detected Simulation Stopped
>>>>>>> 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
>>>>>>
>>>>>> "Local Halt Decider: Infinite Recursion Detected Simulation
>>>>>> Stopped" means
>>>>>> your x86utm emulator has encountered an infinite recursive call.
>>>>>> This is referred to as "undecidable". This is the fact.
>>>>> So you are saying that after H makes the correct halt status decision
>>>>> that this correct halt status decision is impossible to make.
>>>>>
>>>>> That is just like my example a smashing a Boston cream pie in your
>>>>> face
>>>>> and while this pie drips from your face you deny that the pie exists.
>>>>
>>>> Your H did not show 'correct decision' but 'unreachable' (exactly
>>>> what the HP says).
>>>>
>>>> This is like "0.999..." (or repeating decimal) problems: Infinite
>>>> repeating
>>>> simply means INFINITE repeating. Please, respect what it is.
>>> H simulates its input one x86 instruction at a time using an x86
>>> emulator. As soon as H(P,P) detects the same infinitely repeating
>>> pattern (that we can all see), it aborts its simulation and rejects its
>>> input.
>>> --
>>> Copyright 2022 Pete Olcott
>>>
>>> "Talent hits a target no one else can hit;
>>> Genius hits a target no one else can see."
>>> Arthur Schopenhauer
>>
>> Your H shows 'undecidable'. There is no branching codes shown.
>
> Without seeing any of the details of the 264 pages of the execution
> trace of H we can verify on the basis of the x86 source code for P and
> the execution trace that H derives that H does correctly simulate its
> input until it detects the same infinitely repeating pattern that we all
> can see.
>
>


Click here to read the complete article
Re: All my reviewers expect a halt decider to have psychic power

<_n_8K.875225$aT3.409337@fx09.iad>

 copy mid

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

 copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!aioe.org!feeder1.feed.usenet.farm!feed.usenet.farm!news.uzoreto.com!news-out.netnews.com!news.alt.net!fdc2.netnews.com!peer01.ams1!peer.ams1.xlned.com!news.xlned.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.8.1
Subject: Re: All my reviewers expect a halt decider to have psychic power
Content-Language: en-US
Newsgroups: comp.theory
References: <9sudne4_G7qNj_n_nZ2dnUU7_83NnZ2d@giganews.com>
<a9db8e82-955f-48d1-98c9-a4a529b64e56n@googlegroups.com>
<7emdnUtkBq8lvvn_nZ2dnUU7_8zNnZ2d@giganews.com>
<ae21ba1f-e4e2-432b-a274-2d6319af57bdn@googlegroups.com>
<mfmdnYqt3Ys1t_n_nZ2dnUU7_83NnZ2d@giganews.com>
<90544d3f-8d36-4d70-8951-45342b939a06n@googlegroups.com>
<JY2dndGxr5I0s_n_nZ2dnUU7_83NnZ2d@giganews.com>
<5f5837f9-279a-4d02-8d54-18e604a8496an@googlegroups.com>
<3cWdnSN3ZITNqPn_nZ2dnUU7_8xh4p2d@giganews.com>
<97d83870-8f3c-4e54-918c-dac850abce3cn@googlegroups.com>
<U-qdnTrGkI1xpfn_nZ2dnUU7_8xh4p2d@giganews.com>
<70970a80-11a1-4481-a082-6fcea2555162n@googlegroups.com>
<a6ydnWoUeOt8oPn_nZ2dnUU7_81g4p2d@giganews.com>
<5d7c8fbe-8899-4a46-9f0c-e5a11081458en@googlegroups.com>
<ScednYS3GK-j1fn_nZ2dnUU7_8zNnZ2d@giganews.com>
<89b229fa-7657-45a3-9b27-407c23a86cf5n@googlegroups.com>
<0NOdnTFREJs_8fn_nZ2dnUU7_8zNnZ2d@giganews.com>
From: Rich...@Damon-Family.org (Richard Damon)
In-Reply-To: <0NOdnTFREJs_8fn_nZ2dnUU7_8zNnZ2d@giganews.com>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 7bit
Lines: 287
Message-ID: <_n_8K.875225$aT3.409337@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: Sat, 23 Apr 2022 17:41:14 -0400
X-Received-Bytes: 15457
 by: Richard Damon - Sat, 23 Apr 2022 21:41 UTC

On 4/23/22 5:16 PM, olcott wrote:
> On 4/23/2022 3:57 PM, Malcolm McLean wrote:
>> On Saturday, 23 April 2022 at 19:41:09 UTC+1, olcott wrote:
>>> On 4/23/2022 1:35 PM, Malcolm McLean wrote:
>>>> On Saturday, 23 April 2022 at 18:56:56 UTC+1, olcott wrote:
>>>>> On 4/23/2022 12:42 PM, wij wrote:
>>>>>> On Sunday, 24 April 2022 at 01:35:47 UTC+8, olcott wrote:
>>>>>>> On 4/23/2022 12:29 PM, wij wrote:
>>>>>>>> On Sunday, 24 April 2022 at 01:20:23 UTC+8, olcott wrote:
>>>>>>>>> On 4/23/2022 12:15 PM, wij wrote:
>>>>>>>>>> On Sunday, 24 April 2022 at 00:52:00 UTC+8, olcott wrote:
>>>>>>>>>>> On 4/23/2022 11:43 AM, wij wrote:
>>>>>>>>>>>> On Sunday, 24 April 2022 at 00:34:55 UTC+8, olcott wrote:
>>>>>>>>>>>>> On 4/23/2022 11:29 AM, wij wrote:
>>>>>>>>>>>>>> On Sunday, 24 April 2022 at 00:05:19 UTC+8, olcott wrote:
>>>>>>>>>>>>>>> On 4/23/2022 10:58 AM, wij wrote:
>>>>>>>>>>>>>>>> On Saturday, 23 April 2022 at 22:49:59 UTC+8, olcott wrote:
>>>>>>>>>>>>>>>>> All of my reviewers expect H(P,P) to compute the halt
>>>>>>>>>>>>>>>>> status of P(P),
>>>>>>>>>>>>>>>>> yet the behavior specified by the input to H(P,P) is
>>>>>>>>>>>>>>>>> not the same as the
>>>>>>>>>>>>>>>>> behavior specified by P(P).
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> 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
>>>>>>>>>>>>>>>> https://en.wikipedia.org/wiki/Halting_problem
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> If using this common concept, the halting decider H,
>>>>>>>>>>>>>>>> when given an argument P
>>>>>>>>>>>>>>>> (or P P), is supposed to answer whether P(P) will halt
>>>>>>>>>>>>>>>> or not. This is a very
>>>>>>>>>>>>>>>> simple, easy idea to understand even for teenager students.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> When this very simple idea is very rigorously examined
>>>>>>>>>>>>>>> (as it is in my
>>>>>>>>>>>>>>> paper) one sees that this requires the halt decider to be
>>>>>>>>>>>>>>> a mind reader
>>>>>>>>>>>>>>> and compute the halt status other than the actual halt
>>>>>>>>>>>>>>> status specified
>>>>>>>>>>>>>>> by its actual input.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> Your wording/interpretations/paper change all the time. No
>>>>>>>>>>>>>> idea what this new
>>>>>>>>>>>>>> excuse 'mind reader' might mean. As said, the Halting
>>>>>>>>>>>>>> Problem is very simple
>>>>>>>>>>>>>> and intuitive.
>>>>>>>>>>>>>> H should be a decider that computes the actual halt status
>>>>>>>>>>>>>> of P(P). P is the
>>>>>>>>>>>>>> H's actual argument input.
>>>>>>>>>>>>>> I expect you might try to find some bugs of those
>>>>>>>>>>>>>> descriptions to rephrasing it
>>>>>>>>>>>>>> in your favor. But, what would be the point? What is the
>>>>>>>>>>>>>> usefulness of POOP?
>>>>>>>>>>>>> Yet when you carefully examine my paper:
>>>>>>>>>>>>> Anyone that is an expert in the C programming language, the
>>>>>>>>>>>>> x86
>>>>>>>>>>>>> programming language, exactly how C translates into x86 and
>>>>>>>>>>>>> what an x86
>>>>>>>>>>>>> processor emulator is can easily verify that the correctly
>>>>>>>>>>>>> simulated
>>>>>>>>>>>>> input to H(P,P) by H specifies a non-halting sequence of
>>>>>>>>>>>>> configurations.
>>>>>>>>>>>>> Halting problem undecidability and infinitely nested
>>>>>>>>>>>>> simulation (V5)
>>>>>>>>>>>>>
>>>>>>>>>>>>> https://www.researchgate.net/publication/359984584_Halting_problem_undecidability_and_infinitely_nested_simulation_V5
>>>>>>>>>>>>>
>>>>>>>>>>>>> Simply ignoring the verified facts is a ridiculously
>>>>>>>>>>>>> foolish was to form
>>>>>>>>>>>>> any actual rebuttal.
>>>>>>>>>>>>> --
>>>>>>>>>>>>> Copyright 2022 Pete Olcott
>>>>>>>>>>>>>
>>>>>>>>>>>>> "Talent hits a target no one else can hit;
>>>>>>>>>>>>> Genius hits a target no one else can see."
>>>>>>>>>>>>> Arthur Schopenhauer
>>>>>>>>>>>>
>>>>>>>>>>>> You already verified the fact that H(P,P) will be in an
>>>>>>>>>>>> infinite recursive call
>>>>>>>>>>>> (thus, undecidable). Why you say H(P,P)==false (or true)?
>>>>>>>>>>> You might make a wild guess like this if you make sure to
>>>>>>>>>>> hardly pay
>>>>>>>>>>> attention. When you actually pay close attention and
>>>>>>>>>>> carefully study my
>>>>>>>>>>> paper it is very easy to see that H sees the same infinitely
>>>>>>>>>>> repeating
>>>>>>>>>>> pattern that we see, thus can abort its simulation and reject
>>>>>>>>>>> its input.
>>>>>>>>>>> Begin Local Halt Decider Simulation
>>>>>>>>>>>
>>>>>>>>>>> machine stack stack machine assembly
>>>>>>>>>>> address address data code language
>>>>>>>>>>> ======== ======== ======== ========= =============
>>>>>>>>>>> ...[000009d6][00211368][0021136c] 55 push ebp // enter P
>>>>>>>>>>> ...[000009d7][00211368][0021136c] 8bec mov ebp,esp
>>>>>>>>>>> ...[000009d9][00211368][0021136c] 8b4508 mov eax,[ebp+08]
>>>>>>>>>>> ...[000009dc][00211364][000009d6] 50 push eax // Push P
>>>>>>>>>>> ...[000009dd][00211364][000009d6] 8b4d08 mov ecx,[ebp+08]
>>>>>>>>>>> ...[000009e0][00211360][000009d6] 51 push ecx // Push P
>>>>>>>>>>> ...[000009e1][0021135c][000009e6] e840feffff call 00000826 //
>>>>>>>>>>> Call H
>>>>>>>>>>> ...[000009d6][0025bd90][0025bd94] 55 push ebp // enter P
>>>>>>>>>>> ...[000009d7][0025bd90][0025bd94] 8bec mov ebp,esp
>>>>>>>>>>> ...[000009d9][0025bd90][0025bd94] 8b4508 mov eax,[ebp+08]
>>>>>>>>>>> ...[000009dc][0025bd8c][000009d6] 50 push eax // Push P
>>>>>>>>>>> ...[000009dd][0025bd8c][000009d6] 8b4d08 mov ecx,[ebp+08]
>>>>>>>>>>> ...[000009e0][0025bd88][000009d6] 51 push ecx // Push P
>>>>>>>>>>> ...[000009e1][0025bd84][000009e6] e840feffff call 00000826 //
>>>>>>>>>>> Call H
>>>>>>>>>>> Local Halt Decider: Infinite Recursion Detected Simulation
>>>>>>>>>>> Stopped
>>>>>>>>>>> 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
>>>>>>>>>>
>>>>>>>>>> "Local Halt Decider: Infinite Recursion Detected Simulation
>>>>>>>>>> Stopped" means
>>>>>>>>>> your x86utm emulator has encountered an infinite recursive call.
>>>>>>>>>> This is referred to as "undecidable". This is the fact.
>>>>>>>>> So you are saying that after H makes the correct halt status
>>>>>>>>> decision
>>>>>>>>> that this correct halt status decision is impossible to make.
>>>>>>>>>
>>>>>>>>> That is just like my example a smashing a Boston cream pie in
>>>>>>>>> your face
>>>>>>>>> and while this pie drips from your face you deny that the pie
>>>>>>>>> exists.
>>>>>>>>
>>>>>>>> Your H did not show 'correct decision' but 'unreachable'
>>>>>>>> (exactly what the HP says).
>>>>>>>>
>>>>>>>> This is like "0.999..." (or repeating decimal) problems:
>>>>>>>> Infinite repeating
>>>>>>>> simply means INFINITE repeating. Please, respect what it is.
>>>>>>> H simulates its input one x86 instruction at a time using an x86
>>>>>>> emulator. As soon as H(P,P) detects the same infinitely repeating
>>>>>>> pattern (that we can all see), it aborts its simulation and
>>>>>>> rejects its
>>>>>>> input.
>>>>>>> --
>>>>>>> Copyright 2022 Pete Olcott
>>>>>>>
>>>>>>> "Talent hits a target no one else can hit;
>>>>>>> Genius hits a target no one else can see."
>>>>>>> Arthur Schopenhauer
>>>>>>
>>>>>> Your H shows 'undecidable'. There is no branching codes shown.
>>>>> Without seeing any of the details of the 264 pages of the execution
>>>>> trace of H we can verify on the basis of the x86 source code for P and
>>>>> the execution trace that H derives that H does correctly simulate its
>>>>> input until it detects the same infinitely repeating pattern that
>>>>> we all
>>>>> can see.
>>>>>
>>>> Ben believes that H is just a call to P(P), and that there are no
>>>> nested
>>>> simulations (simulations of simulations),
>>> Since I explained "how" I made my simulator re-entrant:
>>> Each simulation has its own registers, RAM and stack,
>>> and this is what is required to make my simulator re-entrant and every
>>> post that I have provided for many months shows that each subsequent
>>> simulation does have its own 64K stack your guess has been refuted.
>>> Begin Local Halt Decider Simulation
>>>
>>> machine stack stack machine assembly
>>> address address data code language
>>> ======== ======== ======== ========= =============
>>> ...[000009d6][00211368][0021136c] 55 push ebp // enter P
>>> ...[000009d7][00211368][0021136c] 8bec mov ebp,esp
>>> ...[000009d9][00211368][0021136c] 8b4508 mov eax,[ebp+08]
>>> ...[000009dc][00211364][000009d6] 50 push eax // Push P
>>> ...[000009dd][00211364][000009d6] 8b4d08 mov ecx,[ebp+08]
>>> ...[000009e0][00211360][000009d6] 51 push ecx // Push P
>>> ...[000009e1][0021135c][000009e6] e840feffff call 00000826 // Call H
>>> ...[000009d6][0025bd90][0025bd94] 55 push ebp // enter P
>>> ...[000009d7][0025bd90][0025bd94] 8bec mov ebp,esp
>>> ...[000009d9][0025bd90][0025bd94] 8b4508 mov eax,[ebp+08]
>>> ...[000009dc][0025bd8c][000009d6] 50 push eax // Push P
>>> ...[000009dd][0025bd8c][000009d6] 8b4d08 mov ecx,[ebp+08]
>>> ...[000009e0][0025bd88][000009d6] 51 push ecx // Push P
>>> ...[000009e1][0025bd84][000009e6] e840feffff call 00000826 // Call H
>>> Local Halt Decider: Infinite Recursion Detected Simulation Stopped
>>>> and that the infinite cycle
>>>> detection code is in the outer layer, not incorporated into H at all.
>>>>
>>> Yes, Ben determines that I must be wrong entirely on the basis that he
>>> really believes that I am wrong. When we get down to actual verified
>>> facts, Ben has nothing and I have everything.
>>>> That would explain why the execution trace shows simuated instructions,
>>>> not the trace of the simulated simulator. it would also explain why you
>>>> are withholding H.
>>>>
>>> The outer-most H sees the infinite pattern first because it has seen
>>> more simulated steps than any of the inner simulations.
>>>> I'm reserving judgement. But it's impossible to verify whether a
>>>> program
>>>> halts or not if portions of it are concealed.
>>> Anyone that is an expert in the C programming language, the x86
>>> programming language, exactly how C translates into x86 and what an x86
>>> processor emulator is can easily verify that the correctly simulated
>>> input to H(P,P) by H specifies a non-halting sequence of configurations.
>>>
>> Anyone who knows what an x86 emulator is knows that the execution trace
>> of the emulator looks nothing like the execution trace of the program
>> it is
>> emulating.
>
> That is ridiculous. That is the same thing as saying the a UTM
> simulation of a TM description of a TM need not have any relationship to
> the behavior of the executed TM.


Click here to read the complete article
Re: All my reviewers expect a halt decider to have psychic power

<0u_8K.625197$7F2.532338@fx12.iad>

 copy mid

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

 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!peer01.iad!feed-me.highwinds-media.com!news.highwinds-media.com!fx12.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.8.1
Subject: Re: All my reviewers expect a halt decider to have psychic power
Content-Language: en-US
Newsgroups: comp.theory
References: <9sudne4_G7qNj_n_nZ2dnUU7_83NnZ2d@giganews.com>
<a9db8e82-955f-48d1-98c9-a4a529b64e56n@googlegroups.com>
<7emdnUtkBq8lvvn_nZ2dnUU7_8zNnZ2d@giganews.com>
<ae21ba1f-e4e2-432b-a274-2d6319af57bdn@googlegroups.com>
<mfmdnYqt3Ys1t_n_nZ2dnUU7_83NnZ2d@giganews.com>
<90544d3f-8d36-4d70-8951-45342b939a06n@googlegroups.com>
<JY2dndGxr5I0s_n_nZ2dnUU7_83NnZ2d@giganews.com>
<5f5837f9-279a-4d02-8d54-18e604a8496an@googlegroups.com>
<3cWdnSN3ZITNqPn_nZ2dnUU7_8xh4p2d@giganews.com>
<97d83870-8f3c-4e54-918c-dac850abce3cn@googlegroups.com>
<U-qdnTrGkI1xpfn_nZ2dnUU7_8xh4p2d@giganews.com>
From: Rich...@Damon-Family.org (Richard Damon)
In-Reply-To: <U-qdnTrGkI1xpfn_nZ2dnUU7_8xh4p2d@giganews.com>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 7bit
Lines: 150
Message-ID: <0u_8K.625197$7F2.532338@fx12.iad>
X-Complaints-To: abuse@easynews.com
Organization: Forte - www.forteinc.com
X-Complaints-Info: Please be sure to forward a copy of ALL headers otherwise we will be unable to process your complaint properly.
Date: Sat, 23 Apr 2022 17:47:39 -0400
X-Received-Bytes: 8829
 by: Richard Damon - Sat, 23 Apr 2022 21:47 UTC

On 4/23/22 1:35 PM, olcott wrote:
> On 4/23/2022 12:29 PM, wij wrote:
>> On Sunday, 24 April 2022 at 01:20:23 UTC+8, olcott wrote:
>>> On 4/23/2022 12:15 PM, wij wrote:
>>>> On Sunday, 24 April 2022 at 00:52:00 UTC+8, olcott wrote:
>>>>> On 4/23/2022 11:43 AM, wij wrote:
>>>>>> On Sunday, 24 April 2022 at 00:34:55 UTC+8, olcott wrote:
>>>>>>> On 4/23/2022 11:29 AM, wij wrote:
>>>>>>>> On Sunday, 24 April 2022 at 00:05:19 UTC+8, olcott wrote:
>>>>>>>>> On 4/23/2022 10:58 AM, wij wrote:
>>>>>>>>>> On Saturday, 23 April 2022 at 22:49:59 UTC+8, olcott wrote:
>>>>>>>>>>> All of my reviewers expect H(P,P) to compute the halt status
>>>>>>>>>>> of P(P),
>>>>>>>>>>> yet the behavior specified by the input to H(P,P) is not the
>>>>>>>>>>> same as the
>>>>>>>>>>> behavior specified by P(P).
>>>>>>>>>>
>>>>>>>>>> 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
>>>>>>>>>> https://en.wikipedia.org/wiki/Halting_problem
>>>>>>>>>>
>>>>>>>>>> If using this common concept, the halting decider H, when
>>>>>>>>>> given an argument P
>>>>>>>>>> (or P P), is supposed to answer whether P(P) will halt or not.
>>>>>>>>>> This is a very
>>>>>>>>>> simple, easy idea to understand even for teenager students.
>>>>>>>>>>
>>>>>>>>> When this very simple idea is very rigorously examined (as it
>>>>>>>>> is in my
>>>>>>>>> paper) one sees that this requires the halt decider to be a
>>>>>>>>> mind reader
>>>>>>>>> and compute the halt status other than the actual halt status
>>>>>>>>> specified
>>>>>>>>> by its actual input.
>>>>>>>>
>>>>>>>> Your wording/interpretations/paper change all the time. No idea
>>>>>>>> what this new
>>>>>>>> excuse 'mind reader' might mean. As said, the Halting Problem is
>>>>>>>> very simple
>>>>>>>> and intuitive.
>>>>>>>> H should be a decider that computes the actual halt status of
>>>>>>>> P(P). P is the
>>>>>>>> H's actual argument input.
>>>>>>>> I expect you might try to find some bugs of those descriptions
>>>>>>>> to rephrasing it
>>>>>>>> in your favor. But, what would be the point? What is the
>>>>>>>> usefulness of POOP?
>>>>>>> Yet when you carefully examine my paper:
>>>>>>> Anyone that is an expert in the C programming language, the x86
>>>>>>> programming language, exactly how C translates into x86 and what
>>>>>>> an x86
>>>>>>> processor emulator is can easily verify that the correctly simulated
>>>>>>> input to H(P,P) by H specifies a non-halting sequence of
>>>>>>> configurations.
>>>>>>> Halting problem undecidability and infinitely nested simulation (V5)
>>>>>>>
>>>>>>> https://www.researchgate.net/publication/359984584_Halting_problem_undecidability_and_infinitely_nested_simulation_V5
>>>>>>>
>>>>>>> Simply ignoring the verified facts is a ridiculously foolish was
>>>>>>> to form
>>>>>>> any actual rebuttal.
>>>>>>> --
>>>>>>> Copyright 2022 Pete Olcott
>>>>>>>
>>>>>>> "Talent hits a target no one else can hit;
>>>>>>> Genius hits a target no one else can see."
>>>>>>> Arthur Schopenhauer
>>>>>>
>>>>>> You already verified the fact that H(P,P) will be in an infinite
>>>>>> recursive call
>>>>>> (thus, undecidable). Why you say H(P,P)==false (or true)?
>>>>> You might make a wild guess like this if you make sure to hardly pay
>>>>> attention. When you actually pay close attention and carefully
>>>>> study my
>>>>> paper it is very easy to see that H sees the same infinitely repeating
>>>>> pattern that we see, thus can abort its simulation and reject its
>>>>> input.
>>>>> Begin Local Halt Decider Simulation
>>>>>
>>>>> machine stack stack machine assembly
>>>>> address address data code language
>>>>> ======== ======== ======== ========= =============
>>>>> ...[000009d6][00211368][0021136c] 55 push ebp // enter P
>>>>> ...[000009d7][00211368][0021136c] 8bec mov ebp,esp
>>>>> ...[000009d9][00211368][0021136c] 8b4508 mov eax,[ebp+08]
>>>>> ...[000009dc][00211364][000009d6] 50 push eax // Push P
>>>>> ...[000009dd][00211364][000009d6] 8b4d08 mov ecx,[ebp+08]
>>>>> ...[000009e0][00211360][000009d6] 51 push ecx // Push P
>>>>> ...[000009e1][0021135c][000009e6] e840feffff call 00000826 // Call H
>>>>> ...[000009d6][0025bd90][0025bd94] 55 push ebp // enter P
>>>>> ...[000009d7][0025bd90][0025bd94] 8bec mov ebp,esp
>>>>> ...[000009d9][0025bd90][0025bd94] 8b4508 mov eax,[ebp+08]
>>>>> ...[000009dc][0025bd8c][000009d6] 50 push eax // Push P
>>>>> ...[000009dd][0025bd8c][000009d6] 8b4d08 mov ecx,[ebp+08]
>>>>> ...[000009e0][0025bd88][000009d6] 51 push ecx // Push P
>>>>> ...[000009e1][0025bd84][000009e6] e840feffff call 00000826 // Call H
>>>>> Local Halt Decider: Infinite Recursion Detected Simulation Stopped
>>>>> 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
>>>>
>>>> "Local Halt Decider: Infinite Recursion Detected Simulation Stopped"
>>>> means
>>>> your x86utm emulator has encountered an infinite recursive call.
>>>> This is referred to as "undecidable". This is the fact.
>>> So you are saying that after H makes the correct halt status decision
>>> that this correct halt status decision is impossible to make.
>>>
>>> That is just like my example a smashing a Boston cream pie in your face
>>> and while this pie drips from your face you deny that the pie exists.
>>
>> Your H did not show 'correct decision' but 'unreachable' (exactly what
>> the HP says).
>>
>> This is like "0.999..." (or repeating decimal) problems: Infinite
>> repeating
>> simply means INFINITE repeating. Please, respect what it is.
>
> H simulates its input one x86 instruction at a time using an x86
> emulator. As soon as H(P,P) detects the same infinitely repeating
> pattern (that we can all see), it aborts its simulation and rejects its
> input.
>

Except that the pattern is proven to not actually be infinitely
recursive, as tracing the execution of that input shows that the H that
P calls will also make that same decision and abort its simulation and
return and then P stops.

What you have actually shown is that a DIFFERENT H, that doesn't abort
its simulation, would create non-halting behavior for both itself and
the P built on it. That is a DIFFERENT H and thus a DIFFERENT P then the
one this H has, because P INCLUDES the H it calls.

This is actually a fatal flaw in your example, your "string" of P is
incomplete and thus doesn't actually have defined behavior, it calls a
location in memory that it doesn't define. You need to include in your
string for P the copy of H that it is using, and that means that if the
H that is deciding is going to abort its simulation, then the P it is
simulting also has a H in it that will abort its simulation, and thus
NOT generate the infinite pattern you claim.


Click here to read the complete article
Re: All my reviewers expect a halt decider to have psychic power

<38SdnVilEOYxdOv_nZ2dnUU7_83NnZ2d@giganews.com>

 copy mid

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

 copy link   Newsgroups: comp.theory comp.ai.philosophy sci.logic comp.lang.prolog
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: Sat, 07 May 2022 16:50:36 -0500
Date: Sat, 7 May 2022 16:50:35 -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: All my reviewers expect a halt decider to have psychic power
Content-Language: en-US
Newsgroups: comp.theory,comp.ai.philosophy,sci.logic,comp.lang.prolog
References: <9sudne4_G7qNj_n_nZ2dnUU7_83NnZ2d@giganews.com>
<a9db8e82-955f-48d1-98c9-a4a529b64e56n@googlegroups.com>
<7emdnUtkBq8lvvn_nZ2dnUU7_8zNnZ2d@giganews.com>
<ae21ba1f-e4e2-432b-a274-2d6319af57bdn@googlegroups.com>
<mfmdnYqt3Ys1t_n_nZ2dnUU7_83NnZ2d@giganews.com>
<90544d3f-8d36-4d70-8951-45342b939a06n@googlegroups.com>
<JY2dndGxr5I0s_n_nZ2dnUU7_83NnZ2d@giganews.com>
<5f5837f9-279a-4d02-8d54-18e604a8496an@googlegroups.com>
<3cWdnSN3ZITNqPn_nZ2dnUU7_8xh4p2d@giganews.com>
<97d83870-8f3c-4e54-918c-dac850abce3cn@googlegroups.com>
From: NoO...@NoWhere.com (olcott)
Followup-To: comp.theory
In-Reply-To: <97d83870-8f3c-4e54-918c-dac850abce3cn@googlegroups.com>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 7bit
Message-ID: <38SdnVilEOYxdOv_nZ2dnUU7_83NnZ2d@giganews.com>
Lines: 122
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-wB04gB4NE3u6EqvxQeDdKqkx7vli+aueiPPvUdpyDEUzllQj/lbhk254cT8efh4lFmuURPcpneCgYP4!4Ut3tTXcdJj6a+Y9SDvqhF817UpZlcs0dUx6ho1yVaczU6eTle/YTAIAloHAmqWubLoYX6p3ty8=
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: 8285
 by: olcott - Sat, 7 May 2022 21:50 UTC

On 4/23/2022 12:29 PM, wij wrote:
> On Sunday, 24 April 2022 at 01:20:23 UTC+8, olcott wrote:
>> On 4/23/2022 12:15 PM, wij wrote:
>>> On Sunday, 24 April 2022 at 00:52:00 UTC+8, olcott wrote:
>>>> On 4/23/2022 11:43 AM, wij wrote:
>>>>> On Sunday, 24 April 2022 at 00:34:55 UTC+8, olcott wrote:
>>>>>> On 4/23/2022 11:29 AM, wij wrote:
>>>>>>> On Sunday, 24 April 2022 at 00:05:19 UTC+8, olcott wrote:
>>>>>>>> On 4/23/2022 10:58 AM, wij wrote:
>>>>>>>>> On Saturday, 23 April 2022 at 22:49:59 UTC+8, olcott wrote:
>>>>>>>>>> All of my reviewers expect H(P,P) to compute the halt status of P(P),
>>>>>>>>>> yet the behavior specified by the input to H(P,P) is not the same as the
>>>>>>>>>> behavior specified by P(P).
>>>>>>>>>
>>>>>>>>> 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
>>>>>>>>> https://en.wikipedia.org/wiki/Halting_problem
>>>>>>>>>
>>>>>>>>> If using this common concept, the halting decider H, when given an argument P
>>>>>>>>> (or P P), is supposed to answer whether P(P) will halt or not. This is a very
>>>>>>>>> simple, easy idea to understand even for teenager students.
>>>>>>>>>
>>>>>>>> When this very simple idea is very rigorously examined (as it is in my
>>>>>>>> paper) one sees that this requires the halt decider to be a mind reader
>>>>>>>> and compute the halt status other than the actual halt status specified
>>>>>>>> by its actual input.
>>>>>>>
>>>>>>> Your wording/interpretations/paper change all the time. No idea what this new
>>>>>>> excuse 'mind reader' might mean. As said, the Halting Problem is very simple
>>>>>>> and intuitive.
>>>>>>> H should be a decider that computes the actual halt status of P(P). P is the
>>>>>>> H's actual argument input.
>>>>>>> I expect you might try to find some bugs of those descriptions to rephrasing it
>>>>>>> in your favor. But, what would be the point? What is the usefulness of POOP?
>>>>>> Yet when you carefully examine my paper:
>>>>>> Anyone that is an expert in the C programming language, the x86
>>>>>> programming language, exactly how C translates into x86 and what an x86
>>>>>> processor emulator is can easily verify that the correctly simulated
>>>>>> input to H(P,P) by H specifies a non-halting sequence of configurations.
>>>>>> Halting problem undecidability and infinitely nested simulation (V5)
>>>>>>
>>>>>> https://www.researchgate.net/publication/359984584_Halting_problem_undecidability_and_infinitely_nested_simulation_V5
>>>>>> Simply ignoring the verified facts is a ridiculously foolish was to form
>>>>>> any actual rebuttal.
>>>>>> --
>>>>>> Copyright 2022 Pete Olcott
>>>>>>
>>>>>> "Talent hits a target no one else can hit;
>>>>>> Genius hits a target no one else can see."
>>>>>> Arthur Schopenhauer
>>>>>
>>>>> You already verified the fact that H(P,P) will be in an infinite recursive call
>>>>> (thus, undecidable). Why you say H(P,P)==false (or true)?
>>>> You might make a wild guess like this if you make sure to hardly pay
>>>> attention. When you actually pay close attention and carefully study my
>>>> paper it is very easy to see that H sees the same infinitely repeating
>>>> pattern that we see, thus can abort its simulation and reject its input.
>>>> Begin Local Halt Decider Simulation
>>>>
>>>> machine stack stack machine assembly
>>>> address address data code language
>>>> ======== ======== ======== ========= =============
>>>> ...[000009d6][00211368][0021136c] 55 push ebp // enter P
>>>> ...[000009d7][00211368][0021136c] 8bec mov ebp,esp
>>>> ...[000009d9][00211368][0021136c] 8b4508 mov eax,[ebp+08]
>>>> ...[000009dc][00211364][000009d6] 50 push eax // Push P
>>>> ...[000009dd][00211364][000009d6] 8b4d08 mov ecx,[ebp+08]
>>>> ...[000009e0][00211360][000009d6] 51 push ecx // Push P
>>>> ...[000009e1][0021135c][000009e6] e840feffff call 00000826 // Call H
>>>> ...[000009d6][0025bd90][0025bd94] 55 push ebp // enter P
>>>> ...[000009d7][0025bd90][0025bd94] 8bec mov ebp,esp
>>>> ...[000009d9][0025bd90][0025bd94] 8b4508 mov eax,[ebp+08]
>>>> ...[000009dc][0025bd8c][000009d6] 50 push eax // Push P
>>>> ...[000009dd][0025bd8c][000009d6] 8b4d08 mov ecx,[ebp+08]
>>>> ...[000009e0][0025bd88][000009d6] 51 push ecx // Push P
>>>> ...[000009e1][0025bd84][000009e6] e840feffff call 00000826 // Call H
>>>> Local Halt Decider: Infinite Recursion Detected Simulation Stopped
>>>> 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
>>>
>>> "Local Halt Decider: Infinite Recursion Detected Simulation Stopped" means
>>> your x86utm emulator has encountered an infinite recursive call.
>>> This is referred to as "undecidable". This is the fact.
>> So you are saying that after H makes the correct halt status decision
>> that this correct halt status decision is impossible to make.
>>
>> That is just like my example a smashing a Boston cream pie in your face
>> and while this pie drips from your face you deny that the pie exists.
>
> Your H did not show 'correct decision' but 'unreachable' (exactly what the HP says).
>
> This is like "0.999..." (or repeating decimal) problems: Infinite repeating
> simply means INFINITE repeating. Please, respect what it is.

My H proves that H(P,P)== false
on the basis that H does correctly compute the mapping from its input
parameters to its own final reject state on the basis of the actual
behavior actually specified by its input parameters.

The details of this are shown here:
https://www.researchgate.net/publication/359984584_Halting_problem_undecidability_and_infinitely_nested_simulation_V5

A bunch of goofy people here do not understand that this meets the
definition of a correct halt decider.

They believe that H must compute a mapping from non-inputs. This is
quite nuts because they already know that no decider can ever do this.

--
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: All my reviewers expect a halt decider to have psychic power

<5b6c8f0a-8558-4110-ac21-8b8349d0c1c5n@googlegroups.com>

 copy mid

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

 copy link   Newsgroups: comp.theory
X-Received: by 2002:a37:e102:0:b0:69f:8463:cbdd with SMTP id c2-20020a37e102000000b0069f8463cbddmr7312654qkm.766.1651965050437;
Sat, 07 May 2022 16:10:50 -0700 (PDT)
X-Received: by 2002:a25:3c41:0:b0:648:f9f7:16a3 with SMTP id
j62-20020a253c41000000b00648f9f716a3mr7615209yba.527.1651965050267; Sat, 07
May 2022 16:10:50 -0700 (PDT)
Path: i2pn2.org!i2pn.org!aioe.org!news.mixmin.net!proxad.net!feeder1-2.proxad.net!209.85.160.216.MISMATCH!news-out.google.com!nntp.google.com!postnews.google.com!google-groups.googlegroups.com!not-for-mail
Newsgroups: comp.theory
Date: Sat, 7 May 2022 16:10:50 -0700 (PDT)
In-Reply-To: <38SdnVilEOYxdOv_nZ2dnUU7_83NnZ2d@giganews.com>
Injection-Info: google-groups.googlegroups.com; posting-host=124.218.76.41; posting-account=A1PyIwoAAACCahK0CVYFlDZG8JWzz_Go
NNTP-Posting-Host: 124.218.76.41
References: <9sudne4_G7qNj_n_nZ2dnUU7_83NnZ2d@giganews.com>
<a9db8e82-955f-48d1-98c9-a4a529b64e56n@googlegroups.com> <7emdnUtkBq8lvvn_nZ2dnUU7_8zNnZ2d@giganews.com>
<ae21ba1f-e4e2-432b-a274-2d6319af57bdn@googlegroups.com> <mfmdnYqt3Ys1t_n_nZ2dnUU7_83NnZ2d@giganews.com>
<90544d3f-8d36-4d70-8951-45342b939a06n@googlegroups.com> <JY2dndGxr5I0s_n_nZ2dnUU7_83NnZ2d@giganews.com>
<5f5837f9-279a-4d02-8d54-18e604a8496an@googlegroups.com> <3cWdnSN3ZITNqPn_nZ2dnUU7_8xh4p2d@giganews.com>
<97d83870-8f3c-4e54-918c-dac850abce3cn@googlegroups.com> <38SdnVilEOYxdOv_nZ2dnUU7_83NnZ2d@giganews.com>
User-Agent: G2/1.0
MIME-Version: 1.0
Message-ID: <5b6c8f0a-8558-4110-ac21-8b8349d0c1c5n@googlegroups.com>
Subject: Re: All my reviewers expect a halt decider to have psychic power
From: wynii...@gmail.com (wij)
Injection-Date: Sat, 07 May 2022 23:10:50 +0000
Content-Type: text/plain; charset="UTF-8"
 by: wij - Sat, 7 May 2022 23:10 UTC

On Sunday, 8 May 2022 at 05:50:43 UTC+8, olcott wrote:
> On 4/23/2022 12:29 PM, wij wrote:
> > On Sunday, 24 April 2022 at 01:20:23 UTC+8, olcott wrote:
> >> On 4/23/2022 12:15 PM, wij wrote:
> >>> On Sunday, 24 April 2022 at 00:52:00 UTC+8, olcott wrote:
> >>>> On 4/23/2022 11:43 AM, wij wrote:
> >>>>> On Sunday, 24 April 2022 at 00:34:55 UTC+8, olcott wrote:
> >>>>>> On 4/23/2022 11:29 AM, wij wrote:
> >>>>>>> On Sunday, 24 April 2022 at 00:05:19 UTC+8, olcott wrote:
> >>>>>>>> On 4/23/2022 10:58 AM, wij wrote:
> >>>>>>>>> On Saturday, 23 April 2022 at 22:49:59 UTC+8, olcott wrote:
> >>>>>>>>>> All of my reviewers expect H(P,P) to compute the halt status of P(P),
> >>>>>>>>>> yet the behavior specified by the input to H(P,P) is not the same as the
> >>>>>>>>>> behavior specified by P(P).
> >>>>>>>>>
> >>>>>>>>> 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
> >>>>>>>>> https://en.wikipedia.org/wiki/Halting_problem
> >>>>>>>>>
> >>>>>>>>> If using this common concept, the halting decider H, when given an argument P
> >>>>>>>>> (or P P), is supposed to answer whether P(P) will halt or not. This is a very
> >>>>>>>>> simple, easy idea to understand even for teenager students.
> >>>>>>>>>
> >>>>>>>> When this very simple idea is very rigorously examined (as it is in my
> >>>>>>>> paper) one sees that this requires the halt decider to be a mind reader
> >>>>>>>> and compute the halt status other than the actual halt status specified
> >>>>>>>> by its actual input.
> >>>>>>>
> >>>>>>> Your wording/interpretations/paper change all the time. No idea what this new
> >>>>>>> excuse 'mind reader' might mean. As said, the Halting Problem is very simple
> >>>>>>> and intuitive.
> >>>>>>> H should be a decider that computes the actual halt status of P(P). P is the
> >>>>>>> H's actual argument input.
> >>>>>>> I expect you might try to find some bugs of those descriptions to rephrasing it
> >>>>>>> in your favor. But, what would be the point? What is the usefulness of POOP?
> >>>>>> Yet when you carefully examine my paper:
> >>>>>> Anyone that is an expert in the C programming language, the x86
> >>>>>> programming language, exactly how C translates into x86 and what an x86
> >>>>>> processor emulator is can easily verify that the correctly simulated
> >>>>>> input to H(P,P) by H specifies a non-halting sequence of configurations.
> >>>>>> Halting problem undecidability and infinitely nested simulation (V5)
> >>>>>>
> >>>>>> https://www.researchgate.net/publication/359984584_Halting_problem_undecidability_and_infinitely_nested_simulation_V5
> >>>>>> Simply ignoring the verified facts is a ridiculously foolish was to form
> >>>>>> any actual rebuttal.
> >>>>>> --
> >>>>>> Copyright 2022 Pete Olcott
> >>>>>>
> >>>>>> "Talent hits a target no one else can hit;
> >>>>>> Genius hits a target no one else can see."
> >>>>>> Arthur Schopenhauer
> >>>>>
> >>>>> You already verified the fact that H(P,P) will be in an infinite recursive call
> >>>>> (thus, undecidable). Why you say H(P,P)==false (or true)?
> >>>> You might make a wild guess like this if you make sure to hardly pay
> >>>> attention. When you actually pay close attention and carefully study my
> >>>> paper it is very easy to see that H sees the same infinitely repeating
> >>>> pattern that we see, thus can abort its simulation and reject its input.
> >>>> Begin Local Halt Decider Simulation
> >>>>
> >>>> machine stack stack machine assembly
> >>>> address address data code language
> >>>> ======== ======== ======== ========= =============
> >>>> ...[000009d6][00211368][0021136c] 55 push ebp // enter P
> >>>> ...[000009d7][00211368][0021136c] 8bec mov ebp,esp
> >>>> ...[000009d9][00211368][0021136c] 8b4508 mov eax,[ebp+08]
> >>>> ...[000009dc][00211364][000009d6] 50 push eax // Push P
> >>>> ...[000009dd][00211364][000009d6] 8b4d08 mov ecx,[ebp+08]
> >>>> ...[000009e0][00211360][000009d6] 51 push ecx // Push P
> >>>> ...[000009e1][0021135c][000009e6] e840feffff call 00000826 // Call H
> >>>> ...[000009d6][0025bd90][0025bd94] 55 push ebp // enter P
> >>>> ...[000009d7][0025bd90][0025bd94] 8bec mov ebp,esp
> >>>> ...[000009d9][0025bd90][0025bd94] 8b4508 mov eax,[ebp+08]
> >>>> ...[000009dc][0025bd8c][000009d6] 50 push eax // Push P
> >>>> ...[000009dd][0025bd8c][000009d6] 8b4d08 mov ecx,[ebp+08]
> >>>> ...[000009e0][0025bd88][000009d6] 51 push ecx // Push P
> >>>> ...[000009e1][0025bd84][000009e6] e840feffff call 00000826 // Call H
> >>>> Local Halt Decider: Infinite Recursion Detected Simulation Stopped
> >>>> 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
> >>>
> >>> "Local Halt Decider: Infinite Recursion Detected Simulation Stopped" means
> >>> your x86utm emulator has encountered an infinite recursive call.
> >>> This is referred to as "undecidable". This is the fact.
> >> So you are saying that after H makes the correct halt status decision
> >> that this correct halt status decision is impossible to make.
> >>
> >> That is just like my example a smashing a Boston cream pie in your face
> >> and while this pie drips from your face you deny that the pie exists.
> >
> > Your H did not show 'correct decision' but 'unreachable' (exactly what the HP says).
> >
> > This is like "0.999..." (or repeating decimal) problems: Infinite repeating
> > simply means INFINITE repeating. Please, respect what it is.
> My H proves that H(P,P)== false
> on the basis that H does correctly compute the mapping from its input
> parameters to its own final reject state on the basis of the actual
> behavior actually specified by its input parameters.
>
> The details of this are shown here:
> https://www.researchgate.net/publication/359984584_Halting_problem_undecidability_and_infinitely_nested_simulation_V5
>
> A bunch of goofy people here do not understand that this meets the
> definition of a correct halt decider.
>
> They believe that H must compute a mapping from non-inputs. This is
> quite nuts because they already know that no decider can ever do this.
> --
> Copyright 2022 Pete Olcott
>
> "Talent hits a target no one else can hit;
> Genius hits a target no one else can see."
> Arthur Schopenhauer

There is no "return false" in the execution trace of your H.
Your H run in infinite recursive calls, it demonstrates H(P,P)==Undecidable.

You only need to show a 'H' that GUR can fail (or the conventional HP proof).

Pages:12
server_pubkey.txt

rocksolid light 0.9.7
clearnet tor