Rocksolid Light

Welcome to novaBBS (click a section below)

mail  files  register  newsreader  groups  login

Message-ID:  

%DCL-MEM-BAD, bad memory VMS-F-PDGERS, pudding between the ears


devel / comp.theory / Re: André doesn't know Rice's Theorem [ Malcolm ]

SubjectAuthor
* Black box halt decider is NOT a partial deciderMr Flibble
`* Black box halt decider is NOT a partial deciderChris M. Thomasson
 `* Black box halt decider is NOT a partial deciderDavid Brown
  `* Black box halt decider is NOT a partial deciderChris M. Thomasson
   +* Black box halt decider is NOT a partial deciderRichard Damon
   |`* Black box halt decider is NOT a partial deciderChris M. Thomasson
   | `* Black box halt decider is NOT a partial deciderRichard Damon
   |  `* Black box halt decider is NOT a partial deciderChris M. Thomasson
   |   +- Black box halt decider is NOT a partial deciderRichard Damon
   |   +* Black box halt decider is NOT a partial deciderBen Bacarisse
   |   |`* Black box halt decider is NOT a partial deciderChris M. Thomasson
   |   | +* Black box halt decider is NOT a partial deciderBen Bacarisse
   |   | |`* Black box halt decider is NOT a partial deciderChris M. Thomasson
   |   | | +- Black box halt decider is NOT a partial deciderRichard Damon
   |   | | `* Black box halt decider is NOT a partial deciderBen Bacarisse
   |   | |  `* Black box halt decider is NOT a partial deciderChris M. Thomasson
   |   | |   +* Black box halt decider is NOT a partial deciderAndré G. Isaak
   |   | |   |`* Black box halt decider is NOT a partial deciderChris M. Thomasson
   |   | |   | `* Black box halt decider is NOT a partial deciderMike Terry
   |   | |   |  `* Black box halt decider is NOT a partial deciderChris M. Thomasson
   |   | |   |   `* Black box halt decider is NOT a partial deciderChris M. Thomasson
   |   | |   |    +- Black box halt decider is NOT a partial deciderMike Terry
   |   | |   |    +* Black box halt decider is NOT a partial deciderBen Bacarisse
   |   | |   |    |+* Black box halt decider is NOT a partial deciderJeff Barnett
   |   | |   |    ||+- Black box halt decider is NOT a partial deciderJeff Barnett
   |   | |   |    ||`* Black box halt decider is NOT a partial deciderMike Terry
   |   | |   |    || +- Black box halt decider is NOT a partial deciderChris M. Thomasson
   |   | |   |    || `* Black box halt decider is NOT a partial deciderJeff Barnett
   |   | |   |    ||  `- Black box halt decider is NOT a partial deciderMike Terry
   |   | |   |    |`* Black box halt decider is NOT a partial deciderChris M. Thomasson
   |   | |   |    | `* Black box halt decider is NOT a partial deciderBen Bacarisse
   |   | |   |    |  `* Black box halt decider is NOT a partial deciderChris M. Thomasson
   |   | |   |    |   +- Black box halt decider is NOT a partial deciderChris M. Thomasson
   |   | |   |    |   `* Black box halt decider is NOT a partial deciderChris M. Thomasson
   |   | |   |    |    `- Black box halt decider is NOT a partial deciderChris M. Thomasson
   |   | |   |    `- Black box halt decider is NOT a partial deciderwij
   |   | |   +* Black box halt decider is NOT a partial deciderRichard Damon
   |   | |   |`* Black box halt decider is NOT a partial deciderChris M. Thomasson
   |   | |   | `* Black box halt decider is NOT a partial deciderRichard Damon
   |   | |   |  `- Black box halt decider is NOT a partial deciderChris M. Thomasson
   |   | |   `* Black box halt decider is NOT a partial deciderBen Bacarisse
   |   | |    +* Black box halt decider is NOT a partial deciderChris M. Thomasson
   |   | |    |`* Black box halt decider is NOT a partial deciderBen Bacarisse
   |   | |    | `* Black box halt decider is NOT a partial deciderChris M. Thomasson
   |   | |    |  `* Black box halt decider is NOT a partial deciderRichard Damon
   |   | |    |   `- Black box halt decider is NOT a partial deciderChris M. Thomasson
   |   | |    `* Black box halt decider is NOT a partial deciderAndré G. Isaak
   |   | |     +* Black box halt decider is NOT a partial deciderBen Bacarisse
   |   | |     |+- Black box halt decider is NOT a partial deciderAndré G. Isaak
   |   | |     |`* Black box halt decider is NOT a partial deciderMike Terry
   |   | |     | +* Black box halt decider is NOT a partial deciderBen Bacarisse
   |   | |     | |+* Black box halt decider is NOT a partial deciderAndy Walker
   |   | |     | ||`* Black box halt decider is NOT a partial deciderMike Terry
   |   | |     | || +* Black box halt decider is NOT a partial deciderMalcolm McLean
   |   | |     | || |+* Black box halt decider is NOT a partial decider [ H(P,P)==0 is always correct ]olcott
   |   | |     | || ||`- Black box halt decider is NOT a partial decider [ H(P,P)==0 isRichard Damon
   |   | |     | || |+* Black box halt decider is NOT a partial decider [ H(P,P)==0 is always correct ]olcott
   |   | |     | || ||+- Black box halt decider is NOT a partial decider [ H(P,P)==0 isAndré G. Isaak
   |   | |     | || ||+* Black box halt decider is NOT a partial decider [ H(P,P)==0 isRichard Damon
   |   | |     | || |||`* Black box halt decider is NOT a partial decider [ H(P,P)==0 isMalcolm McLean
   |   | |     | || ||| `* Black box halt decider is NOT a partial decider [ H(P,P)==0 isRichard Damon
   |   | |     | || |||  `- Black box halt decider is NOT a partial decider [ H(P,P)==0 isJeff Barnett
   |   | |     | || ||`- Black box halt decider is NOT a partial decider [ H(P,P)==0 is always correct ]Ben Bacarisse
   |   | |     | || |+* Black box halt decider is NOT a partial deciderBen Bacarisse
   |   | |     | || ||`* Black box halt decider is NOT a partial deciderMalcolm McLean
   |   | |     | || || `* Black box halt decider is NOT a partial decider [ paradox ratherolcott
   |   | |     | || ||  +- Black box halt decider is NOT a partial decider [ paradox ratherRichard Damon
   |   | |     | || ||  `* Black box halt decider is NOT a partial decider [ paradox ratherAndré G. Isaak
   |   | |     | || ||   `* Black box halt decider is NOT a partial decider [ H refutes Rice's Theorem ]olcott
   |   | |     | || ||    +- Black box halt decider is NOT a partial decider [ H refutesRichard Damon
   |   | |     | || ||    `* Black box halt decider is NOT a partial decider [ H refutesAndré G. Isaak
   |   | |     | || ||     `* Black box halt decider is NOT a partial decider [ H refutes Rice's Theorem ]olcott
   |   | |     | || ||      +* Black box halt decider is NOT a partial decider [ H refutesAndré G. Isaak
   |   | |     | || ||      |`* Black box halt decider is NOT a partial decider [ H refutesolcott
   |   | |     | || ||      | `- Black box halt decider is NOT a partial decider [ H refutesRichard Damon
   |   | |     | || ||      `* Black box halt decider is NOT a partial decider [ H refutesJeff Barnett
   |   | |     | || ||       `* Black box halt decider is NOT a partial decider [ H refutesolcott
   |   | |     | || ||        `* Black box halt decider is NOT a partial decider [ H refutesAndré G. Isaak
   |   | |     | || ||         +* Black box halt decider is NOT a partial decider [ H refutesolcott
   |   | |     | || ||         |+- Black box halt decider is NOT a partial decider [ H refutesAndré G. Isaak
   |   | |     | || ||         |`- Black box halt decider is NOT a partial decider [ H refutesRichard Damon
   |   | |     | || ||         `* Black box halt decider is NOT a partial decider [ H refutesolcott
   |   | |     | || ||          +* Black box halt decider is NOT a partial decider [ H refutesAndré G. Isaak
   |   | |     | || ||          |`* Black box halt decider is NOT a partial decider [ H refutes Rice's Theorem ]olcott
   |   | |     | || ||          | `* Black box halt decider is NOT a partial decider [ H refutesAndré G. Isaak
   |   | |     | || ||          |  `* Black box halt decider is NOT a partial decider [ H refutesolcott
   |   | |     | || ||          |   +- Black box halt decider is NOT a partial decider [ H refutesAndré G. Isaak
   |   | |     | || ||          |   +- Black box halt decider is NOT a partial decider [ H refutesRichard Damon
   |   | |     | || ||          |   `* _Black_box_halt_decider_is_NOT_a_partial_decider_[_André_doesn't_know_Rice's_Theolcott
   |   | |     | || ||          |    +* _Black_box_halt_decider_is_NOT_a_partial_decider_[André G. Isaak
   |   | |     | || ||          |    |`* _Black_box_halt_decider_is_NOT_a_partial_decider_[olcott
   |   | |     | || ||          |    | +* _Black_box_halt_decider_is_NOT_a_partial_decider_[André G. Isaak
   |   | |     | || ||          |    | |`* _Black_box_halt_decider_is_NOT_a_partial_decider_Malcolm McLean
   |   | |     | || ||          |    | | `* _André_doesn't_know_Rice's_Theorem_[_Malcolm_]olcott
   |   | |     | || ||          |    | |  +* _André_doesn't_know_Rice's_Theorem_[_MalcRichard Damon
   |   | |     | || ||          |    | |  |`* _André_doesn't_know_Rice's_Theorem_[_Malcolcott
   |   | |     | || ||          |    | |  | `* _André_doesn't_know_Rice's_Theorem_[_MalcRichard Damon
   |   | |     | || ||          |    | |  |  `* _André_doesn't_know_Rice's_Theorem_[_Malcolm_](_attention_deficit_disorder_)olcott
   |   | |     | || ||          |    | |  |   `* _André_doesn't_know_Rice's_Theorem_[_MalcRichard Damon
   |   | |     | || ||          |    | |  |    `* _André_doesn't_know_Rice's_Theorem_[_Malcolcott
   |   | |     | || ||          |    | |  |     +- _André_doesn't_know_Rice's_Theorem_[_MalcRichard Damon
   |   | |     | || ||          |    | |  |     +* _André_doesn't_know_Rice's_Theorem_[_Malcolm_](_attention_deficit_disorder_)olcott
   |   | |     | || ||          |    | |  |     `* André doesn't know Rice's Theorem [ MalcolmBen Bacarisse
   |   | |     | || ||          |    | |  +* _André_doesn't_know_Rice's_Theorem_[_MalcAndré G. Isaak
   |   | |     | || ||          |    | |  `- _André_doesn't_know_Rice's_Theorem_[_MalcJeff Barnett
   |   | |     | || ||          |    | +- _Black_box_halt_decider_is_NOT_a_partial_decider_[Richard Damon
   |   | |     | || ||          |    | `* _Black_box_halt_decider_is_NOT_a_partial_decider_[_André_doesn't_know_Rice's_Theolcott
   |   | |     | || ||          |    `- _Black_box_halt_decider_is_NOT_a_partial_decider_[Richard Damon
   |   | |     | || ||          `- Black box halt decider is NOT a partial decider [ H refutesRichard Damon
   |   | |     | || |`* Black box halt decider is NOT a partial deciderMike Terry
   |   | |     | || `- Black box halt decider is NOT a partial deciderAndy Walker
   |   | |     | |`* Black box halt decider is NOT a partial deciderMike Terry
   |   | |     | `* Black box halt decider is NOT a partial deciderwij
   |   | |     `- Black box halt decider is NOT a partial deciderChris M. Thomasson
   |   | `* Black box halt decider is NOT a partial deciderRichard Damon
   |   `* Black box halt decider is NOT a partial deciderMalcolm McLean
   `* Black box halt decider is NOT a partial deciderJeff Barnett

Pages:123456789101112131415161718192021
Re: André doesn't know Rice's Theorem [ Malcolm ]( attention deficit disorder )

<KwYLI.77118$VU3.35461@fx46.iad>

 copy mid

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

 copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!paganini.bofh.team!news.dns-netz.com!news.freedyn.net!newsreader4.netcologne.de!news.netcologne.de!peer01.ams1!peer.ams1.xlned.com!news.xlned.com!peer01.iad!feed-me.highwinds-media.com!news.highwinds-media.com!fx46.iad.POSTED!not-for-mail
Subject: Re:_André_doesn't_know_Rice's_Theorem_[_Malc
olm_](_attention_deficit_disorder_)
Newsgroups: comp.theory
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>
<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>
From: Rich...@Damon-Family.org (Richard Damon)
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:78.0)
Gecko/20100101 Thunderbird/78.12.0
MIME-Version: 1.0
In-Reply-To: <7sudnSjP-u48zZ38nZ2dnUU7-XXNnZ2d@giganews.com>
Content-Type: text/plain; charset=utf-8
Content-Language: en-US
Content-Transfer-Encoding: 7bit
Lines: 84
Message-ID: <KwYLI.77118$VU3.35461@fx46.iad>
X-Complaints-To: abuse@easynews.com
Organization: Forte - www.forteinc.com
X-Complaints-Info: Please be sure to forward a copy of ALL headers otherwise we will be unable to process your complaint properly.
Date: Tue, 27 Jul 2021 11:47:05 -0700
X-Received-Bytes: 5499
 by: Richard Damon - Tue, 27 Jul 2021 18:47 UTC

On 7/27/21 11:29 AM, olcott wrote:
> On 7/27/2021 1:17 PM, Richard Damon wrote:
>> On 7/27/21 10:07 AM, olcott wrote:
>>> On 7/27/2021 11:29 AM, Richard Damon wrote:
>>>> On 7/27/21 9:05 AM, olcott wrote:
>>>>> On 7/27/2021 10:54 AM, Richard Damon wrote:
>>>>
>>>>>> Except that you haven't, in fact, you have provided a trace that
>>>>>> shows
>>>>>> that P(P) does NOT specify an infinitely nested simulation for any H
>>>>>> that answers H(H^,H^) as non-halting.
>>>>>>
>>>>> Since I have proved that the input to H(P,P) cannot possibly reach its
>>>>> final state while H remains in pure simulation mode two people have
>>>>> finally quit lying about this key issue.
>>>>>
>>>>
>>>> Wrong. Since H stops simulating P(P), it hasn't 'proved' that P(P) is
>>>> non-halting.
>>>>
>>>
>>> That your attention deficit disorder prevents you from actually seeing
>>> the words that I say until after I have repeated this words to you at
>>> least fifty times provides no actual rebuttal at all that these words
>>> that I say are in any way the slightest bit incorrect.
>>>
>>> Re-read the above words again and again hundreds and hundreds of times
>>> over many hours until you see every single detail how your paraphrase of
>>> my words is incorrect.
>>>
>>> I really believe in your case that the problem is ADD, alternatively you
>>> are simply a God damned liar.
>>>
>>> When I say that people are God damned liars I am referring to this bible
>>> verse:
>>>
>>> Revelation 21:8 KJV
>>> ...all liars, shall have their part in the lake which burneth with fire
>>> and brimstone: which is the second death.
>>>
>>> "God damned" literally means that God has condemned a person to Hell.
>>> Even though I reject that bible verse as incorrect in that if God <is>
>>> love then God <has> no wrath, you might want to err on the safe side.
>>>
>>
>> Since you have been shown guilty of lying, I would be careful about your
>> condenmation of lying.
>>
>
> I have never been shown guilty of lying.

THAT is a lie. If I can prove it, will you promise to shut up?

In one sense, nearly EVERY time you have said you have 'proved'
something is a lie, since you don't use proper analytical proofs to make
your arguments, just rhetorical arguments. You don't start with accepted
truths and then combine them with accepted logical forms to reach your
conclusions. What you do is assert claims that you claim are 'obvious'
(but aren't to anyone but you) or things that are true with one meaning
of the words but then use them in another.

Perhaps you 'language' doesn't classify such things as a 'lie', but that
just shows how far you are from the true meaning of the words you quoted.

>
>> First, I HAVE read the words you have written, and understand them. I
>> can not say the same for you.
> *Then you would acknowledge rather than contradict these words*
> I have proved that the input to H(P,P) cannot possibly reach its
> final state while H remains in pure simulation mode
>

Which is irrelevant to the problem you are claiming to be solving.

That a given H doesn't reach its final state just says that it can't
prove the P(P) halts. It doesn't say that P(P) doesn't halt.

That NO H reachs its final state, just says that NO H can prove that its
P(P) Halts. It doesn't say that its P(P) doesn't halt.

It IS a PROVEN fact that P(P) (or more properly H^(H^) for a P that is
based on a H that says H(P,P) detects non-halting, is in fact a halting
computation and thus H is wrong.

Re: Black box halt decider is NOT a partial decider

<sdpkd3$o0m$1@dont-email.me>

 copy mid

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

 copy link   Newsgroups: comp.theory
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
Subject: Re: Black box halt decider is NOT a partial decider
Date: Tue, 27 Jul 2021 12:48:00 -0600
Organization: A noiseless patient Spider
Lines: 125
Message-ID: <sdpkd3$o0m$1@dont-email.me>
References: <20210719214640.00000dfc@reddwarf.jmc>
<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>
<raOdnaoHSN1b7WD9nZ2dnUU78bfNnZ2d@brightview.co.uk>
<87im0yeagy.fsf@bsb.me.uk> <sdm509$1mci$1@news.muc.de>
<87v94xb4ea.fsf@bsb.me.uk>
<02e7360c-8a87-45da-a4f2-0d667170a692n@googlegroups.com>
<87pmv5b3ql.fsf@bsb.me.uk>
<36217ea8-a443-4068-a7e3-941d82c2530bn@googlegroups.com>
<87eeblb0qh.fsf@bsb.me.uk> <sdmq77$6fu$1@gioia.aioe.org>
<sdmruo$bam$1@dont-email.me> <878s1tapvq.fsf@bsb.me.uk>
<sdn36o$vp2$1@dont-email.me> <sdopjn$164k$1@gioia.aioe.org>
Mime-Version: 1.0
Content-Type: text/plain; charset=utf-8; format=flowed
Content-Transfer-Encoding: quoted-printable
Injection-Date: Tue, 27 Jul 2021 18:48:03 -0000 (UTC)
Injection-Info: reader02.eternal-september.org; posting-host="b2a8b99b9e09bca445ca27cab4dd1631";
logging-data="24598"; mail-complaints-to="abuse@eternal-september.org"; posting-account="U2FsdGVkX19zA3pllnp01fhh+vnTa2IrFBr7vz9QQHo="
User-Agent: Mozilla/5.0 (Windows NT 6.1; Win64; x64; rv:78.0) Gecko/20100101
Thunderbird/78.12.0
Cancel-Lock: sha1:8H/w5QVVZQ+c+F9DTM1XsY22BAw=
In-Reply-To: <sdopjn$164k$1@gioia.aioe.org>
Content-Language: en-US
X-Mozilla-News-Host: news://news.eternal-september.org
 by: Jeff Barnett - Tue, 27 Jul 2021 18:48 UTC

On 7/27/2021 5:10 AM, Andy Walker wrote:
> On 26/07/2021 20:42, Jeff Barnett wrote:
>> On 7/26/2021 12:31 PM, Ben Bacarisse wrote:
>>> Jeff Barnett <jbb@notatt.com> writes:
>>>> The USA in the same time frame had sprouted CS programs at most
>>>> universities, both public and private.
>
>     Well, it depends what you mean by "CS programs".  Ben and I
> were talking about [the paucity of] full honours degrees in CS --
> IOW, 18yos arriving at university, doing CS full time from day 1,
> and graduating three years later having done little else but CS
> for the duration.  That's much harder to set up and run than what
> "most universities" in the UK did, which was to tack elements of
> CS onto maths/engineering/... degrees, as components of those
> degrees, as conversion courses, or as postgrad diplomas.  So CS
> programs of some sort or other were common in the UK;  full CS
> degree courses were rarer.  See also below.

That's what I had in mind. The number of CS degree programs shot up
dramatically as we went from mid 1960s to mid 1970s. The 1960s saw a
good number of programs offering Masters and PhD in CS.

>>>> I'm somewhat surprised to hear in this thread that you all believe
>>>> that your real entry into the CS world occurred so late. My impression
>>>> from this side of the pond was that the British Isles were well on
>>>> there way by then. Perhaps we had better funding in place and that
>>>> certainly helps but money can't necessarily buy interests from smart
>>>> guys.
>
>     The UK and Europe were perfectly well advancedin computing,
> in terms of hardware, languages, research, ...;  in many ways, ahead
> of the USA.  The USA tended to buy IBM and throw money around; the
> rest of the world had to be more ingenious.

I'm aware of that, e.g., Plessey ultra reliable computers, but note that
IBM was virtually giving decent computers to universities. Their
marketing, at that time record sharp, thought that if students were
trained on IBM equipment, then their future employers would find good
sense in using IBM equipment. IBM also supplied low-cost or free
computers to foreign universities: National Polytechnic Institute,
Mexico was one example. Adolfo Guzman Arenas, from there, was the first
Mexican PhD in CS (MIT) in early middle 1960s. There was a huge influx
of ideas and accomplishments from Europe at that time.

>>> I'm not sure what you've taken from the thread that suggests some sort
>>> of late entry.  Your impression is that the UK was well on the way, but
>>> I'm not sure where to, so I can't confirm or deny.  I don't think the UK
>>> was noticeably behind the curve in CS education.
>
>     Indeed. >> Well there were comments about lackof textbooks, emphasis on problem
>> solving (implied not theory), comment on not "a whole honours
>> degree", etc. It sounded like a description of a program that wasn't
>> well started yet. I believed otherwise. Yes computers were expensive
>> and many institutions hadn't decided whether CS was primarily an
>> extension of EE, mathematics, both, or neither (not really an
>> academic area). However, the world as a whole was on its merry way
>> and CS was well established by the middle-late 1970s. That seemed
>> fairly clear to others and myself on this side of the pond. Perhaps I
>> misread the inner intent of some of the comments in this thread that
>> made me think some of you thought otherwise.
>     A full honours program running in Autumn 1979 would have
> had to be advertised from Autumn 1978, else you would have no or
> very few applicants.  So you would have to spend the academic year
> 1977-78 at the latest devising syllabuses, getting regulations
> through relevant academic bodies, sorting out staff and equipment,
> etc, and this process would have to be in someone's mind in 1976-77.
> To set the time frame -- that's just about when Unix started to
> spread in universities.  That was the first catalyst for letting
> students somewhat loose on real computers;  instead of a mainframe
> being used 24/7 for research, you have one or more relatively cheap
> minis with source available for compilers, OS, ...;  you have discs
> and terminals, editors and word-processing.  The second catalyst
> was the ready availability shortly afterwards of personal computers
> and micros, and then inter-computer communication.

UNIX machines, AKA PDP 11s, were being handed out to universities and
research institutes in the very early 1970s. And DARPA was handing out
PDP 6/10 and IBM 360s by then also. "Handing out" was to schools with
DARPA grants. Their research net was up and running in that time frame
too. We were doing joint research and development, using the net and
time sharing systems also. The early net was a big boast and incentive
to CS development in this country and a big incentive to "do" CS.

>     IOW, any full course [again, as opposed to things like
> "maths with computing" degrees or "NA and computing diplomas" or
> similar] already running in the mid-late 1970s would have been
> very constrained;  within a very few years, it was much easier to
> run interesting/useful courses.
University of California, at Irvine started classes in 1965. In the
early 1970s, I taught a few CS classes - a graduate seminar on computer
speech synthesis and recognition and a senior projects course. They were
offering a PhD program by the time I was there. They were specializing
in system theory, networking, foundations, and a few other topics with
some reasonable success. UCI was part of the same university
organization as UCLA, UC Berkley, UC Davis, and a half dozen others.
Many had strong programs with PhD by the early middle 1960s.

I hope these comments are helpful. The reason I popped into what might
be called an "old boy reunion" was that I thought you all were holding
too negative views of back-then. And I thought that was off target since
everything I knew was positive, i.e., great people there participating
and contributing leadership to the current scientific revolution. (Of
course that phrase now refers to the jump in genetics that fast, cheap,
and useful computation capabilities has enabled.)
--
Jeff Barnett

Re: André doesn't know Rice's Theorem [ Malcolm ]( attention deficit disorder )

<g-WdnVu77YeIx538nZ2dnUU7-afNnZ2d@giganews.com>

 copy mid

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

 copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!aioe.org!feeder1.feed.usenet.farm!feed.usenet.farm!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: Tue, 27 Jul 2021 14:10:12 -0500
Subject: Re:_André_doesn't_know_Rice's_Theorem_[_Malcolm_](_attention_deficit_disorder_)
Newsgroups: comp.theory
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> <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> <KwYLI.77118$VU3.35461@fx46.iad>
From: NoO...@NoWhere.com (olcott)
Date: Tue, 27 Jul 2021 14:10:12 -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: <KwYLI.77118$VU3.35461@fx46.iad>
Content-Type: text/plain; charset=utf-8; format=flowed
Content-Language: en-US
Content-Transfer-Encoding: 7bit
Message-ID: <g-WdnVu77YeIx538nZ2dnUU7-afNnZ2d@giganews.com>
Lines: 95
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-J94NpahNRP2AW0p+1x4glMIYYExG4HqYtW4igU8lPaTs5aOyEpcpBYrBYso6BIoiJx2yZGUjhp4IJvU!JgT7xJz8vqQxD4OXd24XhCpbe+2IfdQcJHP8xWJ3eknUV+YY10s+zbWgM67LXRiYwmoaY4DfyA==
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: 6130
 by: olcott - Tue, 27 Jul 2021 19:10 UTC

On 7/27/2021 1:47 PM, Richard Damon wrote:
> On 7/27/21 11:29 AM, olcott wrote:
>> On 7/27/2021 1:17 PM, Richard Damon wrote:
>>> On 7/27/21 10:07 AM, olcott wrote:
>>>> On 7/27/2021 11:29 AM, Richard Damon wrote:
>>>>> On 7/27/21 9:05 AM, olcott wrote:
>>>>>> On 7/27/2021 10:54 AM, Richard Damon wrote:
>>>>>
>>>>>>> Except that you haven't, in fact, you have provided a trace that
>>>>>>> shows
>>>>>>> that P(P) does NOT specify an infinitely nested simulation for any H
>>>>>>> that answers H(H^,H^) as non-halting.
>>>>>>>
>>>>>> Since I have proved that the input to H(P,P) cannot possibly reach its
>>>>>> final state while H remains in pure simulation mode two people have
>>>>>> finally quit lying about this key issue.
>>>>>>
>>>>>
>>>>> Wrong. Since H stops simulating P(P), it hasn't 'proved' that P(P) is
>>>>> non-halting.
>>>>>
>>>>
>>>> That your attention deficit disorder prevents you from actually seeing
>>>> the words that I say until after I have repeated this words to you at
>>>> least fifty times provides no actual rebuttal at all that these words
>>>> that I say are in any way the slightest bit incorrect.
>>>>
>>>> Re-read the above words again and again hundreds and hundreds of times
>>>> over many hours until you see every single detail how your paraphrase of
>>>> my words is incorrect.
>>>>
>>>> I really believe in your case that the problem is ADD, alternatively you
>>>> are simply a God damned liar.
>>>>
>>>> When I say that people are God damned liars I am referring to this bible
>>>> verse:
>>>>
>>>> Revelation 21:8 KJV
>>>> ...all liars, shall have their part in the lake which burneth with fire
>>>> and brimstone: which is the second death.
>>>>
>>>> "God damned" literally means that God has condemned a person to Hell.
>>>> Even though I reject that bible verse as incorrect in that if God <is>
>>>> love then God <has> no wrath, you might want to err on the safe side.
>>>>
>>>
>>> Since you have been shown guilty of lying, I would be careful about your
>>> condenmation of lying.
>>>
>>
>> I have never been shown guilty of lying.
>
> THAT is a lie. If I can prove it, will you promise to shut up?
>
> In one sense, nearly EVERY time you have said you have 'proved'
> something is a lie, since you don't use proper analytical proofs to make
> your arguments, just rhetorical arguments. You don't start with accepted
> truths and then combine them with accepted logical forms to reach your
> conclusions. What you do is assert claims that you claim are 'obvious'
> (but aren't to anyone but you) or things that are true with one meaning
> of the words but then use them in another.
>
> Perhaps you 'language' doesn't classify such things as a 'lie', but that
> just shows how far you are from the true meaning of the words you quoted.
>
>>
>>> First, I HAVE read the words you have written, and understand them. I
>>> can not say the same for you.
>> *Then you would acknowledge rather than contradict these words*
>> I have proved that the input to H(P,P) cannot possibly reach its
>> final state while H remains in pure simulation mode
>>
>
> Which is irrelevant to the problem you are claiming to be solving.
>
> That a given H doesn't reach its final state just says that it can't
> prove the P(P) halts. It doesn't say that P(P) doesn't halt.
>

That the input to H(P,P) cannot possibly reach its final state while H
remains a pure simulator of this input conclusively proves that this
input never halts.

That P of int main(){ P(P); } does reach its final state does not
actually provide any evidence at all that H(P,P)==0 is incorrect.

That this is very hard to understand does not make it untrue.

--
Copyright 2021 Pete Olcott

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

Re: André doesn't know Rice's Theorem [ Malcolm ]

<sdpnjb$1q3$1@dont-email.me>

 copy mid

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

 copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!eternal-september.org!reader02.eternal-september.org!.POSTED!not-for-mail
From: agis...@gm.invalid (André G. Isaak)
Newsgroups: comp.theory
Subject: Re:_André_doesn't_know_Rice's_Theorem_[_Malc
olm_]
Date: Tue, 27 Jul 2021 13:42:34 -0600
Organization: Christians and Atheists United Against Creeping Agnosticism
Lines: 151
Message-ID: <sdpnjb$1q3$1@dont-email.me>
References: <20210719214640.00000dfc@reddwarf.jmc>
<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> <sdpf12$ij8$1@dont-email.me>
<d46dnQp1b-ua3p38nZ2dnUU7-d_NnZ2d@giganews.com>
Mime-Version: 1.0
Content-Type: text/plain; charset=utf-8; format=flowed
Content-Transfer-Encoding: 8bit
Injection-Date: Tue, 27 Jul 2021 19:42:36 -0000 (UTC)
Injection-Info: reader02.eternal-september.org; posting-host="158a058b53b449ecbd3dfd6a1fe7afcf";
logging-data="1859"; mail-complaints-to="abuse@eternal-september.org"; posting-account="U2FsdGVkX1/u0V66cQHo2D/vNbfAVJqa"
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.14; rv:68.0)
Gecko/20100101 Thunderbird/68.12.1
Cancel-Lock: sha1:mNcA2hdpl1nH3uwA+XW7RVx1isM=
In-Reply-To: <d46dnQp1b-ua3p38nZ2dnUU7-d_NnZ2d@giganews.com>
Content-Language: en-US
 by: André G. Isaak - Tue, 27 Jul 2021 19:42 UTC

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)'
or 'the return value of P(P) doesn't equal the return value of H(P, P)'
You want it to mean 'the halting status of P(P) doesn't equal the return
value of H(P, P)'. So I assume that H(P, P) == 0 can mean either H(P, P)
returns 0, signifying that P(P) doesn't halt, or that H(P, P) itself
doesn't halt, and that we're just supposed to guess?

So why don't you actually answer the questions I asked. What is a
'global simulator' and how can it say that P(P) halts when you've
previously claimed that in a simulator P(P) doesn't halt?

André

> question is entirely based on your simply not bothering to pay attention
> this is the only reply that I will make to your reply.
>
>> or that the value returned by P(P) does not equal the value returned
>> by H(P, P)? [The equation means the latter, but I still suspect you
>> mean the former, but you refuse to clarify].
>>
>>> 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.
>>
>> But a human can only recognize this discrepancy in cases where they
>> can shown that P(P) actually halts despite what H(P, P) does. How do
>> you get a Turing Machine to do this? That requires a Halt Detector
>> which is actually always correct to get the real answer to whether
>> P(P) halts, and currently your Halt Decider gets this wrong. So you're
>> begging the question here -- the approach requires an *accurate*
>> universal halt decider, which is exactly the thing you've been trying,
>> but failing to prove is possible despite the fact that it is know to
>> be impossible.
>>
>> André
>>
>>> 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.
>>>
>>>
>>
>>
>
>

--
To email remove 'invalid' & replace 'gm' with well known Google mail
service.

Re: André doesn't know Rice's Theorem [ Malcolm ]( attention deficit disorder )

<sdpogm$d7k$1@dont-email.me>

 copy mid

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

 copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!eternal-september.org!reader02.eternal-september.org!.POSTED!not-for-mail
From: news.x.r...@xoxy.net (Richard Damon)
Newsgroups: comp.theory
Subject: Re:_André_doesn't_know_Rice's_Theorem_[_Malc
olm_](_attention_deficit_disorder_)
Date: Tue, 27 Jul 2021 12:58:09 -0700
Organization: A noiseless patient Spider
Lines: 121
Message-ID: <sdpogm$d7k$1@dont-email.me>
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>
<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>
<KwYLI.77118$VU3.35461@fx46.iad>
<g-WdnVu77YeIx538nZ2dnUU7-afNnZ2d@giganews.com>
Mime-Version: 1.0
Content-Type: text/plain; charset=utf-8
Content-Transfer-Encoding: 7bit
Injection-Date: Tue, 27 Jul 2021 19:58:14 -0000 (UTC)
Injection-Info: reader02.eternal-september.org; posting-host="ebd1e585f254f1b2c6ec4274a9205920";
logging-data="13556"; mail-complaints-to="abuse@eternal-september.org"; posting-account="U2FsdGVkX18e7tqDbVFuHCctQZqOw/F4vQnHyzEnhTQ="
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:78.0)
Gecko/20100101 Thunderbird/78.12.0
Cancel-Lock: sha1:Ma87rf9THZXhb0g9+0vYA/I3bS0=
In-Reply-To: <g-WdnVu77YeIx538nZ2dnUU7-afNnZ2d@giganews.com>
Content-Language: en-US
 by: Richard Damon - Tue, 27 Jul 2021 19:58 UTC

On 7/27/21 12:10 PM, olcott wrote:
> On 7/27/2021 1:47 PM, Richard Damon wrote:
>> On 7/27/21 11:29 AM, olcott wrote:
>>> On 7/27/2021 1:17 PM, Richard Damon wrote:
>>>> On 7/27/21 10:07 AM, olcott wrote:
>>>>> On 7/27/2021 11:29 AM, Richard Damon wrote:
>>>>>> On 7/27/21 9:05 AM, olcott wrote:
>>>>>>> On 7/27/2021 10:54 AM, Richard Damon wrote:
>>>>>>
>>>>>>>> Except that you haven't, in fact, you have provided a trace that
>>>>>>>> shows
>>>>>>>> that P(P) does NOT specify an infinitely nested simulation for
>>>>>>>> any H
>>>>>>>> that answers H(H^,H^) as non-halting.
>>>>>>>>
>>>>>>> Since I have proved that the input to H(P,P) cannot possibly
>>>>>>> reach its
>>>>>>> final state while H remains in pure simulation mode two people have
>>>>>>> finally quit lying about this key issue.
>>>>>>>
>>>>>>
>>>>>> Wrong. Since H stops simulating P(P), it hasn't 'proved' that P(P) is
>>>>>> non-halting.
>>>>>>
>>>>>
>>>>> That your attention deficit disorder prevents you from actually seeing
>>>>> the words that I say until after I have repeated this words to you at
>>>>> least fifty times provides no actual rebuttal at all that these words
>>>>> that I say are in any way the slightest bit incorrect.
>>>>>
>>>>> Re-read the above words again and again hundreds and hundreds of times
>>>>> over many hours until you see every single detail how your
>>>>> paraphrase of
>>>>> my words is incorrect.
>>>>>
>>>>> I really believe in your case that the problem is ADD,
>>>>> alternatively you
>>>>> are simply a God damned liar.
>>>>>
>>>>> When I say that people are God damned liars I am referring to this
>>>>> bible
>>>>> verse:
>>>>>
>>>>> Revelation 21:8 KJV
>>>>> ...all liars, shall have their part in the lake which burneth with
>>>>> fire
>>>>> and brimstone: which is the second death.
>>>>>
>>>>> "God damned" literally means that God has condemned a person to Hell.
>>>>> Even though I reject that bible verse as incorrect in that if God <is>
>>>>> love then God <has> no wrath, you might want to err on the safe side.
>>>>>
>>>>
>>>> Since you have been shown guilty of lying, I would be careful about
>>>> your
>>>> condenmation of lying.
>>>>
>>>
>>> I have never been shown guilty of lying.
>>
>> THAT is a lie. If I can prove it, will you promise to shut up?
>>
>> In one sense, nearly EVERY time you have said you have 'proved'
>> something is a lie, since you don't use proper analytical proofs to make
>> your arguments, just rhetorical arguments. You don't start with accepted
>> truths and then combine them with accepted logical forms to reach your
>> conclusions. What you do is assert claims that you claim are 'obvious'
>> (but aren't to anyone but you) or things that are true with one meaning
>> of the words but then use them in another.
>>
>> Perhaps you 'language' doesn't classify such things as a 'lie', but that
>> just shows how far you are from the true meaning of the words you quoted.
>>
>>>
>>>> First, I HAVE read the words you have written, and understand them. I
>>>> can not say the same for you.
>>> *Then you would acknowledge rather than contradict these words*
>>> I have proved that the input to H(P,P) cannot possibly reach its
>>> final state while H remains in pure simulation mode
>>>
>>
>> Which is irrelevant to the problem you are claiming to be solving.
>>
>> That a given H doesn't reach its final state just says that it can't
>> prove the P(P) halts. It doesn't say that P(P) doesn't halt.
>>
>
> That the input to H(P,P) cannot possibly reach its final state while H
> remains a pure simulator of this input conclusively proves that this
> input never halts.

THAT is a lie. The test for P(P) never halting is to run P(P)

>
> That P of int main(){ P(P); } does reach its final state does not
> actually provide any evidence at all that H(P,P)==0 is incorrect.

THAT is a LIE. The DEFINITION of the correct answer for a Halting
Decider is based on what the actual machine does.

The behavior of P(P) DEFINES the right answer for H(P,P).

THAT IS THE DEFINITION OF HALTING.

>
> That this is very hard to understand does not make it untrue.
>

That you don't understand this simple fact doesn't make what is actually
true untrue.

IT IS A FACT, the fact that P(P) halts shows that the only right answer
to H(P,P) is the answer HALTING.

THAT IS THE DEFINITION.

Anything else is UNSOUND and INCORRECT.

THERE, do you consider yourself a 'damned liar' because you have said
something that is incorrect by the 'scriptures' of Mathematics. Even if
you don't think that, most of the damned don't think they are, but they are.

Re: André doesn't know Rice's Theorem [ Malcolm ]

<2sKdna9mxLcIG538nZ2dnUU78c_NnZ2d@giganews.com>

 copy mid

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

 copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!paganini.bofh.team!news.dns-netz.com!news.freedyn.net!newsfeed.xs4all.nl!newsfeed9.news.xs4all.nl!border2.nntp.ams1.giganews.com!nntp.giganews.com!buffer2.nntp.ams1.giganews.com!news.giganews.com.POSTED!not-for-mail
NNTP-Posting-Date: Tue, 27 Jul 2021 17:20:05 -0500
Subject: Re:_André_doesn't_know_Rice's_Theorem_[_Malc
olm_]
Newsgroups: comp.theory
References: <20210719214640.00000dfc@reddwarf.jmc>
<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> <sdpf12$ij8$1@dont-email.me>
<d46dnQp1b-ua3p38nZ2dnUU7-d_NnZ2d@giganews.com> <sdpnjb$1q3$1@dont-email.me>
From: NoO...@NoWhere.com (olcott)
Date: Tue, 27 Jul 2021 17:20:03 -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: <sdpnjb$1q3$1@dont-email.me>
Content-Type: text/plain; charset=utf-8; format=flowed
Content-Language: en-US
Content-Transfer-Encoding: 8bit
Message-ID: <2sKdna9mxLcIG538nZ2dnUU78c_NnZ2d@giganews.com>
Lines: 168
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-Uxj/VS9Rq2b1yxAU3LV3JSRrZTv2K72YUBIgLuBoFTVcrr3Q2a7dQlAu0fdgXgV6lqwW2SsVaILwY86!aG7LPwlKlSi1K15lxttmSCHSfS9P9lfSbTHlSmvOVUhZ+kPOtWsnqje/yZfgCbSYSizvOIMSvA==
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: 9361
 by: olcott - Tue, 27 Jul 2021 22:20 UTC

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,

I stipulated what the notation means, You grossly disrespected me by
making sure to ignore what I said.

I find that tolerating this degree of gross disrespect is not conducive
to an honest dialogue.

Once we get past this point we can move on to the next.

> 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)'
> or 'the return value of P(P) doesn't equal the return value of H(P, P)'
> You want it to mean 'the halting status of P(P) doesn't equal the return
> value of H(P, P)'. So I assume that H(P, P) == 0 can mean either H(P, P)
> returns 0, signifying that P(P) doesn't halt, or that H(P, P) itself
> doesn't halt, and that we're just supposed to guess?
>
> So why don't you actually answer the questions I asked. What is a
> 'global simulator' and how can it say that P(P) halts when you've
> previously claimed that in a simulator P(P) doesn't halt?
>
> André
>
>> question is entirely based on your simply not bothering to pay
>> attention this is the only reply that I will make to your reply.
>>
>>> or that the value returned by P(P) does not equal the value returned
>>> by H(P, P)? [The equation means the latter, but I still suspect you
>>> mean the former, but you refuse to clarify].
>>>
>>>> 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.
>>>
>>> But a human can only recognize this discrepancy in cases where they
>>> can shown that P(P) actually halts despite what H(P, P) does. How do
>>> you get a Turing Machine to do this? That requires a Halt Detector
>>> which is actually always correct to get the real answer to whether
>>> P(P) halts, and currently your Halt Decider gets this wrong. So
>>> you're begging the question here -- the approach requires an
>>> *accurate* universal halt decider, which is exactly the thing you've
>>> been trying, but failing to prove is possible despite the fact that
>>> it is know to be impossible.
>>>
>>> André
>>>
>>>> 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

Re: André doesn't know Rice's Theorem [ Malcolm ]

<NpmdnV9AwpJkV538nZ2dnUU7-QXNnZ2d@giganews.com>

 copy mid

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

 copy link   Newsgroups: comp.theory
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!buffer1.nntp.dca1.giganews.com!news.giganews.com.POSTED!not-for-mail
NNTP-Posting-Date: Tue, 27 Jul 2021 22:11:53 -0500
Subject: Re:_André_doesn't_know_Rice's_Theorem_[_Malc
olm_]
Newsgroups: comp.theory
References: <20210719214640.00000dfc@reddwarf.jmc>
<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> <sdpf12$ij8$1@dont-email.me>
<d46dnQp1b-ua3p38nZ2dnUU7-d_NnZ2d@giganews.com> <sdpnjb$1q3$1@dont-email.me>
From: NoO...@NoWhere.com (olcott)
Date: Tue, 27 Jul 2021 22:11:53 -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: <sdpnjb$1q3$1@dont-email.me>
Content-Type: text/plain; charset=utf-8; format=flowed
Content-Language: en-US
Content-Transfer-Encoding: 8bit
Message-ID: <NpmdnV9AwpJkV538nZ2dnUU7-QXNnZ2d@giganews.com>
Lines: 175
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-BogX/hke5CljmLb9MpDJssnJiePcEiu9sYjrW9xCp2XF2aMXFtwuGLdbmIS5xfwctpximIDiBGIsWkF!V7AXlsi9UZD4aTmhh224wRIfVXhE2h26ex30oeXvvFC6xQLTY8Dn9GNRJHB6fby9Da4+fQ2PIg==
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: 9745
 by: olcott - Wed, 28 Jul 2021 03:11 UTC

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.

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.

> or 'the return value of P(P) doesn't equal the return value of H(P, P)'
> You want it to mean 'the halting status of P(P) doesn't equal the return
> value of H(P, P)'. So I assume that H(P, P) == 0 can mean either H(P, P)
> returns 0, signifying that P(P) doesn't halt, or that H(P, P) itself
> doesn't halt, and that we're just supposed to guess?
>
> So why don't you actually answer the questions I asked. What is a
> 'global simulator' and how can it say that P(P) halts when you've
> previously claimed that in a simulator P(P) doesn't halt?
>
> André
>
>> question is entirely based on your simply not bothering to pay
>> attention this is the only reply that I will make to your reply.
>>
>>> or that the value returned by P(P) does not equal the value returned
>>> by H(P, P)? [The equation means the latter, but I still suspect you
>>> mean the former, but you refuse to clarify].
>>>
>>>> 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.
>>>
>>> But a human can only recognize this discrepancy in cases where they
>>> can shown that P(P) actually halts despite what H(P, P) does. How do
>>> you get a Turing Machine to do this? That requires a Halt Detector
>>> which is actually always correct to get the real answer to whether
>>> P(P) halts, and currently your Halt Decider gets this wrong. So
>>> you're begging the question here -- the approach requires an
>>> *accurate* universal halt decider, which is exactly the thing you've
>>> been trying, but failing to prove is possible despite the fact that
>>> it is know to be impossible.
>>>
>>> André
>>>
>>>> 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.
>>>>
>>>>
>>>
>>>
>>
>>
>
>


Click here to read the complete article
Re: André doesn't know Rice's Theorem [ Malcolm ]

<sdqjgu$mun$1@dont-email.me>

 copy mid

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

 copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!eternal-september.org!reader02.eternal-september.org!.POSTED!not-for-mail
From: agis...@gm.invalid (André G. Isaak)
Newsgroups: comp.theory
Subject: Re:_André_doesn't_know_Rice's_Theorem_[_Malc
olm_]
Date: Tue, 27 Jul 2021 21:39:08 -0600
Organization: Christians and Atheists United Against Creeping Agnosticism
Lines: 124
Message-ID: <sdqjgu$mun$1@dont-email.me>
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>
Mime-Version: 1.0
Content-Type: text/plain; charset=utf-8; format=flowed
Content-Transfer-Encoding: 8bit
Injection-Date: Wed, 28 Jul 2021 03:39:11 -0000 (UTC)
Injection-Info: reader02.eternal-september.org; posting-host="8b8dc4ef1c6458a163725aec75235371";
logging-data="23511"; mail-complaints-to="abuse@eternal-september.org"; posting-account="U2FsdGVkX18NLAWoqVUIG1ywLObKwwaK"
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.14; rv:68.0)
Gecko/20100101 Thunderbird/68.12.1
Cancel-Lock: sha1:sbYk4ypjliHiEcPllB3cuTA3cfQ=
In-Reply-To: <NpmdnV9AwpJkV538nZ2dnUU7-QXNnZ2d@giganews.com>
Content-Language: en-US
 by: André G. Isaak - Wed, 28 Jul 2021 03:39 UTC

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?

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é

--
To email remove 'invalid' & replace 'gm' with well known Google mail
service.

Re: André doesn't know Rice's Theorem [ Malcolm ]

<6bef0b63-a1dc-4ec9-91ca-303b0e882a7bn@googlegroups.com>

 copy mid

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

 copy link   Newsgroups: comp.theory
X-Received: by 2002:a0c:d68f:: with SMTP id k15mr27293162qvi.14.1627465306663;
Wed, 28 Jul 2021 02:41:46 -0700 (PDT)
X-Received: by 2002:a25:324d:: with SMTP id y74mr36323669yby.198.1627465306500;
Wed, 28 Jul 2021 02:41:46 -0700 (PDT)
Path: i2pn2.org!i2pn.org!weretis.net!feeder8.news.weretis.net!proxad.net!feeder1-2.proxad.net!209.85.160.216.MISMATCH!news-out.google.com!nntp.google.com!postnews.google.com!google-groups.googlegroups.com!not-for-mail
Newsgroups: comp.theory
Date: Wed, 28 Jul 2021 02:41:46 -0700 (PDT)
In-Reply-To: <NpmdnV9AwpJkV538nZ2dnUU7-QXNnZ2d@giganews.com>
Injection-Info: google-groups.googlegroups.com; posting-host=2a00:23a8:400a:5601:28a0:8681:e837:40f9;
posting-account=Dz2zqgkAAADlK5MFu78bw3ab-BRFV4Qn
NNTP-Posting-Host: 2a00:23a8:400a:5601:28a0:8681:e837:40f9
References: <20210719214640.00000dfc@reddwarf.jmc> <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> <sdpf12$ij8$1@dont-email.me>
<d46dnQp1b-ua3p38nZ2dnUU7-d_NnZ2d@giganews.com> <sdpnjb$1q3$1@dont-email.me> <NpmdnV9AwpJkV538nZ2dnUU7-QXNnZ2d@giganews.com>
User-Agent: G2/1.0
MIME-Version: 1.0
Message-ID: <6bef0b63-a1dc-4ec9-91ca-303b0e882a7bn@googlegroups.com>
Subject: Re:_André_doesn't_know_Rice's_Theorem_[_Malcolm_]
From: malcolm....@gmail.com (Malcolm McLean)
Injection-Date: Wed, 28 Jul 2021 09:41:46 +0000
Content-Type: text/plain; charset="UTF-8"
 by: Malcolm McLean - Wed, 28 Jul 2021 09:41 UTC

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.

Re: André doesn't know Rice's Theorem [ Malcolm ]

<y5CdnQBL7riZ_5z8nZ2dnUU7-R_NnZ2d@giganews.com>

 copy mid

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

 copy link   Newsgroups: comp.theory comp.ai.philosophy comp.software-eng sci.math.symbolic
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
 by: olcott - Wed, 28 Jul 2021 13:56 UTC

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

Re: André doesn't know Rice's Theorem [ Malcolm ]

<yvKdnaD9etCe-Jz8nZ2dnUU7-Q3NnZ2d@giganews.com>

 copy mid

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

 copy link   Newsgroups: comp.theory comp.ai.philosophy comp.software-eng sci.math.symbolic
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
 by: olcott - Wed, 28 Jul 2021 14:09 UTC

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

Re: André doesn't know Rice's Theorem [ Malcolm ]( attention deficit disorder )

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

 copy mid

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

 copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!eternal-september.org!reader02.eternal-september.org!.POSTED!not-for-mail
From: ben.use...@bsb.me.uk (Ben Bacarisse)
Newsgroups: comp.theory
Subject: Re: André doesn't know Rice's Theorem [ Malcolm
]( attention deficit disorder )
Date: Wed, 28 Jul 2021 16:23:25 +0100
Organization: A noiseless patient Spider
Lines: 30
Message-ID: <87mtq68nte.fsf@bsb.me.uk>
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>
Mime-Version: 1.0
Content-Type: text/plain; charset=utf-8
Content-Transfer-Encoding: 8bit
Injection-Info: reader02.eternal-september.org; posting-host="c19169802dbf3300bc479b5bddd1b72c";
logging-data="12054"; mail-complaints-to="abuse@eternal-september.org"; posting-account="U2FsdGVkX18ozhVFj5Wu2IQKYcMuRLQduzkSxdU00/w="
Cancel-Lock: sha1:WulKsWI7uG+SZViYlc774WI13B8=
sha1:Z8zrFT5+XlQKwStRsO0Hi+9oFuc=
X-BSB-Auth: 1.46ce1ee9890255b0ff96.20210728162325BST.87mtq68nte.fsf@bsb.me.uk
 by: Ben Bacarisse - Wed, 28 Jul 2021 15:23 UTC

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."

"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."

"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 (Ĥ, Ĥ)."

"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."

"Ĥ does not copy its input"

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

--
Ben.

Re: André doesn't know Rice's Theorem [ Malcolm ]

<sdrt9e$upt$1@dont-email.me>

 copy mid

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

 copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!eternal-september.org!reader02.eternal-september.org!.POSTED!not-for-mail
From: agis...@gm.invalid (André G. Isaak)
Newsgroups: comp.theory
Subject: Re:_André_doesn't_know_Rice's_Theorem_[_Malc
olm_]
Date: Wed, 28 Jul 2021 09:31:56 -0600
Organization: Christians and Atheists United Against Creeping Agnosticism
Lines: 82
Message-ID: <sdrt9e$upt$1@dont-email.me>
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>
Mime-Version: 1.0
Content-Type: text/plain; charset=utf-8; format=flowed
Content-Transfer-Encoding: 8bit
Injection-Date: Wed, 28 Jul 2021 15:31:58 -0000 (UTC)
Injection-Info: reader02.eternal-september.org; posting-host="e1f8584450e8a78902972a133b1698cf";
logging-data="31549"; mail-complaints-to="abuse@eternal-september.org"; posting-account="U2FsdGVkX1/nzwYa5vFJcSLhcIArhD4A"
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.14; rv:68.0)
Gecko/20100101 Thunderbird/68.12.1
Cancel-Lock: sha1:Egj8Kjbru3cIazZJIOORzcJG/1w=
In-Reply-To: <yvKdnaD9etCe-Jz8nZ2dnUU7-Q3NnZ2d@giganews.com>
Content-Language: en-US
 by: André G. Isaak - Wed, 28 Jul 2021 15:31 UTC

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.

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

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).

But if P(P) doesn't halt in a 'pure simulator' then what kind of
simulator is your 'global simulator' which, apparently, correctly
detects that P(P) halts?

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

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

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.

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é

--
To email remove 'invalid' & replace 'gm' with well known Google mail
service.

Re: André doesn't know Rice's Theorem [ Malcolm ]( attention deficit disorder )

<Sq-dnbKtfMj_4pz8nZ2dnUU7-bfNnZ2d@giganews.com>

 copy mid

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

 copy link   Newsgroups: comp.theory comp.ai.philosophy comp.software-eng sci.math.symbolic
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
 by: olcott - Wed, 28 Jul 2021 16:01 UTC

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

Re: Black box halt decider is NOT a partial decider

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

 copy mid

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

 copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!eternal-september.org!reader02.eternal-september.org!.POSTED!not-for-mail
From: ben.use...@bsb.me.uk (Ben Bacarisse)
Newsgroups: comp.theory
Subject: Re: Black box halt decider is NOT a partial decider
Date: Wed, 28 Jul 2021 17:25:27 +0100
Organization: A noiseless patient Spider
Lines: 26
Message-ID: <87h7ge8ky0.fsf@bsb.me.uk>
References: <20210719214640.00000dfc@reddwarf.jmc>
<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>
<raOdnaoHSN1b7WD9nZ2dnUU78bfNnZ2d@brightview.co.uk>
<87im0yeagy.fsf@bsb.me.uk> <sdm509$1mci$1@news.muc.de>
<87v94xb4ea.fsf@bsb.me.uk>
<02e7360c-8a87-45da-a4f2-0d667170a692n@googlegroups.com>
<87pmv5b3ql.fsf@bsb.me.uk>
<36217ea8-a443-4068-a7e3-941d82c2530bn@googlegroups.com>
<87eeblb0qh.fsf@bsb.me.uk> <sdmq77$6fu$1@gioia.aioe.org>
<sdmruo$bam$1@dont-email.me> <878s1tapvq.fsf@bsb.me.uk>
<sdn36o$vp2$1@dont-email.me> <sdopjn$164k$1@gioia.aioe.org>
<sdpkd3$o0m$1@dont-email.me>
Mime-Version: 1.0
Content-Type: text/plain
Injection-Info: reader02.eternal-september.org; posting-host="c19169802dbf3300bc479b5bddd1b72c";
logging-data="31371"; mail-complaints-to="abuse@eternal-september.org"; posting-account="U2FsdGVkX1+b0s19gh/UeWocSRSBJwUrp+yAejmywNo="
Cancel-Lock: sha1:J82r+ftPq4rcCA4xtyfi6CYidNU=
sha1:9ptnrMumROxqzyCGtaTkB19bfJk=
X-BSB-Auth: 1.1cd98fda71ae13d2fd71.20210728172527BST.87h7ge8ky0.fsf@bsb.me.uk
 by: Ben Bacarisse - Wed, 28 Jul 2021 16:25 UTC

I'm picking just a few lines because I think they need clarification...

Jeff Barnett <jbb@notatt.com> writes:

> The number of CS degree programs shot up dramatically as we went from
> mid 1960s to mid 1970s.

It's not clear if you mean full-length undergraduate degree programs.
In the UK there were very few of these, even by the mid 70s. I have no
idea how many there were in USA so it would be interesting to know if
this is what you meant.

> The 1960s saw a good number of programs offering Masters and PhD in
> CS.

That was the case in the UK as well.

> University of California, at Irvine started classes in 1965. In the
> early 1970s, I taught a few CS classes - a graduate seminar on
> computer speech synthesis and recognition and a senior projects
> course. They were offering a PhD program by the time I was there.

Do you know when a full-length undergraduate program stated there?

--
Ben.

Re: André doesn't know Rice's Theorem [ Malcolm ]( attention deficit disorder )

<sds0er$85m$1@dont-email.me>

 copy mid

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

 copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!eternal-september.org!reader02.eternal-september.org!.POSTED!not-for-mail
From: news.x.r...@xoxy.net (Richard Damon)
Newsgroups: comp.theory
Subject: Re:_André_doesn't_know_Rice's_Theorem_[_Malc
olm_](_attention_deficit_disorder_)
Date: Wed, 28 Jul 2021 09:25:59 -0700
Organization: A noiseless patient Spider
Lines: 106
Message-ID: <sds0er$85m$1@dont-email.me>
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>
<Sq-dnbKtfMj_4pz8nZ2dnUU7-bfNnZ2d@giganews.com>
Mime-Version: 1.0
Content-Type: text/plain; charset=utf-8
Content-Transfer-Encoding: 8bit
Injection-Date: Wed, 28 Jul 2021 16:26:04 -0000 (UTC)
Injection-Info: reader02.eternal-september.org; posting-host="8702d07b86f8551f41d9969dac2de217";
logging-data="8374"; mail-complaints-to="abuse@eternal-september.org"; posting-account="U2FsdGVkX18Uwc/+edgAnkbsU+NwJas+SLuzo7uJ044="
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:78.0)
Gecko/20100101 Thunderbird/78.12.0
Cancel-Lock: sha1:QDLt7hFaRGpheu8Xz0U5xrGuRHY=
In-Reply-To: <Sq-dnbKtfMj_4pz8nZ2dnUU7-bfNnZ2d@giganews.com>
Content-Language: en-US
 by: Richard Damon - Wed, 28 Jul 2021 16:25 UTC

On 7/28/21 9:01 AM, olcott wrote:
> 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.

But a LIE, as what you have isn't even a Turing Equivalent Computation.

>
>>    "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.

No, it doesn't. Thus A LIE.

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

You may have THOUGHT is was, but it isn't. You H/H^ are NOT equivalent
to the Turing Machine defined. Perhaps (almost certainly) you are too
ignorant to understand that they are, but the fact that you don't have
the copy step, which is REQUIRED by the Turing Machine is a strong point
that should make you think about it.

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

No, it seems you broke the requirements that they be actual computation
per the definitipons of Computation Theory.

>
>>    "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.
>

Which doesn't matter, as that isn't the question that H is supposed to
answer. All that says is that no H can prove that its H^ halts. But
since not all Truth is Provable, that doesn't say anything about if any
of those H^s halt, and we can actually PROVE that any H^ built on an H
that gives H(H^,H^) as a non-halting answer actually does Halt, thus all
such H are wrong.

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

Right, If H is a pure simulator, the H^ will not halt, but that H never
gives an answer to H(H^,H^) so was never right.

Your argument ignores that fact that H^ is built on H, so changing H
changes H^.

>
>>    "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.
>

WHERE? YOUR STATEMENT IS A LIE.

Note, that the input it H^ is a FULL representation of the algorithm of
H^ including that of H. Thus H is given two independent COPIES of this,
not just the 'address' of this info twice.

You have previous stated that it isn't allowed to make a copy of H, but
that is REQUIRED to be a proper H^.

Re: André doesn't know Rice's Theorem [ Malcolm ]

<5GfMI.23505$uj5.20344@fx03.iad>

 copy mid

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

 copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!aioe.org!news.uzoreto.com!newsfeed.xs4all.nl!newsfeed9.news.xs4all.nl!news-out.netnews.com!news.alt.net!fdc2.netnews.com!peer01.ams1!peer.ams1.xlned.com!news.xlned.com!peer03.iad!feed-me.highwinds-media.com!news.highwinds-media.com!fx03.iad.POSTED!not-for-mail
Subject: Re:_André_doesn't_know_Rice's_Theorem_[_Malc
olm_]
Newsgroups: comp.theory
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>
From: Rich...@Damon-Family.org (Richard Damon)
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:78.0)
Gecko/20100101 Thunderbird/78.12.0
MIME-Version: 1.0
In-Reply-To: <yvKdnaD9etCe-Jz8nZ2dnUU7-Q3NnZ2d@giganews.com>
Content-Type: text/plain; charset=utf-8
Content-Language: en-US
Content-Transfer-Encoding: 8bit
Lines: 23
Message-ID: <5GfMI.23505$uj5.20344@fx03.iad>
X-Complaints-To: abuse@easynews.com
Organization: Forte - www.forteinc.com
X-Complaints-Info: Please be sure to forward a copy of ALL headers otherwise we will be unable to process your complaint properly.
Date: Wed, 28 Jul 2021 09:34:09 -0700
X-Received-Bytes: 2809
 by: Richard Damon - Wed, 28 Jul 2021 16:34 UTC

On 7/28/21 7:09 AM, 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.

Which still meets the requirements of halting. So you are still WRONG.

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

WRONG. You aren't allowed to 'reject' some inputs as 'invalid'. That is
just the decider admitting it can't answer that question.

FAIL.

Re: André doesn't know Rice's Theorem [ Malcolm ]

<aJfMI.18420$Ei1.12624@fx07.iad>

 copy mid

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

 copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!weretis.net!feeder8.news.weretis.net!newsreader4.netcologne.de!news.netcologne.de!peer03.ams1!peer.ams1.xlned.com!news.xlned.com!peer03.iad!feed-me.highwinds-media.com!news.highwinds-media.com!fx07.iad.POSTED!not-for-mail
Subject: Re:_André_doesn't_know_Rice's_Theorem_[_Malc
olm_]
Newsgroups: comp.theory
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>
<6bef0b63-a1dc-4ec9-91ca-303b0e882a7bn@googlegroups.com>
<y5CdnQBL7riZ_5z8nZ2dnUU7-R_NnZ2d@giganews.com>
From: Rich...@Damon-Family.org (Richard Damon)
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:78.0)
Gecko/20100101 Thunderbird/78.12.0
MIME-Version: 1.0
In-Reply-To: <y5CdnQBL7riZ_5z8nZ2dnUU7-R_NnZ2d@giganews.com>
Content-Type: text/plain; charset=utf-8
Content-Language: en-US
Content-Transfer-Encoding: 7bit
Lines: 43
Message-ID: <aJfMI.18420$Ei1.12624@fx07.iad>
X-Complaints-To: abuse@easynews.com
Organization: Forte - www.forteinc.com
X-Complaints-Info: Please be sure to forward a copy of ALL headers otherwise we will be unable to process your complaint properly.
Date: Wed, 28 Jul 2021 09:37:26 -0700
X-Received-Bytes: 3813
 by: Richard Damon - Wed, 28 Jul 2021 16:37 UTC

On 7/28/21 6:56 AM, olcott wrote:
> 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.
>

But is that a 'semantic' property or a 'syntactic' property. It seems to
be a syntactic property, and thus not within realm of Rice's theorem.

FAIL.

Re: André doesn't know Rice's Theorem [ Malcolm ]

<Z6qdna6B7Zq-FZz8nZ2dnUU7-SHNnZ2d@giganews.com>

 copy mid

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

 copy link   Newsgroups: comp.theory comp.ai.philosophy comp.software-eng sci.math.symbolic
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
 by: olcott - Wed, 28 Jul 2021 16:38 UTC

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

Re: André doesn't know Rice's Theorem [ Malcolm ]

<vagMI.91486$Vv6.59949@fx45.iad>

 copy mid

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

 copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!paganini.bofh.team!news.dns-netz.com!news.freedyn.net!newsfeed.xs4all.nl!newsfeed8.news.xs4all.nl!peer03.ams1!peer.ams1.xlned.com!news.xlned.com!peer01.iad!feed-me.highwinds-media.com!news.highwinds-media.com!fx45.iad.POSTED!not-for-mail
Subject: Re:_André_doesn't_know_Rice's_Theorem_[_Malc
olm_]
Newsgroups: comp.theory
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: Rich...@Damon-Family.org (Richard Damon)
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; 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
Content-Language: en-US
Content-Transfer-Encoding: 8bit
Lines: 190
Message-ID: <vagMI.91486$Vv6.59949@fx45.iad>
X-Complaints-To: abuse@easynews.com
Organization: Forte - www.forteinc.com
X-Complaints-Info: Please be sure to forward a copy of ALL headers otherwise we will be unable to process your complaint properly.
Date: Wed, 28 Jul 2021 10:08:42 -0700
X-Received-Bytes: 9096
 by: Richard Damon - Wed, 28 Jul 2021 17:08 UTC

On 7/28/21 9: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.

Except that the sequence is NOT infinitely recursive, BECAUSE in that
sequence is a BUNCH of routines that will stop it before it gets to
infinity.

You FORGET that H is part of that loop, and if H does abort the loop,
then the loop is not infinite.

So, H^ is only infinitly recursive for H that don't abort, but then
those H never answer H(H^,H^) so it doesn't matter that those H^(H^) are
non-halting

You logic forgets that H^ includes H as part of it, so if you change H
you change H^ and to see what H^ does you have to look at what H does.

UNSOUND Logic in analyzing H^ gives you a wrong answer.

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

Right. If H IS a pure simulator, then H(P,P) will Never return an answer
and P(P) will be non-halting. This case does NOT disprove Linz etc, as H
never answer.

If H DOES abort its simulation, then H(P,P) can give an answer, but its
answer will be wrong because for these H, P(P) will halt if H answers
non-halting.

Thus H is wrong. For ANY H that answers H(P,P) as non-halting, its P(P)
is halting.

Again, you neglect the fact that P is a function of H, so you can't
argue about one P by using a wrong H.

>
>> 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, but is seems to difficult for you to understand that you are getting
your Ps and Hs confused.

Given an Hn that doesn't abort and a Ha that does, and there associated
Pn and Pa,

Yes, Pn(Pn) doesn't Halt, but Pa(Pa) does Halt.

Hn(Pn,Pn) will never return an answer, so it isn't a valid halt decider.

Ha(Pa,Pa) will answer non-halting, but Pa(Pa) is Halting so it is wrong.

Your logic shows that Ha(Pn,Pn) is correctly decided as non-halting, but
this isn't the problem that it needs to get right, so is doesn't
actually prove anything.

>> 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, since your H (in order to answer) will leave its pure simulator
mode, the P that uses it becomes halting.

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

Note, 'Rejecting Input' isn't an option for a decider that want to talk
about being universal.

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

So?

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

If the only equivalant of the Machine H is your whole OS, then maybe you
need to see what is needed to look at it. Note, that if you OS can
detect that it is creating this infinitely recursive state and aborts
it, then you don't actually get to an infinitely nested OS. of course,
do that is a much tougher problem (just like the one that H should be
having to do if it needs to deal with COPIES of H, not just multiple
occurrences of calls to it.

Re: Black box halt decider is NOT a partial decider

<sds4bp$qfd$1@dont-email.me>

 copy mid

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

 copy link   Newsgroups: comp.theory
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
Subject: Re: Black box halt decider is NOT a partial decider
Date: Wed, 28 Jul 2021 11:32:38 -0600
Organization: A noiseless patient Spider
Lines: 46
Message-ID: <sds4bp$qfd$1@dont-email.me>
References: <20210719214640.00000dfc@reddwarf.jmc>
<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>
<raOdnaoHSN1b7WD9nZ2dnUU78bfNnZ2d@brightview.co.uk>
<87im0yeagy.fsf@bsb.me.uk> <sdm509$1mci$1@news.muc.de>
<87v94xb4ea.fsf@bsb.me.uk>
<02e7360c-8a87-45da-a4f2-0d667170a692n@googlegroups.com>
<87pmv5b3ql.fsf@bsb.me.uk>
<36217ea8-a443-4068-a7e3-941d82c2530bn@googlegroups.com>
<87eeblb0qh.fsf@bsb.me.uk> <sdmq77$6fu$1@gioia.aioe.org>
<sdmruo$bam$1@dont-email.me> <878s1tapvq.fsf@bsb.me.uk>
<sdn36o$vp2$1@dont-email.me> <sdopjn$164k$1@gioia.aioe.org>
<sdpkd3$o0m$1@dont-email.me> <87h7ge8ky0.fsf@bsb.me.uk>
Mime-Version: 1.0
Content-Type: text/plain; charset=utf-8; format=flowed
Content-Transfer-Encoding: 7bit
Injection-Date: Wed, 28 Jul 2021 17:32:42 -0000 (UTC)
Injection-Info: reader02.eternal-september.org; posting-host="64d0e60a34ebeb848ae97a5bab2b0377";
logging-data="27117"; mail-complaints-to="abuse@eternal-september.org"; posting-account="U2FsdGVkX1/tfn207sodg9YQrtWXBRtz9tufEMgDUnk="
User-Agent: Mozilla/5.0 (Windows NT 6.1; Win64; x64; rv:78.0) Gecko/20100101
Thunderbird/78.12.0
Cancel-Lock: sha1:jZUF6ci9fWQcybpMi+PZx+YKZ3k=
In-Reply-To: <87h7ge8ky0.fsf@bsb.me.uk>
Content-Language: en-US
 by: Jeff Barnett - Wed, 28 Jul 2021 17:32 UTC

On 7/28/2021 10:25 AM, Ben Bacarisse wrote:
> I'm picking just a few lines because I think they need clarification...
>
> Jeff Barnett <jbb@notatt.com> writes:
>
>> The number of CS degree programs shot up dramatically as we went from
>> mid 1960s to mid 1970s.
>
> It's not clear if you mean full-length undergraduate degree programs.
> In the UK there were very few of these, even by the mid 70s. I have no
> idea how many there were in USA so it would be interesting to know if
> this is what you meant.

Yes, I meant full blown undergraduate programs and the number of master
and PhD programs was not far behind. By the mid 1970s the "career to die
for" or at least to get well paid for doing novel things with CS. The
field was well enough established to have lots and lots of scam schools
advertising programs (by mail) to get some sort of credential in the
information sciences.

>> The 1960s saw a good number of programs offering Masters and PhD in
>> CS.
>
> That was the case in the UK as well.
>
>> University of California, at Irvine started classes in 1965. In the
>> early 1970s, I taught a few CS classes - a graduate seminar on
>> computer speech synthesis and recognition and a senior projects
>> course. They were offering a PhD program by the time I was there.
>
> Do you know when a full-length undergraduate program stated there?

When the University of California system thought there was a need to
expand their overall offerings, they erected 5 or 6 new large campuses
(campi?); UCI was one of then. They all opened there doors circa 1965
for students. The senior projects course that I taught was to the first
group that had started the CS program there, i.e., the class was full of
fourth year undergraduates. (Do you folks run three year programs
instead?) There were also several PhD students that had got to the point
of approved dissertation topics, committees, etc., and were busy
writing. From these recollections, I assumed they started their full CS
degree program around 1968 plus or minus a year. Other schools in the
University of California system (UCLA, UC Berkeley for example) were in
business much earlier.
--
Jeff Barnett

Re: André doesn't know Rice's Theorem [ Malcolm ] [ PSR Decider is fully operational ]

<JJOdnSDoV9bjPpz8nZ2dnUU7-TudnZ2d@giganews.com>

 copy mid

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

 copy link   Newsgroups: comp.theory comp.ai.philosophy comp.software-eng sci.math.symbolic
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
 by: olcott - Wed, 28 Jul 2021 18:35 UTC

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

Re: André doesn't know Rice's Theorem [ Malcolm ]

<sds8a4$djb$1@dont-email.me>

 copy mid

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

 copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!eternal-september.org!reader02.eternal-september.org!.POSTED!not-for-mail
From: agis...@gm.invalid (André G. Isaak)
Newsgroups: comp.theory
Subject: Re:_André_doesn't_know_Rice's_Theorem_[_Malc
olm_]
Date: Wed, 28 Jul 2021 12:40:02 -0600
Organization: Christians and Atheists United Against Creeping Agnosticism
Lines: 158
Message-ID: <sds8a4$djb$1@dont-email.me>
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>
Mime-Version: 1.0
Content-Type: text/plain; charset=utf-8; format=flowed
Content-Transfer-Encoding: 8bit
Injection-Date: Wed, 28 Jul 2021 18:40:04 -0000 (UTC)
Injection-Info: reader02.eternal-september.org; posting-host="e1f8584450e8a78902972a133b1698cf";
logging-data="13931"; mail-complaints-to="abuse@eternal-september.org"; posting-account="U2FsdGVkX1/cc/Ifo57H9CtBOAAhKYTP"
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.14; rv:68.0)
Gecko/20100101 Thunderbird/68.12.1
Cancel-Lock: sha1:nPO8Zl/vKjjaJCpmHoe0pm0Hnjg=
In-Reply-To: <Z6qdna6B7Zq-FZz8nZ2dnUU7-SHNnZ2d@giganews.com>
Content-Language: en-US
 by: André G. Isaak - Wed, 28 Jul 2021 18:40 UTC

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.

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

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

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

--
To email remove 'invalid' & replace 'gm' with well known Google mail
service.

Re: André doesn't know Rice's Theorem [ Malcolm ] [ PSR Decider is fully operational ]

<sds8ns$j19$1@dont-email.me>

 copy mid

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

 copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!eternal-september.org!reader02.eternal-september.org!.POSTED!not-for-mail
From: agis...@gm.invalid (André G. Isaak)
Newsgroups: comp.theory
Subject: Re:_André_doesn't_know_Rice's_Theorem_[_Malc
olm_]_[_PSR_Decider_is_fully_operational_]
Date: Wed, 28 Jul 2021 12:47:23 -0600
Organization: Christians and Atheists United Against Creeping Agnosticism
Lines: 154
Message-ID: <sds8ns$j19$1@dont-email.me>
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> <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>
Mime-Version: 1.0
Content-Type: text/plain; charset=utf-8; format=flowed
Content-Transfer-Encoding: 8bit
Injection-Date: Wed, 28 Jul 2021 18:47:25 -0000 (UTC)
Injection-Info: reader02.eternal-september.org; posting-host="e1f8584450e8a78902972a133b1698cf";
logging-data="19497"; mail-complaints-to="abuse@eternal-september.org"; posting-account="U2FsdGVkX1/tTPCS3KqmYeFMukdcsjjC"
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.14; rv:68.0)
Gecko/20100101 Thunderbird/68.12.1
Cancel-Lock: sha1:oBdWKi/FU9A8gZAWeiOE4+cGOM0=
In-Reply-To: <JJOdnSDoV9bjPpz8nZ2dnUU7-TudnZ2d@giganews.com>
Content-Language: en-US
 by: André G. Isaak - Wed, 28 Jul 2021 18:47 UTC

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é

--
To email remove 'invalid' & replace 'gm' with well known Google mail
service.

Re: André doesn't know Rice's Theorem [ Malcolm ] [ PSR Decider is fully operational ]

<U8WdnXDsfuZlN5z8nZ2dnUU7-anNnZ2d@giganews.com>

 copy mid

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

 copy link   Newsgroups: comp.theory comp.ai.philosophy comp.software-eng sci.math.symbolic
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
 by: olcott - Wed, 28 Jul 2021 19:07 UTC

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

Pages:123456789101112131415161718192021
server_pubkey.txt

rocksolid light 0.9.7
clearnet tor