Rocksolid Light

Welcome to novaBBS (click a section below)

mail  files  register  nodelist  faq  login

It's hard to tune heavily tuned code. :-) -- Larry Wall in <199801141725.JAA07555@wall.org>


computers / comp.ai.philosophy / Concise refutation of halting problem proofs V27 [ finally mathematically precise ]

SubjectAuthor
* Concise refutation of halting problem proofs V27 [ finallyolcott
`* Re: Concise refutation of halting problem proofs V27 [ finallyolcott
 `* Re: Concise refutation of halting problem proofs V27 [ input is notolcott
  `- Re: Concise refutation of halting problem proofs V27 [ input is notolcott

1
Subject: Concise refutation of halting problem proofs V27 [ finally mathematically precise ]
From: olcott
Newsgroups: comp.theory, comp.ai.philosophy, sci.logic, sci.math
Followup: comp.theory
Date: Mon, 22 Nov 2021 20:32 UTC
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: Mon, 22 Nov 2021 14:32:55 -0600
Date: Mon, 22 Nov 2021 14:32:54 -0600
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:91.0) Gecko/20100101
Thunderbird/91.3.2
Newsgroups: comp.theory,comp.ai.philosophy,sci.logic,sci.math
Content-Language: en-US
Followup-To: comp.theory
From: NoO...@NoWhere.com (olcott)
Subject: Concise refutation of halting problem proofs V27 [ finally
mathematically precise ]
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Message-ID: <5-2dncs2MNPqYwb8nZ2dnUU7-KvNnZ2d@giganews.com>
Lines: 59
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-135M95SDSjK1g+PI2+QjZ6z4RTZn1/5CmXmhSXOcSZptKE89Z6ufpN9jCS8tnzrdW5j4D0r/ap4vE6I!UT+y52JcmxU2G8GXqvKm8bQXhXA/D4Bx1htVwVhBfZY+sv8l6gF8RzCrMLffS/VbbKwxm+krSfl7!SA==
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: 2959
View all headers
#include <stdint.h>
#include <stdio.h>
typedef int (*ptr)();

int H(ptr x, ptr y)
{
   x(y); // direct execution of P(P)
   return 1;
}

// Minimal essence of Linz(1990) Ĥ
// and Strachey(1965) P
int P(ptr x)
{
   H(x, x);
   return 1; // Give P a last instruction at the "c" level
}

int main(void)
{
   H(P, P);
}

Computation that halts
a computation is said to halt whenever it enters a final state. (Linz:1990:234)

[PSR_set] Combinations of H/P having pathological self-reference
For every H of H(P,P) where P(P) calls this same H(P,P) and H simulates or executes its input and aborts or does not abort its input.
∀H ∊ PSR_set ∀P ∊ PSR_set (Input_Never_Halts(H(P,P)))
[PSR_subset_A] ∃H ∊ PSR_set ∃P ∊ PSR_set (Halts(  H(P,P)  ))
[PSR_subset_B] ∃H ∊ PSR_set ∃P ∊ PSR_set (Halts(  P(P)  ))

[PSR_subset_C] The subset of the PSR_subset_A where H returns 0 on the basis that H correctly detects that its input never halts (reaches its final instruction). H could detect that its simulated P is calling H(P,P) with the same parameters that it was called with, thus specifying infinite recursion.

H is a computable function that accepts or rejects inputs in its domain on the basis that these inputs specify a sequence of configurations that reach their final state.
H is a correct decider and H has a correct halt deciding basis.

*(see page 3)*
Halting problem undecidability and infinitely nested simulation V2

https://www.researchgate.net/publication/356105750_Halting_problem_undecidability_and_infinitely_nested_simulation_V2 --
Copyright 2021 Pete Olcott

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


Subject: Re: Concise refutation of halting problem proofs V27 [ finally mathematically precise ]
From: olcott
Newsgroups: comp.theory, comp.ai.philosophy, sci.logic, sci.math
Followup: comp.theory
Date: Tue, 23 Nov 2021 03:59 UTC
References: 1 2 3 4 5 6 7 8 9 10 11 12
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: Mon, 22 Nov 2021 21:59:15 -0600
Date: Mon, 22 Nov 2021 21:59:13 -0600
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:91.0) Gecko/20100101
Thunderbird/91.3.2
Subject: Re: Concise refutation of halting problem proofs V27 [ finally
mathematically precise ]
Content-Language: en-US
Newsgroups: comp.theory,comp.ai.philosophy,sci.logic,sci.math
References: <5-2dncs2MNPqYwb8nZ2dnUU7-KvNnZ2d@giganews.com>
<NvednQUyFr32mQH8nZ2dnUU7-IGdnZ2d@giganews.com> <snh212$mup$1@dont-email.me>
<MpydnY7JbLEWkgH8nZ2dnUU7-SHNnZ2d@giganews.com>
<TtUmJ.126712$831.100143@fx40.iad> <snh4jm$a0i$1@dont-email.me>
<cNKdnX6ckqwSvAH8nZ2dnUU7-WXNnZ2d@giganews.com> <snh8d4$4t1$1@dont-email.me>
<xdmdndTsRo2SrwH8nZ2dnUU7-dfNnZ2d@giganews.com> <snhes8$c1c$1@dont-email.me>
<LZSdnSHg28173QH8nZ2dnUU7-dfNnZ2d@giganews.com> <snhh1j$nre$1@dont-email.me>
From: NoO...@NoWhere.com (olcott)
Followup-To: comp.theory
In-Reply-To: <snhh1j$nre$1@dont-email.me>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Message-ID: <V92dnfjztvyO-gH8nZ2dnUU7-enNnZ2d@giganews.com>
Lines: 97
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-u9B40TXJCwtbb56GNNQ0pqrj3T7TRTLjuvKYT1fmjuITL44CirJvVudQ/mcV/v6HaKoG+FLU9eTWOBt!HEibx3/aP4E7wDkdlY7sSy/CuPUcwBOm5weoBwH1tfXp/LEzpghdzFC2X9AUMITn2zlclLtgcLVU!hw==
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: 5154
View all headers
On 11/22/2021 7:44 PM, André G. Isaak wrote:
On 2021-11-22 18:16, olcott wrote:
On 11/22/2021 7:07 PM, André G. Isaak wrote:
On 2021-11-22 17:13, olcott wrote:
On 11/22/2021 5:16 PM, André G. Isaak wrote:

And this bit is particularly mystifying:

 > PSR_set: for n = 0 to ∞
 > {
 >    (Input_Never_Halts(  Hn(Pn,Pn)  ))
 >    (Sometimes_Halts(  Hn(Pn,Pn)  ))
 >    (Sometimes_Halts(   Pn(Pn)  ))
 > }

André



Numbered elements of the infinite set of finite string C encodings of H and P. The source-code that I provided is the (H0, P0) element.

That wasn't the mystifying part despite it being a strange abuse of syntax. I assumed this was just a deranged way of writing ∀n rather than being a syntactically ill-formed C program, though why you continuously insist on inventing your own undefined notation is beyond me.

How can the input of Hn(Pn, Pn) never halt when Pn(Pn) sometimes halt?

The input to Hn(Pn,Pn) never reaches its final state.
For some of these exact same Pn(Pn) P does reach its final state.

Which goes back to Richard's question which you refused to answer: What does Input_Never_Halts mean?

The input to a halt decider is a *string*. The input can't halt. It also can't not halt. Only the computation which it describes has a halting status, and in the case of Hn(Pn, Pn) the input describes the computation Pn(Pn).

You keep talking about what the 'input' does, but unless by 'input' you mean 'the computation described by the input' this is a completely undefined and, as far as I can tell, meaningless notion. Halting is a property of *computations*, not of strings.

So what does Input_Never_Halts mean?

What does it mean for an input to halt or not halt?


It turns out that the independent execution of P(P) actually means an input to H(P,P) that *is not* an input to H(P,P).

It turns out that the independent execution of P(P) means that main() directly executes P(P) without H being involved.

No deciders can actually work that way. All deciders either accept or reject finite string inputs.

H is a computable function that accepts or rejects inputs in its domain on the basis that these inputs specify a sequence of configurations that reach their final state.

What all you guys have been asking for is for H to have an input that *is not* its input.

The x86 equivalent of a TM description and its input is an x86 machine language string and some other finite string or references to these.



And if Hn is a halt decider, how can it only sometimes halt?


I am using categorically exhaustive reasoning examining the behavior of every possible Hn(Pn,Pn) by examining the categories of possible behavior.

Only a subset of Hn(Pn,Pn) is H a decider and in only a subset of these is H a correct halt decider.

And what does it even mean for something to sometimes halt? For any given value of n it either halts or it doesn't.

Not going to answer this, I take it?

André



--
Copyright 2021 Pete Olcott

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


Subject: Re: Concise refutation of halting problem proofs V27 [ input is not in domain ]
From: olcott
Newsgroups: comp.theory, comp.ai.philosophy, sci.logic, sci.math
Followup: comp.theory
Date: Wed, 24 Nov 2021 03:24 UTC
References: 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25
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: Tue, 23 Nov 2021 21:24:53 -0600
Date: Tue, 23 Nov 2021 21:24:52 -0600
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:91.0) Gecko/20100101
Thunderbird/91.3.2
Subject: Re: Concise refutation of halting problem proofs V27 [ input is not
in domain ]
Content-Language: en-US
Newsgroups: comp.theory,comp.ai.philosophy,sci.logic,sci.math
References: <5-2dncs2MNPqYwb8nZ2dnUU7-KvNnZ2d@giganews.com>
<cNKdnX6ckqwSvAH8nZ2dnUU7-WXNnZ2d@giganews.com> <snh8d4$4t1$1@dont-email.me>
<xdmdndTsRo2SrwH8nZ2dnUU7-dfNnZ2d@giganews.com> <snhes8$c1c$1@dont-email.me>
<LZSdnSHg28173QH8nZ2dnUU7-dfNnZ2d@giganews.com> <snhh1j$nre$1@dont-email.me>
<V92dnfjztvyO-gH8nZ2dnUU7-enNnZ2d@giganews.com> <snhq6t$9bg$1@dont-email.me>
<ru6dnRcSxdCo4gH8nZ2dnUU7-f3NnZ2d@giganews.com> <sni0pq$54o$1@dont-email.me>
<ivSdnVvS3JNFnAD8nZ2dnUU7-W3NnZ2d@giganews.com> <snj6bs$utp$1@dont-email.me>
<lfSdnXZ8BOtOtAD8nZ2dnUU7-TPNnZ2d@giganews.com> <snjas5$22o$1@dont-email.me>
<WfidnVXHgel1rAD8nZ2dnUU7-K2dnZ2d@giganews.com> <snjlc9$g4m$1@dont-email.me>
<8-udnSXeWdV19gD8nZ2dnUU7-fHNnZ2d@giganews.com> <snjqvs$lp6$1@dont-email.me>
<7Y-dnTBnr7XbHgD8nZ2dnUU7-T2dnZ2d@giganews.com> <snk1n5$t3o$1@dont-email.me>
<6_SdnR5DMbtgEwD8nZ2dnUU7-ffNnZ2d@giganews.com> <snk4rc$cuu$1@dont-email.me>
<k6GdnTubureFBgD8nZ2dnUU7-KHNnZ2d@giganews.com> <snk7kc$pr8$1@dont-email.me>
Followup-To: comp.theory
From: NoO...@NoWhere.com (olcott)
In-Reply-To: <snk7kc$pr8$1@dont-email.me>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Message-ID: <bt6dncqPsKYYLQD8nZ2dnUU7-afNnZ2d@giganews.com>
Lines: 57
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-PDH98ly41//dBLYw2P55rdnVCOjV/gJjpljDjMZWI7o9/X7E4zOW/ztm7gQFc7iQIvMMhUh1Yl/DJMP!cOInaQrIQQ/Efi0nhyeGAVljivCL0/B9prqrOxf5FJ25owpP7LqoJmNAFVkLdLv5D64JyosqBI4z!WQ==
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: 4494
View all headers
On 11/23/2021 8:22 PM, André G. Isaak wrote:
On 2021-11-23 18:53, olcott wrote:
On 11/23/2021 7:34 PM, André G. Isaak wrote:

Crucially, the halting function exists *independently* and *prior* to any Turing Machine which attempts to compute this function. The halting function is *not* associated with any sort of algorithm; it is simply a mapping. In other words it is simply a denumerably infinite list of all possible computations and their halting status expressed as ordered pairs.



You don't realize it but you are asking a decider to make its decision on the basis of a hypothetical string that does not actually exist.

int  H(ptr x, ptr y) { x(y);    }
int  P(ptr x)        { H(x, x); }
int H1(ptr x, ptr y) { x(y);    }

The input to H requires that P call this very same H.
The input to H1 has no such pathological relationship to P.

By simply ignoring the pathological relationship between H and P you are answering the wrong question.

You are answering the question:
What would the behavior of P be if P called H1 instead of calling H?

That makes the "input" to H hypothetical rather than an actual string.

The computation P(P) will occur in this list exactly once, as will be true for all other computation. Since your P(P) halts, it will map to 'halts'.

A halt decider, given <P> <P> as its input, is tasked with determining what the entry for that computation in the list described above actually is in a finite number of steps. If <P> <P> maps to 'halts' in the halting function, then a halt decider must accept it. If it maps to 'doesn't halt', it must reject it.

That means that the halting value of P(P) is *not* specific to a given halt decider. Your H and H1 must both provide the same answer if they are both halt deciders. It means that it is non-sensical to talk about the halting value of P(P) 'inside' some H, since H's job is to determine what value this computation maps to in the halting FUNCTION which is independent of any halt decider.

André



--
Copyright 2021 Pete Olcott

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


Subject: Re: Concise refutation of halting problem proofs V27 [ input is not in domain ]
From: olcott
Newsgroups: comp.theory, comp.ai.philosophy, sci.logic, sci.math
Followup: comp.theory
Date: Thu, 25 Nov 2021 04:54 UTC
References: 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25
Path: i2pn2.org!i2pn.org!weretis.net!feeder6.news.weretis.net!news.misty.com!border2.nntp.dca1.giganews.com!nntp.giganews.com!buffer2.nntp.dca1.giganews.com!buffer1.nntp.dca1.giganews.com!news.giganews.com.POSTED!not-for-mail
NNTP-Posting-Date: Wed, 24 Nov 2021 22:54:43 -0600
Date: Wed, 24 Nov 2021 22:54:41 -0600
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:91.0) Gecko/20100101
Thunderbird/91.3.2
Subject: Re: Concise refutation of halting problem proofs V27 [ input is not
in domain ]
Content-Language: en-US
Newsgroups: comp.theory,comp.ai.philosophy,sci.logic,sci.math
References: <5-2dncs2MNPqYwb8nZ2dnUU7-KvNnZ2d@giganews.com>
<ru6dnRcSxdCo4gH8nZ2dnUU7-f3NnZ2d@giganews.com> <sni0pq$54o$1@dont-email.me>
<ivSdnVvS3JNFnAD8nZ2dnUU7-W3NnZ2d@giganews.com> <snj6bs$utp$1@dont-email.me>
<lfSdnXZ8BOtOtAD8nZ2dnUU7-TPNnZ2d@giganews.com> <snjas5$22o$1@dont-email.me>
<WfidnVXHgel1rAD8nZ2dnUU7-K2dnZ2d@giganews.com> <snjlc9$g4m$1@dont-email.me>
<8-udnSXeWdV19gD8nZ2dnUU7-fHNnZ2d@giganews.com> <snjqvs$lp6$1@dont-email.me>
<7Y-dnTBnr7XbHgD8nZ2dnUU7-T2dnZ2d@giganews.com> <snk1n5$t3o$1@dont-email.me>
<6_SdnR5DMbtgEwD8nZ2dnUU7-ffNnZ2d@giganews.com> <snk4rc$cuu$1@dont-email.me>
<k6GdnTubureFBgD8nZ2dnUU7-KHNnZ2d@giganews.com> <snk7kc$pr8$1@dont-email.me>
<bt6dncqPsKYYLQD8nZ2dnUU7-afNnZ2d@giganews.com> <snkcf3$kb7$1@dont-email.me>
<9LWdnRLm0vQeJAD8nZ2dnUU7-efNnZ2d@giganews.com> <snkef3$tik$1@dont-email.me>
<K7WdnUb8UoOATwD8nZ2dnUU7-RvNnZ2d@giganews.com> <snkm1f$ta2$1@dont-email.me>
<j7WdndVGIL-5yQP8nZ2dnUU7-U3NnZ2d@giganews.com> <snln12$sfn$1@dont-email.me>
Followup-To: comp.theory
From: NoO...@NoWhere.com (olcott)
In-Reply-To: <snln12$sfn$1@dont-email.me>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Message-ID: <F6mdnTvACp2OigL8nZ2dnUU7-LHNnZ2d@giganews.com>
Lines: 193
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-OpB0oTo72TYegUxY6B0nr82OLT5lGrkzRUptKYV1VJCpy+NpjkhtBc80jl1g4XKfCpDRbGO3qzl1sri!4PZLcmhnBxLkuA6zmYw3nAqcN/UO3fk3ELuveddwH/SRCgncXtgL/TmVTj70VGzNqzfRsBeR6KMi!rw==
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: 9899
View all headers
On 11/24/2021 9:50 AM, André G. Isaak wrote:
On 2021-11-24 08:02, olcott wrote:
On 11/24/2021 12:27 AM, André G. Isaak wrote:
On 2021-11-23 22:48, olcott wrote:
On 11/23/2021 10:18 PM, André G. Isaak wrote:
On 2021-11-23 21:03, olcott wrote:
On 11/23/2021 9:44 PM, André G. Isaak wrote:
On 2021-11-23 20:24, olcott wrote:
On 11/23/2021 8:22 PM, André G. Isaak wrote:
On 2021-11-23 18:53, olcott wrote:
On 11/23/2021 7:34 PM, André G. Isaak wrote:

Crucially, the halting function exists *independently* and *prior* to any Turing Machine which attempts to compute this function. The halting function is *not* associated with any sort of algorithm; it is simply a mapping. In other words it is simply a denumerably infinite list of all possible computations and their halting status expressed as ordered pairs.



You don't realize it but you are asking a decider to make its decision on the basis of a hypothetical string that does not actually exist.

???

So now you claim the STRING <P> <P> can't exist? But at the same time you claim that your H1 returns the correct answer for this allegedly impossible string? How on earth does that work.


int H(ptr x, ptr y) { x(y); }
int H1(ptr x, ptr y) { x(y); int P(ptr x) { H(x, x); }
int P1(ptr x) { H1(x, x); }


What does any of this have to do with your ridiculous claim that the string <P> <P> does not actually exist?

If you want the actual behavior of P(P) run independently
then you have to change P or H into something that they are not
because they are defined with hardwired inter-dependency.

If you want the actual behaviour of P(P) run independently, you simply run P(P) independently.


So in other words H must report on the behavior of a finite string that is not is input.

H doesn't report on the behaviour of finite strings at all. It reports on the behaviour of computations.

P(P) is a computation which halts.

Your H needs to be able to report that P(P) halts (or any other arbitrary computation).

Determining exactly how that particular computation must be encoded as a finite string so it can be passed as an input to H is part of your job when designing H.

Maybe you don't grasp this. Consider two UTMs, X and Y (and by UTM I mean actual UTMs). Both of these should be able to emulate P(P) if we give them two copies of a string which describes the Turing Machine P.

But the strings we pass to X and the string we pass to Y are *not* necessarily the same string. X and Y may use different alphabets and may use different encoding schemes. To constitute a UTM, it must be the case, though, that it is possible to represent every possible computation as a string that can be passed to that UTM.

If you've designed an H such that there is no possible way to represent the independent computation P(P) as a string which can be passed to H as an input, then there is something wrong with your design.

I think what you mean to say is if you want H to give you the correct answer about the actual behaviour of P(P) run independently, which it can't. The interdependency prevents this.


It is incorrect to think of H having the hypothetical input where P does not call H.All deciders must have finite string inputs. Because P foes

Where did I (or anyone) mention a P that does not simulate/call H?

H is required to describe the halting behaviour of the independent computation P(P). That means it must describe how P(P) behaves when called directly from main rather than from within your halt decider.

call this same H changing P so that it does not call this same H is incorrect.

It is equally incorrect to have H report on the behavior of P as if H was H1 where P does not call H1.

But that does not change the fact that the computation P(P) halts, and

The fact there there are no cats in the kitchen does not have one damn thing to do with dogs in the living room. I can't imagine how people can so persistently make this strawman error even after being warned dozens of times.

#include <stdint.h>
#include <stdio.h>
typedef int (*ptr)();

int H(ptr x, ptr y)
{
   x(y); // direct execution of P(P)
   return 1;
}

// Minimal essence of Linz(1990) Ĥ
// and Strachey(1965) P
int P(ptr x)
{
   H(x, x);
   return 1; // Give P a last instruction at the "c" level
}

int main(void)
{
   H(P, P);
}

Combinations of (H,P) having pathological self-reference (PSR)
   H(P,P) simulates or executes its input and aborts or does
   not abort its input and P(P) calls this same H(P,P) with itself.

for all Hn(Pn,Pn) in the above PSR set Pn never reaches its final instruction.


that this therefore is the only correct answer to the question which a halt decider is required to answer.

That is not the freaking way that deciders work.

A decider accepts or rejects all possible inputs based on some criteria determined by the problem at hand.

For the halting problem, the criterion is that the decider must accept all and only those independent computations which HALT.


If H(P,P) reports on the behavior of H1(P,P) or H(P1,P1) it freaking answered the wrong freaking question.

Those are the only pair of combinations that show P(P) as an independent computation and they are both answers to the wrong question.

NEITHER of those show P(P) as an independent computation.

H(P,P) must report on the behaviour of P(P). That's the *only* behaviour it is being asked about.


The one key verified fact that everyone simply assumes away even though it is a verified fact is that there are elements of the PSR set such that the input to Hn(Pn,Pn) never reaches its final state and Pn(Pn) does reach its final state in this exact same sequence of configurations.

People assume that the placement in the execution trace can't make a difference and yet it is a verified fact that this placement does make a difference. The one way dependency relationship that Pn(Pn) has on Hn(Pn,Pn) causes the outer Pn to behave differently than the inner Pn.

Simply assuming this away is flat out dishonest.

None of this is relevant (or even coherent). H(P, P) by the definition of the problem must report the behaviour of the independent computation P(P). Whether the "placement in the execution trace can make a difference" has no bearing on the behaviour of P(P). It might have some bearing on the behaviour of the simulation of P(P) inside of H, but that's not what the halt decider is being asked about.

The sequence of 1 to N configurations specified by the input to H(X, Y) cannot be correctly construed as anything other than the sequence of 1 to N steps of the (direct execution, x86 emulation or UTM simulation of this input by H.



--
Copyright 2021 Pete Olcott

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


1
rocksolid light 0.7.2
clearneti2ptor