Rocksolid Light

Welcome to novaBBS (click a section below)

mail  files  register  nodelist  faq  login

<< WAIT >>


computers / comp.ai.philosophy / Re: Black box halt decider is NOT a partial decider [ paradox rather than contradiction ]

SubjectAuthor
* Re: Black box halt decider is NOT a partial decider [ paradox ratherolcott
`* Re: Black box halt decider is NOT a partial decider [ H refutes Rice's Theolcott
 `* Re: Black box halt decider is NOT a partial decider [ H refutes Rice's Theolcott
  +* Re: Black box halt decider is NOT a partial decider [ H refutesJeff Barnett
  |`* Re: Black box halt decider is NOT a partial decider [ H refutesolcott
  | +- Re: Black box halt decider is NOT a partial decider [ H refutesolcott
  | `* Re: Black box halt decider is NOT a partial decider [ H refutesolcott
  |  `* Re: Black box halt decider is NOT a partial decider [ H refutes Rice's Theolcott
  |   `* Re: Black box halt decider is NOT a partial decider [ H refutesolcott
  |    `* Re: _Black_box_halt_decider_is_NOT_a_partial_decider_[_André_doesn't_know_olcott
  |     `* Re: _André_doesn't_know_Rice's_Theorem_[_Malcolm_]olcott
  |      +- Re: _André_doesn't_know_Rice's_Theorem_[_MalcJeff Barnett
  |      +- Re: _André_doesn't_know_Rice's_Theorem_[_Malcolm_]olcott
  |      +* Re: _André_doesn't_know_Rice's_Theorem_[_Malcolm_]olcott
  |      |`* Re: _André_doesn't_know_Rice's_Theorem_[_Malcolm_]olcott
  |      | +* Re: _André_doesn't_know_Rice's_Theorem_[_Malcolcott
  |      | |`* Re: _André_doesn't_know_Rice's_Theorem_[_Malcolcott
  |      | | `- Re: _André_doesn't_know_Rice's_Theorem_[_Malcolm_]_[_PSR_Decider_is_fully_olcott
  |      | `* Re: _André_doesn't_know_Rice's_Theorem_[_Malcolm_]_[_self-contradiction_muolcott
  |      |  `* Re: _André_doesn't_know_Rice's_Theorem_[_Malcolm_]_[_self-contradiction_muolcott
  |      |   +* Re: _André_doesn't_know_Rice's_Theorem_[_Malcolm_]_[_self-contradiction_muolcott
  |      |   |`- Re: _André_doesn't_know_Rice's_Theorem_[_Malcolm_]_[_self-contradiction_muolcott
  |      |   `* Re: _André_doesn't_know_Rice's_Theorem_[_Malcolcott
  |      |    `* Re: _André_doesn't_know_Rice's_Theorem_[_Malcolcott
  |      |     `* Re: _André_doesn't_know_Rice's_Theorem_[_Malcolm_]_[_Try_and_provide_a_couolcott
  |      |      `* Re: _André_doesn't_know_Rice's_Theorem_[_Malcolcott
  |      |       +- Re: _André_doesn't_know_Rice's_Theorem_[_Malcolcott
  |      |       `- Re: _André_doesn't_know_Rice's_Theorem_[_Malcolm_]_[_Try_and_provide_a_couolcott
  |      `- Re: _André_doesn't_know_Rice's_Theorem_[_Malcolcott
  `- Re: Black box halt decider is NOT a partial decider [ H refutesolcott

Pages:12
Subject: Re: Black box halt decider is NOT a partial decider [ paradox rather than contradiction ]
From: olcott
Newsgroups: comp.theory, comp.ai.philosophy, comp.software-eng, sci.math.symbolic
Date: Mon, 26 Jul 2021 03:53 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
Path: i2pn2.org!i2pn.org!weretis.net!feeder8.news.weretis.net!feeds.phibee-telecom.net!newsfeed.xs4all.nl!newsfeed7.news.xs4all.nl!news-out.netnews.com!news.alt.net!fdc2.netnews.com!peer02.ams1!peer.ams1.xlned.com!news.xlned.com!peer02.iad!feed-me.highwinds-media.com!news.highwinds-media.com!border1.nntp.dca1.giganews.com!nntp.giganews.com!buffer1.nntp.dca1.giganews.com!buffer2.nntp.dca1.giganews.com!news.giganews.com.POSTED!not-for-mail
NNTP-Posting-Date: Sun, 25 Jul 2021 22:53:57 -0500
Subject: Re: Black box halt decider is NOT a partial decider [ paradox rather
than contradiction ]
Newsgroups: comp.theory,comp.ai.philosophy,comp.software-eng,sci.math.symbolic
References: <20210719214640.00000dfc@reddwarf.jmc>
<sd76r9$r63$3@dont-email.me> <sd7cgs$1qmn$1@gioia.aioe.org>
<uMGJI.28030$qk6.2244@fx36.iad> <sd7een$js8$1@gioia.aioe.org>
<zyHJI.20655$7H7.13829@fx42.iad> <sd8bim$1set$1@gioia.aioe.org>
<87eebrlv2m.fsf@bsb.me.uk> <sdckqo$cm8$1@gioia.aioe.org>
<87a6mehx5q.fsf@bsb.me.uk> <sdfbv2$14bi$2@gioia.aioe.org>
<875yx0he2s.fsf@bsb.me.uk> <sdffqm$jsh$1@gioia.aioe.org>
<87zgucfux4.fsf@bsb.me.uk> <sdi9vb$r9b$1@dont-email.me>
<87eebnfc8c.fsf@bsb.me.uk>
<19Kdna-u6-AOSWH9nZ2dnUU78QXNnZ2d@brightview.co.uk>
<87tukjdqmi.fsf@bsb.me.uk> <sdjlo4$1oct$1@gioia.aioe.org>
<eOadnfv1CNxEEGD9nZ2dnUU78RPNnZ2d@brightview.co.uk>
<4826ab33-061b-472e-a1a5-e2ded35ecd82n@googlegroups.com>
<87r1fmcgta.fsf@bsb.me.uk>
<8978f969-8b53-4535-9bd3-e838818b9755n@googlegroups.com>
From: NoO...@NoWhere.com (olcott)
Date: Sun, 25 Jul 2021 22:53:56 -0500
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:78.0) Gecko/20100101
Thunderbird/78.12.0
MIME-Version: 1.0
In-Reply-To: <8978f969-8b53-4535-9bd3-e838818b9755n@googlegroups.com>
Content-Type: text/plain; charset=utf-8; format=flowed
Content-Language: en-US
Content-Transfer-Encoding: 7bit
Message-ID: <dLudnbEJjIhIrGP9nZ2dnUU7-dPNnZ2d@giganews.com>
Lines: 85
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-MNn5mH7WwG95HTbF4mj1HlOmNAOFPHDqQS6QFjp/5Zvp/HkPNDGhwU3ni/8OzIHTmuRYpPNLqPgrU1P!3VTWkYyVJu6IOzcoYnCVz5CgTzX8qezINEyayRMwb4CfGOFzm8o5EvYnWCrc9iNK4TRfe/Or1g==
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: 6511
X-Received-Bytes: 6721
View all headers
On 7/25/2021 3:54 PM, Malcolm McLean wrote:
On Sunday, 25 July 2021 at 20:52:04 UTC+1, Ben Bacarisse wrote:
Malcolm McLean <malcolm.ar...@gmail.com> writes:

On Sunday, 25 July 2021 at 17:14:20 UTC+1, Mike Terry wrote:

I think this is all a bit like Malcolm suggesting that PO is raising
"interesting ideas" that might be useful with more study, or that some
basic idea of PO's is "really quite clever...". It is NOT. PO has no
incling of those possibilities and really no interest in them. He is
simply saying things he naively thinks are true, without any logical
reasoning going on. No cleverness at all. He is not "performing a
magic trick", where he will pull a rabit out of a hat - he genuinely
believes he is refuting the Linz proof, no tricks. Pretending otherwise
may be being nice to PO, making him feel better, but is ultimately
unhelpful IMO. I'd say it seems like "dishonest niceness" to me. (But
maybe Malcolm really thinks PO is producing worthwhile results, or is on
the path to that, in which case it's just being "actually nice"!)

I've always been very clear that I haven't yet seen from PO anything that
constitutes a refutation of Linz.
Unless I've misunderstood what you mean, that's an extraordinary thing
to say. What do you mean by a "a refutation of Linz"? PO won't say, so
you can't be using the term as he does. Do you mean a demonstration
that a TM halt decider does exist (as PO sometimes claims)? Do you mean
the production of a TM X such that X(<[X^][X^]> is correct about
X^([X^]) (as PO originally clamed)? Or do you mean the finding of
irreparable errors in the two proofs of the theorem in Linz?

What would you accept as proof that the Earth is flat? I had a very good
teacher who used to pretend to be a flat earther. His case was that light
didn't travel in straight lines. When you relax the requirement that light travels
in straight lines, all of the simple proofs you read in  geography textbooks
become invalid, and as schoolboys we didn't have the intellectual equipment
to refute him. But of course we knew that he was kidding. No one for a
moment supposed seriously that the Earth wasn't round.

All the things you have mentioned would be extraordinary, and all have been
attempted by PO (he won't show the halt decider but he does show the
execution traces, he claims that Linz's roof is based on a "pathological
liar paradox"). I and plenty of others have pointed out why we don't accept
that he truly has an extraordinary result, much less a refutation.

Whilst on the face of it your question seems reasonable, I think really
it's a poor basis on which to proceed. If there's an argument from PO
that seems to make sense, and doesn't have an obvious hole in it, that's
the time to start worrying about what criteria we'll apply to accept that
Linz has been refuted.

I have established that H(P,P)==0 is the correct return value for the input to H even though the P of int main(){ P(P); } does halt.

No one is willing to carefully examine the detailed steps that I have provided that prove this, they all skip to the end and simply assume that it must be incorrect because the P of int main(){ P(P); } does halt.

If they bothered to go through the steps of this proof they would see the actual paradox rather than what superficially seems to be a contradiction. I take this as direct dishonestly.

You ask: "What criteria we'll apply to accept that Linz has been refuted?"

The answer is that almost no one will accept any criteria because they have no interest in me being right the only care about me being wrong. Flibble, wij and you may be exceptions to this rule.

I have proved that there is a paradox rather than a contradiction. The reason that there is a paradox is that self-contradictory input is inherently erroneous in the same way that the liar paradox is simply erroneous.


In all cases your "yet" is a very odd word to use. What concept of such
a simple and well-established theorem do you have that using the word
"yet" is reasonable in this context?

"Yet" is disingenuous.



--
Copyright 2021 Pete Olcott

"Great spirits have always encountered violent opposition from mediocre minds." Einstein


Subject: Re: Black box halt decider is NOT a partial decider [ H refutes Rice's Theorem ]
From: olcott
Newsgroups: comp.theory, comp.ai.philosophy, comp.software-eng, sci.math.symbolic
Date: Mon, 26 Jul 2021 14:20 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!feeder8.news.weretis.net!feeder1.feed.usenet.farm!feed.usenet.farm!tr2.eu1.usenetexpress.com!feeder.usenetexpress.com!tr2.iad1.usenetexpress.com!border1.nntp.dca1.giganews.com!nntp.giganews.com!buffer1.nntp.dca1.giganews.com!news.giganews.com.POSTED!not-for-mail
NNTP-Posting-Date: Mon, 26 Jul 2021 09:20:43 -0500
Subject: Re: Black box halt decider is NOT a partial decider [ H refutes Rice's Theorem ]
Newsgroups: comp.theory,comp.ai.philosophy,comp.software-eng,sci.math.symbolic
References: <20210719214640.00000dfc@reddwarf.jmc> <sd76r9$r63$3@dont-email.me> <sd7cgs$1qmn$1@gioia.aioe.org> <uMGJI.28030$qk6.2244@fx36.iad> <sd7een$js8$1@gioia.aioe.org> <zyHJI.20655$7H7.13829@fx42.iad> <sd8bim$1set$1@gioia.aioe.org> <87eebrlv2m.fsf@bsb.me.uk> <sdckqo$cm8$1@gioia.aioe.org> <87a6mehx5q.fsf@bsb.me.uk> <sdfbv2$14bi$2@gioia.aioe.org> <875yx0he2s.fsf@bsb.me.uk> <sdffqm$jsh$1@gioia.aioe.org> <87zgucfux4.fsf@bsb.me.uk> <sdi9vb$r9b$1@dont-email.me> <87eebnfc8c.fsf@bsb.me.uk> <19Kdna-u6-AOSWH9nZ2dnUU78QXNnZ2d@brightview.co.uk> <87tukjdqmi.fsf@bsb.me.uk> <sdjlo4$1oct$1@gioia.aioe.org> <eOadnfv1CNxEEGD9nZ2dnUU78RPNnZ2d@brightview.co.uk> <4826ab33-061b-472e-a1a5-e2ded35ecd82n@googlegroups.com> <87r1fmcgta.fsf@bsb.me.uk> <8978f969-8b53-4535-9bd3-e838818b9755n@googlegroups.com> <dLudnbEJjIhIrGP9nZ2dnUU7-dPNnZ2d@giganews.com> <sdlg2u$tth$1@dont-email.me>
From: NoO...@NoWhere.com (olcott)
Date: Mon, 26 Jul 2021 09:20:42 -0500
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:78.0) Gecko/20100101 Thunderbird/78.12.0
MIME-Version: 1.0
In-Reply-To: <sdlg2u$tth$1@dont-email.me>
Content-Type: text/plain; charset=utf-8; format=flowed
Content-Language: en-US
Content-Transfer-Encoding: 8bit
Message-ID: <g5Cdndhbg9ImWWP9nZ2dnUU7-S3NnZ2d@giganews.com>
Lines: 48
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-j9cY4jRwBcZvZAz4s9sgdSlYOz/IOqvF7Df3TuMpDl7B5sQ6xeBUypLSSIHN/XEX06qS/W0SsWPsRmR!jqg/Nt1J9xtUHZmR4LdlsJvEwrKHz3vrhKhrNrPYuOn8k+wvBVTKdXyjD7Sg0E2VPQW0HGVy2g==
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: 3907
View all headers
On 7/26/2021 12:09 AM, André G. Isaak wrote:
On 2021-07-25 21:53, olcott wrote:

I have established that H(P,P)==0 is the correct return value for the input to H even though the P of int main(){ P(P); } does halt.

The behaviour of int main(){ P(P); } is, *by definition*, the only correct answer to H(P,P)


The behavior of H(P,P) and P(P) varies only because of the erroneous self-contradictory input.

That the input has the pathological-self-reference(Olcott 2004) error can be discerned on the basis that H(P,P) != P(P). This refutes Rice.

No one is willing to carefully examine the detailed steps that I have provided that prove this, they all skip to the end and simply assume that it must be incorrect because the P of int main(){ P(P); } does halt.

If they bothered to go through the steps of this proof they would see the actual paradox rather than what superficially seems to be a contradiction. I take this as direct dishonestly.

How exactly do you distinguish between a paradox and a contradiction?

If H(P,P) is verified as correct and P(P) is verified as correct then H(P,P) != P(P) is not a contradiction.

Because of the fact that No P ever halts unless H(P,P) aborts the simulation of its input H(P,P) is more correct than P(P).

The error is not with H(P,P)==0 if all of the steps are analyzed no error can be found because there is no error. That the input to H(P,P) never halts is a verified fact. By not examining all of these steps when repeatedly asked to do so really seems to prove that you must be dishonest.


André




--
Copyright 2021 Pete Olcott

"Great spirits have always encountered violent opposition from mediocre minds." Einstein


Subject: Re: Black box halt decider is NOT a partial decider [ H refutes Rice's Theorem ]
From: olcott
Newsgroups: comp.theory, comp.ai.philosophy, comp.software-eng, sci.math.symbolic
Date: Mon, 26 Jul 2021 16:41 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 26 27
Path: i2pn2.org!i2pn.org!aioe.org!news.uzoreto.com!tr3.eu1.usenetexpress.com!feeder.usenetexpress.com!tr2.iad1.usenetexpress.com!border1.nntp.dca1.giganews.com!nntp.giganews.com!buffer1.nntp.dca1.giganews.com!news.giganews.com.POSTED!not-for-mail
NNTP-Posting-Date: Mon, 26 Jul 2021 11:41:33 -0500
Subject: Re: Black box halt decider is NOT a partial decider [ H refutes Rice's Theorem ]
Newsgroups: comp.theory,comp.ai.philosophy,comp.software-eng,sci.math.symbolic
References: <20210719214640.00000dfc@reddwarf.jmc> <sd76r9$r63$3@dont-email.me> <sd7cgs$1qmn$1@gioia.aioe.org> <uMGJI.28030$qk6.2244@fx36.iad> <sd7een$js8$1@gioia.aioe.org> <zyHJI.20655$7H7.13829@fx42.iad> <sd8bim$1set$1@gioia.aioe.org> <87eebrlv2m.fsf@bsb.me.uk> <sdckqo$cm8$1@gioia.aioe.org> <87a6mehx5q.fsf@bsb.me.uk> <sdfbv2$14bi$2@gioia.aioe.org> <875yx0he2s.fsf@bsb.me.uk> <sdffqm$jsh$1@gioia.aioe.org> <87zgucfux4.fsf@bsb.me.uk> <sdi9vb$r9b$1@dont-email.me> <87eebnfc8c.fsf@bsb.me.uk> <19Kdna-u6-AOSWH9nZ2dnUU78QXNnZ2d@brightview.co.uk> <87tukjdqmi.fsf@bsb.me.uk> <sdjlo4$1oct$1@gioia.aioe.org> <eOadnfv1CNxEEGD9nZ2dnUU78RPNnZ2d@brightview.co.uk> <4826ab33-061b-472e-a1a5-e2ded35ecd82n@googlegroups.com> <87r1fmcgta.fsf@bsb.me.uk> <8978f969-8b53-4535-9bd3-e838818b9755n@googlegroups.com> <dLudnbEJjIhIrGP9nZ2dnUU7-dPNnZ2d@giganews.com> <sdlg2u$tth$1@dont-email.me> <g5Cdndhbg9ImWWP9nZ2dnUU7-S3NnZ2d@giganews.com> <sdmmo7$72r$1@dont-email.me>
From: NoO...@NoWhere.com (olcott)
Date: Mon, 26 Jul 2021 11:41:32 -0500
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:78.0) Gecko/20100101 Thunderbird/78.12.0
MIME-Version: 1.0
In-Reply-To: <sdmmo7$72r$1@dont-email.me>
Content-Type: text/plain; charset=utf-8; format=flowed
Content-Language: en-US
Content-Transfer-Encoding: 8bit
Message-ID: <_7OdnVI71OcgeGP9nZ2dnUU7-UXNnZ2d@giganews.com>
Lines: 109
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-Y1GV9LSEyd7kLhFzFrKyumceUut3QsTRe8nMbl8vqWTJRGBjros1jGb7uWpksMAY2jiY8slgnlvOHbg!PL5G1e7GxeIa/lEX+bBsrMpaSjkocP0uedrfIlyCRuMTbSiit9PujyOcLCqE1drFPcNlkKmeUA==
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: 6857
View all headers
On 7/26/2021 11:09 AM, André G. Isaak wrote:
On 2021-07-26 08:20, olcott wrote:
On 7/26/2021 12:09 AM, André G. Isaak wrote:
On 2021-07-25 21:53, olcott wrote:

I have established that H(P,P)==0 is the correct return value for the input to H even though the P of int main(){ P(P); } does halt.

The behaviour of int main(){ P(P); } is, *by definition*, the only correct answer to H(P,P)


The behavior of H(P,P) and P(P) varies only because of the erroneous self-contradictory input.

That the input has the pathological-self-reference(Olcott 2004) error can be discerned on the basis that H(P,P) != P(P). This refutes Rice.

No one is willing to carefully examine the detailed steps that I have provided that prove this, they all skip to the end and simply assume that it must be incorrect because the P of int main(){ P(P); } does halt.

If they bothered to go through the steps of this proof they would see the actual paradox rather than what superficially seems to be a contradiction. I take this as direct dishonestly.

How exactly do you distinguish between a paradox and a contradiction?

If H(P,P) is verified as correct and P(P) is verified as correct then H(P,P) != P(P) is not a contradiction.

But H(P, P) *isn't* verified as correct.

While the input to H(P,P) is simulated in pure simulation mode it cannot possibly ever reach a final state thus conclusively proving that this input never halts.

Anyone bothering to carefully examine these things must necessarily conclude that the pure simulation of the input to H(P,P) cannot possibly reach its final state. Anyone not bothering to carefully examine these things is a liar and a cheat.

_P()
[00000c36](01)  55          push ebp
[00000c37](02)  8bec        mov ebp,esp
[00000c39](03)  8b4508      mov eax,[ebp+08] // 2nd Param
[00000c3c](01)  50          push eax
[00000c3d](03)  8b4d08      mov ecx,[ebp+08] // 1st Param
[00000c40](01)  51          push ecx
[00000c41](05)  e820fdffff  call 00000966    // call H(P,P)
[00000c46](03)  83c408      add esp,+08
[00000c49](02)  85c0        test eax,eax
[00000c4b](02)  7402        jz 00000c4f
[00000c4d](02)  ebfe        jmp 00000c4d
[00000c4f](01)  5d          pop ebp
[00000c50](01)  c3          ret
Size in bytes:(0027) [00000c50]

  machine   stack     stack     machine    assembly
  address   address   data      code       language
  ========  ========  ========  =========  =============
Begin Local Halt Decider Simulation at Machine Address:c36
[00000c36][002117ca][002117ce] 55          push ebp
[00000c37][002117ca][002117ce] 8bec        mov ebp,esp
[00000c39][002117ca][002117ce] 8b4508      mov eax,[ebp+08]
[00000c3c][002117c6][00000c36] 50          push eax       // push P
[00000c3d][002117c6][00000c36] 8b4d08      mov ecx,[ebp+08]
[00000c40][002117c2][00000c36] 51          push ecx       // push P
[00000c41][002117be][00000c46] e820fdffff  call 00000966  // call H(P,P)

[00000c36][0025c1f2][0025c1f6] 55          push ebp
[00000c37][0025c1f2][0025c1f6] 8bec        mov ebp,esp
[00000c39][0025c1f2][0025c1f6] 8b4508      mov eax,[ebp+08]
[00000c3c][0025c1ee][00000c36] 50          push eax       // push P
[00000c3d][0025c1ee][00000c36] 8b4d08      mov ecx,[ebp+08]
[00000c40][0025c1ea][00000c36] 51          push ecx       // push P
[00000c41][0025c1e6][00000c46] e820fdffff  call 00000966  // call H(P,P)
Local Halt Decider: Infinite Recursion Detected Simulation Stopped

 H(P, P) is required by the definition of the halting problem accept P(P) if and only if P(P), when run as an independent computation halts. The *only* correct answer to the question 'does P(P) halt' is the one that corresponds to the *actual* behaviour of P(P).

Because of the fact that No P ever halts unless H(P,P) aborts the simulation of its input H(P,P) is more correct than P(P).

You really need to reread what you've written above and think carefully about it.

You're claiming that an answer which does *not* correspond to the actual answer to the question is somehow 'more correct' than the one which does correspond to the actual answer to the question.

That's what I would call a 'pathological claim'.

André


P(P) != H(P,P) recognizes the pathological self-reference(Olcott 2004) error thus refuting Rice's theorem.

--
Copyright 2021 Pete Olcott

"Great spirits have always encountered violent opposition from mediocre minds." Einstein


Subject: Re: Black box halt decider is NOT a partial decider [ H refutes Rice's Theorem ]
From: Jeff Barnett
Newsgroups: comp.theory, comp.ai.philosophy, comp.software-eng, sci.math.symbolic
Organization: A noiseless patient Spider
Date: Mon, 26 Jul 2021 17:16 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 26 27 28
Path: i2pn2.org!i2pn.org!eternal-september.org!reader02.eternal-september.org!.POSTED!not-for-mail
From: jbb...@notatt.com (Jeff Barnett)
Newsgroups: comp.theory,comp.ai.philosophy,comp.software-eng,sci.math.symbolic
Subject: Re: Black box halt decider is NOT a partial decider [ H refutes
Rice's Theorem ]
Date: Mon, 26 Jul 2021 11:16:45 -0600
Organization: A noiseless patient Spider
Lines: 33
Message-ID: <sdmqm4$2hr$1@dont-email.me>
References: <20210719214640.00000dfc@reddwarf.jmc>
<sd76r9$r63$3@dont-email.me> <sd7cgs$1qmn$1@gioia.aioe.org>
<uMGJI.28030$qk6.2244@fx36.iad> <sd7een$js8$1@gioia.aioe.org>
<zyHJI.20655$7H7.13829@fx42.iad> <sd8bim$1set$1@gioia.aioe.org>
<87eebrlv2m.fsf@bsb.me.uk> <sdckqo$cm8$1@gioia.aioe.org>
<87a6mehx5q.fsf@bsb.me.uk> <sdfbv2$14bi$2@gioia.aioe.org>
<875yx0he2s.fsf@bsb.me.uk> <sdffqm$jsh$1@gioia.aioe.org>
<87zgucfux4.fsf@bsb.me.uk> <sdi9vb$r9b$1@dont-email.me>
<87eebnfc8c.fsf@bsb.me.uk>
<19Kdna-u6-AOSWH9nZ2dnUU78QXNnZ2d@brightview.co.uk>
<87tukjdqmi.fsf@bsb.me.uk> <sdjlo4$1oct$1@gioia.aioe.org>
<eOadnfv1CNxEEGD9nZ2dnUU78RPNnZ2d@brightview.co.uk>
<4826ab33-061b-472e-a1a5-e2ded35ecd82n@googlegroups.com>
<87r1fmcgta.fsf@bsb.me.uk>
<8978f969-8b53-4535-9bd3-e838818b9755n@googlegroups.com>
<dLudnbEJjIhIrGP9nZ2dnUU7-dPNnZ2d@giganews.com> <sdlg2u$tth$1@dont-email.me>
<g5Cdndhbg9ImWWP9nZ2dnUU7-S3NnZ2d@giganews.com> <sdmmo7$72r$1@dont-email.me>
<_7OdnVI71OcgeGP9nZ2dnUU7-UXNnZ2d@giganews.com>
Mime-Version: 1.0
Content-Type: text/plain; charset=utf-8; format=flowed
Content-Transfer-Encoding: quoted-printable
Injection-Date: Mon, 26 Jul 2021 17:16:52 -0000 (UTC)
Injection-Info: reader02.eternal-september.org; posting-host="ffe59912923cf984e1f7ff94634f1622";
logging-data="2619"; mail-complaints-to="abuse@eternal-september.org"; posting-account="U2FsdGVkX19NukdyKQLtuyjtD1e2uTbzUfAw0hQJyyY="
User-Agent: Mozilla/5.0 (Windows NT 6.1; Win64; x64; rv:78.0) Gecko/20100101
Thunderbird/78.12.0
Cancel-Lock: sha1:mDhI50Nh0QxLtlmwzD41Bcu1WNg=
In-Reply-To: <_7OdnVI71OcgeGP9nZ2dnUU7-UXNnZ2d@giganews.com>
Content-Language: en-US
View all headers
On 7/26/2021 10:41 AM, olcott wrote:
On 7/26/2021 11:09 AM, André G. Isaak wrote:

<SNIP>

You're claiming that an answer which does *not* correspond to the actual answer to the question is somehow 'more correct' than the one which does correspond to the actual answer to the question.

That's what I would call a 'pathological claim'.

André


P(P) != H(P,P) recognizes the pathological self-reference(Olcott 2004) error thus refuting Rice's theorem.

Reread the above and note how polite and nurturing Andre has been. And yet you reject his simple, near trivial point. Of course he is correct. You should apologize to him, not make silly arguments.

oh yes, how was Andres so polite to you? Well he called it a "pathological claim"; a "pathological and irrational claimer" is much nearer the mark others would say.

And what do you know about Rice? Since you likely can't boil water without supervision to keep you from harm, you couldn't prepare rice. I know it's a silly play on words but it's hard to believe that you can function in the real world with such a disoriented mind.
--
Jeff Barnett



Subject: Re: Black box halt decider is NOT a partial decider [ H refutes Rice's Theorem ]
From: olcott
Newsgroups: comp.theory, comp.ai.philosophy, comp.software-eng, sci.math.symbolic
Date: Mon, 26 Jul 2021 18:57 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 26 27 28
Path: i2pn2.org!i2pn.org!weretis.net!feeder6.news.weretis.net!news.snarked.org!border2.nntp.dca1.giganews.com!nntp.giganews.com!buffer2.nntp.dca1.giganews.com!news.giganews.com.POSTED!not-for-mail
NNTP-Posting-Date: Mon, 26 Jul 2021 13:57:20 -0500
Subject: Re: Black box halt decider is NOT a partial decider [ H refutes
Rice's Theorem ]
Newsgroups: comp.theory,comp.ai.philosophy,comp.software-eng,sci.math.symbolic
References: <20210719214640.00000dfc@reddwarf.jmc>
<sd7cgs$1qmn$1@gioia.aioe.org> <uMGJI.28030$qk6.2244@fx36.iad>
<sd7een$js8$1@gioia.aioe.org> <zyHJI.20655$7H7.13829@fx42.iad>
<sd8bim$1set$1@gioia.aioe.org> <87eebrlv2m.fsf@bsb.me.uk>
<sdckqo$cm8$1@gioia.aioe.org> <87a6mehx5q.fsf@bsb.me.uk>
<sdfbv2$14bi$2@gioia.aioe.org> <875yx0he2s.fsf@bsb.me.uk>
<sdffqm$jsh$1@gioia.aioe.org> <87zgucfux4.fsf@bsb.me.uk>
<sdi9vb$r9b$1@dont-email.me> <87eebnfc8c.fsf@bsb.me.uk>
<19Kdna-u6-AOSWH9nZ2dnUU78QXNnZ2d@brightview.co.uk>
<87tukjdqmi.fsf@bsb.me.uk> <sdjlo4$1oct$1@gioia.aioe.org>
<eOadnfv1CNxEEGD9nZ2dnUU78RPNnZ2d@brightview.co.uk>
<4826ab33-061b-472e-a1a5-e2ded35ecd82n@googlegroups.com>
<87r1fmcgta.fsf@bsb.me.uk>
<8978f969-8b53-4535-9bd3-e838818b9755n@googlegroups.com>
<dLudnbEJjIhIrGP9nZ2dnUU7-dPNnZ2d@giganews.com> <sdlg2u$tth$1@dont-email.me>
<g5Cdndhbg9ImWWP9nZ2dnUU7-S3NnZ2d@giganews.com> <sdmmo7$72r$1@dont-email.me>
<_7OdnVI71OcgeGP9nZ2dnUU7-UXNnZ2d@giganews.com> <sdmqm4$2hr$1@dont-email.me>
From: NoO...@NoWhere.com (olcott)
Date: Mon, 26 Jul 2021 13:57:20 -0500
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:78.0) Gecko/20100101
Thunderbird/78.12.0
MIME-Version: 1.0
In-Reply-To: <sdmqm4$2hr$1@dont-email.me>
Content-Type: text/plain; charset=utf-8; format=flowed
Content-Language: en-US
Content-Transfer-Encoding: 8bit
Message-ID: <ZNCdndMEKogNmGL9nZ2dnUU7-KvNnZ2d@giganews.com>
Lines: 100
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-aMKOwXudI7UMFdyy6qjC33HNS67SYywnGvsbK4S4r3JWxxITWmv7w3ASqVrLz44p7SavT7PK5Qmi93Y!OTWStIeas2fv/1mbUYqgvBAAw0/gkSyaDFbXykfuWynSZSoRBJ07ffGp99MJtroY095sCTqeGA==
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: 6578
View all headers
On 7/26/2021 12:16 PM, Jeff Barnett wrote:
On 7/26/2021 10:41 AM, olcott wrote:
On 7/26/2021 11:09 AM, André G. Isaak wrote:

<SNIP>

You're claiming that an answer which does *not* correspond to the actual answer to the question is somehow 'more correct' than the one which does correspond to the actual answer to the question.

That's what I would call a 'pathological claim'.

André


P(P) != H(P,P) recognizes the pathological self-reference(Olcott 2004) error thus refuting Rice's theorem.

Reread the above and note how polite and nurturing Andre has been. And yet you reject his simple, near trivial point. Of course he is correct. You should apologize to him, not make silly arguments.

oh yes, how was Andres so polite to you? Well he called it a "pathological claim"; a "pathological and irrational claimer" is much nearer the mark others would say.

And what do you know about Rice? Since you likely can't boil water without supervision to keep you from harm, you couldn't prepare rice. I know it's a silly play on words but it's hard to believe that you can function in the real world with such a disoriented mind.

The HP has the same self-contradictory pattern as the Liar Paradox.
"This sentence is not true." is indeed not true just
like the P of int main() { P(P); } definitely reaches its halting state.

It is a mistake to take the fact that "This sentence is not true" is not true as an indication that it is true.

In the exact same way it is a mistake to take the fact that the P of int main() { P(P); } definitely reaches its halting state as an indication that it is a halting computation.

_P()
[00000c36](01)  55          push ebp
[00000c37](02)  8bec        mov ebp,esp
[00000c39](03)  8b4508      mov eax,[ebp+08] // 2nd Param
[00000c3c](01)  50          push eax
[00000c3d](03)  8b4d08      mov ecx,[ebp+08] // 1st Param
[00000c40](01)  51          push ecx
[00000c41](05)  e820fdffff  call 00000966    // call H(P,P)
[00000c46](03)  83c408      add esp,+08
[00000c49](02)  85c0        test eax,eax
[00000c4b](02)  7402        jz 00000c4f
[00000c4d](02)  ebfe        jmp 00000c4d
[00000c4f](01)  5d          pop ebp
[00000c50](01)  c3          ret
Size in bytes:(0027) [00000c50]

  machine   stack     stack     machine    assembly
  address   address   data      code       language
  ========  ========  ========  =========  =============
Begin Local Halt Decider Simulation at Machine Address:c36
[00000c36][002117ca][002117ce] 55          push ebp
[00000c37][002117ca][002117ce] 8bec        mov ebp,esp
[00000c39][002117ca][002117ce] 8b4508      mov eax,[ebp+08]
[00000c3c][002117c6][00000c36] 50          push eax       // push P
[00000c3d][002117c6][00000c36] 8b4d08      mov ecx,[ebp+08]
[00000c40][002117c2][00000c36] 51          push ecx       // push P
[00000c41][002117be][00000c46] e820fdffff  call 00000966  // call H(P,P)

[00000c36][0025c1f2][0025c1f6] 55          push ebp
[00000c37][0025c1f2][0025c1f6] 8bec        mov ebp,esp
[00000c39][0025c1f2][0025c1f6] 8b4508      mov eax,[ebp+08]
[00000c3c][0025c1ee][00000c36] 50          push eax       // push P
[00000c3d][0025c1ee][00000c36] 8b4d08      mov ecx,[ebp+08]
[00000c40][0025c1ea][00000c36] 51          push ecx       // push P
[00000c41][0025c1e6][00000c46] e820fdffff  call 00000966  // call H(P,P)
Local Halt Decider: Infinite Recursion Detected Simulation Stopped

It is very easy to see that the pure simulation of the input to H(P,P) cannot possibly ever reach its final state by the fact that there are no conditional instructions that can possibly break out of the above infinite recursion.

It looks like people greatly prefer to be God damned liars on this issue.

I would hope for their sake that the following verse is not literally true. If it was up to me they would simply be forgiven rather than condemned to Hell (the literal meaning of: "God damned").

Revelation 21:8 (KJV)
....all liars, shall have their part in the lake which burneth with fire and brimstone: which is the second death.


--
Copyright 2021 Pete Olcott

"Great spirits have always encountered violent opposition from mediocre minds." Einstein


Subject: Re: Black box halt decider is NOT a partial decider [ H refutes Rice's Theorem ]
From: olcott
Newsgroups: comp.theory, comp.ai.philosophy, comp.software-eng, sci.math.symbolic
Date: Mon, 26 Jul 2021 19:40 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 26 27 28
Path: i2pn2.org!i2pn.org!weretis.net!feeder6.news.weretis.net!news.snarked.org!border2.nntp.dca1.giganews.com!nntp.giganews.com!buffer2.nntp.dca1.giganews.com!news.giganews.com.POSTED!not-for-mail
NNTP-Posting-Date: Mon, 26 Jul 2021 14:40:06 -0500
Subject: Re: Black box halt decider is NOT a partial decider [ H refutes
Rice's Theorem ]
Newsgroups: comp.theory,comp.ai.philosophy,comp.software-eng,sci.math.symbolic
References: <20210719214640.00000dfc@reddwarf.jmc>
<sd7cgs$1qmn$1@gioia.aioe.org> <uMGJI.28030$qk6.2244@fx36.iad>
<sd7een$js8$1@gioia.aioe.org> <zyHJI.20655$7H7.13829@fx42.iad>
<sd8bim$1set$1@gioia.aioe.org> <87eebrlv2m.fsf@bsb.me.uk>
<sdckqo$cm8$1@gioia.aioe.org> <87a6mehx5q.fsf@bsb.me.uk>
<sdfbv2$14bi$2@gioia.aioe.org> <875yx0he2s.fsf@bsb.me.uk>
<sdffqm$jsh$1@gioia.aioe.org> <87zgucfux4.fsf@bsb.me.uk>
<sdi9vb$r9b$1@dont-email.me> <87eebnfc8c.fsf@bsb.me.uk>
<19Kdna-u6-AOSWH9nZ2dnUU78QXNnZ2d@brightview.co.uk>
<87tukjdqmi.fsf@bsb.me.uk> <sdjlo4$1oct$1@gioia.aioe.org>
<eOadnfv1CNxEEGD9nZ2dnUU78RPNnZ2d@brightview.co.uk>
<4826ab33-061b-472e-a1a5-e2ded35ecd82n@googlegroups.com>
<87r1fmcgta.fsf@bsb.me.uk>
<8978f969-8b53-4535-9bd3-e838818b9755n@googlegroups.com>
<dLudnbEJjIhIrGP9nZ2dnUU7-dPNnZ2d@giganews.com> <sdlg2u$tth$1@dont-email.me>
<g5Cdndhbg9ImWWP9nZ2dnUU7-S3NnZ2d@giganews.com> <sdmmo7$72r$1@dont-email.me>
<_7OdnVI71OcgeGP9nZ2dnUU7-UXNnZ2d@giganews.com> <sdmpob$rnp$1@dont-email.me>
From: NoO...@NoWhere.com (olcott)
Date: Mon, 26 Jul 2021 14:40:06 -0500
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:78.0) Gecko/20100101
Thunderbird/78.12.0
MIME-Version: 1.0
In-Reply-To: <sdmpob$rnp$1@dont-email.me>
Content-Type: text/plain; charset=utf-8; format=flowed
Content-Language: en-US
Content-Transfer-Encoding: 8bit
Message-ID: <1ZidnRe_AtgLkmL9nZ2dnUU7-KvNnZ2d@giganews.com>
Lines: 70
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-xAXxhogLEWiS+9J/ioXKjP+pZvzlqAeYJwGFzCk5g4oy08PG40Vsixtq2LFTloqwCcAwutc/fI786QT!ulj/Z0xZlPJOOI9KSzrz05Y0CwAJEA17J+isQZE1UtVsDE55lhc09hTgVSu9sHpwpK+UkPiQsA==
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: 4888
View all headers
On 7/26/2021 12:00 PM, André G. Isaak wrote:
On 2021-07-26 10:41, olcott wrote:
On 7/26/2021 11:09 AM, André G. Isaak wrote:

But H(P, P) *isn't* verified as correct.

While the input to H(P,P) is simulated in pure simulation mode it cannot possibly ever reach a final state thus conclusively proving that this input never halts.

But P(P) is defined as including a copy of H which *isn't* run in 'pure simulation mode'.


Because it is common knowledge that in any scientific investigation when we examine the effect of an independent variable[1] on a dependent variable[2] that any back-channel communication from the dependent variable[2] to the independent variable[1] corrupts the analysis.

[1] The behavior of P
[2] The halt status evaluation by H

The way to correct for this when an input to the halt decider was intentionally defined to corrupt this process is to examine the behavior of the input in pure simulation mode expressly disallowing any corrupting back-channel communication from H to P.

You can set the *outermost* H to run in 'pure simulator mode' if you want. But you can't change what occurs in P's copy of H (or put it in some other 'mode') or you are no longer evaluating P but something else.

Because of the fact that No P ever halts unless H(P,P) aborts the simulation of its input H(P,P) is more correct than P(P).

You really need to reread what you've written above and think carefully about it.

You're claiming that an answer which does *not* correspond to the actual answer to the question is somehow 'more correct' than the one which does correspond to the actual answer to the question.

That's what I would call a 'pathological claim'.

André


P(P) != H(P,P) recognizes the pathological self-reference(Olcott 2004) error thus refuting Rice's theorem.

There is no 'pathological self-reference error'. Nothing in Linz's proof involves something which refers at all, let alone something which refers to itself.


https://www.researchgate.net/publication/351947980_Halting_problem_undecidability_and_infinitely_nested_simulation

In the last page of the Linz proof provided in my paper above Linz does apply Ĥ to its own machine decription.  Why lie?

The only pathological error here is your claim that an incorrect answer is 'more correct' than a correct answer.




--
Copyright 2021 Pete Olcott

"Great spirits have always encountered violent opposition from mediocre minds." Einstein


Subject: Re: Black box halt decider is NOT a partial decider [ H refutes Rice's Theorem ]
From: olcott
Newsgroups: comp.theory, comp.ai.philosophy, comp.software-eng, sci.math.symbolic
Date: Mon, 26 Jul 2021 20:34 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 26 27
Path: i2pn2.org!i2pn.org!weretis.net!feeder6.news.weretis.net!news.snarked.org!border2.nntp.dca1.giganews.com!nntp.giganews.com!buffer2.nntp.dca1.giganews.com!news.giganews.com.POSTED!not-for-mail
NNTP-Posting-Date: Mon, 26 Jul 2021 15:34:46 -0500
Subject: Re: Black box halt decider is NOT a partial decider [ H refutes
Rice's Theorem ]
Newsgroups: comp.theory,comp.ai.philosophy,comp.software-eng,sci.math.symbolic
References: <20210719214640.00000dfc@reddwarf.jmc>
<zyHJI.20655$7H7.13829@fx42.iad> <sd8bim$1set$1@gioia.aioe.org>
<87eebrlv2m.fsf@bsb.me.uk> <sdckqo$cm8$1@gioia.aioe.org>
<87a6mehx5q.fsf@bsb.me.uk> <sdfbv2$14bi$2@gioia.aioe.org>
<875yx0he2s.fsf@bsb.me.uk> <sdffqm$jsh$1@gioia.aioe.org>
<87zgucfux4.fsf@bsb.me.uk> <sdi9vb$r9b$1@dont-email.me>
<87eebnfc8c.fsf@bsb.me.uk>
<19Kdna-u6-AOSWH9nZ2dnUU78QXNnZ2d@brightview.co.uk>
<87tukjdqmi.fsf@bsb.me.uk> <sdjlo4$1oct$1@gioia.aioe.org>
<eOadnfv1CNxEEGD9nZ2dnUU78RPNnZ2d@brightview.co.uk>
<4826ab33-061b-472e-a1a5-e2ded35ecd82n@googlegroups.com>
<87r1fmcgta.fsf@bsb.me.uk>
<8978f969-8b53-4535-9bd3-e838818b9755n@googlegroups.com>
<dLudnbEJjIhIrGP9nZ2dnUU7-dPNnZ2d@giganews.com> <sdlg2u$tth$1@dont-email.me>
<g5Cdndhbg9ImWWP9nZ2dnUU7-S3NnZ2d@giganews.com> <sdmmo7$72r$1@dont-email.me>
<_7OdnVI71OcgeGP9nZ2dnUU7-UXNnZ2d@giganews.com> <sdmqm4$2hr$1@dont-email.me>
<ZNCdndMEKogNmGL9nZ2dnUU7-KvNnZ2d@giganews.com> <sdn40f$5ea$1@dont-email.me>
From: NoO...@NoWhere.com (olcott)
Date: Mon, 26 Jul 2021 15:34:45 -0500
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:78.0) Gecko/20100101
Thunderbird/78.12.0
MIME-Version: 1.0
In-Reply-To: <sdn40f$5ea$1@dont-email.me>
Content-Type: text/plain; charset=utf-8; format=flowed
Content-Language: en-US
Content-Transfer-Encoding: 8bit
Message-ID: <iYqdnZGWc7_7gWL9nZ2dnUU7-UXNnZ2d@giganews.com>
Lines: 86
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-SVqGUxVcnp8qsXBhiZq8TdE08ihgkE4ySFmIMWJHwl/VG+PWfU+i5lEug1WGXVopyCB/u/k0qpyf7ge!ER7IiZb+bo8LxvY3orHF4ny89A4jJjZFYoTkiiMn1O2V1FBeQDCoVtGJOtCzbO2Ar7Vf6RIdLQ==
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: 5634
View all headers
On 7/26/2021 2:55 PM, André G. Isaak wrote:
On 2021-07-26 12:57, olcott wrote:

In the exact same way it is a mistake to take the fact that the P of int main() { P(P); } definitely reaches its halting state as an indication that it is a halting computation.

You seem to have a serious difficulty processing definitions.

The *definition* of a halting computation is a computation which reaches one of its final states in a finite number of steps. This refers only to the *actual* computation.

This definition exhaustively partitions the set of computations into two mutually-exclusive groups. If we observe that a computation such as P(P) reaches a final state in a finite number of steps, it goes in the halting group. Otherwise, it goes into the non-halting group.

The definition is clear and unambiguous.

It does not mention anything about simulators or aborted simulations.

It makes no exceptions for 'pathological' inputs.

It doesn't care *how* they end up in their final state. That is, it doesn't say "except if the only reason it halted was become some otherwise infinite chain of simulations was aborted".

The *only* thing it cares about is whether the computation ends up in a final state after a finite number of steps.

Once we have observed that P(P) *does* reach a final state in a finite number of steps, we put it in the 'halting' group and we are done.

At this point, there are absolutely no additional considerations which can have any relevance whatsoever. No arguments, or traces, or claims about 'pathological' anything will make a difference to the fact that it has been placed in the halting group and thus *cannot* be a non-halting computation.

The *only* possible way you can claim that H(P, P)==0 is if you are using an entirely different definition of 'halting' from the rest of the world,

A self-contradictory inputs such as the last page of the Linz proof where the Linz Ĥ is applied to its own TM description must be handled differently than inputs that are not self-contradictory.

You can say that when Ĥ is applied to its own TM description that it is not a case of a TM being applied to its own TM description (an obvious lie) or you can admit that this is a case of self-reference.

Being able to simply recognize that this input is self-contradictory refutes Rice's Theorem. If the halt decider returned 2 for invalid input this refutes Rices Theorem.

// Simplified Linz Ĥ (Linz:1990:319)
// Strachey(1965) CPL translated to C
void P(u32 x)
{
   if (H(x, x))
     HERE: goto HERE;
}

You can also say that when the input to H does the opposite of whatever that halt decider decides that it is not doing the opposite of whatever that halt decider decides. This would be an obvious lie.

Or you can admit that when the input does the opposite of whatever the halt decider decides that it is contradicting the halt decider.



in which case your argument has no bearing on the halting problem since that problem uses the standard definition of halting. An Olcott-Halting Decider is *not* a Halting Decider.

André



--
Copyright 2021 Pete Olcott

"Great spirits have always encountered violent opposition from mediocre minds." Einstein


Subject: Re: Black box halt decider is NOT a partial decider [ H refutes Rice's Theorem ]
From: olcott
Newsgroups: comp.theory, comp.ai.philosophy, comp.software-eng, sci.math.symbolic
Date: Tue, 27 Jul 2021 00:14 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 26 27
Path: i2pn2.org!i2pn.org!weretis.net!feeder6.news.weretis.net!news.snarked.org!border2.nntp.dca1.giganews.com!nntp.giganews.com!buffer2.nntp.dca1.giganews.com!news.giganews.com.POSTED!not-for-mail
NNTP-Posting-Date: Mon, 26 Jul 2021 19:14:54 -0500
Subject: Re: Black box halt decider is NOT a partial decider [ H refutes
Rice's Theorem ]
Newsgroups: comp.theory,comp.ai.philosophy,comp.software-eng,sci.math.symbolic
References: <20210719214640.00000dfc@reddwarf.jmc>
<zyHJI.20655$7H7.13829@fx42.iad> <sd8bim$1set$1@gioia.aioe.org>
<87eebrlv2m.fsf@bsb.me.uk> <sdckqo$cm8$1@gioia.aioe.org>
<87a6mehx5q.fsf@bsb.me.uk> <sdfbv2$14bi$2@gioia.aioe.org>
<875yx0he2s.fsf@bsb.me.uk> <sdffqm$jsh$1@gioia.aioe.org>
<87zgucfux4.fsf@bsb.me.uk> <sdi9vb$r9b$1@dont-email.me>
<87eebnfc8c.fsf@bsb.me.uk>
<19Kdna-u6-AOSWH9nZ2dnUU78QXNnZ2d@brightview.co.uk>
<87tukjdqmi.fsf@bsb.me.uk> <sdjlo4$1oct$1@gioia.aioe.org>
<eOadnfv1CNxEEGD9nZ2dnUU78RPNnZ2d@brightview.co.uk>
<4826ab33-061b-472e-a1a5-e2ded35ecd82n@googlegroups.com>
<87r1fmcgta.fsf@bsb.me.uk>
<8978f969-8b53-4535-9bd3-e838818b9755n@googlegroups.com>
<dLudnbEJjIhIrGP9nZ2dnUU7-dPNnZ2d@giganews.com> <sdlg2u$tth$1@dont-email.me>
<g5Cdndhbg9ImWWP9nZ2dnUU7-S3NnZ2d@giganews.com> <sdmmo7$72r$1@dont-email.me>
<_7OdnVI71OcgeGP9nZ2dnUU7-UXNnZ2d@giganews.com> <sdmqm4$2hr$1@dont-email.me>
<ZNCdndMEKogNmGL9nZ2dnUU7-KvNnZ2d@giganews.com> <sdn40f$5ea$1@dont-email.me>
From: NoO...@NoWhere.com (olcott)
Date: Mon, 26 Jul 2021 19:14:54 -0500
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:78.0) Gecko/20100101
Thunderbird/78.12.0
MIME-Version: 1.0
In-Reply-To: <sdn40f$5ea$1@dont-email.me>
Content-Type: text/plain; charset=utf-8; format=flowed
Content-Language: en-US
Content-Transfer-Encoding: 8bit
Message-ID: <IYGdnV9avtZj0mL9nZ2dnUU7-d-dnZ2d@giganews.com>
Lines: 36
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-WszesJZ4ZkRV8d8ySXDCIVznck7zmshgSDLBgY+Jh+I+aYAWnhqdm0QJlDVbge0yiEMVz47SxnLgItV!nj7GYE7VDQG+WWyebsM8wRA4q8914cJiVz3uwEkReIc4qG9SVjBccL8iIdQKx7G61d0h8YYguQ==
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: 3680
View all headers
On 7/26/2021 2:55 PM, André G. Isaak wrote:
On 2021-07-26 12:57, olcott wrote:

In the exact same way it is a mistake to take the fact that the P of int main() { P(P); } definitely reaches its halting state as an indication that it is a halting computation.

You seem to have a serious difficulty processing definitions.

The *definition* of a halting computation is a computation which reaches one of its final states in a finite number of steps. This refers only to the *actual* computation.

This definition exhaustively partitions the set of computations into two mutually-exclusive groups. If we observe that a computation such as P(P) reaches a final state in a finite number of steps, it goes in the halting group. Otherwise, it goes into the non-halting group.

The definition is clear and unambiguous.

It does not mention anything about simulators or aborted simulations.

It makes no exceptions for 'pathological' inputs.


None-the-less if pathological inputs can be recognized this refutes Rice.
None-the-less if pathological inputs can be recognized this refutes Rice.
None-the-less if pathological inputs can be recognized this refutes Rice.
None-the-less if pathological inputs can be recognized this refutes Rice.


--
Copyright 2021 Pete Olcott

"Great spirits have always encountered violent opposition from mediocre minds." Einstein


Subject: Re: Black box halt decider is NOT a partial decider [ H refutes Rice's Theorem ]
From: olcott
Newsgroups: comp.theory, comp.ai.philosophy, comp.software-eng, sci.math.symbolic
Date: Tue, 27 Jul 2021 01:03 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 26 27
Path: i2pn2.org!i2pn.org!paganini.bofh.team!news.dns-netz.com!news.freedyn.net!newsfeed.xs4all.nl!newsfeed9.news.xs4all.nl!tr1.eu1.usenetexpress.com!feeder.usenetexpress.com!tr3.iad1.usenetexpress.com!border1.nntp.dca1.giganews.com!nntp.giganews.com!buffer1.nntp.dca1.giganews.com!news.giganews.com.POSTED!not-for-mail
NNTP-Posting-Date: Mon, 26 Jul 2021 20:03:31 -0500
Subject: Re: Black box halt decider is NOT a partial decider [ H refutes Rice's Theorem ]
Newsgroups: comp.theory,comp.ai.philosophy,comp.software-eng,sci.math.symbolic
References: <20210719214640.00000dfc@reddwarf.jmc> <87eebrlv2m.fsf@bsb.me.uk> <sdckqo$cm8$1@gioia.aioe.org> <87a6mehx5q.fsf@bsb.me.uk> <sdfbv2$14bi$2@gioia.aioe.org> <875yx0he2s.fsf@bsb.me.uk> <sdffqm$jsh$1@gioia.aioe.org> <87zgucfux4.fsf@bsb.me.uk> <sdi9vb$r9b$1@dont-email.me> <87eebnfc8c.fsf@bsb.me.uk> <19Kdna-u6-AOSWH9nZ2dnUU78QXNnZ2d@brightview.co.uk> <87tukjdqmi.fsf@bsb.me.uk> <sdjlo4$1oct$1@gioia.aioe.org> <eOadnfv1CNxEEGD9nZ2dnUU78RPNnZ2d@brightview.co.uk> <4826ab33-061b-472e-a1a5-e2ded35ecd82n@googlegroups.com> <87r1fmcgta.fsf@bsb.me.uk> <8978f969-8b53-4535-9bd3-e838818b9755n@googlegroups.com> <dLudnbEJjIhIrGP9nZ2dnUU7-dPNnZ2d@giganews.com> <sdlg2u$tth$1@dont-email.me> <g5Cdndhbg9ImWWP9nZ2dnUU7-S3NnZ2d@giganews.com> <sdmmo7$72r$1@dont-email.me> <_7OdnVI71OcgeGP9nZ2dnUU7-UXNnZ2d@giganews.com> <sdmqm4$2hr$1@dont-email.me> <ZNCdndMEKogNmGL9nZ2dnUU7-KvNnZ2d@giganews.com> <sdn40f$5ea$1@dont-email.me> <IYGdnV9avtZj0mL9nZ2dnUU7-d-dnZ2d@giganews.com> <sdnjhs$30s$1@dont-email.me>
From: NoO...@NoWhere.com (olcott)
Date: Mon, 26 Jul 2021 20:03:31 -0500
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:78.0) Gecko/20100101 Thunderbird/78.12.0
MIME-Version: 1.0
In-Reply-To: <sdnjhs$30s$1@dont-email.me>
Content-Type: text/plain; charset=utf-8; format=flowed
Content-Language: en-US
Content-Transfer-Encoding: 8bit
Message-ID: <QNOdnRIn-O3-xmL9nZ2dnUU7-fvNnZ2d@giganews.com>
Lines: 52
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-3V3CMZpw5jp/Af7zaJ2nfF/81Y8mcAyK4cjf2H5XbbQtkODtHD+/m/U/pyWehhmfrS9nHJqKhGzFfT9!vvcWUF4RsP6alb7y77eAdKi2kxOQZD3Ng9nudVXaxy+rs53QNahf1Lm2Sc/B3TEd0H4+Fy4wbQ==
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: 4403
View all headers
On 7/26/2021 7:21 PM, André G. Isaak wrote:
On 2021-07-26 18:14, olcott wrote:
On 7/26/2021 2:55 PM, André G. Isaak wrote:
On 2021-07-26 12:57, olcott wrote:

In the exact same way it is a mistake to take the fact that the P of int main() { P(P); } definitely reaches its halting state as an indication that it is a halting computation.

You seem to have a serious difficulty processing definitions.

The *definition* of a halting computation is a computation which reaches one of its final states in a finite number of steps. This refers only to the *actual* computation.

This definition exhaustively partitions the set of computations into two mutually-exclusive groups. If we observe that a computation such as P(P) reaches a final state in a finite number of steps, it goes in the halting group. Otherwise, it goes into the non-halting group.

The definition is clear and unambiguous.

It does not mention anything about simulators or aborted simulations.

It makes no exceptions for 'pathological' inputs.


None-the-less if pathological inputs can be recognized this refutes Rice.
None-the-less if pathological inputs can be recognized this refutes Rice.
None-the-less if pathological inputs can be recognized this refutes Rice.
None-the-less if pathological inputs can be recognized this refutes Rice.

There *are no* patholological inputs. There are simply inputs that H gets wrong. There's nothing absolutely 'pathological' about that.

If my system recognizes whatever you want to call it the cases where the halt decider gets wrong, this refutes Rice.

At this point I suspect that you may think that I am talking about the breakfast cereal and have no idea about Rice's Theorem.

In computability theory, Rice's theorem states that all non-trivial, semantic properties of programs are undecidable.
https://en.wikipedia.org/wiki/Rice%27s_theorem



--
Copyright 2021 Pete Olcott

"Great spirits have always encountered violent opposition from mediocre minds." Einstein


Subject: Re: Black box halt decider is NOT a partial decider [ H refutes Rice's Theorem ]
From: olcott
Newsgroups: comp.theory, comp.ai.philosophy, comp.software-eng, sci.math.symbolic
Date: Tue, 27 Jul 2021 01:30 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 26
Path: i2pn2.org!i2pn.org!usenet.goja.nl.eu.org!news.dns-netz.com!news.freedyn.net!newsfeed.xs4all.nl!newsfeed7.news.xs4all.nl!news-out.netnews.com!news.alt.net!fdc2.netnews.com!peer03.ams1!peer.ams1.xlned.com!news.xlned.com!peer02.iad!feed-me.highwinds-media.com!news.highwinds-media.com!border1.nntp.dca1.giganews.com!nntp.giganews.com!buffer1.nntp.dca1.giganews.com!buffer2.nntp.dca1.giganews.com!news.giganews.com.POSTED!not-for-mail
NNTP-Posting-Date: Mon, 26 Jul 2021 20:30:32 -0500
Subject: Re: Black box halt decider is NOT a partial decider [ H refutes
Rice's Theorem ]
Newsgroups: comp.theory,comp.ai.philosophy,comp.software-eng,sci.math.symbolic
References: <20210719214640.00000dfc@reddwarf.jmc>
<sdfbv2$14bi$2@gioia.aioe.org> <875yx0he2s.fsf@bsb.me.uk>
<sdffqm$jsh$1@gioia.aioe.org> <87zgucfux4.fsf@bsb.me.uk>
<sdi9vb$r9b$1@dont-email.me> <87eebnfc8c.fsf@bsb.me.uk>
<19Kdna-u6-AOSWH9nZ2dnUU78QXNnZ2d@brightview.co.uk>
<87tukjdqmi.fsf@bsb.me.uk> <sdjlo4$1oct$1@gioia.aioe.org>
<eOadnfv1CNxEEGD9nZ2dnUU78RPNnZ2d@brightview.co.uk>
<4826ab33-061b-472e-a1a5-e2ded35ecd82n@googlegroups.com>
<87r1fmcgta.fsf@bsb.me.uk>
<8978f969-8b53-4535-9bd3-e838818b9755n@googlegroups.com>
<dLudnbEJjIhIrGP9nZ2dnUU7-dPNnZ2d@giganews.com> <sdlg2u$tth$1@dont-email.me>
<g5Cdndhbg9ImWWP9nZ2dnUU7-S3NnZ2d@giganews.com> <sdmmo7$72r$1@dont-email.me>
<_7OdnVI71OcgeGP9nZ2dnUU7-UXNnZ2d@giganews.com> <sdmqm4$2hr$1@dont-email.me>
<ZNCdndMEKogNmGL9nZ2dnUU7-KvNnZ2d@giganews.com> <sdn40f$5ea$1@dont-email.me>
<IYGdnV9avtZj0mL9nZ2dnUU7-d-dnZ2d@giganews.com> <sdnjhs$30s$1@dont-email.me>
<QNOdnRIn-O3-xmL9nZ2dnUU7-fvNnZ2d@giganews.com> <sdnn91$k7p$1@dont-email.me>
From: NoO...@NoWhere.com (olcott)
Date: Mon, 26 Jul 2021 20:30:31 -0500
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:78.0) Gecko/20100101
Thunderbird/78.12.0
MIME-Version: 1.0
In-Reply-To: <sdnn91$k7p$1@dont-email.me>
Content-Type: text/plain; charset=utf-8; format=flowed
Content-Language: en-US
Content-Transfer-Encoding: 8bit
Message-ID: <tbGdnZb32okl_GL9nZ2dnUU7-UvNnZ2d@giganews.com>
Lines: 75
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-J8tV9m2ZiC7qWhJv2/TIIVB0L9KaJvb4SbvmT4UdZBqYmFm4bvZcNQOBlrtIZRX24gQBF3f/TnDgaHA!APXXCmGhNuYdkwFrPPrfLeN86pAIYdiL7LJLuFCIj+TlVqRVCkMpNMxeqvMcmtOvNpPDMrq9qQ==
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: 5137
X-Received-Bytes: 5347
View all headers
On 7/26/2021 8:24 PM, André G. Isaak wrote:
On 2021-07-26 19:03, olcott wrote:
On 7/26/2021 7:21 PM, André G. Isaak wrote:
On 2021-07-26 18:14, olcott wrote:
On 7/26/2021 2:55 PM, André G. Isaak wrote:
On 2021-07-26 12:57, olcott wrote:

In the exact same way it is a mistake to take the fact that the P of int main() { P(P); } definitely reaches its halting state as an indication that it is a halting computation.

You seem to have a serious difficulty processing definitions.

The *definition* of a halting computation is a computation which reaches one of its final states in a finite number of steps. This refers only to the *actual* computation.

This definition exhaustively partitions the set of computations into two mutually-exclusive groups. If we observe that a computation such as P(P) reaches a final state in a finite number of steps, it goes in the halting group. Otherwise, it goes into the non-halting group.

The definition is clear and unambiguous.

It does not mention anything about simulators or aborted simulations.

It makes no exceptions for 'pathological' inputs.


None-the-less if pathological inputs can be recognized this refutes Rice.
None-the-less if pathological inputs can be recognized this refutes Rice.
None-the-less if pathological inputs can be recognized this refutes Rice.
None-the-less if pathological inputs can be recognized this refutes Rice.

There *are no* patholological inputs. There are simply inputs that H gets wrong. There's nothing absolutely 'pathological' about that.

If my system recognizes whatever you want to call it the cases where the halt decider gets wrong, this refutes Rice.

What does that unsubstantiated claim have to do with the question I'd asked, which was:

How can the claim that H(P, P)==0 be justified *in terms of the definition of halting* and in terms of the *actual behaviour* of P(P).


That does not currently matter, as long as we can consistently use H(P,P) != P(P) to detect and reject the halting problem counter-examples we have refuted Rice's theorem.

Is it possible for you to detect when the subject has been changed or do you have a hard-coded robot brain?

P(P) meets this definition. Therefore P(P) halts.

If your your system is really capable of recogonizing the inputs that it gets wrong, why does it still get them wrong?

André


Self-contradictory input is incorrect in the same way that the liar paradox is neither true nor false.

--
Copyright 2021 Pete Olcott

"Great spirits have always encountered violent opposition from mediocre minds." Einstein


Subject: Re:_Black_box_halt_decider_is_NOT_a_partial_decider_[_André_doesn't_know_Rice's_Theorem_]
From: olcott
Newsgroups: comp.theory, comp.ai.philosophy, comp.software-eng, sci.math.symbolic
Date: Tue, 27 Jul 2021 03:18 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!feeder8.news.weretis.net!news.uzoreto.com!tr2.eu1.usenetexpress.com!feeder.usenetexpress.com!tr3.iad1.usenetexpress.com!border1.nntp.dca1.giganews.com!nntp.giganews.com!buffer1.nntp.dca1.giganews.com!buffer2.nntp.dca1.giganews.com!news.giganews.com.POSTED!not-for-mail
NNTP-Posting-Date: Mon, 26 Jul 2021 22:18:47 -0500
Subject: Re:_Black_box_halt_decider_is_NOT_a_partial_decider_[_André_doesn't_know_Rice's_Theorem_]
Newsgroups: comp.theory,comp.ai.philosophy,comp.software-eng,sci.math.symbolic
References: <20210719214640.00000dfc@reddwarf.jmc> <87zgucfux4.fsf@bsb.me.uk> <sdi9vb$r9b$1@dont-email.me> <87eebnfc8c.fsf@bsb.me.uk> <19Kdna-u6-AOSWH9nZ2dnUU78QXNnZ2d@brightview.co.uk> <87tukjdqmi.fsf@bsb.me.uk> <sdjlo4$1oct$1@gioia.aioe.org> <eOadnfv1CNxEEGD9nZ2dnUU78RPNnZ2d@brightview.co.uk> <4826ab33-061b-472e-a1a5-e2ded35ecd82n@googlegroups.com> <87r1fmcgta.fsf@bsb.me.uk> <8978f969-8b53-4535-9bd3-e838818b9755n@googlegroups.com> <dLudnbEJjIhIrGP9nZ2dnUU7-dPNnZ2d@giganews.com> <sdlg2u$tth$1@dont-email.me> <g5Cdndhbg9ImWWP9nZ2dnUU7-S3NnZ2d@giganews.com> <sdmmo7$72r$1@dont-email.me> <_7OdnVI71OcgeGP9nZ2dnUU7-UXNnZ2d@giganews.com> <sdmqm4$2hr$1@dont-email.me> <ZNCdndMEKogNmGL9nZ2dnUU7-KvNnZ2d@giganews.com> <sdn40f$5ea$1@dont-email.me> <IYGdnV9avtZj0mL9nZ2dnUU7-d-dnZ2d@giganews.com> <sdnjhs$30s$1@dont-email.me> <QNOdnRIn-O3-xmL9nZ2dnUU7-fvNnZ2d@giganews.com> <sdnn91$k7p$1@dont-email.me> <tbGdnZb32okl_GL9nZ2dnUU7-UvNnZ2d@giganews.com> <sdnrb7$al5$1@dont-email.me>
From: NoO...@NoWhere.com (olcott)
Date: Mon, 26 Jul 2021 22:18:46 -0500
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:78.0) Gecko/20100101 Thunderbird/78.12.0
MIME-Version: 1.0
In-Reply-To: <sdnrb7$al5$1@dont-email.me>
Content-Type: text/plain; charset=utf-8; format=flowed
Content-Language: en-US
Content-Transfer-Encoding: 8bit
Message-ID: <PMCdnSCWQLiK5mL9nZ2dnUU7-S_NnZ2d@giganews.com>
Lines: 108
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-1FxUhiFz4MbxZ0t68T5tU6G/4C8SGZjpmKraQ9nSP1CQI37TBi2XBTgxmPthXHTtlmBxQvVBsUkPCxA!vI8rSNGUu/C1DUVwfi5YVcDECNoTcgvg5BaRNrSzGvXs6TYFTOQz60WHz7x2U+W1K2Lzpokt2Q==
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: 6570
View all headers
On 7/26/2021 9:34 PM, André G. Isaak wrote:
On 2021-07-26 19:30, olcott wrote:
On 7/26/2021 8:24 PM, André G. Isaak wrote:
On 2021-07-26 19:03, olcott wrote:
On 7/26/2021 7:21 PM, André G. Isaak wrote:
On 2021-07-26 18:14, olcott wrote:
On 7/26/2021 2:55 PM, André G. Isaak wrote:
On 2021-07-26 12:57, olcott wrote:

In the exact same way it is a mistake to take the fact that the P of int main() { P(P); } definitely reaches its halting state as an indication that it is a halting computation.

You seem to have a serious difficulty processing definitions.

The *definition* of a halting computation is a computation which reaches one of its final states in a finite number of steps. This refers only to the *actual* computation.

This definition exhaustively partitions the set of computations into two mutually-exclusive groups. If we observe that a computation such as P(P) reaches a final state in a finite number of steps, it goes in the halting group. Otherwise, it goes into the non-halting group.

The definition is clear and unambiguous.

It does not mention anything about simulators or aborted simulations.

It makes no exceptions for 'pathological' inputs.


None-the-less if pathological inputs can be recognized this refutes Rice.
None-the-less if pathological inputs can be recognized this refutes Rice.
None-the-less if pathological inputs can be recognized this refutes Rice.
None-the-less if pathological inputs can be recognized this refutes Rice.

There *are no* patholological inputs. There are simply inputs that H gets wrong. There's nothing absolutely 'pathological' about that.

If my system recognizes whatever you want to call it the cases where the halt decider gets wrong, this refutes Rice.

What does that unsubstantiated claim have to do with the question I'd asked, which was:

How can the claim that H(P, P)==0 be justified *in terms of the definition of halting* and in terms of the *actual behaviour* of P(P).


That does not currently matter,

Of course it currently matters.

as long as we can consistently use H(P,P) != P(P) to detect and reject the halting problem counter-examples we have refuted Rice's theorem.

How on earth would that refute Rice's theorem?

I *think* that by H(P,P) != P(P) you're *trying* (badly) to say 'the answer given by H(P, P) does not match the halting behaviour of P(P).

But *we* would be the ones recognizing these counterexamples. That your machine gets these cases wrong means the machine certainly isn't recognizing them.


When the machine is able to reject these inputs it defeats Rice's theorem. You must be clueless on this aspect.

When the machine is able to reject these inputs it defeats Rice's theorem. You must be clueless on this aspect.

When the machine is able to reject these inputs it defeats Rice's theorem. You must be clueless on this aspect.

Is it possible for you to detect when the subject has been changed or do you have a hard-coded robot brain?

You seem to 'change the subject' whenever you get stuck. Why not try actually sticking with a subject for a change rather than simply sweeping all objections under the rug and then claiming that no one has given you good arguments (a common tact with you).

 >> If your your system is really capable of recogonizing the inputs that
 >> it gets wrong, why does it still get them wrong?

Self-contradictory input is incorrect in the same way that the liar paradox is neither true nor false.

There *is no input* when I ask you to justify the claim that P(P) doesn't halt when it clearly does not. I'm asking about the behaviour of the computation P(P).

André



--
Copyright 2021 Pete Olcott

"Great spirits have always encountered violent opposition from mediocre minds." Einstein


Subject: Re:_André_doesn't_know_Rice's_Theorem_[_Malcolm_]
From: olcott
Newsgroups: comp.theory, comp.ai.philosophy, comp.software-eng, sci.math.symbolic
Date: Tue, 27 Jul 2021 15: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
Path: i2pn2.org!i2pn.org!weretis.net!feeder8.news.weretis.net!feeder1.feed.usenet.farm!feed.usenet.farm!tr3.eu1.usenetexpress.com!feeder.usenetexpress.com!tr1.iad1.usenetexpress.com!border1.nntp.dca1.giganews.com!nntp.giganews.com!buffer1.nntp.dca1.giganews.com!news.giganews.com.POSTED!not-for-mail
NNTP-Posting-Date: Tue, 27 Jul 2021 10:24:53 -0500
Subject: Re:_André_doesn't_know_Rice's_Theorem_[_Malcolm_]
Newsgroups: comp.theory,comp.ai.philosophy,comp.software-eng,sci.math.symbolic
References: <20210719214640.00000dfc@reddwarf.jmc> <eOadnfv1CNxEEGD9nZ2dnUU78RPNnZ2d@brightview.co.uk> <4826ab33-061b-472e-a1a5-e2ded35ecd82n@googlegroups.com> <87r1fmcgta.fsf@bsb.me.uk> <8978f969-8b53-4535-9bd3-e838818b9755n@googlegroups.com> <dLudnbEJjIhIrGP9nZ2dnUU7-dPNnZ2d@giganews.com> <sdlg2u$tth$1@dont-email.me> <g5Cdndhbg9ImWWP9nZ2dnUU7-S3NnZ2d@giganews.com> <sdmmo7$72r$1@dont-email.me> <_7OdnVI71OcgeGP9nZ2dnUU7-UXNnZ2d@giganews.com> <sdmqm4$2hr$1@dont-email.me> <ZNCdndMEKogNmGL9nZ2dnUU7-KvNnZ2d@giganews.com> <sdn40f$5ea$1@dont-email.me> <IYGdnV9avtZj0mL9nZ2dnUU7-d-dnZ2d@giganews.com> <sdnjhs$30s$1@dont-email.me> <QNOdnRIn-O3-xmL9nZ2dnUU7-fvNnZ2d@giganews.com> <sdnn91$k7p$1@dont-email.me> <tbGdnZb32okl_GL9nZ2dnUU7-UvNnZ2d@giganews.com> <sdnrb7$al5$1@dont-email.me> <PMCdnSCWQLiK5mL9nZ2dnUU7-S_NnZ2d@giganews.com> <sdnua6$n7p$1@dont-email.me> <zPudnUgsAvKV42L9nZ2dnUU7-fXNnZ2d@giganews.com> <sdo03c$uid$1@dont-email.me> <d619424f-35d7-4fc2-bc33-d4b0bdb57966n@googlegroups.com>
From: NoO...@NoWhere.com (olcott)
Date: Tue, 27 Jul 2021 10:24:52 -0500
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:78.0) Gecko/20100101 Thunderbird/78.12.0
MIME-Version: 1.0
In-Reply-To: <d619424f-35d7-4fc2-bc33-d4b0bdb57966n@googlegroups.com>
Content-Type: text/plain; charset=utf-8; format=flowed
Content-Language: en-US
Content-Transfer-Encoding: 8bit
Message-ID: <m-mdnbNOsMXYuJ38nZ2dnUU7-YnNnZ2d@giganews.com>
Lines: 92
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-xLBjLSM2TJPspFa7pczVZ0t9EnY1GbVRgxK4ChWMrcBJczCknbCMVkha3/wlSiRStBaeO8wnKFVd7le!7SX/bBsDs2osMt1oGQbNucUi9E6VO4ruJU9XIbFyLuvJCEvydYqEobfVtzAFqz6L8CTHa51pAw==
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: 6120
View all headers
On 7/27/2021 4:42 AM, Malcolm McLean wrote:
On Tuesday, 27 July 2021 at 04:55:26 UTC+1, André G. Isaak wrote:
On 2021-07-26 21:31, olcott wrote:


I have explained this totally several times now.
if H(P,P) != P(P)
incorrect input
else
correct input.
Will you please explain what is meant by H(P,P) != P(P)?

As written, it mean 'if the result returned by H(P, P) does not equal
the result returned by P(P)', but as I said I *think* by P(P) you
actually mean 'the halting status of P'.

If that is what you mean then how is H(P,P) != P(P) supposed to be
evaluated *by a Turing Machine*? Rice's Theorem is about what can be
computed, not just about things that can be stated.

H(P, P) gets P(P) wrong, but it doesn't *know* that it gets this wrong
(otherwise you'd be able to easily fix H to get it right).

We've had a development. The claim that H(P,P) = false is correct when
P(P) halts has been modified.
Now we run H on P(P), and run P(P). If they match, then obviously H has
done its job. If they don't, then that means that the input is "pathological".
The special case suggested by Linz has been detected.

There are snags with this approach, of course. For example, if P(P) is
non-halting, how would you know when to terminate it?  Ben said that
this suggestion always comes up (UCL is a pretty high status university
with the UK that attracts intelligent students).

No one has ever gotten as far as I have. No one has ever previously shown that the input to a simulating halt decider specifies infinitely nested simulation to this halt decider in the HP counter-example cases.

Any rebuttals to this assertion require complete citations.

Since no one has ever previously accomplished this key insight this makes it impossible that anyone created any software system that correctly recognizes and reports this infinitely nested simulation.

When the global simulator reports that the P of int main(){ P(P); }
halts this is encoded here as P(P)==1

When the local partial halt decider H reports that P(P) never halts
this is encoded here as H(P,P)==0

When they are out-of-sync for inputs with the pathological self-reference(Olcott 2004) error we say P(P) != H(P,P)

We will show that this error is exactly the same as the Liar Paradox in that both Boolean values are contradicted.

When P(P) != H(P,P) if we change H(P,P)==0 to correspond with P(P)==1
then the P of int main(){ P(P); } never halts.

Because P was intentionally defined to do the opposite of whatever
halt status value that H reports neither Boolean value is correct.

This is exactly the same result as the Liar Paradox.

Because it is true that no P ever halts unless some P is aborted it still seems to me that H(P,P)==0 is correct and the fact that the P of int main(){ P(P); } halts is the error.

Because no P ever halts unless some P is aborted seems to prove that int main(){ P(P); } specifies a non-halting computation.

The suggestion is to detect
the Linz input and special case it.


I don't even have to write any more code. Whenever a human sees that H(P,P) reports 0 and the P of int main(){ P(P); } reaches its final state we know this is a case of the self-contradictory input pathological self-reference(Olcott 2004) error.

Applying this same idea to a fully elaborated complete halt decider would derive a halt decider where the only time that the input reaches a final state and the halt decider reports that this input never halts are the self-contradictory input pathological self-reference(Olcott 2004) error cases.


--
Copyright 2021 Pete Olcott

"Great spirits have always encountered violent opposition from mediocre minds." Einstein


Subject: Re:_André_doesn't_know_Rice's_Theorem_[_Malcolm_]
From: Jeff Barnett
Newsgroups: comp.theory, comp.ai.philosophy, comp.software-eng, sci.math.symbolic
Organization: A noiseless patient Spider
Date: Tue, 27 Jul 2021 17:21 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
Path: i2pn2.org!i2pn.org!eternal-september.org!reader02.eternal-september.org!.POSTED!not-for-mail
From: jbb...@notatt.com (Jeff Barnett)
Newsgroups: comp.theory,comp.ai.philosophy,comp.software-eng,sci.math.symbolic
Subject: Re:_André_doesn't_know_Rice's_Theorem_[_Malc
olm_]
Date: Tue, 27 Jul 2021 11:21:43 -0600
Organization: A noiseless patient Spider
Lines: 22
Message-ID: <sdpfb9$mkg$1@dont-email.me>
References: <20210719214640.00000dfc@reddwarf.jmc>
<4826ab33-061b-472e-a1a5-e2ded35ecd82n@googlegroups.com>
<87r1fmcgta.fsf@bsb.me.uk>
<8978f969-8b53-4535-9bd3-e838818b9755n@googlegroups.com>
<dLudnbEJjIhIrGP9nZ2dnUU7-dPNnZ2d@giganews.com> <sdlg2u$tth$1@dont-email.me>
<g5Cdndhbg9ImWWP9nZ2dnUU7-S3NnZ2d@giganews.com> <sdmmo7$72r$1@dont-email.me>
<_7OdnVI71OcgeGP9nZ2dnUU7-UXNnZ2d@giganews.com> <sdmqm4$2hr$1@dont-email.me>
<ZNCdndMEKogNmGL9nZ2dnUU7-KvNnZ2d@giganews.com> <sdn40f$5ea$1@dont-email.me>
<IYGdnV9avtZj0mL9nZ2dnUU7-d-dnZ2d@giganews.com> <sdnjhs$30s$1@dont-email.me>
<QNOdnRIn-O3-xmL9nZ2dnUU7-fvNnZ2d@giganews.com> <sdnn91$k7p$1@dont-email.me>
<tbGdnZb32okl_GL9nZ2dnUU7-UvNnZ2d@giganews.com> <sdnrb7$al5$1@dont-email.me>
<PMCdnSCWQLiK5mL9nZ2dnUU7-S_NnZ2d@giganews.com> <sdnua6$n7p$1@dont-email.me>
<zPudnUgsAvKV42L9nZ2dnUU7-fXNnZ2d@giganews.com> <sdo03c$uid$1@dont-email.me>
<d619424f-35d7-4fc2-bc33-d4b0bdb57966n@googlegroups.com>
<m-mdnbNOsMXYuJ38nZ2dnUU7-YnNnZ2d@giganews.com>
Mime-Version: 1.0
Content-Type: text/plain; charset=utf-8; format=flowed
Content-Transfer-Encoding: 7bit
Injection-Date: Tue, 27 Jul 2021 17:21:45 -0000 (UTC)
Injection-Info: reader02.eternal-september.org; posting-host="b2a8b99b9e09bca445ca27cab4dd1631";
logging-data="23184"; mail-complaints-to="abuse@eternal-september.org"; posting-account="U2FsdGVkX1+8YhfG0YElEldPr7IpsWenckqRVthHqwg="
User-Agent: Mozilla/5.0 (Windows NT 6.1; Win64; x64; rv:78.0) Gecko/20100101
Thunderbird/78.12.0
Cancel-Lock: sha1:fO4BEzIdB1pzlXC5D+RgqsXwW80=
In-Reply-To: <m-mdnbNOsMXYuJ38nZ2dnUU7-YnNnZ2d@giganews.com>
Content-Language: en-US
View all headers
On 7/27/2021 9:24 AM, olcott wrote:

<SNIP>

No one has ever gotten as far as I have. No one has ever previously shown that the input to a simulating halt decider specifies infinitely nested simulation to this halt decider in the HP counter-example cases.

I'm glad to see you have something to take pride in. However, lets make sure we all know what that accomplishment really is: You have set a world record in number of wrong conclusions reached by a record long chain of improper inferences. You have also set a world record for turning a deaf ear to all of those trying-to-help people who have pointed out the mistakes at each and every step.

I have not cut the set of newsgroups this message will reach: I think all will rejoice at your success and hope you will retire into silence. Should we contact Guinness? Or will you take care of that?

Alright everyone, lets hear a loud cheer for PO!
--
Jeff Barnett


Subject: Re:_André_doesn't_know_Rice's_Theorem_[_Malcolm_]
From: olcott
Newsgroups: comp.theory, comp.ai.philosophy, comp.software-eng, sci.math.symbolic
Date: Wed, 28 Jul 2021 13:56 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
Path: i2pn2.org!i2pn.org!weretis.net!feeder6.news.weretis.net!4.us.feeder.erje.net!2.eu.feeder.erje.net!feeder.erje.net!feeds.phibee-telecom.net!newsfeed.xs4all.nl!newsfeed7.news.xs4all.nl!tr2.eu1.usenetexpress.com!feeder.usenetexpress.com!tr1.iad1.usenetexpress.com!border1.nntp.dca1.giganews.com!nntp.giganews.com!buffer1.nntp.dca1.giganews.com!news.giganews.com.POSTED!not-for-mail
NNTP-Posting-Date: Wed, 28 Jul 2021 08:56:20 -0500
Subject: Re:_André_doesn't_know_Rice's_Theorem_[_Malcolm_]
Newsgroups: comp.theory,comp.ai.philosophy,comp.software-eng,sci.math.symbolic
References: <20210719214640.00000dfc@reddwarf.jmc> <g5Cdndhbg9ImWWP9nZ2dnUU7-S3NnZ2d@giganews.com> <sdmmo7$72r$1@dont-email.me> <_7OdnVI71OcgeGP9nZ2dnUU7-UXNnZ2d@giganews.com> <sdmqm4$2hr$1@dont-email.me> <ZNCdndMEKogNmGL9nZ2dnUU7-KvNnZ2d@giganews.com> <sdn40f$5ea$1@dont-email.me> <IYGdnV9avtZj0mL9nZ2dnUU7-d-dnZ2d@giganews.com> <sdnjhs$30s$1@dont-email.me> <QNOdnRIn-O3-xmL9nZ2dnUU7-fvNnZ2d@giganews.com> <sdnn91$k7p$1@dont-email.me> <tbGdnZb32okl_GL9nZ2dnUU7-UvNnZ2d@giganews.com> <sdnrb7$al5$1@dont-email.me> <PMCdnSCWQLiK5mL9nZ2dnUU7-S_NnZ2d@giganews.com> <sdnua6$n7p$1@dont-email.me> <zPudnUgsAvKV42L9nZ2dnUU7-fXNnZ2d@giganews.com> <sdo03c$uid$1@dont-email.me> <d619424f-35d7-4fc2-bc33-d4b0bdb57966n@googlegroups.com> <m-mdnbNOsMXYuJ38nZ2dnUU7-YnNnZ2d@giganews.com> <sdpf12$ij8$1@dont-email.me> <d46dnQp1b-ua3p38nZ2dnUU7-d_NnZ2d@giganews.com> <sdpnjb$1q3$1@dont-email.me> <NpmdnV9AwpJkV538nZ2dnUU7-QXNnZ2d@giganews.com> <6bef0b63-a1dc-4ec9-91ca-303b0e882a7bn@googlegroups.com>
From: NoO...@NoWhere.com (olcott)
Date: Wed, 28 Jul 2021 08:56:15 -0500
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:78.0) Gecko/20100101 Thunderbird/78.12.0
MIME-Version: 1.0
In-Reply-To: <6bef0b63-a1dc-4ec9-91ca-303b0e882a7bn@googlegroups.com>
Content-Type: text/plain; charset=utf-8; format=flowed
Content-Language: en-US
Content-Transfer-Encoding: 7bit
Message-ID: <y5CdnQBL7riZ_5z8nZ2dnUU7-R_NnZ2d@giganews.com>
Lines: 41
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-YdPQbFWSPzzX123aRnvX7dChttW3C6czohp8jraFYsW7Dxeyxfx9AnwGNyiECSCV5BLCPwn9HCagaac!0k/gCIpolhRaDgVwPH+Sqcwrr55j9EOiyQxvCELr6KMzVOztx997mvZF1nVOCrnUJvNrj+USOA==
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: 4048
View all headers
On 7/28/2021 4:41 AM, Malcolm McLean wrote:
On Wednesday, 28 July 2021 at 04:12:00 UTC+1, olcott wrote:

Simulate(P,P)==1 indicates that the global simulator embedded in the
x86utm operating system has determined that the function called by main
has reached its final state.

There will not actually be any function call Simulate(P,P) per say and
this code has not been designed yet.

The very easy part that you should have understood many messages ago is
that when the code somehow determines that the halt decider return value
is not consistent with the behavior of P this is freaking used to
freaking refute Rice.

Yo argued against even considering Rice because you Are stuck in
rebuttal mode. This bias is a form of dishonesty.

"Confounds H" is maybe a non-trivial semantic property of a machine. Not
quite sure about this. But to compute it, you need H, and a correct halt decider.
So I doubt it's a fruitful path for invesigation.


The reason that no one has solved these things before is that they never bothered to think through ALL the possibilities. They try a few things that don't work and then give up. The key advantage that I have over other people is my system of categorically exhaustive reasoning. This system makes it possible to discover possibilities that were previously overlooked.

Any system that divides all inputs into those having the pathological self-reference(Olcott 2004) error and those not having this error does refute Rice's theorem no matter how it accomplishes this feat.

I am working on creating the code for this.

--
Copyright 2021 Pete Olcott

"Great spirits have always encountered violent opposition from mediocre minds." Einstein


Subject: Re:_André_doesn't_know_Rice's_Theorem_[_Malcolm_]
From: olcott
Newsgroups: comp.theory, comp.ai.philosophy, comp.software-eng, sci.math.symbolic
Date: Wed, 28 Jul 2021 14:09 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!feeder8.news.weretis.net!news.uzoreto.com!tr2.eu1.usenetexpress.com!feeder.usenetexpress.com!tr3.iad1.usenetexpress.com!border1.nntp.dca1.giganews.com!nntp.giganews.com!buffer1.nntp.dca1.giganews.com!news.giganews.com.POSTED!not-for-mail
NNTP-Posting-Date: Wed, 28 Jul 2021 09:09:07 -0500
Subject: Re:_André_doesn't_know_Rice's_Theorem_[_Malcolm_]
Newsgroups: comp.theory,comp.ai.philosophy,comp.software-eng,sci.math.symbolic
References: <20210719214640.00000dfc@reddwarf.jmc> <sdlg2u$tth$1@dont-email.me> <g5Cdndhbg9ImWWP9nZ2dnUU7-S3NnZ2d@giganews.com> <sdmmo7$72r$1@dont-email.me> <_7OdnVI71OcgeGP9nZ2dnUU7-UXNnZ2d@giganews.com> <sdmqm4$2hr$1@dont-email.me> <ZNCdndMEKogNmGL9nZ2dnUU7-KvNnZ2d@giganews.com> <sdn40f$5ea$1@dont-email.me> <IYGdnV9avtZj0mL9nZ2dnUU7-d-dnZ2d@giganews.com> <sdnjhs$30s$1@dont-email.me> <QNOdnRIn-O3-xmL9nZ2dnUU7-fvNnZ2d@giganews.com> <sdnn91$k7p$1@dont-email.me> <tbGdnZb32okl_GL9nZ2dnUU7-UvNnZ2d@giganews.com> <sdnrb7$al5$1@dont-email.me> <PMCdnSCWQLiK5mL9nZ2dnUU7-S_NnZ2d@giganews.com> <sdnua6$n7p$1@dont-email.me> <zPudnUgsAvKV42L9nZ2dnUU7-fXNnZ2d@giganews.com> <sdo03c$uid$1@dont-email.me> <d619424f-35d7-4fc2-bc33-d4b0bdb57966n@googlegroups.com> <m-mdnbNOsMXYuJ38nZ2dnUU7-YnNnZ2d@giganews.com> <sdpf12$ij8$1@dont-email.me> <d46dnQp1b-ua3p38nZ2dnUU7-d_NnZ2d@giganews.com> <sdpnjb$1q3$1@dont-email.me> <NpmdnV9AwpJkV538nZ2dnUU7-QXNnZ2d@giganews.com> <sdqjgu$mun$1@dont-email.me>
From: NoO...@NoWhere.com (olcott)
Date: Wed, 28 Jul 2021 09:09:06 -0500
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:78.0) Gecko/20100101 Thunderbird/78.12.0
MIME-Version: 1.0
In-Reply-To: <sdqjgu$mun$1@dont-email.me>
Content-Type: text/plain; charset=utf-8; format=flowed
Content-Language: en-US
Content-Transfer-Encoding: 8bit
Message-ID: <yvKdnaD9etCe-Jz8nZ2dnUU7-Q3NnZ2d@giganews.com>
Lines: 145
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-fKvgUKBgZP7epePwcH+YG1pw0iqWs/uvidipveEir3DDGP75XGqKpoA5V/375SRO5CiBs7h2xL1Swfj!mzQ3Ad1BqpYmGk5VC30osWi9Hdm2rR1GvrbkMDWXhnm/a+3ew1Hi5NCZ2RD1qwlsc5JBB3P9PA==
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: 8621
View all headers
On 7/27/2021 10:39 PM, André G. Isaak wrote:
On 2021-07-27 21:11, olcott wrote:
On 7/27/2021 2:42 PM, André G. Isaak wrote:
On 2021-07-27 11:31, olcott wrote:
On 7/27/2021 12:16 PM, André G. Isaak wrote:
On 2021-07-27 09:24, olcott wrote:
On 7/27/2021 4:42 AM, Malcolm McLean wrote:
On Tuesday, 27 July 2021 at 04:55:26 UTC+1, André G. Isaak wrote:
On 2021-07-26 21:31, olcott wrote:


I have explained this totally several times now.
if H(P,P) != P(P)
incorrect input
else
correct input.
Will you please explain what is meant by H(P,P) != P(P)?

As written, it mean 'if the result returned by H(P, P) does not equal
the result returned by P(P)', but as I said I *think* by P(P) you
actually mean 'the halting status of P'.

If that is what you mean then how is H(P,P) != P(P) supposed to be
evaluated *by a Turing Machine*? Rice's Theorem is about what can be
computed, not just about things that can be stated.

H(P, P) gets P(P) wrong, but it doesn't *know* that it gets this wrong
(otherwise you'd be able to easily fix H to get it right).

We've had a development. The claim that H(P,P) = false is correct when
P(P) halts has been modified.
Now we run H on P(P), and run P(P). If they match, then obviously H has
done its job. If they don't, then that means that the input is "pathological".
The special case suggested by Linz has been detected.

There are snags with this approach, of course. For example, if P(P) is
non-halting, how would you know when to terminate it?  Ben said that
this suggestion always comes up (UCL is a pretty high status university
with the UK that attracts intelligent students).

No one has ever gotten as far as I have. No one has ever previously shown that the input to a simulating halt decider specifies infinitely nested simulation to this halt decider in the HP counter-example cases.

Any rebuttals to this assertion require complete citations.

Since no one has ever previously accomplished this key insight this makes it impossible that anyone created any software system that correctly recognizes and reports this infinitely nested simulation.

When the global simulator reports that the P of int main(){ P(P); }
halts this is encoded here as P(P)==1

What exactly is the 'global simulator'?

You used to have something called a 'global halt decider' but according to you this *also* wrongly decides that P(P) doesn't halt.

And in previous posts you've claimed that a 'pure simulation' of P(P) doesn't halt. Now your saying that it *does* halt inside a 'global simulator'? So what's the difference between a 'global' simulator and a 'pure simulator'? Why do you claim it halts in one and not in the other?

When the local partial halt decider H reports that P(P) never halts
this is encoded here as H(P,P)==0

When they are out-of-sync for inputs with the pathological self-reference(Olcott 2004) error we say P(P) != H(P,P)

We will show that this error is exactly the same as the Liar Paradox in that both Boolean values are contradicted.

When P(P) != H(P,P) if we change H(P,P)==0 to correspond with P(P)==1
then the P of int main(){ P(P); } never halts.

Again, does P(P) != H(P,P) mean that the halting status of P(P) doesn't match H(P,P),

Since I already totally explained this immediately above and your

Not clearly, you didn't. P(P) != H(P, P) is an abuse of notation, because you're comparing apples and oranges. This should either mean 'the halting status of P(P) doesn't equal the halting status of H(P,P)'

Simulate(P,P)==1 indicates that the global simulator embedded in the x86utm operating system has determined that the function called by main has reached its final state.

So does P(P) halt or not?


Even though the first P in the invocation sequence reaches its final state the fact that it only reaches its final state because the second P in the invocation sequence was aborted proves that H(P,P)==0 is correct.

Because this is too difficult to understand and accept I have temporarily changed the subject to refuting Rice's theorem. The fact that the first P reaches its final state and the second P is aborted can   be used as the criterion measure to consistently reject all and only self-contradictory inputs. This does refute Rices theorem.

You have on the one hand acknowledged that it does, while at the same time claimed that it doesn't halt in a 'pure simulator'. So if your 'global simulator' is not a pure simulator, what kind of simulator is it?

There will not actually be any function call Simulate(P,P) per say and this code has not been designed yet.

The very easy part that you should have understood many messages ago is that when the code somehow determines that the halt decider return value is not consistent with the behavior of P this is freaking used to freaking refute Rice.
The problem is that H isn't doing the detecting. To the extent that what you say makes sense it is some other software which tests the result of H(P,P) against the result of your 'global simulator'. But *that* piece of software will have its *own* H_Hat which will be just as susceptible to the Linz proof as your H.

Every putative halt decider has its *own* H_Hat which it will not be able to decide, which is perfectly in line with Rice.

André

That each of these putative halt deciders recognize and reject all and only self-contradictory inputs refutes Rice.




--
Copyright 2021 Pete Olcott

"Great spirits have always encountered violent opposition from mediocre minds." Einstein


Subject: Re:_André_doesn't_know_Rice's_Theorem_[_Malcolm_](_attention_deficit_disorder_)
From: olcott
Newsgroups: comp.theory, comp.ai.philosophy, comp.software-eng, sci.math.symbolic
Date: Wed, 28 Jul 2021 16:01 UTC
References: 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22
Path: i2pn2.org!i2pn.org!weretis.net!feeder6.news.weretis.net!news.snarked.org!border2.nntp.dca1.giganews.com!nntp.giganews.com!buffer2.nntp.dca1.giganews.com!news.giganews.com.POSTED!not-for-mail
NNTP-Posting-Date: Wed, 28 Jul 2021 11:01:38 -0500
Subject: Re:_André_doesn't_know_Rice's_Theorem_[_Malc
olm_](_attention_deficit_disorder_)
Newsgroups: comp.theory,comp.ai.philosophy,comp.software-eng,sci.math.symbolic
References: <20210719214640.00000dfc@reddwarf.jmc>
<ZNCdndMEKogNmGL9nZ2dnUU7-KvNnZ2d@giganews.com> <sdn40f$5ea$1@dont-email.me>
<IYGdnV9avtZj0mL9nZ2dnUU7-d-dnZ2d@giganews.com> <sdnjhs$30s$1@dont-email.me>
<QNOdnRIn-O3-xmL9nZ2dnUU7-fvNnZ2d@giganews.com> <sdnn91$k7p$1@dont-email.me>
<tbGdnZb32okl_GL9nZ2dnUU7-UvNnZ2d@giganews.com> <sdnrb7$al5$1@dont-email.me>
<PMCdnSCWQLiK5mL9nZ2dnUU7-S_NnZ2d@giganews.com> <sdnua6$n7p$1@dont-email.me>
<zPudnUgsAvKV42L9nZ2dnUU7-fXNnZ2d@giganews.com> <sdo03c$uid$1@dont-email.me>
<d619424f-35d7-4fc2-bc33-d4b0bdb57966n@googlegroups.com>
<m-mdnbNOsMXYuJ38nZ2dnUU7-YnNnZ2d@giganews.com>
<x_VLI.64834$h8.24317@fx47.iad>
<zqudnWgUwtJds538nZ2dnUU7-LvNnZ2d@giganews.com>
<SvWLI.16512$qL.7415@fx14.iad>
<JP2dncfyZIvLoJ38nZ2dnUU7-e_NnZ2d@giganews.com>
<i5YLI.77117$VU3.11059@fx46.iad>
<7sudnSjP-u48zZ38nZ2dnUU7-XXNnZ2d@giganews.com> <87mtq68nte.fsf@bsb.me.uk>
From: NoO...@NoWhere.com (olcott)
Date: Wed, 28 Jul 2021 11:01:37 -0500
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:78.0) Gecko/20100101
Thunderbird/78.12.0
MIME-Version: 1.0
In-Reply-To: <87mtq68nte.fsf@bsb.me.uk>
Content-Type: text/plain; charset=utf-8; format=flowed
Content-Language: en-US
Content-Transfer-Encoding: 8bit
Message-ID: <Sq-dnbKtfMj_4pz8nZ2dnUU7-bfNnZ2d@giganews.com>
Lines: 66
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-FyK7m3eWVLTfvWyFEQ5ezXZqvVZb30AlKPAOiWAe+mvvxoHvjClPW3oXpgTUMLfXK7P2omAFR4X6dW1!C/wcBw/NPcQGbk2Bc22Y430RZPnMFGB2XNg8/vbDJ0+Sl4xskrAQiSWQtWvQhEDrIZvcNGLjdg==
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: 4533
View all headers
On 7/28/2021 10:23 AM, Ben Bacarisse wrote:
olcott <NoOne@NoWhere.com> writes:

I have never been shown guilty of lying.

It's hard, in your case, to distinguish between ignorance and deception,
but here are some top candidates:

   "I now have an actual H that decides actual halting for an actual (Ĥ,
   Ĥ) input pair."


This still seems sufficiently true as elaborated below.

   "Everyone has claimed that H on input pair (Ĥ, Ĥ) meeting the Linz
   specs does not exist. I now have a fully encoded pair of Turing
   Machines H / Ĥ proving them wrong."


This uses a little poetic license in that what I actually had was the sufficiently complete C code that correctly decides the impossible counter-example inputs.

At the time I knew that it was computationally equivalent to Turing machines yet was unaware that the concept of: "computationally equivalent to Turing machines" was understood to exist.

As it currently stands I apparently did augment the conventional concept of Turing equivalence making it broader to encompass all computations that can be correctly completed in whatever memory is available.

   "I provide the exact ... states after the Linz H.q0 and after Ĥ.qx
   ... showing exactly how the actual Linz H would correctly decide the
   actual Linz (Ĥ, Ĥ)."


This idea is elaborated to a much greater extent when H(P,P) correctly decides that its input cannot possibly reach its final state while H remains a pure simulator of this input.

The same applies here: The input to H.qx(Ĥ, Ĥ) cannot possibly reach its final state while H.qx remains a pure simulator of this input.

   "I really do have a halting decider."

   "The non-halting decider that I defined accepts any and all
   non-halting inputs and rejects any and all halting inputs."


When we apply my design to the halting problem the conventional proofs utterly lose their entire basis thus no longer prove that a full halt decider cannot exist.

   "Ĥ does not copy its input"

Maybe you could point out which of these are simply mistakes and which
are deliberate untruths?


Ĥ does copy its input.

--
Copyright 2021 Pete Olcott

"Great spirits have always encountered violent opposition from mediocre minds." Einstein


Subject: Re:_André_doesn't_know_Rice's_Theorem_[_Malcolm_]
From: olcott
Newsgroups: comp.theory, comp.ai.philosophy, comp.software-eng, sci.math.symbolic
Date: Wed, 28 Jul 2021 16:38 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!feeder8.news.weretis.net!feeder5.feed.usenet.farm!feeder1.feed.usenet.farm!feed.usenet.farm!tr1.eu1.usenetexpress.com!feeder.usenetexpress.com!tr1.iad1.usenetexpress.com!border1.nntp.dca1.giganews.com!nntp.giganews.com!buffer1.nntp.dca1.giganews.com!news.giganews.com.POSTED!not-for-mail
NNTP-Posting-Date: Wed, 28 Jul 2021 11:38:59 -0500
Subject: Re:_André_doesn't_know_Rice's_Theorem_[_Malcolm_]
Newsgroups: comp.theory,comp.ai.philosophy,comp.software-eng,sci.math.symbolic
References: <20210719214640.00000dfc@reddwarf.jmc> <sdmmo7$72r$1@dont-email.me> <_7OdnVI71OcgeGP9nZ2dnUU7-UXNnZ2d@giganews.com> <sdmqm4$2hr$1@dont-email.me> <ZNCdndMEKogNmGL9nZ2dnUU7-KvNnZ2d@giganews.com> <sdn40f$5ea$1@dont-email.me> <IYGdnV9avtZj0mL9nZ2dnUU7-d-dnZ2d@giganews.com> <sdnjhs$30s$1@dont-email.me> <QNOdnRIn-O3-xmL9nZ2dnUU7-fvNnZ2d@giganews.com> <sdnn91$k7p$1@dont-email.me> <tbGdnZb32okl_GL9nZ2dnUU7-UvNnZ2d@giganews.com> <sdnrb7$al5$1@dont-email.me> <PMCdnSCWQLiK5mL9nZ2dnUU7-S_NnZ2d@giganews.com> <sdnua6$n7p$1@dont-email.me> <zPudnUgsAvKV42L9nZ2dnUU7-fXNnZ2d@giganews.com> <sdo03c$uid$1@dont-email.me> <d619424f-35d7-4fc2-bc33-d4b0bdb57966n@googlegroups.com> <m-mdnbNOsMXYuJ38nZ2dnUU7-YnNnZ2d@giganews.com> <sdpf12$ij8$1@dont-email.me> <d46dnQp1b-ua3p38nZ2dnUU7-d_NnZ2d@giganews.com> <sdpnjb$1q3$1@dont-email.me> <NpmdnV9AwpJkV538nZ2dnUU7-QXNnZ2d@giganews.com> <sdqjgu$mun$1@dont-email.me> <yvKdnaD9etCe-Jz8nZ2dnUU7-Q3NnZ2d@giganews.com> <sdrt9e$upt$1@dont-email.me>
From: NoO...@NoWhere.com (olcott)
Date: Wed, 28 Jul 2021 11:38:59 -0500
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:78.0) Gecko/20100101 Thunderbird/78.12.0
MIME-Version: 1.0
In-Reply-To: <sdrt9e$upt$1@dont-email.me>
Content-Type: text/plain; charset=utf-8; format=flowed
Content-Language: en-US
Content-Transfer-Encoding: 8bit
Message-ID: <Z6qdna6B7Zq-FZz8nZ2dnUU7-SHNnZ2d@giganews.com>
Lines: 125
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-KxCG8nAP+okgNvImuogYjwlNl5oa7sRlslsnUEPmEtVEP3O4CVCUSiWR9dJXYcsUi3wRFUH47JDXCsJ!kML2CzPnSmZ2oaF7NSGqOiZtC7j/tWPbD6jI0qUWFMweuewAjaxMSaMjKnrpLvE9gP1thx6+Pg==
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: 7038
View all headers
On 7/28/2021 10:31 AM, André G. Isaak wrote:
On 2021-07-28 08:09, olcott wrote:
On 7/27/2021 10:39 PM, André G. Isaak wrote:

So does P(P) halt or not?


Even though the first P in the invocation sequence reaches its final state the fact that it only reaches its final state because the second P in the invocation sequence was aborted proves that H(P,P)==0 is correct.

If a car only crashes because its brakes failed, that does not imply that it didn't crash.

If a program returns the wrong result only because it has a bug, that does not imply that it didn't return the right answer.

If a program only halts because the second P was aborted, that does not imply that it didn't halt.


If an infinitely recursive sequence of function calls is aborted on the second call instead of the first call that does not mean that it was not an infinitely recursive sequence.

Because this is too difficult to understand and accept I have temporarily changed the subject to refuting Rice's theorem. The fact that the first P reaches its final state and the second P is aborted can   be used as the criterion measure to consistently reject all and only self-contradictory inputs. This does refute Rices theorem.

You have on the one hand acknowledged that it does, while at the same time claimed that it doesn't halt in a 'pure simulator'. So if your 'global simulator' is not a pure simulator, what kind of simulator is it?

You didn't answer the above. In the past you've claimed (falsely) that in a pure simulator, P(P) doesn't halt.


While H remains a pure simulator of its input H(P,P) its input never halts thus proving that its input never halts.

Now you appear to be using your 'global simulator' to recognise that P(P) does halt so that you can compare this with the results of H(P, P).


It is still true that H(P,P) did correctly decide that its input never halts. Because this is difficult to understand I am temporarily changing the subject to Rice's theorem.

But if P(P) doesn't halt in a 'pure simulator' then what kind of

I did not say that P(P) does not halt in a pure simulator, you must pay careful attention to every single word that I say. When you skip a single word that reverses the meaning of what I say.

The input to H(P,P) never halts while H remains in pure simulator mode.

simulator is your 'global simulator' which, apparently, correctly detects that P(P) halts?


It correctly detects that the P of int main() { P(P); } reaches its final state.

There will not actually be any function call Simulate(P,P) per say and this code has not been designed yet.

The very easy part that you should have understood many messages ago is that when the code somehow determines that the halt decider return value is not consistent with the behavior of P this is freaking used to freaking refute Rice.
The problem is that H isn't doing the detecting. To the extent that what you say makes sense it is some other software which tests the result of H(P,P) against the result of your 'global simulator'. But *that* piece of software will have its *own* H_Hat which will be just as susceptible to the Linz proof as your H.

Every putative halt decider has its *own* H_Hat which it will not be able to decide, which is perfectly in line with Rice.

André

That each of these putative halt deciders recognize and reject all and only self-contradictory inputs refutes Rice.

And you've demonstrated this where, exactly?

As far as I can tell your H doesn't reject anything. It simply gets some cases wrong.


The code to reject inputs has not even been fully designed yet.
It is easy to see that the criteria for this already exists.

Your H(P, P) claims that P(P) doesn't halt, which is wrong.


The input to H(P,P) never halts while H remains in pure simulator mode.

You claim that you can reject this based on the fact that it doesn't match which your 'global simulator' concludes.

But that means that neither the global simulator nor H on their own are capable of rejecting anything.


So what?

Whatever code is comparing these two values is what is doing the rejecting. And we can construct from *that* piece of code another H_Hat which *that* piece of code cannot answer correctly.

André


I am not going to go down the path of infinitely nested operating systems.

--
Copyright 2021 Pete Olcott

"Great spirits have always encountered violent opposition from mediocre minds." Einstein


Subject: Re:_André_doesn't_know_Rice's_Theorem_[_Malcolm_]_[_PSR_Decider_is_fully_operational_]
From: olcott
Newsgroups: comp.theory, comp.ai.philosophy, comp.software-eng, sci.math.symbolic
Date: Wed, 28 Jul 2021 18:35 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
Path: i2pn2.org!i2pn.org!weretis.net!feeder6.news.weretis.net!news.snarked.org!border2.nntp.dca1.giganews.com!nntp.giganews.com!buffer2.nntp.dca1.giganews.com!news.giganews.com.POSTED!not-for-mail
NNTP-Posting-Date: Wed, 28 Jul 2021 13:35:42 -0500
Subject: Re:_André_doesn't_know_Rice's_Theorem_[_Malc
olm_]_[_PSR_Decider_is_fully_operational_]
Newsgroups: comp.theory,comp.ai.philosophy,comp.software-eng,sci.math.symbolic
References: <20210719214640.00000dfc@reddwarf.jmc>
<sdmqm4$2hr$1@dont-email.me> <ZNCdndMEKogNmGL9nZ2dnUU7-KvNnZ2d@giganews.com>
<sdn40f$5ea$1@dont-email.me> <IYGdnV9avtZj0mL9nZ2dnUU7-d-dnZ2d@giganews.com>
<sdnjhs$30s$1@dont-email.me> <QNOdnRIn-O3-xmL9nZ2dnUU7-fvNnZ2d@giganews.com>
<sdnn91$k7p$1@dont-email.me> <tbGdnZb32okl_GL9nZ2dnUU7-UvNnZ2d@giganews.com>
<sdnrb7$al5$1@dont-email.me> <PMCdnSCWQLiK5mL9nZ2dnUU7-S_NnZ2d@giganews.com>
<sdnua6$n7p$1@dont-email.me> <zPudnUgsAvKV42L9nZ2dnUU7-fXNnZ2d@giganews.com>
<sdo03c$uid$1@dont-email.me>
<d619424f-35d7-4fc2-bc33-d4b0bdb57966n@googlegroups.com>
<m-mdnbNOsMXYuJ38nZ2dnUU7-YnNnZ2d@giganews.com> <sdpf12$ij8$1@dont-email.me>
<d46dnQp1b-ua3p38nZ2dnUU7-d_NnZ2d@giganews.com> <sdpnjb$1q3$1@dont-email.me>
<NpmdnV9AwpJkV538nZ2dnUU7-QXNnZ2d@giganews.com> <sdqjgu$mun$1@dont-email.me>
<yvKdnaD9etCe-Jz8nZ2dnUU7-Q3NnZ2d@giganews.com> <sdrt9e$upt$1@dont-email.me>
<Z6qdna6B7Zq-FZz8nZ2dnUU7-SHNnZ2d@giganews.com>
From: NoO...@NoWhere.com (olcott)
Date: Wed, 28 Jul 2021 13:35:41 -0500
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:78.0) Gecko/20100101
Thunderbird/78.12.0
MIME-Version: 1.0
In-Reply-To: <Z6qdna6B7Zq-FZz8nZ2dnUU7-SHNnZ2d@giganews.com>
Content-Type: text/plain; charset=utf-8; format=flowed
Content-Language: en-US
Content-Transfer-Encoding: 8bit
Message-ID: <JJOdnSDoV9bjPpz8nZ2dnUU7-TudnZ2d@giganews.com>
Lines: 152
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-Jvpgwp8Q3Z3kr7tCqy2fkJqzkwY2jHgjvX0bXeP1100JKuGHMZdANwE2hh6ZCjDRHH9FT47Wy+Pl/t4!6yLcJU/0ubRk/oNv7OBscphQnjiosDep/efM+rM20Y/GK7Rbm0B8rFd/dYU+2q2q3kt7oMmNLw==
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: 7496
View all headers
On 7/28/2021 11:38 AM, olcott wrote:
On 7/28/2021 10:31 AM, André G. Isaak wrote:
On 2021-07-28 08:09, olcott wrote:
On 7/27/2021 10:39 PM, André G. Isaak wrote:

So does P(P) halt or not?


Even though the first P in the invocation sequence reaches its final state the fact that it only reaches its final state because the second P in the invocation sequence was aborted proves that H(P,P)==0 is correct.

If a car only crashes because its brakes failed, that does not imply that it didn't crash.

If a program returns the wrong result only because it has a bug, that does not imply that it didn't return the right answer.

If a program only halts because the second P was aborted, that does not imply that it didn't halt.


If an infinitely recursive sequence of function calls is aborted on the second call instead of the first call that does not mean that it was not an infinitely recursive sequence.

Because this is too difficult to understand and accept I have temporarily changed the subject to refuting Rice's theorem. The fact that the first P reaches its final state and the second P is aborted can   be used as the criterion measure to consistently reject all and only self-contradictory inputs. This does refute Rices theorem.

You have on the one hand acknowledged that it does, while at the same time claimed that it doesn't halt in a 'pure simulator'. So if your 'global simulator' is not a pure simulator, what kind of simulator is it?

You didn't answer the above. In the past you've claimed (falsely) that in a pure simulator, P(P) doesn't halt.


While H remains a pure simulator of its input H(P,P) its input never halts thus proving that its input never halts.

Now you appear to be using your 'global simulator' to recognise that P(P) does halt so that you can compare this with the results of H(P, P).


It is still true that H(P,P) did correctly decide that its input never halts. Because this is difficult to understand I am temporarily changing the subject to Rice's theorem.

But if P(P) doesn't halt in a 'pure simulator' then what kind of

I did not say that P(P) does not halt in a pure simulator, you must pay careful attention to every single word that I say. When you skip a single word that reverses the meaning of what I say.

The input to H(P,P) never halts while H remains in pure simulator mode.

simulator is your 'global simulator' which, apparently, correctly detects that P(P) halts?


It correctly detects that the P of int main() { P(P); } reaches its final state.

There will not actually be any function call Simulate(P,P) per say and this code has not been designed yet.

The very easy part that you should have understood many messages ago is that when the code somehow determines that the halt decider return value is not consistent with the behavior of P this is freaking used to freaking refute Rice.
The problem is that H isn't doing the detecting. To the extent that what you say makes sense it is some other software which tests the result of H(P,P) against the result of your 'global simulator'. But *that* piece of software will have its *own* H_Hat which will be just as susceptible to the Linz proof as your H.

Every putative halt decider has its *own* H_Hat which it will not be able to decide, which is perfectly in line with Rice.

André

That each of these putative halt deciders recognize and reject all and only self-contradictory inputs refutes Rice.

And you've demonstrated this where, exactly?

As far as I can tell your H doesn't reject anything. It simply gets some cases wrong.


The code to reject inputs has not even been fully designed yet.
It is easy to see that the criteria for this already exists.

Your H(P, P) claims that P(P) doesn't halt, which is wrong.


The input to H(P,P) never halts while H remains in pure simulator mode.

You claim that you can reject this based on the fact that it doesn't match which your 'global simulator' concludes.

But that means that neither the global simulator nor H on their own are capable of rejecting anything.


So what?

Whatever code is comparing these two values is what is doing the rejecting. And we can construct from *that* piece of code another H_Hat which *that* piece of code cannot answer correctly.

André



int Simulate(u32 P, u32 I)
{
   ((int(*)(int))P)(I);
   return 1;
}

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

u32 PSR_Decider(u32 P, u32 I)
{
   if (Simulate(P, I) != H(P, I))
     return 1;
   return 0;
}

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




--
Copyright 2021 Pete Olcott

"Great spirits have always encountered violent opposition from mediocre minds." Einstein


Subject: Re:_André_doesn't_know_Rice's_Theorem_[_Malcolm_]_[_PSR_Decider_is_fully_operational_]
From: olcott
Newsgroups: comp.theory, comp.ai.philosophy, comp.software-eng, sci.math.symbolic
Date: Wed, 28 Jul 2021 19:07 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
Path: i2pn2.org!i2pn.org!aioe.org!news.uzoreto.com!fdc2.netnews.com!news-out.netnews.com!news.alt.net!fdc3.netnews.com!peer03.ams1!peer.ams1.xlned.com!news.xlned.com!peer03.iad!feed-me.highwinds-media.com!news.highwinds-media.com!border1.nntp.dca1.giganews.com!nntp.giganews.com!buffer1.nntp.dca1.giganews.com!buffer2.nntp.dca1.giganews.com!news.giganews.com.POSTED!not-for-mail
NNTP-Posting-Date: Wed, 28 Jul 2021 14:07:35 -0500
Subject: Re:_André_doesn't_know_Rice's_Theorem_[_Malc
olm_]_[_PSR_Decider_is_fully_operational_]
Newsgroups: comp.theory,comp.ai.philosophy,comp.software-eng,sci.math.symbolic
References: <20210719214640.00000dfc@reddwarf.jmc>
<sdn40f$5ea$1@dont-email.me> <IYGdnV9avtZj0mL9nZ2dnUU7-d-dnZ2d@giganews.com>
<sdnjhs$30s$1@dont-email.me> <QNOdnRIn-O3-xmL9nZ2dnUU7-fvNnZ2d@giganews.com>
<sdnn91$k7p$1@dont-email.me> <tbGdnZb32okl_GL9nZ2dnUU7-UvNnZ2d@giganews.com>
<sdnrb7$al5$1@dont-email.me> <PMCdnSCWQLiK5mL9nZ2dnUU7-S_NnZ2d@giganews.com>
<sdnua6$n7p$1@dont-email.me> <zPudnUgsAvKV42L9nZ2dnUU7-fXNnZ2d@giganews.com>
<sdo03c$uid$1@dont-email.me>
<d619424f-35d7-4fc2-bc33-d4b0bdb57966n@googlegroups.com>
<m-mdnbNOsMXYuJ38nZ2dnUU7-YnNnZ2d@giganews.com> <sdpf12$ij8$1@dont-email.me>
<d46dnQp1b-ua3p38nZ2dnUU7-d_NnZ2d@giganews.com> <sdpnjb$1q3$1@dont-email.me>
<NpmdnV9AwpJkV538nZ2dnUU7-QXNnZ2d@giganews.com> <sdqjgu$mun$1@dont-email.me>
<yvKdnaD9etCe-Jz8nZ2dnUU7-Q3NnZ2d@giganews.com> <sdrt9e$upt$1@dont-email.me>
<Z6qdna6B7Zq-FZz8nZ2dnUU7-SHNnZ2d@giganews.com>
<JJOdnSDoV9bjPpz8nZ2dnUU7-TudnZ2d@giganews.com> <sds8ns$j19$1@dont-email.me>
From: NoO...@NoWhere.com (olcott)
Date: Wed, 28 Jul 2021 14:07:28 -0500
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:78.0) Gecko/20100101
Thunderbird/78.12.0
MIME-Version: 1.0
In-Reply-To: <sds8ns$j19$1@dont-email.me>
Content-Type: text/plain; charset=utf-8; format=flowed
Content-Language: en-US
Content-Transfer-Encoding: 8bit
Message-ID: <U8WdnXDsfuZlN5z8nZ2dnUU7-anNnZ2d@giganews.com>
Lines: 163
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-RHFjlgd6iKiJ6JPjBpY6JQlfnpOatpZ76FSklC8OEgkpm6thameijP53zWGcL4nYJAr9+/wjb/f01NI!kUSzCfz4w9N7bwGPzsDhXFfnujCLVyY1N+SUiWz967GxLgJmi1kOf3cpzERZhbMlqpxQHTUl8Q==
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: 8275
X-Received-Bytes: 8485
View all headers
On 7/28/2021 1:47 PM, André G. Isaak wrote:
On 2021-07-28 12:35, olcott wrote:
On 7/28/2021 11:38 AM, olcott wrote:
On 7/28/2021 10:31 AM, André G. Isaak wrote:
On 2021-07-28 08:09, olcott wrote:
On 7/27/2021 10:39 PM, André G. Isaak wrote:

So does P(P) halt or not?


Even though the first P in the invocation sequence reaches its final state the fact that it only reaches its final state because the second P in the invocation sequence was aborted proves that H(P,P)==0 is correct.

If a car only crashes because its brakes failed, that does not imply that it didn't crash.

If a program returns the wrong result only because it has a bug, that does not imply that it didn't return the right answer.

If a program only halts because the second P was aborted, that does not imply that it didn't halt.


If an infinitely recursive sequence of function calls is aborted on the second call instead of the first call that does not mean that it was not an infinitely recursive sequence.

Because this is too difficult to understand and accept I have temporarily changed the subject to refuting Rice's theorem. The fact that the first P reaches its final state and the second P is aborted can   be used as the criterion measure to consistently reject all and only self-contradictory inputs. This does refute Rices theorem.

You have on the one hand acknowledged that it does, while at the same time claimed that it doesn't halt in a 'pure simulator'. So if your 'global simulator' is not a pure simulator, what kind of simulator is it?

You didn't answer the above. In the past you've claimed (falsely) that in a pure simulator, P(P) doesn't halt.


While H remains a pure simulator of its input H(P,P) its input never halts thus proving that its input never halts.

Now you appear to be using your 'global simulator' to recognise that P(P) does halt so that you can compare this with the results of H(P, P).


It is still true that H(P,P) did correctly decide that its input never halts. Because this is difficult to understand I am temporarily changing the subject to Rice's theorem.

But if P(P) doesn't halt in a 'pure simulator' then what kind of

I did not say that P(P) does not halt in a pure simulator, you must pay careful attention to every single word that I say. When you skip a single word that reverses the meaning of what I say.

The input to H(P,P) never halts while H remains in pure simulator mode.

simulator is your 'global simulator' which, apparently, correctly detects that P(P) halts?


It correctly detects that the P of int main() { P(P); } reaches its final state.

There will not actually be any function call Simulate(P,P) per say and this code has not been designed yet.

The very easy part that you should have understood many messages ago is that when the code somehow determines that the halt decider return value is not consistent with the behavior of P this is freaking used to freaking refute Rice.
The problem is that H isn't doing the detecting. To the extent that what you say makes sense it is some other software which tests the result of H(P,P) against the result of your 'global simulator'. But *that* piece of software will have its *own* H_Hat which will be just as susceptible to the Linz proof as your H.

Every putative halt decider has its *own* H_Hat which it will not be able to decide, which is perfectly in line with Rice.

André

That each of these putative halt deciders recognize and reject all and only self-contradictory inputs refutes Rice.

And you've demonstrated this where, exactly?

As far as I can tell your H doesn't reject anything. It simply gets some cases wrong.


The code to reject inputs has not even been fully designed yet.
It is easy to see that the criteria for this already exists.

Your H(P, P) claims that P(P) doesn't halt, which is wrong.


The input to H(P,P) never halts while H remains in pure simulator mode.

You claim that you can reject this based on the fact that it doesn't match which your 'global simulator' concludes.

But that means that neither the global simulator nor H on their own are capable of rejecting anything.


So what?

Whatever code is comparing these two values is what is doing the rejecting. And we can construct from *that* piece of code another H_Hat which *that* piece of code cannot answer correctly.

André



int Simulate(u32 P, u32 I)
{
   ((int(*)(int))P)(I);
   return 1;
}

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

u32 PSR_Decider(u32 P, u32 I)
{
   if (Simulate(P, I) != H(P, I))
     return 1;
   return 0;
}

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

So what exactly happens for a *genuine* non-halting computation? Your H returns 0 for non-halting and your Simulate runs forever to confirm that this is correct? Remember that a decider, by definition, must *halt*.

André


When H is fully elaborated to become a full decider its divides all inputs into halting / (not-halting or PSR Error), this still refutes Rice.

--
Copyright 2021 Pete Olcott

"Great spirits have always encountered violent opposition from mediocre minds." Einstein


Subject: Re:_André_doesn't_know_Rice's_Theorem_[_Malcolm_]_[_self-contradiction_must_be_treated_differently_]
From: olcott
Newsgroups: comp.theory, comp.ai.philosophy, comp.software-eng, sci.math.symbolic
Date: Wed, 28 Jul 2021 20:06 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!feeder8.news.weretis.net!feeds.phibee-telecom.net!newsfeed.xs4all.nl!newsfeed8.news.xs4all.nl!tr1.eu1.usenetexpress.com!feeder.usenetexpress.com!tr1.iad1.usenetexpress.com!border1.nntp.dca1.giganews.com!nntp.giganews.com!buffer1.nntp.dca1.giganews.com!news.giganews.com.POSTED!not-for-mail
NNTP-Posting-Date: Wed, 28 Jul 2021 15:06:44 -0500
Subject: Re:_André_doesn't_know_Rice's_Theorem_[_Malcolm_]_[_self-contradiction_must_be_treated_differently_]
Newsgroups: comp.theory,comp.ai.philosophy,comp.software-eng,sci.math.symbolic
References: <20210719214640.00000dfc@reddwarf.jmc> <sdmqm4$2hr$1@dont-email.me> <ZNCdndMEKogNmGL9nZ2dnUU7-KvNnZ2d@giganews.com> <sdn40f$5ea$1@dont-email.me> <IYGdnV9avtZj0mL9nZ2dnUU7-d-dnZ2d@giganews.com> <sdnjhs$30s$1@dont-email.me> <QNOdnRIn-O3-xmL9nZ2dnUU7-fvNnZ2d@giganews.com> <sdnn91$k7p$1@dont-email.me> <tbGdnZb32okl_GL9nZ2dnUU7-UvNnZ2d@giganews.com> <sdnrb7$al5$1@dont-email.me> <PMCdnSCWQLiK5mL9nZ2dnUU7-S_NnZ2d@giganews.com> <sdnua6$n7p$1@dont-email.me> <zPudnUgsAvKV42L9nZ2dnUU7-fXNnZ2d@giganews.com> <sdo03c$uid$1@dont-email.me> <d619424f-35d7-4fc2-bc33-d4b0bdb57966n@googlegroups.com> <m-mdnbNOsMXYuJ38nZ2dnUU7-YnNnZ2d@giganews.com> <sdpf12$ij8$1@dont-email.me> <d46dnQp1b-ua3p38nZ2dnUU7-d_NnZ2d@giganews.com> <sdpnjb$1q3$1@dont-email.me> <NpmdnV9AwpJkV538nZ2dnUU7-QXNnZ2d@giganews.com> <sdqjgu$mun$1@dont-email.me> <yvKdnaD9etCe-Jz8nZ2dnUU7-Q3NnZ2d@giganews.com> <sdrt9e$upt$1@dont-email.me> <Z6qdna6B7Zq-FZz8nZ2dnUU7-SHNnZ2d@giganews.com> <sds8a4$djb$1@dont-email.me>
From: NoO...@NoWhere.com (olcott)
Date: Wed, 28 Jul 2021 15:06:44 -0500
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:78.0) Gecko/20100101 Thunderbird/78.12.0
MIME-Version: 1.0
In-Reply-To: <sds8a4$djb$1@dont-email.me>
Content-Type: text/plain; charset=utf-8; format=flowed
Content-Language: en-US
Content-Transfer-Encoding: 8bit
Message-ID: <uISdndIApsxJJZz8nZ2dnUU7-YvNnZ2d@giganews.com>
Lines: 221
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-UgCFdA5xaqufFm26O9ko/lv1bGSNPZTzJcCKeGV8GVy6jxDwCn6RjABBfuThulY9r3cbr5zOBLpMpVw!LxJcTHracLD2zT21fni3fMD4X9wsUbjVSh2QLNkFMG8bH4NOXuByvfewpVQYeo7kt84y0Dl9HA==
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: 11444
View all headers
On 7/28/2021 1:40 PM, André G. Isaak wrote:
On 2021-07-28 10:38, olcott wrote:
On 7/28/2021 10:31 AM, André G. Isaak wrote:
On 2021-07-28 08:09, olcott wrote:
On 7/27/2021 10:39 PM, André G. Isaak wrote:

So does P(P) halt or not?


Even though the first P in the invocation sequence reaches its final state the fact that it only reaches its final state because the second P in the invocation sequence was aborted proves that H(P,P)==0 is correct.

If a car only crashes because its brakes failed, that does not imply that it didn't crash.

If a program returns the wrong result only because it has a bug, that does not imply that it didn't return the right answer.

If a program only halts because the second P was aborted, that does not imply that it didn't halt.


If an infinitely recursive sequence of function calls is aborted on the second call instead of the first call that does not mean that it was not an infinitely recursive sequence.

But the definition of halting makes no mention of infinitely recursive sequences or aborted function calls. It only requires that P(P) reach a final state in a finite amount of time. P(P) meets this definition.


If we base the decision on whether or not P halts entirely on the fact that it reaches its final state then we have the same situation as "This sentence is not true." It is indeed not true and the definition of a true sentence is whether or not its assertion is satisfied.

When we explicitly take into account the self-contradictory nature of these two cases things are not as cut-and-dried.

"This sentence is not true." is indeed not true yet when we apply this to the satisfaction of the whole sentence and not just its assertion then we get a contradiction. If it is true that it is not true then that makes is not true.

It is an easily verifiable fact that the input to H(P,P) cannot possibly reach its final state while H remains a pure simulator. Because H remains a pure simulator until after it makes its halt status decision then its decision that its input never halts is necessarily correct.

That the first P in the infinitely recursive sequence reaches its final state after H has made its correct halt status decision is just like saying the liar paradox is true on the basis that its assertion is satisfied.

Because this is too difficult to understand and accept I have temporarily changed the subject to refuting Rice's theorem. The fact that the first P reaches its final state and the second P is aborted can   be used as the criterion measure to consistently reject all and only self-contradictory inputs. This does refute Rices theorem.

You have on the one hand acknowledged that it does, while at the same time claimed that it doesn't halt in a 'pure simulator'. So if your 'global simulator' is not a pure simulator, what kind of simulator is it?

You didn't answer the above. In the past you've claimed (falsely) that in a pure simulator, P(P) doesn't halt.


While H remains a pure simulator of its input H(P,P) its input never halts thus proving that its input never halts.

But the definition of halting makes no mention of what happens inside H, regardless of whether it remains a 'pure simulator'. It only requires that the actual computation P(P) reach a final state in a finite amount of time. P(P) meets this definition.

Now you appear to be using your 'global simulator' to recognise that P(P) does halt so that you can compare this with the results of H(P, P).

It is still true that H(P,P) did correctly decide that its input never halts. Because this is difficult to understand I am temporarily changing the subject to Rice's theorem.

No, it is not. The definition of halting is clearly defined, and P(P) clearly meets the definition of halting. Rice's theorem has no bearing on the fact that P(P) is halting computation.


In this exact same way we would have to say that the liar paradox is true because its assertion that it is not true is fully satisfied.

Whenever the assertion of a declarative sentence is satisfied we know that this declarative sentence is true unless this declarative sentence is self-contradictory.

Whenever H decides that its input never halts its input never reaches a final state. When its input is self-contradictory then another different instance of the program that is not an input to H may halt.

But if P(P) doesn't halt in a 'pure simulator' then what kind of

I did not say that P(P) does not halt in a pure simulator, you must pay careful attention to every single word that I say. When you skip a single word that reverses the meaning of what I say.

The input to H(P,P) never halts while H remains in pure simulator mode.

So what's the difference between a 'pure simulator' and H running in 'pure simulator mode'? One would have assumed that the latter meant that H was acting as a pure simulator.


H is evaluating the halt status of its input on the basis of what the behavior of this input would be if H never aborts the simulation of this input.

As Ben has unequivocally agreed any simulation that only halts because it was aborted is a non-halting computation.

simulator is your 'global simulator' which, apparently, correctly detects that P(P) halts?


It correctly detects that the P of int main() { P(P); } reaches its final state.

Which means that P(P) meets the definition of halting and is therefore a halting computation.

There will not actually be any function call Simulate(P,P) per say and this code has not been designed yet.

The very easy part that you should have understood many messages ago is that when the code somehow determines that the halt decider return value is not consistent with the behavior of P this is freaking used to freaking refute Rice.
The problem is that H isn't doing the detecting. To the extent that what you say makes sense it is some other software which tests the result of H(P,P) against the result of your 'global simulator'. But *that* piece of software will have its *own* H_Hat which will be just as susceptible to the Linz proof as your H.

Every putative halt decider has its *own* H_Hat which it will not be able to decide, which is perfectly in line with Rice.

André

That each of these putative halt deciders recognize and reject all and only self-contradictory inputs refutes Rice.

And you've demonstrated this where, exactly?

As far as I can tell your H doesn't reject anything. It simply gets some cases wrong.


The code to reject inputs has not even been fully designed yet.

So why talk about it, then? Until you actually have it you're just blowing smoke.

It is easy to see that the criteria for this already exists.

No. It isn't.

Your H(P, P) claims that P(P) doesn't halt, which is wrong.


The input to H(P,P) never halts while H remains in pure simulator mode.

But the definition of halting makes no mention of what happens inside H, regardless of whether it remains in 'pure simulator mode'. It makes no mention of H at all. It only requires that the *actual* computation P(P) reach a final state in a finite amount of time. P(P) meets this definition.

André

You claim that you can reject this based on the fact that it doesn't match which your 'global simulator' concludes.

But that means that neither the global simulator nor H on their own are capable of rejecting anything.


So what?

Whatever code is comparing these two values is what is doing the rejecting. And we can construct from *that* piece of code another H_Hat which *that* piece of code cannot answer correctly.

André


I am not going to go down the path of infinitely nested operating systems.




The bottom line is that self-contradiction must be treated differently, the conventional rules do not apply to self-contradiction.

When the assertion of a declarative sentence is satisfied this makes the sentence true unless the sentence is self-contradictory.

The fact that "This sentence is not true." is not true does not make the sentence true because the sentence is self-contradictory.

When a simulating halt decider reports that its input does not halt then no instance of the same program ever reaches a final state unless the input program specifies self-contradiction.


--
Copyright 2021 Pete Olcott

"Great spirits have always encountered violent opposition from mediocre minds." Einstein


Subject: Re:_André_doesn't_know_Rice's_Theorem_[_Malcolm_]_[_PSR_Decider_is_fully_operational_]
From: olcott
Newsgroups: comp.theory, comp.ai.philosophy, comp.software-eng, sci.math.symbolic
Date: Thu, 29 Jul 2021 03:25 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
Path: i2pn2.org!i2pn.org!aioe.org!news.uzoreto.com!tr3.eu1.usenetexpress.com!feeder.usenetexpress.com!tr1.iad1.usenetexpress.com!border1.nntp.dca1.giganews.com!nntp.giganews.com!buffer1.nntp.dca1.giganews.com!buffer2.nntp.dca1.giganews.com!news.giganews.com.POSTED!not-for-mail
NNTP-Posting-Date: Wed, 28 Jul 2021 22:25:57 -0500
Subject: Re:_André_doesn't_know_Rice's_Theorem_[_Malcolm_]_[_PSR_Decider_is_fully_operational_]
Newsgroups: comp.theory,comp.ai.philosophy,comp.software-eng,sci.math.symbolic
References: <20210719214640.00000dfc@reddwarf.jmc> <sdnjhs$30s$1@dont-email.me> <QNOdnRIn-O3-xmL9nZ2dnUU7-fvNnZ2d@giganews.com> <sdnn91$k7p$1@dont-email.me> <tbGdnZb32okl_GL9nZ2dnUU7-UvNnZ2d@giganews.com> <sdnrb7$al5$1@dont-email.me> <PMCdnSCWQLiK5mL9nZ2dnUU7-S_NnZ2d@giganews.com> <sdnua6$n7p$1@dont-email.me> <zPudnUgsAvKV42L9nZ2dnUU7-fXNnZ2d@giganews.com> <sdo03c$uid$1@dont-email.me> <d619424f-35d7-4fc2-bc33-d4b0bdb57966n@googlegroups.com> <m-mdnbNOsMXYuJ38nZ2dnUU7-YnNnZ2d@giganews.com> <sdpf12$ij8$1@dont-email.me> <d46dnQp1b-ua3p38nZ2dnUU7-d_NnZ2d@giganews.com> <sdpnjb$1q3$1@dont-email.me> <NpmdnV9AwpJkV538nZ2dnUU7-QXNnZ2d@giganews.com> <sdqjgu$mun$1@dont-email.me> <yvKdnaD9etCe-Jz8nZ2dnUU7-Q3NnZ2d@giganews.com> <sdrt9e$upt$1@dont-email.me> <Z6qdna6B7Zq-FZz8nZ2dnUU7-SHNnZ2d@giganews.com> <JJOdnSDoV9bjPpz8nZ2dnUU7-TudnZ2d@giganews.com> <sds8ns$j19$1@dont-email.me> <U8WdnXDsfuZlN5z8nZ2dnUU7-anNnZ2d@giganews.com> <sdsp19$vpa$1@dont-email.me>
From: NoO...@NoWhere.com (olcott)
Date: Wed, 28 Jul 2021 22:25:57 -0500
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:78.0) Gecko/20100101 Thunderbird/78.12.0
MIME-Version: 1.0
In-Reply-To: <sdsp19$vpa$1@dont-email.me>
Content-Type: text/plain; charset=utf-8; format=flowed
Content-Language: en-US
Content-Transfer-Encoding: 8bit
Message-ID: <_LWdnRC5OuhYgp_8nZ2dnUU7-IXNnZ2d@giganews.com>
Lines: 41
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-mSgbx+qX9u4/5F26g4OnIuOARnClpH0fRRADg4wVAU2tjgcD5nDu4+QgDa0EhuwE+pNXBMUVuN33/T4!oyEHjiQWK8F+91iBALPHo/ex8yHap2knTPBw+C5aIl3fkSOS+eiqy9/fD7zB27q9Whzvb9D9cA==
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: 3552
View all headers
On 7/28/2021 6:25 PM, André G. Isaak wrote:
On 2021-07-28 13:07, olcott wrote:

So what exactly happens for a *genuine* non-halting computation? Your H returns 0 for non-halting and your Simulate runs forever to confirm that this is correct? Remember that a decider, by definition, must *halt*.

André


When H is fully elaborated to become a full decider its divides all inputs into halting / (not-halting or PSR Error), this still refutes Rice.

First off, that wasn't an answer to my question.

Secondly, (not halting or PSR error) isn't a legitimate semantic property so it has nothing to do with Rice.

Halting vs. Non-Halting would be a legitimate semantic property.

Halting vs. Non-Halting + all the cases H get wrong isn't.

André



This is an improvement over what anyone else has ever done:
Every input to a simulating halt decider that only stops running when its simulation is aborted unequivocally specifies a computation that never halts.

The P of int main(){ P(P); } is one of these inputs therefore H correctly decides that it never halts.

--
Copyright 2021 Pete Olcott

"Great spirits have always encountered violent opposition from mediocre minds." Einstein


Subject: Re:_André_doesn't_know_Rice's_Theorem_[_Malcolm_]_[_self-contradiction_must_be_treated_differently_]
From: olcott
Newsgroups: comp.theory, comp.ai.philosophy, comp.software-eng, sci.math.symbolic
Date: Thu, 29 Jul 2021 03:51 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!aioe.org!news.uzoreto.com!tr3.eu1.usenetexpress.com!feeder.usenetexpress.com!tr2.iad1.usenetexpress.com!border1.nntp.dca1.giganews.com!nntp.giganews.com!buffer1.nntp.dca1.giganews.com!buffer2.nntp.dca1.giganews.com!news.giganews.com.POSTED!not-for-mail
NNTP-Posting-Date: Wed, 28 Jul 2021 22:51:48 -0500
Subject: Re:_André_doesn't_know_Rice's_Theorem_[_Malcolm_]_[_self-contradiction_must_be_treated_differently_]
Newsgroups: comp.theory,comp.ai.philosophy,comp.software-eng,sci.math.symbolic
References: <20210719214640.00000dfc@reddwarf.jmc> <sdn40f$5ea$1@dont-email.me> <IYGdnV9avtZj0mL9nZ2dnUU7-d-dnZ2d@giganews.com> <sdnjhs$30s$1@dont-email.me> <QNOdnRIn-O3-xmL9nZ2dnUU7-fvNnZ2d@giganews.com> <sdnn91$k7p$1@dont-email.me> <tbGdnZb32okl_GL9nZ2dnUU7-UvNnZ2d@giganews.com> <sdnrb7$al5$1@dont-email.me> <PMCdnSCWQLiK5mL9nZ2dnUU7-S_NnZ2d@giganews.com> <sdnua6$n7p$1@dont-email.me> <zPudnUgsAvKV42L9nZ2dnUU7-fXNnZ2d@giganews.com> <sdo03c$uid$1@dont-email.me> <d619424f-35d7-4fc2-bc33-d4b0bdb57966n@googlegroups.com> <m-mdnbNOsMXYuJ38nZ2dnUU7-YnNnZ2d@giganews.com> <sdpf12$ij8$1@dont-email.me> <d46dnQp1b-ua3p38nZ2dnUU7-d_NnZ2d@giganews.com> <sdpnjb$1q3$1@dont-email.me> <NpmdnV9AwpJkV538nZ2dnUU7-QXNnZ2d@giganews.com> <sdqjgu$mun$1@dont-email.me> <yvKdnaD9etCe-Jz8nZ2dnUU7-Q3NnZ2d@giganews.com> <sdrt9e$upt$1@dont-email.me> <Z6qdna6B7Zq-FZz8nZ2dnUU7-SHNnZ2d@giganews.com> <sds8a4$djb$1@dont-email.me> <uISdndIApsxJJZz8nZ2dnUU7-YvNnZ2d@giganews.com> <sdsplo$9fe$1@dont-email.me>
From: NoO...@NoWhere.com (olcott)
Date: Wed, 28 Jul 2021 22:51:48 -0500
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:78.0) Gecko/20100101 Thunderbird/78.12.0
MIME-Version: 1.0
In-Reply-To: <sdsplo$9fe$1@dont-email.me>
Content-Type: text/plain; charset=utf-8; format=flowed
Content-Language: en-US
Content-Transfer-Encoding: 8bit
Message-ID: <O62dnbVMDplJuJ_8nZ2dnUU7-UGdnZ2d@giganews.com>
Lines: 248
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-OvAkgNtjJ8uUUop2f6ypgDXWMmeWyS7eVihvccr2LZkGDGYo5IhuWXnaY7N276Zr+gRfzE0bP0a95vP!tcdm1uWaLmagGpX1imdv70q5LEvREeLH5pOks8m0L4TwPz+uuVxNrvC/Bkwdq66IyO7ONys2tA==
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: 12404
View all headers
On 7/28/2021 6:36 PM, André G. Isaak wrote:
On 2021-07-28 14:06, olcott wrote:
On 7/28/2021 1:40 PM, André G. Isaak wrote:
On 2021-07-28 10:38, olcott wrote:
On 7/28/2021 10:31 AM, André G. Isaak wrote:
On 2021-07-28 08:09, olcott wrote:
On 7/27/2021 10:39 PM, André G. Isaak wrote:

So does P(P) halt or not?


Even though the first P in the invocation sequence reaches its final state the fact that it only reaches its final state because the second P in the invocation sequence was aborted proves that H(P,P)==0 is correct.

If a car only crashes because its brakes failed, that does not imply that it didn't crash.

If a program returns the wrong result only because it has a bug, that does not imply that it didn't return the right answer.

If a program only halts because the second P was aborted, that does not imply that it didn't halt.


If an infinitely recursive sequence of function calls is aborted on the second call instead of the first call that does not mean that it was not an infinitely recursive sequence.

But the definition of halting makes no mention of infinitely recursive sequences or aborted function calls. It only requires that P(P) reach a final state in a finite amount of time. P(P) meets this definition.


If we base the decision on whether or not P halts entirely on the fact that it reaches its final state

That's the DEFINITION of halting, so of course that's the only thing we should base the decision of whether P halts on.


This is equally the definition of not halting:
Every input to a simulating halt decider that only stops running when its simulation is aborted unequivocally specifies a computation that never halts.

then we have the same situation as "This sentence is not true." It is indeed not true and the definition of a true sentence is whether or not its assertion is satisfied.

I fail to see any parallels between P and the liar.

When we explicitly take into account the self-contradictory nature of these two cases things are not as cut-and-dried.

There's nothing self-contradictory about it.

"This sentence is not true." is indeed not true yet when we apply this to the satisfaction of the whole sentence and not just its assertion

That is gibberish.

then we get a contradiction. If it is true that it is not true then that makes is not true.

It is an easily verifiable fact that the input to H(P,P) cannot possibly reach its final state while H remains a pure simulator. Because H

But the definition of halting makes no reference to what H does at all, nor to pure simulators. whether P(P) halts is based solely on the behaviour of P(P).


The definition of UTM does make reference to computational equivalence forcing this statement to be necessarily true:

Every input to a simulating halt decider that only stops running when its simulation is aborted unequivocally specifies a computation that never halts.

remains a pure simulator until after it makes its halt status decision then its decision that its input never halts is necessarily correct.

That the first P in the infinitely recursive sequence reaches its final state after H has made its correct halt status decision is just like saying the liar paradox is true on the basis that its assertion is satisfied.

No. That the first P reaches its final state means that P(P) halts. The definition of halting doesn't care how or why it reaches this state. Only that it does.

So then we must conclude the the self contradictory input causes the logic of the system to be inconsistent because it proves that P halts and it proves that P never halts.

Because this is too difficult to understand and accept I have temporarily changed the subject to refuting Rice's theorem. The fact that the first P reaches its final state and the second P is aborted can   be used as the criterion measure to consistently reject all and only self-contradictory inputs. This does refute Rices theorem.

You have on the one hand acknowledged that it does, while at the same time claimed that it doesn't halt in a 'pure simulator'. So if your 'global simulator' is not a pure simulator, what kind of simulator is it?

You didn't answer the above. In the past you've claimed (falsely) that in a pure simulator, P(P) doesn't halt.


While H remains a pure simulator of its input H(P,P) its input never halts thus proving that its input never halts.

But the definition of halting makes no mention of what happens inside H, regardless of whether it remains a 'pure simulator'. It only requires that the actual computation P(P) reach a final state in a finite amount of time. P(P) meets this definition.

Now you appear to be using your 'global simulator' to recognise that P(P) does halt so that you can compare this with the results of H(P, P).

It is still true that H(P,P) did correctly decide that its input never halts. Because this is difficult to understand I am temporarily changing the subject to Rice's theorem.

No, it is not. The definition of halting is clearly defined, and P(P) clearly meets the definition of halting. Rice's theorem has no bearing on the fact that P(P) is halting computation.


In this exact same way we would have to say that the liar paradox is true because its assertion that it is not true is fully satisfied.

The LP's "assertion that it is not true" is *not* satisfied, fully or otherwise.

The Liar Paradox: "This sentence is not true."
is indeed provably not true on the basis that it leads to a contradiction and on the basis that it specifies and infinite cycle.

Only my own unique work finally resolves this:

Apparently in all of the years prior to my original (2016) paper no one ever separated the analysis of propositions into their atomic units of semantic compositionality:
(a) Assertion  (Boolean) //  What the expression of language claims to be True
(b) Satisfied   (Boolean) //  Whether or not the expression of language is True

https://www.researchgate.net/publication/323866366_The_Notion_of_Truth_in_Natural_and_Formal_Languages

P(P), on the other hand, fully meets the definition of halting.

Whenever the assertion of a declarative sentence is satisfied we know that this declarative sentence is true unless this declarative sentence is self-contradictory.

Whenever H decides that its input never halts its input never reaches a final state. When its input is self-contradictory then another different

The input to H is simply *data*. Halting applies to *computations*.


Not exactly: UTM(P,I) ≡ P(I)

instance of the program that is not an input to H may halt.

But if P(P) doesn't halt in a 'pure simulator' then what kind of

I did not say that P(P) does not halt in a pure simulator, you must pay careful attention to every single word that I say. When you skip a single word that reverses the meaning of what I say.

The input to H(P,P) never halts while H remains in pure simulator mode.

So what's the difference between a 'pure simulator' and H running in 'pure simulator mode'? One would have assumed that the latter meant that H was acting as a pure simulator.


H is evaluating the halt status of its input on the basis of what the behavior of this input would be if H never aborts the simulation of this input.

Which is the wrong criterion for evaluating this. The correct criterion is simply whether P(P) reaches a final state.

<snippage>

The bottom line is that self-contradiction must be treated differently, the conventional rules do not apply to self-contradiction.

Where does the definition of halting entail some class which must be treated differently? All computations either reach a final state in a finite amount of time or they do not. There is no third option.


It is generally always the case that self-contradictory expressions of language must always be treated differently than non self-contradictory expressions of language.

That some sub-fields never noticed this is their fault and limitation.

When the assertion of a declarative sentence is satisfied this makes the sentence true unless the sentence is self-contradictory.

The fact that "This sentence is not true." is not true does not make the sentence true because the sentence is self-contradictory.

When a simulating halt decider reports that its input does not halt then no instance of the same program ever reaches a final state unless the input program specifies self-contradiction.

There are no 'instances of the same program' when talking in terms of Turing Machines.

André


Ĥ.q0 wM ⊢* Ĥ.qx wM wM ⊢* Ĥ.qy ∞
if M applied to wM halts, and

Ĥ.q0 wM ⊢* Ĥ.qx wM wM ⊢* Ĥ.qn
if M applied to wM does not halt

Ĥ( ⟨Ĥ⟩ ) specifies an infinite cycle from Ĥ.qx to Ĥ.q0 all the time that Ĥ.qx remains a pure simulator of its input.

Every simulation that would never stop unless its simulating halt decider stops it at some point specifies infinite execution. This remains true for: Ĥ.qx(⟨Ĥ⟩, ⟨Ĥ⟩)

Ĥ( ⟨Ĥ⟩ ) only stops because its simulating halt decider stops it at some point.

--
Copyright 2021 Pete Olcott

"Great spirits have always encountered violent opposition from mediocre minds." Einstein


Subject: Re:_André_doesn't_know_Rice's_Theorem_[_Malcolm_]_[_self-contradiction_must_be_treated_differently_]
From: olcott
Newsgroups: comp.theory, comp.ai.philosophy, comp.software-eng, sci.math.symbolic
Date: Thu, 29 Jul 2021 04:31 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!aioe.org!news.uzoreto.com!news-out.netnews.com!news.alt.net!fdc3.netnews.com!feeder.usenetexpress.com!tr3.iad1.usenetexpress.com!border1.nntp.dca1.giganews.com!nntp.giganews.com!buffer1.nntp.dca1.giganews.com!news.giganews.com.POSTED!not-for-mail
NNTP-Posting-Date: Wed, 28 Jul 2021 23:31:50 -0500
Subject: Re:_André_doesn't_know_Rice's_Theorem_[_Malcolm_]_[_self-contradiction_must_be_treated_differently_]
Newsgroups: comp.theory,comp.ai.philosophy,comp.software-eng,sci.math.symbolic
References: <20210719214640.00000dfc@reddwarf.jmc> <sdnjhs$30s$1@dont-email.me> <QNOdnRIn-O3-xmL9nZ2dnUU7-fvNnZ2d@giganews.com> <sdnn91$k7p$1@dont-email.me> <tbGdnZb32okl_GL9nZ2dnUU7-UvNnZ2d@giganews.com> <sdnrb7$al5$1@dont-email.me> <PMCdnSCWQLiK5mL9nZ2dnUU7-S_NnZ2d@giganews.com> <sdnua6$n7p$1@dont-email.me> <zPudnUgsAvKV42L9nZ2dnUU7-fXNnZ2d@giganews.com> <sdo03c$uid$1@dont-email.me> <d619424f-35d7-4fc2-bc33-d4b0bdb57966n@googlegroups.com> <m-mdnbNOsMXYuJ38nZ2dnUU7-YnNnZ2d@giganews.com> <sdpf12$ij8$1@dont-email.me> <d46dnQp1b-ua3p38nZ2dnUU7-d_NnZ2d@giganews.com> <sdpnjb$1q3$1@dont-email.me> <NpmdnV9AwpJkV538nZ2dnUU7-QXNnZ2d@giganews.com> <sdqjgu$mun$1@dont-email.me> <yvKdnaD9etCe-Jz8nZ2dnUU7-Q3NnZ2d@giganews.com> <sdrt9e$upt$1@dont-email.me> <Z6qdna6B7Zq-FZz8nZ2dnUU7-SHNnZ2d@giganews.com> <sds8a4$djb$1@dont-email.me> <uISdndIApsxJJZz8nZ2dnUU7-YvNnZ2d@giganews.com> <sdsplo$9fe$1@dont-email.me> <O62dnbVMDplJuJ_8nZ2dnUU7-UGdnZ2d@giganews.com> <sdta1u$emq$1@dont-email.me>
From: NoO...@NoWhere.com (olcott)
Date: Wed, 28 Jul 2021 23:31:50 -0500
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:78.0) Gecko/20100101 Thunderbird/78.12.0
MIME-Version: 1.0
In-Reply-To: <sdta1u$emq$1@dont-email.me>
Content-Type: text/plain; charset=utf-8; format=flowed
Content-Language: en-US
Content-Transfer-Encoding: 8bit
Message-ID: <ALqdnZRdO4Grsp_8nZ2dnUU7-anNnZ2d@giganews.com>
Lines: 373
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-QNoxwdLRBIsEsUuspiHfDnDR0F5zEU1lUr21AY1qwTCo4exDmbOGTe4CTBPy2W8NVL/q18oCgv9tsbt!bOw82ftZFYH/pM7J4zHg9LLBLCVTcjotiRsGk44eG8481NYo7LXK3VenO2VPXF+MSwpmvRpL+g==
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: 17781
View all headers
On 7/28/2021 11:15 PM, André G. Isaak wrote:
On 2021-07-28 21:51, olcott wrote:
On 7/28/2021 6:36 PM, André G. Isaak wrote:
On 2021-07-28 14:06, olcott wrote:
On 7/28/2021 1:40 PM, André G. Isaak wrote:
On 2021-07-28 10:38, olcott wrote:
On 7/28/2021 10:31 AM, André G. Isaak wrote:
On 2021-07-28 08:09, olcott wrote:
On 7/27/2021 10:39 PM, André G. Isaak wrote:

So does P(P) halt or not?


Even though the first P in the invocation sequence reaches its final state the fact that it only reaches its final state because the second P in the invocation sequence was aborted proves that H(P,P)==0 is correct.

If a car only crashes because its brakes failed, that does not imply that it didn't crash.

If a program returns the wrong result only because it has a bug, that does not imply that it didn't return the right answer.

If a program only halts because the second P was aborted, that does not imply that it didn't halt.


If an infinitely recursive sequence of function calls is aborted on the second call instead of the first call that does not mean that it was not an infinitely recursive sequence.

But the definition of halting makes no mention of infinitely recursive sequences or aborted function calls. It only requires that P(P) reach a final state in a finite amount of time. P(P) meets this definition.


If we base the decision on whether or not P halts entirely on the fact that it reaches its final state

That's the DEFINITION of halting, so of course that's the only thing we should base the decision of whether P halts on.


This is equally the definition of not halting:
Every input to a simulating halt decider that only stops running when its simulation is aborted unequivocally specifies a computation that never halts.

No, it isn't a definition of halting. At best, it is something which you have proposed as a *test* for halting, but it is a broken test since, at least according to you, it sometimes gives an answer that does *not* correspond to the *actual* definition of halting.


It is computationally equivalent to not halting.


then we have the same situation as "This sentence is not true." It is indeed not true and the definition of a true sentence is whether or not its assertion is satisfied.

I fail to see any parallels between P and the liar.

When we explicitly take into account the self-contradictory nature of these two cases things are not as cut-and-dried.

There's nothing self-contradictory about it.

"This sentence is not true." is indeed not true yet when we apply this to the satisfaction of the whole sentence and not just its assertion

That is gibberish.

then we get a contradiction. If it is true that it is not true then that makes is not true.

It is an easily verifiable fact that the input to H(P,P) cannot possibly reach its final state while H remains a pure simulator. Because H

But the definition of halting makes no reference to what H does at all, nor to pure simulators. whether P(P) halts is based solely on the behaviour of P(P).


The definition of UTM does make reference to computational equivalence forcing this statement to be necessarily true:

Please show me a definition of UTM which makes reference to computational equivalence.


The simulation of the TM description of TM P on input I is stipulated to be computationally equivalent to P(I). In an honest dialogue I would not have to repeat this fifty times.

Every input to a simulating halt decider that only stops running when its simulation is aborted unequivocally specifies a computation that never halts.

A 'simulating halt decider' and UTM are different things.


Not while the simulating halt decider is in pure simulator mode.

remains a pure simulator until after it makes its halt status decision then its decision that its input never halts is necessarily correct.

That the first P in the infinitely recursive sequence reaches its final state after H has made its correct halt status decision is just like saying the liar paradox is true on the basis that its assertion is satisfied.

No. That the first P reaches its final state means that P(P) halts. The definition of halting doesn't care how or why it reaches this state. Only that it does.

So then we must conclude the the self contradictory input causes the logic of the system to be inconsistent because it proves that P halts and it proves that P never halts.

It shows the logic of the *decider* to be inconsistent. It doesn't show anything inconsistent about the definition of halting, nor does it provide to treat a computation which halts as anything other than a computation which halts.


Within the hypothesis that this is correct:
Within the hypothesis that this is correct:
Within the hypothesis that this is correct:
Within the hypothesis that this is correct:

Every input to a simulating halt decider that only stops running when
its simulation is aborted unequivocally specifies a computation that
never halts.

Then the fact that the first P of int main(){ P(P); } reaches its final state wold seem to prove that we are getting the same contradiction as the liar paradox.

This make perfect sense:
garbage in  (self contradictory input)
garbage out (contradictory result).


Whether P(P) halts is a question which is independent of any 'halt decider'.

H cannot decide P(P) correctly. Other partial deciders are able to decide it correctly. But the definition of halting makes no reference to whether any other TM can decide it correctly. It refers only to whether P(P) reaches a final state in a finite number of steps. It does. Therefore it halts.

Because this is too difficult to understand and accept I have temporarily changed the subject to refuting Rice's theorem. The fact that the first P reaches its final state and the second P is aborted can   be used as the criterion measure to consistently reject all and only self-contradictory inputs. This does refute Rices theorem.

You have on the one hand acknowledged that it does, while at the same time claimed that it doesn't halt in a 'pure simulator'. So if your 'global simulator' is not a pure simulator, what kind of simulator is it?

You didn't answer the above. In the past you've claimed (falsely) that in a pure simulator, P(P) doesn't halt.


While H remains a pure simulator of its input H(P,P) its input never halts thus proving that its input never halts.

But the definition of halting makes no mention of what happens inside H, regardless of whether it remains a 'pure simulator'. It only requires that the actual computation P(P) reach a final state in a finite amount of time. P(P) meets this definition.

Now you appear to be using your 'global simulator' to recognise that P(P) does halt so that you can compare this with the results of H(P, P).

It is still true that H(P,P) did correctly decide that its input never halts. Because this is difficult to understand I am temporarily changing the subject to Rice's theorem.

No, it is not. The definition of halting is clearly defined, and P(P) clearly meets the definition of halting. Rice's theorem has no bearing on the fact that P(P) is halting computation.


In this exact same way we would have to say that the liar paradox is true because its assertion that it is not true is fully satisfied.

The LP's "assertion that it is not true" is *not* satisfied, fully or otherwise.

The Liar Paradox: "This sentence is not true."
is indeed provably not true on the basis that it leads to a contradiction and on the basis that it specifies and infinite cycle.

Only my own unique work finally resolves this:

Apparently in all of the years prior to my original (2016) paper no one ever separated the analysis of propositions into their atomic units of semantic compositionality:
(a) Assertion  (Boolean) //  What the expression of language claims to be True
(b) Satisfied   (Boolean) //  Whether or not the expression of language is True

You've raised this before. It's as meaningless now as it was when you first suggested it.


No it is not. It does perfectly address the issue of the liar paradox.

https://www.researchgate.net/publication/323866366_The_Notion_of_Truth_in_Natural_and_Formal_Languages
P(P), on the other hand, fully meets the definition of halting.

Whenever the assertion of a declarative sentence is satisfied we know that this declarative sentence is true unless this declarative sentence is self-contradictory.

Whenever H decides that its input never halts its input never reaches a final state. When its input is self-contradictory then another different

The input to H is simply *data*. Halting applies to *computations*.


Not exactly: UTM(P,I) ≡ P(I)

The inputs to a UTM are equally not a computation. They are data.


The simulation of the TM description of TM P on input I is stipulated to be computationally equivalent to P(I). In an honest dialogue I would not have to repeat this fifty times.

The simulation of the TM description of TM P on input I is stipulated to be computationally equivalent to P(I). In an honest dialogue I would not have to repeat this fifty times.

The simulation of the TM description of TM P on input I is stipulated to be computationally equivalent to P(I). In an honest dialogue I would not have to repeat this fifty times.

The simulation of the TM description of TM P on input I is stipulated to be computationally equivalent to P(I). In an honest dialogue I would not have to repeat this fifty times.

Click here to read the complete article
Subject: Re:_André_doesn't_know_Rice's_Theorem_[_Malcolm_]_[_self-contradiction_must_be_treated_differently_]
From: olcott
Newsgroups: comp.theory, comp.ai.philosophy, comp.software-eng, sci.math.symbolic
Date: Thu, 29 Jul 2021 17:39 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!feeder8.news.weretis.net!feeder1.feed.usenet.farm!feed.usenet.farm!tr1.eu1.usenetexpress.com!feeder.usenetexpress.com!tr2.iad1.usenetexpress.com!border1.nntp.dca1.giganews.com!nntp.giganews.com!buffer1.nntp.dca1.giganews.com!news.giganews.com.POSTED!not-for-mail
NNTP-Posting-Date: Thu, 29 Jul 2021 12:39:20 -0500
Subject: Re:_André_doesn't_know_Rice's_Theorem_[_Malcolm_]_[_self-contradiction_must_be_treated_differently_]
Newsgroups: comp.theory,comp.ai.philosophy,comp.software-eng,sci.math.symbolic
References: <20210719214640.00000dfc@reddwarf.jmc> <sdnn91$k7p$1@dont-email.me> <tbGdnZb32okl_GL9nZ2dnUU7-UvNnZ2d@giganews.com> <sdnrb7$al5$1@dont-email.me> <PMCdnSCWQLiK5mL9nZ2dnUU7-S_NnZ2d@giganews.com> <sdnua6$n7p$1@dont-email.me> <zPudnUgsAvKV42L9nZ2dnUU7-fXNnZ2d@giganews.com> <sdo03c$uid$1@dont-email.me> <d619424f-35d7-4fc2-bc33-d4b0bdb57966n@googlegroups.com> <m-mdnbNOsMXYuJ38nZ2dnUU7-YnNnZ2d@giganews.com> <sdpf12$ij8$1@dont-email.me> <d46dnQp1b-ua3p38nZ2dnUU7-d_NnZ2d@giganews.com> <sdpnjb$1q3$1@dont-email.me> <NpmdnV9AwpJkV538nZ2dnUU7-QXNnZ2d@giganews.com> <sdqjgu$mun$1@dont-email.me> <yvKdnaD9etCe-Jz8nZ2dnUU7-Q3NnZ2d@giganews.com> <sdrt9e$upt$1@dont-email.me> <Z6qdna6B7Zq-FZz8nZ2dnUU7-SHNnZ2d@giganews.com> <sds8a4$djb$1@dont-email.me> <uISdndIApsxJJZz8nZ2dnUU7-YvNnZ2d@giganews.com> <sdsplo$9fe$1@dont-email.me> <O62dnbVMDplJuJ_8nZ2dnUU7-UGdnZ2d@giganews.com> <sdta1u$emq$1@dont-email.me> <ALqdnZRdO4Grsp_8nZ2dnUU7-anNnZ2d@giganews.com> <sdtcmb$eii$1@dont-email.me>
From: NoO...@NoWhere.com (olcott)
Date: Thu, 29 Jul 2021 12:39:20 -0500
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:78.0) Gecko/20100101 Thunderbird/78.12.0
MIME-Version: 1.0
In-Reply-To: <sdtcmb$eii$1@dont-email.me>
Content-Type: text/plain; charset=utf-8; format=flowed
Content-Language: en-US
Content-Transfer-Encoding: 8bit
Message-ID: <M6Kdna_NMKVVep_8nZ2dnUU7-K3NnZ2d@giganews.com>
Lines: 240
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-tbAFxiFD/JVJTW6vmWi2n2WXWN2SBMd7x68NO9pLRjwd+xF5RlhjhAGdaQPWBEfls51GtORD8nMKqL4!TcrIOcj1Ssm+mgEezSLFf3XZHhiWFYrJu20elmkfdc+0B1SKfkk43xzSyexYOIvJy8iGf/OncQ==
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: 11770
View all headers
On 7/29/2021 12:00 AM, André G. Isaak wrote:
On 2021-07-28 22:31, olcott wrote:
On 7/28/2021 11:15 PM, André G. Isaak wrote:
On 2021-07-28 21:51, olcott wrote:
On 7/28/2021 6:36 PM, André G. Isaak wrote:
On 2021-07-28 14:06, olcott wrote:
On 7/28/2021 1:40 PM, André G. Isaak wrote:
On 2021-07-28 10:38, olcott wrote:
On 7/28/2021 10:31 AM, André G. Isaak wrote:
On 2021-07-28 08:09, olcott wrote:
On 7/27/2021 10:39 PM, André G. Isaak wrote:

So does P(P) halt or not?


Even though the first P in the invocation sequence reaches its final state the fact that it only reaches its final state because the second P in the invocation sequence was aborted proves that H(P,P)==0 is correct.

If a car only crashes because its brakes failed, that does not imply that it didn't crash.

If a program returns the wrong result only because it has a bug, that does not imply that it didn't return the right answer.

If a program only halts because the second P was aborted, that does not imply that it didn't halt.


If an infinitely recursive sequence of function calls is aborted on the second call instead of the first call that does not mean that it was not an infinitely recursive sequence.

But the definition of halting makes no mention of infinitely recursive sequences or aborted function calls. It only requires that P(P) reach a final state in a finite amount of time. P(P) meets this definition.


If we base the decision on whether or not P halts entirely on the fact that it reaches its final state

That's the DEFINITION of halting, so of course that's the only thing we should base the decision of whether P halts on.


This is equally the definition of not halting:
Every input to a simulating halt decider that only stops running when its simulation is aborted unequivocally specifies a computation that never halts.

No, it isn't a definition of halting. At best, it is something which you have proposed as a *test* for halting, but it is a broken test since, at least according to you, it sometimes gives an answer that does *not* correspond to the *actual* definition of halting.


It is computationally equivalent to not halting.

By the definition of halting, P(P) halts.

According to you, your definition leads to the conclusion that P(P) doesn't halt.

They cannot be equivalent if they lead to different results (and I have no idea why you use the expression 'computationally equivalent').


We have two different equally correct definitions of halting that have a contradictory result thus proving garbage in garbage out.
Self-contradictory inputs derive contradictory conclusions.


then we have the same situation as "This sentence is not true." It is indeed not true and the definition of a true sentence is whether or not its assertion is satisfied.

I fail to see any parallels between P and the liar.

When we explicitly take into account the self-contradictory nature of these two cases things are not as cut-and-dried.

There's nothing self-contradictory about it.

"This sentence is not true." is indeed not true yet when we apply this to the satisfaction of the whole sentence and not just its assertion

That is gibberish.

then we get a contradiction. If it is true that it is not true then that makes is not true.

It is an easily verifiable fact that the input to H(P,P) cannot possibly reach its final state while H remains a pure simulator. Because H

But the definition of halting makes no reference to what H does at all, nor to pure simulators. whether P(P) halts is based solely on the behaviour of P(P).


The definition of UTM does make reference to computational equivalence forcing this statement to be necessarily true:

Please show me a definition of UTM which makes reference to computational equivalence.


The simulation of the TM description of TM P on input I is stipulated to be computationally equivalent to P(I). In an honest dialogue I would not have to repeat this fifty times.

I asked you to show me a *definition* of UTM which refers to computational equivalence. The above is not a definition.

Perhaps you are proving that you are unqualified to evaluate my work?
....anything which can be “computed”, can also be computed by that one universal machine. Conversely, any problem that is not computable by the universal machine is considered to be uncomputable.
https://plato.stanford.edu/entries/turing-machine/#TuriUnivMach

Every input to a simulating halt decider that only stops running when its simulation is aborted unequivocally specifies a computation that never halts.

A 'simulating halt decider' and UTM are different things.


Not while the simulating halt decider is in pure simulator mode.

UTM(P, P) halts.

You claim that your 'simulating halt decider in pure simulator mode' doesn't halt on input P, P.


Which is another way of saying:
Every input to a simulating halt decider that only stops running when its simulation is aborted unequivocally specifies a computation that never halts.

Therefore they are not the same thing.

And why does it matter what happens in a 'simulating halt decider in pure simulator mode'?

The definition of halting is only concerned with what the computation P(P) does, not with what happens inside a 'simulating halt decider in pure simulator mode'.


None-the-less my definitions are computationally equivalent to the standard ones on this basis: UTM(P,I) ≡ P(I)

That you deny this seems to indicate that you do not know the subject matter well enough to be qualified to evaluate my work.

remains a pure simulator until after it makes its halt status decision then its decision that its input never halts is necessarily correct.

That the first P in the infinitely recursive sequence reaches its final state after H has made its correct halt status decision is just like saying the liar paradox is true on the basis that its assertion is satisfied.

No. That the first P reaches its final state means that P(P) halts. The definition of halting doesn't care how or why it reaches this state. Only that it does.

So then we must conclude the the self contradictory input causes the logic of the system to be inconsistent because it proves that P halts and it proves that P never halts.

It shows the logic of the *decider* to be inconsistent. It doesn't show anything inconsistent about the definition of halting, nor does it provide to treat a computation which halts as anything other than a computation which halts.


Within the hypothesis that this is correct:
Within the hypothesis that this is correct:
Within the hypothesis that this is correct:
Within the hypothesis that this is correct:

Every input to a simulating halt decider that only stops running when
its simulation is aborted unequivocally specifies a computation that
never halts.

Then the fact that the first P of int main(){ P(P); } reaches its final state wold seem to prove that we are getting the same contradiction as the liar paradox.

Bad logic on your part leads to bad results on your part. Your 'hypothesis' as you interpret it is *not* correct.

This make perfect sense:
garbage in  (self contradictory input)
garbage out (contradictory result).

No. It does not make perfect sense since P(P) very clearly meets the actual definition of halting.

And in this exact same way the fact that the following sentence is not true: "this sentence is not true" should make it true, but it does not.

    The input is defined to contradict whatever the halt decider decides
    Now we construct a new Turing machine D with H as a subroutine.
    This new TM calls H to determine what M does when the input to
    M is its own description ⟨M⟩. Once D has determined this information,
    it does the opposite.  (Sipser:1997:165)

Where does a 'self-contradictory expression of language' appear in the above? Nowhere that I can see.


When we encode the above in C and this function is executed with input: P its behavior contradicts every halt status that H can return.

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


André

<snip remainder, including, asinine, juvenile repetition>




--
Copyright 2021 Pete Olcott

"Great spirits have always encountered violent opposition from mediocre minds." Einstein


Subject: Re:_André_doesn't_know_Rice's_Theorem_[_Malcolm_]_[_Try_and_provide_a_counter-example_]
From: olcott
Newsgroups: comp.theory, comp.ai.philosophy, comp.software-eng, sci.math.symbolic
Date: Thu, 29 Jul 2021 18:15 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.snarked.org!border2.nntp.dca1.giganews.com!nntp.giganews.com!buffer2.nntp.dca1.giganews.com!news.giganews.com.POSTED!not-for-mail
NNTP-Posting-Date: Thu, 29 Jul 2021 13:15:15 -0500
Subject: Re:_André_doesn't_know_Rice's_Theorem_[_Malc
olm_]_[_Try_and_provide_a_counter-example_]
Newsgroups: comp.theory,comp.ai.philosophy,comp.software-eng,sci.math.symbolic
References: <20210719214640.00000dfc@reddwarf.jmc>
<sdnjhs$30s$1@dont-email.me> <QNOdnRIn-O3-xmL9nZ2dnUU7-fvNnZ2d@giganews.com>
<sdnn91$k7p$1@dont-email.me> <tbGdnZb32okl_GL9nZ2dnUU7-UvNnZ2d@giganews.com>
<sdnrb7$al5$1@dont-email.me> <PMCdnSCWQLiK5mL9nZ2dnUU7-S_NnZ2d@giganews.com>
<sdnua6$n7p$1@dont-email.me> <zPudnUgsAvKV42L9nZ2dnUU7-fXNnZ2d@giganews.com>
<sdo03c$uid$1@dont-email.me>
<d619424f-35d7-4fc2-bc33-d4b0bdb57966n@googlegroups.com>
<m-mdnbNOsMXYuJ38nZ2dnUU7-YnNnZ2d@giganews.com> <sdpf12$ij8$1@dont-email.me>
<d46dnQp1b-ua3p38nZ2dnUU7-d_NnZ2d@giganews.com> <sdpnjb$1q3$1@dont-email.me>
<NpmdnV9AwpJkV538nZ2dnUU7-QXNnZ2d@giganews.com> <sdqjgu$mun$1@dont-email.me>
<yvKdnaD9etCe-Jz8nZ2dnUU7-Q3NnZ2d@giganews.com> <sdrt9e$upt$1@dont-email.me>
<Z6qdna6B7Zq-FZz8nZ2dnUU7-SHNnZ2d@giganews.com> <sds8a4$djb$1@dont-email.me>
<uISdndIApsxJJZz8nZ2dnUU7-YvNnZ2d@giganews.com> <sdsplo$9fe$1@dont-email.me>
<O62dnbVMDplJuJ_8nZ2dnUU7-UGdnZ2d@giganews.com> <sdta1u$emq$1@dont-email.me>
From: NoO...@NoWhere.com (olcott)
Date: Thu, 29 Jul 2021 13:15:15 -0500
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:78.0) Gecko/20100101
Thunderbird/78.12.0
MIME-Version: 1.0
In-Reply-To: <sdta1u$emq$1@dont-email.me>
Content-Type: text/plain; charset=utf-8; format=flowed
Content-Language: en-US
Content-Transfer-Encoding: 8bit
Message-ID: <HN-dnQDk7oWubZ_8nZ2dnUU7-eXNnZ2d@giganews.com>
Lines: 20
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-ZvGgbNx5WRLTHdPzOf24xhkAQTdxMgKGYOl93ieZMxHEV3wvxZ9NzKvmFwrzaun6R2letHqbXNNwyb5!+Kl5IWvx4udjP5DmzZa7MZVoqY7whipvzyNjdRCvz+vbU6g5w9ubzSmrdVJ7iDbgJnJe2C0Rqw==
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: 3142
View all headers
On 7/28/2021 11:15 PM, André G. Isaak wrote:
On 2021-07-28 21:51, olcott wrote:

This is equally the definition of not halting:
Every input to a simulating halt decider that only stops running when its simulation is aborted unequivocally specifies a computation that never halts.

No, it isn't a definition of halting. At best, it is something which you have proposed as a *test* for halting, but it is a broken test since, at least according to you, it sometimes gives an answer that does *not* correspond to the *actual* definition of halting.
Try and provide a counter-example of an input to H that is a halting computation even though it never halts unless its simulation is aborted.

--
Copyright 2021 Pete Olcott

"Great spirits have always encountered violent opposition from mediocre minds." Einstein


Pages:12
rocksolid light 0.7.2
clearneti2ptor