Rocksolid Light

Welcome to novaBBS (click a section below)

mail  files  register  newsreader  groups  login

Message-ID:  

Only a fool fights in a burning house. -- Kank the Klingon, "Day of the Dove", stardate unknown


computers / comp.ai.philosophy / Concise refutation of halting problem proofs V18

SubjectAuthor
* Concise refutation of halting problem proofs V18olcott
`* Re: Concise refutation of halting problem proofs V18 [ strawman errorolcott
 `* Re: Concise refutation of halting problem proofs V18 [ strawman errorolcott
  `* Re: Concise refutation of halting problem proofs V18 [ strawman errorolcott
   `* Re: Concise refutation of halting problem proofs V18 [ strawman error ]olcott
    `* Re: Concise refutation of halting problem proofs V18 [ strawman error ]olcott
     +- Re: Concise refutation of halting problem proofs V18 [ strawman errorolcott
     `* Re: Concise refutation of halting problem proofs V18 [ strawman errorolcott
      `* Re: Concise refutation of halting problem proofs V18 [ strawman errorolcott
       `* Re: Concise refutation of halting problem proofs V21 [ preciselyolcott
        `* Re: Concise refutation of halting problem proofs V21 [ precisely defined sets ]olcott
         `* Re: Concise refutation of halting problem proofs V21 [ preciselyolcott
          +* Re: Concise refutation of halting problem proofs V21 [ preciselyolcott
          |`* Re: Concise refutation of halting problem proofs V21olcott
          | `* Re: Concise refutation of halting problem proofs V21olcott
          |  `- Re: Concise refutation of halting problem proofs V21 [ Richard is notolcott
          `- Re: Concise refutation of halting problem proofs V21olcott

1
Concise refutation of halting problem proofs V18

<OqOdnSk-es33vwr8nZ2dnUU7-VXNnZ2d@giganews.com>

 copy mid

https://www.novabbs.com/computers/article-flat.php?id=7606&group=comp.ai.philosophy#7606

 copy link   Newsgroups: comp.theory comp.ai.philosophy sci.logic sci.math
Followup: comp.theory
Path: i2pn2.org!i2pn.org!weretis.net!feeder6.news.weretis.net!news.misty.com!border2.nntp.dca1.giganews.com!nntp.giganews.com!buffer2.nntp.dca1.giganews.com!news.giganews.com.POSTED!not-for-mail
NNTP-Posting-Date: Thu, 18 Nov 2021 22:04:58 -0600
Date: Thu, 18 Nov 2021 22:04:56 -0600
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:91.0) Gecko/20100101
Thunderbird/91.3.1
Newsgroups: comp.theory,comp.ai.philosophy,sci.logic,sci.math
Content-Language: en-US
From: NoO...@NoWhere.com (olcott)
Subject: Concise refutation of halting problem proofs V18
Followup-To: comp.theory
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Message-ID: <OqOdnSk-es33vwr8nZ2dnUU7-VXNnZ2d@giganews.com>
Lines: 63
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-fvkNUNIYAT8KG0xabOvpIevC5xD4Kkzeov1RKsYRzRR165bCtL7BENF6r/pzf5CYcs+a4t22kNs624h!TGxyOCSAsVBlwa90PNFIv0Ms7ae9untbh6EMfiz/X5NLydnZPAUc4wEyN2xOD4t+sB7sPC8194Rb!PQ==
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: 3075
 by: olcott - Fri, 19 Nov 2021 04:04 UTC

typedef void (*ptr)();

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

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

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

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

Combinations of H/P having pathological self-reference (PSR set)
For every possible H of H(P,P) invoked from main() where P(P) calls this
same H(P,P) and H simulates or executes its input and aborts or does not
abort its input P never reaches its last instruction.

One element of the above (PSR set) Hz simply simulates 100 steps of Pz
and returns.

This provides a specific concrete example where the input to H(P,P)
never halts and P(P) halts thus conclusively proving that such an
example exists.

Instead of simply simulating the first 100 instructions of P halt
decider H might abort the simulation of its input on the basis of the
behavior of this input. It is still the case that the input to H(P,P)
never halts and P(P) halts.

When H sees that P calls H(P,P) with the same parameters that it was
called with this gives H its correct (infinite recursion) halt deciding
basis. H(P,P) then aborts the simulation of its input and returns 0.

Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
The reasoning applied to H(P,P) and P(P) equally applies to Linz Ĥ.qx
⟨Ĥ⟩ ⟨Ĥ⟩ and Ĥ ⟨Ĥ⟩

Halting problem undecidability and infinitely nested simulation (V2)
November 2021 PL Olcott

https://www.researchgate.net/publication/356105750_Halting_problem_undecidability_and_infinitely_nested_simulation_V2

--
Copyright 2021 Pete Olcott

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

Re: Concise refutation of halting problem proofs V18 [ strawman error ]

<csednfY4fZugrQr8nZ2dnUU7-YnNnZ2d@giganews.com>

 copy mid

https://www.novabbs.com/computers/article-flat.php?id=7607&group=comp.ai.philosophy#7607

 copy link   Newsgroups: comp.theory comp.ai.philosophy sci.logic sci.math
Followup: comp.theory
Path: i2pn2.org!rocksolid2!i2pn.org!weretis.net!feeder6.news.weretis.net!news.misty.com!border2.nntp.dca1.giganews.com!nntp.giganews.com!buffer2.nntp.dca1.giganews.com!news.giganews.com.POSTED!not-for-mail
NNTP-Posting-Date: Thu, 18 Nov 2021 23:03:57 -0600
Date: Thu, 18 Nov 2021 23:03:56 -0600
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:91.0) Gecko/20100101
Thunderbird/91.3.1
Subject: Re: Concise refutation of halting problem proofs V18 [ strawman error
]
Content-Language: en-US
Newsgroups: comp.theory,comp.ai.philosophy,sci.logic,sci.math
References: <OqOdnSk-es33vwr8nZ2dnUU7-VXNnZ2d@giganews.com>
<0QFlJ.4132$aF1.1545@fx98.iad>
From: NoO...@NoWhere.com (olcott)
Followup-To: comp.theory
In-Reply-To: <0QFlJ.4132$aF1.1545@fx98.iad>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Message-ID: <csednfY4fZugrQr8nZ2dnUU7-YnNnZ2d@giganews.com>
Lines: 131
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-Kw2WpRsWev7IAKmOdfIbF2Xji9jmPlvVINV84AzQzbexy9/q7q3SrwGH1VAuABIYMkM5lq7VqVqNCRC!riOIEEwSOofz7GqA34EnrEgaMnP0/FsTo3xMbagSVX7BRSCmwgbuQvf3TXbpVhDRA5H1l30DsOfb!cg==
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: 5776
 by: olcott - Fri, 19 Nov 2021 05:03 UTC

On 11/18/2021 10:35 PM, Richard Damon wrote:
>
> On 11/18/21 11:04 PM, olcott wrote:
>> typedef void (*ptr)();
>>
>> int H(ptr x, ptr y)
>> {
>>    x(y);  // direct execution of P(P)
>>    return 1;
>> }
>>
>> // Minimal essence of Linz(1990) Ĥ
>> // and Strachey(1965) P
>> int P(ptr x)
>> {
>>    H(x, x);
>>    return 1;  // Give P a last instruction at the "c" level
>> }
>>
>> int main(void)
>> {
>>    H(P, P);
>> }
>>
>> computation that halts
>> a computation is said to halt whenever it enters a final state.
>> (Linz:1990:234)
>>
>> Combinations of H/P having pathological self-reference (PSR set)
>> For every possible H of H(P,P) invoked from main() where P(P) calls
>> this same H(P,P) and H simulates or executes its input and aborts or
>> does not abort its input P never reaches its last instruction.
>>
>
> Right, H will never see its processing of its input reach a final state,
> so maybe H is a correct POOP decider, but that is not the definiton of
> Halting, that looks at the ACTUAL behavior of the computation the input
> represents, which if H(P,P) returns 0, will be halting.
>
>> One element of the above (PSR set) Hz simply simulates 100 steps of Pz
>> and returns.
>>
>> This provides a specific concrete example where the input to H(P,P)
>> never halts and P(P) halts thus conclusively proving that such an
>> example exists.
>
> Right, and now let us look at what Pz(Pz) does, when we DIRECTLY run
> Pz(Pz), which is what we need to do to see what that computation does.
>
> 1) Pz(Pz) calls Hz(Pz,Pz)
>
> 2) Hz(Pz,Pz) will execute 100 steps, flipping between code in Hz and Pz
> perhaps many times.
>
> 3) Hz will then abort its processing of the input.
>
> 4) Hz(Pz,Pz) will return 0 to the Pz(Pz) that called it
>

Now that I finally have a precisely defined and named set PSR.
I can say that your rebuttal is the strawman error.

A straw man (sometimes written as strawman) is a form of argument and an
informal fallacy of having the impression of refuting an argument,
whereas the real subject of the argument was not addressed or refuted,
but instead replaced with a false one.
https://en.wikipedia.org/wiki/Straw_man

Every technically competent person can easily see that your rebuttal is
incorrect.

> 5) Pz(Pz) then returns 1
>
> Thus, the computation Pz(Pz) is shown to reach its final state when run,
> and thus is halting.
>
>>
>> Instead of simply simulating the first 100 instructions of P halt
>> decider H might abort the simulation of its input on the basis of the
>> behavior of this input. It is still the case that the input to H(P,P)
>> never halts and P(P) halts.
>
> But then the above trace is STILL the results of directly running P(P).
>
>>
>> When H sees that P calls H(P,P) with the same parameters that it was
>> called with this gives H its correct (infinite recursion) halt
>> deciding basis. H(P,P) then aborts the simulation of its input and
>> returns 0.
>>
>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>> The reasoning applied to H(P,P) and P(P) equally applies to Linz Ĥ.qx
>> ⟨Ĥ⟩ ⟨Ĥ⟩ and Ĥ ⟨Ĥ⟩
>
> Right, and since this is showing the execution path of H^ applied to
> <H^> is shows that H^ applied to <H^> reaches the final state H.qn,
> which is a halting state, thus H^ applied to <H^> is a halting computation.
>
> We also have that since H^.qx is a copy of H we have that H applied to
> <H^><H^> gives the decision that its input is non-halting.
>
> But its input is the representaiton of H^ appied to <H^> which we just
> showed halted, so H is wrong.
>
> We can also see this by taking that exact input <H^><H^> and applying a
> UTM to it, which BY DEFINITION will behave exactly like H^ applied to
> <H^> so iit will also halt.
>
> Thus H is wrong, and you claim that it was right is shown to be a LIE.
>
>>
>> Halting problem undecidability and infinitely nested simulation (V2)
>> November 2021 PL Olcott
>>
>> https://www.researchgate.net/publication/356105750_Halting_problem_undecidability_and_infinitely_nested_simulation_V2
>>
>>
>>
>>
>
> FAIL.
>
> You just prove your ignorance of what you are talking about.

--
Copyright 2021 Pete Olcott

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

Re: Concise refutation of halting problem proofs V18 [ strawman error ]

<MoGdna8BU9xUSQr8nZ2dnUU7-QvNnZ2d@giganews.com>

 copy mid

https://www.novabbs.com/computers/article-flat.php?id=7608&group=comp.ai.philosophy#7608

 copy link   Newsgroups: comp.theory comp.ai.philosophy sci.logic sci.math
Followup: comp.theory
Path: i2pn2.org!i2pn.org!weretis.net!feeder6.news.weretis.net!news.misty.com!border2.nntp.dca1.giganews.com!nntp.giganews.com!buffer2.nntp.dca1.giganews.com!news.giganews.com.POSTED!not-for-mail
NNTP-Posting-Date: Fri, 19 Nov 2021 10:46:01 -0600
Date: Fri, 19 Nov 2021 10:45:57 -0600
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:91.0) Gecko/20100101
Thunderbird/91.3.1
Subject: Re: Concise refutation of halting problem proofs V18 [ strawman error
]
Content-Language: en-US
Newsgroups: comp.theory,comp.ai.philosophy,sci.logic,sci.math
References: <OqOdnSk-es33vwr8nZ2dnUU7-VXNnZ2d@giganews.com>
<0QFlJ.4132$aF1.1545@fx98.iad>
<csednfY4fZugrQr8nZ2dnUU7-YnNnZ2d@giganews.com>
<nSMlJ.92781$AJ2.12422@fx33.iad>
<W96dnV1_X_P4JQr8nZ2dnUU7-QPNnZ2d@giganews.com> <sn8el5$a6k$1@dont-email.me>
Followup-To: comp.theory
From: NoO...@NoWhere.com (olcott)
In-Reply-To: <sn8el5$a6k$1@dont-email.me>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Message-ID: <MoGdna8BU9xUSQr8nZ2dnUU7-QvNnZ2d@giganews.com>
Lines: 43
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-jXo5vWBWpB0DJnivDGHt851BoHpqeG7xCHCoR6xrM75+0HfV5KOw8+lhR80H/n+w/cVuUuRMQbyUKv8!td6lKYyXw6qzP4VaSEVxgffFFh8ImhKafS9XF79/tOvlwKlsATAGMr62a7rr2RMit6qfL2YvzGbX!Fg==
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: 3075
 by: olcott - Fri, 19 Nov 2021 16:45 UTC

On 11/19/2021 9:08 AM, André G. Isaak wrote:
> On 2021-11-19 07:44, olcott wrote:
>> On 11/19/2021 6:35 AM, Richard Damon wrote:
>>> Except that just calling something a 'Strawman' doesn't make it go away.
>>
>> Yes it does make it go away.
>>
>> When I refer to a the behavior of P in a precisely defined set of
>> computations and your rebuttal refers to the behavior of P in an
>> entirely different set of computations then you make the logic mistake
>> known at the strawman error.
>
> The problem is that your 'precisely defined set of computations' doesn't
> match the ones which the halting problem is concerned with.

Yes it does that you fail to comprehend this is not may fault.

This is the exact set of all of the "Impossible" inputs to the halting
theorem's halt decider:

Combinations of H/P having pathological self-reference (PSR set)
For every possible H of H(P,P) invoked from main() where P(P) calls this
same H(P,P) and H simulates or executes its input and aborts or does not
abort its input P never reaches its last instruction.

> You can't
> claim to have 'solved' this problem when you are concerned with an
> entirely different set of behaviours than the actual problem is.
>
> The halting problem is interested *only* in the behaviour of P(P) when
> it is run *outside* of H. You are determined to only discuss its
> behaviour when it is run inside of H.
>
> André
>

--
Copyright 2021 Pete Olcott

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

Re: Concise refutation of halting problem proofs V18 [ strawman error ]

<6cydnTBU7YNYQgr8nZ2dnUU7-evNnZ2d@giganews.com>

 copy mid

https://www.novabbs.com/computers/article-flat.php?id=7609&group=comp.ai.philosophy#7609

 copy link   Newsgroups: comp.theory comp.ai.philosophy sci.logic sci.math
Followup: comp.theory
Path: i2pn2.org!i2pn.org!weretis.net!feeder6.news.weretis.net!news.misty.com!border2.nntp.dca1.giganews.com!nntp.giganews.com!buffer2.nntp.dca1.giganews.com!news.giganews.com.POSTED!not-for-mail
NNTP-Posting-Date: Fri, 19 Nov 2021 11:32:53 -0600
Date: Fri, 19 Nov 2021 11:32:51 -0600
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:91.0) Gecko/20100101
Thunderbird/91.3.1
Subject: Re: Concise refutation of halting problem proofs V18 [ strawman error
]
Content-Language: en-US
Newsgroups: comp.theory,comp.ai.philosophy,sci.logic,sci.math
References: <OqOdnSk-es33vwr8nZ2dnUU7-VXNnZ2d@giganews.com>
<0QFlJ.4132$aF1.1545@fx98.iad>
<csednfY4fZugrQr8nZ2dnUU7-YnNnZ2d@giganews.com>
<nSMlJ.92781$AJ2.12422@fx33.iad>
<W96dnV1_X_P4JQr8nZ2dnUU7-QPNnZ2d@giganews.com> <sn8el5$a6k$1@dont-email.me>
<MoGdna8BU9xUSQr8nZ2dnUU7-QvNnZ2d@giganews.com> <sn8l2e$sgf$1@dont-email.me>
Followup-To: comp.theory
From: NoO...@NoWhere.com (olcott)
In-Reply-To: <sn8l2e$sgf$1@dont-email.me>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Message-ID: <6cydnTBU7YNYQgr8nZ2dnUU7-evNnZ2d@giganews.com>
Lines: 93
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-TAffq9yocRkFlQyqdb1t1q2VMcT9D40ChX/UA5XqFw3Ob+rCz5zM+cIqwEahxaA056KBR/snpg1gcHl!SEcY7sOxQW4qn+GIDPEWVTITqKeXC/DtV3ePHymBVwgtJIen7DHs8R1IBLTIPxlGkSk1JsAKFKNu!hQ==
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: 4809
 by: olcott - Fri, 19 Nov 2021 17:32 UTC

On 11/19/2021 10:57 AM, André G. Isaak wrote:
> On 2021-11-19 09:45, olcott wrote:
>> On 11/19/2021 9:08 AM, André G. Isaak wrote:
>>> On 2021-11-19 07:44, olcott wrote:
>>>> On 11/19/2021 6:35 AM, Richard Damon wrote:
>>>>> Except that just calling something a 'Strawman' doesn't make it go
>>>>> away.
>>>>
>>>> Yes it does make it go away.
>>>>
>>>> When I refer to a the behavior of P in a precisely defined set of
>>>> computations and your rebuttal refers to the behavior of P in an
>>>> entirely different set of computations then you make the logic
>>>> mistake known at the strawman error.
>>>
>>> The problem is that your 'precisely defined set of computations'
>>> doesn't match the ones which the halting problem is concerned with.
>>
>> Yes it does that you fail to comprehend this is not may fault.
>>
>> This is the exact set of all of the "Impossible" inputs to the halting
>> theorem's halt decider:
>>
>> Combinations of H/P having pathological self-reference (PSR set)
>> For every possible H of H(P,P) invoked from main() where P(P) calls
>> this same H(P,P) and H simulates or executes its input and aborts or
>> does not abort its input P never reaches its last instruction.
>
>
> Yes, but the definition of a halt decider, translated into C for your
> benefit, is a program H which takes an input P, I such that the H in
>
> int main { H(P, I); }
>
> returns true if and only if the following computation halts:
>
> int main { P(I); }
>

NO That is a very very persistent fallacy of equivocation error.

A correct halt decider must base its halt status decision on:
(a) the actual sequence of instruction steps
(b) that are actually specified by
(c) an actual direct execution or
(d) actual correct simulation of
(e) the actual input.
If you get rid of any of the "actuals" the halt decider cannot be relied
on as correct.

The input to (H,P) never halts P(P) halts.
Here are the divergent execution sequences at the C level:

int main(){ H(P,P); }
(1) main()
(2) calls H(P,P) that simulates the input to H(P,P)
(3) that calls H(P,P) which aborts its simulation of P(P) and returns to
(4) main().

int main(){ P(P); }
(a) main() calls P(P) that
(b) calls H(P,P) that simulates the input to H(P,P)
(c) that calls H(P,P) which aborts its simulation of P(P) and returns to
(d) P(P) that returns to main()

(1) diverges from (a) causing (4) to diverge from (d)

> It doesn't make a bit of difference whether you call P(P) 'pathological'
> or not. The crucial point is that your H does not correctly answer the
> question that a halt decider is required to answer for this particular
> input.
>
> Your claim that your H is 'correct' is because you assume that your H is
> answering an entirely different question from the above.
>
> No one, including Linz, has ever claimed that that a TM cannot be
> constructed that answers that question, largely because no one has ever
> even found your question to be sufficiently interesting to even think
> about.
>
> André
>

--
Copyright 2021 Pete Olcott

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

Re: Concise refutation of halting problem proofs V18 [ strawman error ]

<pLudnSyOj6cnegr8nZ2dnUU7-UPNnZ2d@giganews.com>

 copy mid

https://www.novabbs.com/computers/article-flat.php?id=7610&group=comp.ai.philosophy#7610

 copy link   Newsgroups: comp.theory comp.ai.philosophy sci.logic sci.math
Followup: comp.theory
Path: i2pn2.org!i2pn.org!aioe.org!news.uzoreto.com!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: Fri, 19 Nov 2021 12:06:50 -0600
Date: Fri, 19 Nov 2021 12:06:48 -0600
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:91.0) Gecko/20100101 Thunderbird/91.3.1
Subject: Re: Concise refutation of halting problem proofs V18 [ strawman error ]
Content-Language: en-US
Newsgroups: comp.theory,comp.ai.philosophy,sci.logic,sci.math
References: <OqOdnSk-es33vwr8nZ2dnUU7-VXNnZ2d@giganews.com> <0QFlJ.4132$aF1.1545@fx98.iad> <csednfY4fZugrQr8nZ2dnUU7-YnNnZ2d@giganews.com> <nSMlJ.92781$AJ2.12422@fx33.iad> <W96dnV1_X_P4JQr8nZ2dnUU7-QPNnZ2d@giganews.com> <sn8el5$a6k$1@dont-email.me> <MoGdna8BU9xUSQr8nZ2dnUU7-QvNnZ2d@giganews.com> <sn8l2e$sgf$1@dont-email.me> <6cydnTBU7YNYQgr8nZ2dnUU7-evNnZ2d@giganews.com> <sn8ntm$j1d$1@dont-email.me>
Followup-To: comp.theory
From: NoO...@NoWhere.com (olcott)
In-Reply-To: <sn8ntm$j1d$1@dont-email.me>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Message-ID: <pLudnSyOj6cnegr8nZ2dnUU7-UPNnZ2d@giganews.com>
Lines: 110
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-kfYwId4XC5nS/nMPEpEtvdZhaXMp3QzII1MDm6ONzJLV9h8j5X+Yg74YGWKwdsx+DUOvr21z8HOjJOE!PHmx+E/fgknMsEmYFwjfJBMcrifRaOFofPRMX+1rFpNcFOrkRQuZ0EbcMexG5ad3N8KhzEbSlzw3!vg==
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: 5736
 by: olcott - Fri, 19 Nov 2021 18:06 UTC

On 11/19/2021 11:46 AM, André G. Isaak wrote:
> On 2021-11-19 10:32, olcott wrote:
>> On 11/19/2021 10:57 AM, André G. Isaak wrote:
>>> On 2021-11-19 09:45, olcott wrote:
>>>> On 11/19/2021 9:08 AM, André G. Isaak wrote:
>>>>> On 2021-11-19 07:44, olcott wrote:
>>>>>> On 11/19/2021 6:35 AM, Richard Damon wrote:
>>>>>>> Except that just calling something a 'Strawman' doesn't make it
>>>>>>> go away.
>>>>>>
>>>>>> Yes it does make it go away.
>>>>>>
>>>>>> When I refer to a the behavior of P in a precisely defined set of
>>>>>> computations and your rebuttal refers to the behavior of P in an
>>>>>> entirely different set of computations then you make the logic
>>>>>> mistake known at the strawman error.
>>>>>
>>>>> The problem is that your 'precisely defined set of computations'
>>>>> doesn't match the ones which the halting problem is concerned with.
>>>>
>>>> Yes it does that you fail to comprehend this is not may fault.
>>>>
>>>> This is the exact set of all of the "Impossible" inputs to the
>>>> halting theorem's halt decider:
>>>>
>>>> Combinations of H/P having pathological self-reference (PSR set)
>>>> For every possible H of H(P,P) invoked from main() where P(P) calls
>>>> this same H(P,P) and H simulates or executes its input and aborts or
>>>> does not abort its input P never reaches its last instruction.
>>>
>>>
>>> Yes, but the definition of a halt decider, translated into C for your
>>> benefit, is a program H which takes an input P, I such that the H in
>>>
>>> int main { H(P, I); }
>>>
>>> returns true if and only if the following computation halts:
>>>
>>> int main { P(I); }
>>>
>>
>> NO That is a very very persistent fallacy of equivocation error.
>
> Where am I equivocating? I am telling you how 'halt decider' is actually
> DEFINED. The definition is precise and unambiguous. The fact that you
> have come up with a deranged interpretation in attempting to translate
> the Turing Machine terminology (which you really don't understand) into
> C terminology is your problem, not mine.
>
>> A correct halt decider must base its halt status decision on:
>> (a) the actual sequence of instruction steps
>> (b) that are actually specified by
>> (c) an actual direct execution or
>> (d) actual correct simulation of
>> (e) the actual input.
>> If you get rid of any of the "actuals" the halt decider cannot be
>> relied on as correct.
>
> The 'actual input' to a halt decider is a description of a computation.
> The behaviour which it is supposed to decide is that of the computation
> itself.
>
> A computation is a self-contained entity which runs independently, not
> something which runs 'inside' the halt decider.
>
> André
>
>>
>>
>>
>> The input to (H,P) never halts P(P) halts.
>> Here are the divergent execution sequences at the C level:
>>
>> int main(){ H(P,P); }
>> (1) main()
>> (2) calls H(P,P) that simulates the input to H(P,P)
>> (3) that calls H(P,P) which aborts its simulation of P(P) and returns to
>> (4) main().
>>
>> int main(){ P(P); }
>> (a) main() calls P(P) that
>> (b) calls H(P,P) that simulates the input to H(P,P)
>> (c) that calls H(P,P) which aborts its simulation of P(P) and returns to
>> (d) P(P) that returns to main()
>>
>> (1) diverges from (a) causing (4) to diverge from (d)
>
> And a halt decider is concerned only with the SECOND case, not the first.
>

The halt decider is concerned with the execution trace of a sequence of
instructions other than the actual execution trace that is specified by
actually executing or simulating its actual input?

> This is a simple matter of definition. If you are addressing the first
> case rather than the second you are not addressing the halting problem
> but rather some other problem of your own making. Neither Linz nor
> anyone else cares about that other problem.
>
> André
>

--
Copyright 2021 Pete Olcott

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

Re: Concise refutation of halting problem proofs V18 [ strawman error ]

<wd2dnW1XgcfhZwr8nZ2dnUU7-VnNnZ2d@giganews.com>

 copy mid

https://www.novabbs.com/computers/article-flat.php?id=7611&group=comp.ai.philosophy#7611

 copy link   Newsgroups: comp.theory comp.ai.philosophy sci.philosophy sci.math.symbolic
Followup: comp.theory
Path: i2pn2.org!i2pn.org!weretis.net!feeder8.news.weretis.net!2.eu.feeder.erje.net!feeder.erje.net!newsfeed.xs4all.nl!newsfeed7.news.xs4all.nl!tr2.eu1.usenetexpress.com!feeder.usenetexpress.com!tr2.iad1.usenetexpress.com!border1.nntp.dca1.giganews.com!nntp.giganews.com!buffer1.nntp.dca1.giganews.com!buffer2.nntp.dca1.giganews.com!news.giganews.com.POSTED!not-for-mail
NNTP-Posting-Date: Fri, 19 Nov 2021 13:26:52 -0600
Date: Fri, 19 Nov 2021 13:26:50 -0600
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:91.0) Gecko/20100101 Thunderbird/91.3.1
Subject: Re: Concise refutation of halting problem proofs V18 [ strawman error ]
Content-Language: en-US
Newsgroups: comp.theory,comp.ai.philosophy,sci.philosophy,sci.math.symbolic
References: <OqOdnSk-es33vwr8nZ2dnUU7-VXNnZ2d@giganews.com> <0QFlJ.4132$aF1.1545@fx98.iad> <csednfY4fZugrQr8nZ2dnUU7-YnNnZ2d@giganews.com> <nSMlJ.92781$AJ2.12422@fx33.iad> <W96dnV1_X_P4JQr8nZ2dnUU7-QPNnZ2d@giganews.com> <sn8el5$a6k$1@dont-email.me> <MoGdna8BU9xUSQr8nZ2dnUU7-QvNnZ2d@giganews.com> <sn8l2e$sgf$1@dont-email.me> <6cydnTBU7YNYQgr8nZ2dnUU7-evNnZ2d@giganews.com> <sn8ntm$j1d$1@dont-email.me> <pLudnSyOj6cnegr8nZ2dnUU7-UPNnZ2d@giganews.com> <sn8qhq$7jn$1@dont-email.me>
From: NoO...@NoWhere.com (olcott)
Followup-To: comp.theory
In-Reply-To: <sn8qhq$7jn$1@dont-email.me>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Message-ID: <wd2dnW1XgcfhZwr8nZ2dnUU7-VnNnZ2d@giganews.com>
Lines: 83
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-kS8UAYdqf4h4OQ9RD3rTxwdC5LmWNU2Km4XI1TZllc37riS6m4rx0EDKnTw8Fuxpz8+wHf65YDLICsJ!VB6XanqRMeZjLAevJ4oujJ+rZ7uFb74da3IRR6sLkBmUEV4L0i0EbLo3Xpgoxr5l8AUQ23INWyQG!Lg==
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: 4518
 by: olcott - Fri, 19 Nov 2021 19:26 UTC

On 11/19/2021 12:31 PM, André G. Isaak wrote:
> On 2021-11-19 11:06, olcott wrote:
>> On 11/19/2021 11:46 AM, André G. Isaak wrote:
>>> On 2021-11-19 10:32, olcott wrote:
>
>>>> The input to (H,P) never halts P(P) halts.
>>>> Here are the divergent execution sequences at the C level:
>>>>
>>>> int main(){ H(P,P); }
>>>> (1) main()
>>>> (2) calls H(P,P) that simulates the input to H(P,P)
>>>> (3) that calls H(P,P) which aborts its simulation of P(P) and
>>>> returns to
>>>> (4) main().
>>>>
>>>> int main(){ P(P); }
>>>> (a) main() calls P(P) that
>>>> (b) calls H(P,P) that simulates the input to H(P,P)
>>>> (c) that calls H(P,P) which aborts its simulation of P(P) and
>>>> returns to
>>>> (d) P(P) that returns to main()
>>>>
>>>> (1) diverges from (a) causing (4) to diverge from (d)
>>>
>>> And a halt decider is concerned only with the SECOND case, not the
>>> first.
>>>
>>
>> The halt decider is concerned with the execution trace of a sequence
>> of instructions other than the actual execution trace that is
>> specified by actually executing or simulating its actual input?
>
> Your question makes no sense.

It is proven that the execution trace of P(P) and the execution trace of
the input to H(P,P) are not the same and that this difference results in
different behavior.

int main(){ H(P,P); }
(1) main()
(2) calls H(P,P) that simulates the input to H(P,P)
(3) that calls H(P,P) which aborts its simulation of P(P) and returns to
(4) main().

int main(){ P(P); }
(a) main() calls P(P) that
(b) calls H(P,P) that simulates the input to H(P,P)
(c) that calls H(P,P) which aborts its simulation of P(P) and returns to
(d) P(P) that returns to main()

P(P) has a whole other invocation of P(P) prepended to the execution
trace of the input to H(P,P). It is proven that this different execution
trace derives opposite halting behavior between P(P) and the input to
H(P,P).

>
> int main() { P(P); } *is* actually executing the input to int main() {
> H(P,P); }. In int main() { H(P,P); } it is *not* being executed; it is
> being passed as a parameter to another function.
>
> The halting problem asks whether a given computation will halt *when it
> is performed*.
>
> When you execute H(H_Hat, H_Hat) the computation H_Hat(H_Hat) is *not*
> being performed. It is having a question asked about it. That's true
> even if H makes use of partial simulation.
>
> The computation is being performed only when you actually run
> H_Hat(H_Hat), not when you provide a description of it to another Turing
> Machine.
>
> André
>

--
Copyright 2021 Pete Olcott

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

Re: Concise refutation of halting problem proofs V18 [ strawman error ]

<-6udnelNUqLWgAX8nZ2dnUU7-SnNnZ2d@giganews.com>

 copy mid

https://www.novabbs.com/computers/article-flat.php?id=7612&group=comp.ai.philosophy#7612

 copy link   Newsgroups: comp.theory comp.ai.philosophy sci.logic sci.math
Followup: comp.theory
Path: i2pn2.org!i2pn.org!weretis.net!feeder6.news.weretis.net!news.misty.com!border2.nntp.dca1.giganews.com!nntp.giganews.com!buffer2.nntp.dca1.giganews.com!buffer1.nntp.dca1.giganews.com!news.giganews.com.POSTED!not-for-mail
NNTP-Posting-Date: Fri, 19 Nov 2021 15:55:23 -0600
Date: Fri, 19 Nov 2021 15:55:21 -0600
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:91.0) Gecko/20100101
Thunderbird/91.3.1
Subject: Re: Concise refutation of halting problem proofs V18 [ strawman error
]
Content-Language: en-US
Newsgroups: comp.theory,comp.ai.philosophy,sci.logic,sci.math
References: <OqOdnSk-es33vwr8nZ2dnUU7-VXNnZ2d@giganews.com>
<0QFlJ.4132$aF1.1545@fx98.iad>
<csednfY4fZugrQr8nZ2dnUU7-YnNnZ2d@giganews.com>
<nSMlJ.92781$AJ2.12422@fx33.iad>
<W96dnV1_X_P4JQr8nZ2dnUU7-QPNnZ2d@giganews.com> <sn8el5$a6k$1@dont-email.me>
<MoGdna8BU9xUSQr8nZ2dnUU7-QvNnZ2d@giganews.com> <sn8l2e$sgf$1@dont-email.me>
<6cydnTBU7YNYQgr8nZ2dnUU7-evNnZ2d@giganews.com> <sn8ntm$j1d$1@dont-email.me>
<pLudnSyOj6cnegr8nZ2dnUU7-UPNnZ2d@giganews.com> <sn8qhq$7jn$1@dont-email.me>
<wd2dnW1XgcfhZwr8nZ2dnUU7-VnNnZ2d@giganews.com> <sn8vv7$fqo$1@dont-email.me>
<sn90hk$k4m$1@dont-email.me> <sn93ja$b5a$1@dont-email.me>
From: NoO...@NoWhere.com (olcott)
Followup-To: comp.theory
In-Reply-To: <sn93ja$b5a$1@dont-email.me>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Message-ID: <-6udnelNUqLWgAX8nZ2dnUU7-SnNnZ2d@giganews.com>
Lines: 88
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-pPprEU0hOE6YGkE67aN0Y4HapzRBVHD235roY/QbkRFVHrhjrBi7pJMeIOUgYdWmrGCq3hrRSY/jpne!5AbFpqT+sqJe0wl/Kzp4Neodd7mfite8bezS0A8EopFj0mhMMrmIoCdVx42s9qV9gkSxXIQUijDi!ug==
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: 5037
 by: olcott - Fri, 19 Nov 2021 21:55 UTC

On 11/19/2021 3:05 PM, André G. Isaak wrote:
> On 2021-11-19 13:13, olcott wrote:
>> On 11/19/2021 2:03 PM, André G. Isaak wrote:
>>> On 2021-11-19 12:26, olcott wrote:
>>>> On 11/19/2021 12:31 PM, André G. Isaak wrote:
>>>>> On 2021-11-19 11:06, olcott wrote:
>>>>>> On 11/19/2021 11:46 AM, André G. Isaak wrote:
>>>>>>> On 2021-11-19 10:32, olcott wrote:
>>>>>
>>>>>>>> The input to (H,P) never halts P(P) halts.
>>>>>>>> Here are the divergent execution sequences at the C level:
>>>>>>>>
>>>>>>>> int main(){ H(P,P); }
>>>>>>>> (1) main()
>>>>>>>> (2) calls H(P,P) that simulates the input to H(P,P)
>>>>>>>> (3) that calls H(P,P) which aborts its simulation of P(P) and
>>>>>>>> returns to
>>>>>>>> (4) main().
>>>>>>>>
>>>>>>>> int main(){ P(P); }
>>>>>>>> (a) main() calls P(P) that
>>>>>>>> (b) calls H(P,P) that simulates the input to H(P,P)
>>>>>>>> (c) that calls H(P,P) which aborts its simulation of P(P) and
>>>>>>>> returns to
>>>>>>>> (d) P(P) that returns to main()
>>>>>>>>
>>>>>>>> (1) diverges from (a) causing (4) to diverge from (d)
>>>>>>>
>>>>>>> And a halt decider is concerned only with the SECOND case, not
>>>>>>> the first.
>>>>>>>
>>>>>>
>>>>>> The halt decider is concerned with the execution trace of a
>>>>>> sequence of instructions other than the actual execution trace
>>>>>> that is specified by actually executing or simulating its actual
>>>>>> input?
>>>>>
>>>>> Your question makes no sense.
>>>>
>>>>
>>>> It is proven that the execution trace of P(P) and the execution
>>>> trace of the input to H(P,P) are not the same and that this
>>>> difference results in different behavior.
>>>
>>> And the halting problem, BY DEFINITION, is concerned only with the
>>> former. The latter is not of interest to anyone.
>>>
>>
>> It may seem that way until you realize that any other case would not
>> be reporting on the actual behavior of the actual sequence of
>> instructions specified by the actual execution trace of the actual
>> simulation or execution of its actual input.
>
> The definition is what it is. A halt reporter reports on the behaviour
> of the computation described by its input when that computation is run
> as an independent computation; not when it is wrapped inside your H.

No academic definition of halt decider that I have ever seen directly
contradicts this definition that I provide:

A halt decider must base its halt status decision on the sequence
instruction steps (sequence of configurations) specified by the direct
execution or correct simulation of its actual input. **

** For non-halting inputs this execution or simulation need not be
complete.

>
> Just because you don't like the definition doesn't mean you can change it.
>
>> When Bill Jones robs a liquor store people may get confused and arrest
>> his identical twin brother that is also named Bill Jones.
>
> Except that you are the one who is arresting the wrong Bill Jones.
>
> André
>
>

--
Copyright 2021 Pete Olcott

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

Re: Concise refutation of halting problem proofs V18 [ strawman error ]

<LbqdnVNler6IvwX8nZ2dnUU7-bHNnZ2d@giganews.com>

 copy mid

https://www.novabbs.com/computers/article-flat.php?id=7613&group=comp.ai.philosophy#7613

 copy link   Newsgroups: comp.theory comp.ai.philosophy sci.logic sci.math
Followup: comp.theory
Path: i2pn2.org!i2pn.org!weretis.net!feeder6.news.weretis.net!news.misty.com!border2.nntp.dca1.giganews.com!nntp.giganews.com!buffer2.nntp.dca1.giganews.com!buffer1.nntp.dca1.giganews.com!news.giganews.com.POSTED!not-for-mail
NNTP-Posting-Date: Fri, 19 Nov 2021 16:15:49 -0600
Date: Fri, 19 Nov 2021 16:15:47 -0600
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:91.0) Gecko/20100101
Thunderbird/91.3.2
Subject: Re: Concise refutation of halting problem proofs V18 [ strawman error
]
Content-Language: en-US
Newsgroups: comp.theory,comp.ai.philosophy,sci.logic,sci.math
References: <OqOdnSk-es33vwr8nZ2dnUU7-VXNnZ2d@giganews.com>
<0QFlJ.4132$aF1.1545@fx98.iad>
<csednfY4fZugrQr8nZ2dnUU7-YnNnZ2d@giganews.com>
<nSMlJ.92781$AJ2.12422@fx33.iad>
<W96dnV1_X_P4JQr8nZ2dnUU7-QPNnZ2d@giganews.com> <sn8el5$a6k$1@dont-email.me>
<MoGdna8BU9xUSQr8nZ2dnUU7-QvNnZ2d@giganews.com> <sn8l2e$sgf$1@dont-email.me>
<6cydnTBU7YNYQgr8nZ2dnUU7-evNnZ2d@giganews.com> <sn8ntm$j1d$1@dont-email.me>
<pLudnSyOj6cnegr8nZ2dnUU7-UPNnZ2d@giganews.com> <sn8qhq$7jn$1@dont-email.me>
<wd2dnW1XgcfhZwr8nZ2dnUU7-VnNnZ2d@giganews.com> <sn8vv7$fqo$1@dont-email.me>
<sn90hk$k4m$1@dont-email.me> <sn93ja$b5a$1@dont-email.me>
From: NoO...@NoWhere.com (olcott)
Followup-To: comp.theory
In-Reply-To: <sn93ja$b5a$1@dont-email.me>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Message-ID: <LbqdnVNler6IvwX8nZ2dnUU7-bHNnZ2d@giganews.com>
Lines: 85
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-MqQJiFbrI0hyfHjQhtNr9UK7zBq/hI0a2NzEqbA2JSf9l90sIswQFj/eXycFZiFXHa8W/0+CMY9RSgK!FdrwL+D779B1OZ7IgVyt4m275PWZw2fyEDmXmjHhZ8XgfqcAKj8cJ+RXtEvY8g8RBUoLbvm3GXlE!bg==
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: 4861
 by: olcott - Fri, 19 Nov 2021 22:15 UTC

On 11/19/2021 3:05 PM, André G. Isaak wrote:
> On 2021-11-19 13:13, olcott wrote:
>> On 11/19/2021 2:03 PM, André G. Isaak wrote:
>>> On 2021-11-19 12:26, olcott wrote:
>>>> On 11/19/2021 12:31 PM, André G. Isaak wrote:
>>>>> On 2021-11-19 11:06, olcott wrote:
>>>>>> On 11/19/2021 11:46 AM, André G. Isaak wrote:
>>>>>>> On 2021-11-19 10:32, olcott wrote:
>>>>>
>>>>>>>> The input to (H,P) never halts P(P) halts.
>>>>>>>> Here are the divergent execution sequences at the C level:
>>>>>>>>
>>>>>>>> int main(){ H(P,P); }
>>>>>>>> (1) main()
>>>>>>>> (2) calls H(P,P) that simulates the input to H(P,P)
>>>>>>>> (3) that calls H(P,P) which aborts its simulation of P(P) and
>>>>>>>> returns to
>>>>>>>> (4) main().
>>>>>>>>
>>>>>>>> int main(){ P(P); }
>>>>>>>> (a) main() calls P(P) that
>>>>>>>> (b) calls H(P,P) that simulates the input to H(P,P)
>>>>>>>> (c) that calls H(P,P) which aborts its simulation of P(P) and
>>>>>>>> returns to
>>>>>>>> (d) P(P) that returns to main()
>>>>>>>>
>>>>>>>> (1) diverges from (a) causing (4) to diverge from (d)
>>>>>>>
>>>>>>> And a halt decider is concerned only with the SECOND case, not
>>>>>>> the first.
>>>>>>>
>>>>>>
>>>>>> The halt decider is concerned with the execution trace of a
>>>>>> sequence of instructions other than the actual execution trace
>>>>>> that is specified by actually executing or simulating its actual
>>>>>> input?
>>>>>
>>>>> Your question makes no sense.
>>>>
>>>>
>>>> It is proven that the execution trace of P(P) and the execution
>>>> trace of the input to H(P,P) are not the same and that this
>>>> difference results in different behavior.
>>>
>>> And the halting problem, BY DEFINITION, is concerned only with the
>>> former. The latter is not of interest to anyone.
>>>
>>
>> It may seem that way until you realize that any other case would not
>> be reporting on the actual behavior of the actual sequence of
>> instructions specified by the actual execution trace of the actual
>> simulation or execution of its actual input.
>
> The definition is what it is. A halt reporter reports on the behaviour
> of the computation described by its input when that computation is run
> as an independent computation; not when it is wrapped inside your H.
>
> Just because you don't like the definition doesn't mean you can change it.

given the description of a Turing machine M and an input w, does M,
when started in the initial configuration q0 w, perform a computation
that eventually halts? (Linz:1990:317)

In other words: Does UTM(M, w) halt?

>
>> When Bill Jones robs a liquor store people may get confused and arrest
>> his identical twin brother that is also named Bill Jones.
>
> Except that you are the one who is arresting the wrong Bill Jones.
>
> André
>
>

--
Copyright 2021 Pete Olcott

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

Re: Concise refutation of halting problem proofs V18 [ strawman error ]

<fsKdneznstvwowX8nZ2dnUU7-XnNnZ2d@giganews.com>

 copy mid

https://www.novabbs.com/computers/article-flat.php?id=7614&group=comp.ai.philosophy#7614

 copy link   Newsgroups: comp.theory comp.ai.philosophy sci.logic sci.math
Followup: comp.theory
Path: i2pn2.org!i2pn.org!weretis.net!feeder6.news.weretis.net!news.misty.com!border2.nntp.dca1.giganews.com!nntp.giganews.com!buffer2.nntp.dca1.giganews.com!news.giganews.com.POSTED!not-for-mail
NNTP-Posting-Date: Fri, 19 Nov 2021 18:16:45 -0600
Date: Fri, 19 Nov 2021 18:16:43 -0600
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:91.0) Gecko/20100101
Thunderbird/91.3.2
Subject: Re: Concise refutation of halting problem proofs V18 [ strawman error
]
Content-Language: en-US
Newsgroups: comp.theory,comp.ai.philosophy,sci.logic,sci.math
References: <OqOdnSk-es33vwr8nZ2dnUU7-VXNnZ2d@giganews.com>
<0QFlJ.4132$aF1.1545@fx98.iad>
<csednfY4fZugrQr8nZ2dnUU7-YnNnZ2d@giganews.com>
<nSMlJ.92781$AJ2.12422@fx33.iad>
<W96dnV1_X_P4JQr8nZ2dnUU7-QPNnZ2d@giganews.com> <sn8el5$a6k$1@dont-email.me>
<MoGdna8BU9xUSQr8nZ2dnUU7-QvNnZ2d@giganews.com> <sn8l2e$sgf$1@dont-email.me>
<6cydnTBU7YNYQgr8nZ2dnUU7-evNnZ2d@giganews.com> <sn8ntm$j1d$1@dont-email.me>
<pLudnSyOj6cnegr8nZ2dnUU7-UPNnZ2d@giganews.com> <sn8qhq$7jn$1@dont-email.me>
<wd2dnW1XgcfhZwr8nZ2dnUU7-VnNnZ2d@giganews.com> <sn8vv7$fqo$1@dont-email.me>
<sn90hk$k4m$1@dont-email.me> <sn93ja$b5a$1@dont-email.me>
<LbqdnVNler6IvwX8nZ2dnUU7-bHNnZ2d@giganews.com> <sn9c8i$522$1@dont-email.me>
From: NoO...@NoWhere.com (olcott)
Followup-To: comp.theory
In-Reply-To: <sn9c8i$522$1@dont-email.me>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Message-ID: <fsKdneznstvwowX8nZ2dnUU7-XnNnZ2d@giganews.com>
Lines: 102
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-PhE0eOA42vWM31EQvsYI16ID9BsUmjXHpDf7dbVOYS+5E/9op5DvuuaBvrkY2NgFBxxLV6BZojyNswr!XGoGxr1r7pNb+iJtCtNBH0uDt3ndao+iZusb1mnVxDGr/fnng2sHNSxwG+tyHMAT4VgVo4C6Y5TE!9Q==
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: 6066
 by: olcott - Sat, 20 Nov 2021 00:16 UTC

On 11/19/2021 5:33 PM, André G. Isaak wrote:
> On 2021-11-19 15:15, olcott wrote:
>> On 11/19/2021 3:05 PM, André G. Isaak wrote:
>>> On 2021-11-19 13:13, olcott wrote:
>>>> On 11/19/2021 2:03 PM, André G. Isaak wrote:
>>>>> On 2021-11-19 12:26, olcott wrote:
>>>>>> On 11/19/2021 12:31 PM, André G. Isaak wrote:
>>>>>>> On 2021-11-19 11:06, olcott wrote:
>>>>>>>> On 11/19/2021 11:46 AM, André G. Isaak wrote:
>>>>>>>>> On 2021-11-19 10:32, olcott wrote:
>>>>>>>
>>>>>>>>>> The input to (H,P) never halts P(P) halts.
>>>>>>>>>> Here are the divergent execution sequences at the C level:
>>>>>>>>>>
>>>>>>>>>> int main(){ H(P,P); }
>>>>>>>>>> (1) main()
>>>>>>>>>> (2) calls H(P,P) that simulates the input to H(P,P)
>>>>>>>>>> (3) that calls H(P,P) which aborts its simulation of P(P) and
>>>>>>>>>> returns to
>>>>>>>>>> (4) main().
>>>>>>>>>>
>>>>>>>>>> int main(){ P(P); }
>>>>>>>>>> (a) main() calls P(P) that
>>>>>>>>>> (b) calls H(P,P) that simulates the input to H(P,P)
>>>>>>>>>> (c) that calls H(P,P) which aborts its simulation of P(P) and
>>>>>>>>>> returns to
>>>>>>>>>> (d) P(P) that returns to main()
>>>>>>>>>>
>>>>>>>>>> (1) diverges from (a) causing (4) to diverge from (d)
>>>>>>>>>
>>>>>>>>> And a halt decider is concerned only with the SECOND case, not
>>>>>>>>> the first.
>>>>>>>>>
>>>>>>>>
>>>>>>>> The halt decider is concerned with the execution trace of a
>>>>>>>> sequence of instructions other than the actual execution trace
>>>>>>>> that is specified by actually executing or simulating its actual
>>>>>>>> input?
>>>>>>>
>>>>>>> Your question makes no sense.
>>>>>>
>>>>>>
>>>>>> It is proven that the execution trace of P(P) and the execution
>>>>>> trace of the input to H(P,P) are not the same and that this
>>>>>> difference results in different behavior.
>>>>>
>>>>> And the halting problem, BY DEFINITION, is concerned only with the
>>>>> former. The latter is not of interest to anyone.
>>>>>
>>>>
>>>> It may seem that way until you realize that any other case would not
>>>> be reporting on the actual behavior of the actual sequence of
>>>> instructions specified by the actual execution trace of the actual
>>>> simulation or execution of its actual input.
>>>
>>> The definition is what it is. A halt reporter reports on the
>>> behaviour of the computation described by its input when that
>>> computation is run as an independent computation; not when it is
>>> wrapped inside your H.
>>>
>>> Just because you don't like the definition doesn't mean you can
>>> change it.
>>
>> given the description of a Turing machine M and an input w, does M,
>> when started in the initial configuration q0 w, perform a computation
>> that eventually halts? (Linz:1990:317)
>>
>> In other words: Does UTM(M, w) halt?
>
> That definition makes no mention of UTMs, and he carefully distinguishes
> between the description of M (which he elsewhere notates as w_M).
>
> But yes, UTM(w_M, w) will halt if and only if M(w) halts.
>

Because the behavior of the UTM simulation of the machine description of
TM X on input Y is defined to precisely correspond to the direct
execution of TM X on input Y we can also always rely on the following:

If UTM U is adapted to become a halt decider H for a subset of inputs Z
such that it aborts the simulation of its input only when the behavior
of the pure simulation of this input conclusively proves that this input
would never reach its final state, then H can abort the simulation of
every element of Z and correctly report that its input does not halt.

> But that isn't what you've been claiming since your H is not a UTM, nor
> are you claiming that H(P, P) halts if and only if P(P) halts but are
> instead claiming something about the "input" to H.
>
> If an actual UTM were applied to P(P), you would find that UTM(P, P)
> does in fact halt just as P(P) does.
>
> André
>

--
Copyright 2021 Pete Olcott

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

Re: Concise refutation of halting problem proofs V21 [ precisely defined sets ]

<KPmdnbIicsClqQT8nZ2dnUU7-cXNnZ2d@giganews.com>

 copy mid

https://www.novabbs.com/computers/article-flat.php?id=7619&group=comp.ai.philosophy#7619

 copy link   Newsgroups: comp.theory comp.ai.philosophy sci.logic sci.math
Followup: comp.theory
Path: i2pn2.org!i2pn.org!weretis.net!feeder6.news.weretis.net!news.misty.com!border2.nntp.dca1.giganews.com!nntp.giganews.com!buffer2.nntp.dca1.giganews.com!news.giganews.com.POSTED!not-for-mail
NNTP-Posting-Date: Sat, 20 Nov 2021 11:45:28 -0600
Date: Sat, 20 Nov 2021 11:45:28 -0600
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:91.0) Gecko/20100101
Thunderbird/91.3.2
Subject: Re: Concise refutation of halting problem proofs V21 [ precisely
defined sets ]
Content-Language: en-US
Newsgroups: comp.theory,comp.ai.philosophy,sci.logic,sci.math
References: <OqOdnSk-es33vwr8nZ2dnUU7-VXNnZ2d@giganews.com>
<0QFlJ.4132$aF1.1545@fx98.iad>
<csednfY4fZugrQr8nZ2dnUU7-YnNnZ2d@giganews.com>
<nSMlJ.92781$AJ2.12422@fx33.iad>
<W96dnV1_X_P4JQr8nZ2dnUU7-QPNnZ2d@giganews.com> <sn8el5$a6k$1@dont-email.me>
<MoGdna8BU9xUSQr8nZ2dnUU7-QvNnZ2d@giganews.com> <sn8l2e$sgf$1@dont-email.me>
<6cydnTBU7YNYQgr8nZ2dnUU7-evNnZ2d@giganews.com> <sn8ntm$j1d$1@dont-email.me>
<pLudnSyOj6cnegr8nZ2dnUU7-UPNnZ2d@giganews.com> <sn8qhq$7jn$1@dont-email.me>
<wd2dnW1XgcfhZwr8nZ2dnUU7-VnNnZ2d@giganews.com> <sn8vv7$fqo$1@dont-email.me>
<sn90hk$k4m$1@dont-email.me> <sn93ja$b5a$1@dont-email.me>
<LbqdnVNler6IvwX8nZ2dnUU7-bHNnZ2d@giganews.com> <sn9c8i$522$1@dont-email.me>
<fsKdneznstvwowX8nZ2dnUU7-XnNnZ2d@giganews.com> <sna68l$89c$1@dont-email.me>
Followup-To: comp.theory
From: NoO...@NoWhere.com (olcott)
In-Reply-To: <sna68l$89c$1@dont-email.me>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Message-ID: <KPmdnbIicsClqQT8nZ2dnUU7-cXNnZ2d@giganews.com>
Lines: 148
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-dEfyJa0R+mcjhsz1z9zB5PTVBtL1zsuIZ11fmOxv+sJgUrmkROh64WpughHKb9upeYE8pMW99kzJwWg!u3X6EMG/wWyEwBlA3Oh0wj4pQBRvC8jm//zMICHGo40vHPETPjEucMjwb15VdMQ6IkZUsNgfzSYn!IQ==
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: 8188
 by: olcott - Sat, 20 Nov 2021 17:45 UTC

On 11/20/2021 12:57 AM, André G. Isaak wrote:
> On 2021-11-19 17:16, olcott wrote:
>> On 11/19/2021 5:33 PM, André G. Isaak wrote:
>>> On 2021-11-19 15:15, olcott wrote:
>>>> On 11/19/2021 3:05 PM, André G. Isaak wrote:
>>>>> On 2021-11-19 13:13, olcott wrote:
>>>>>> On 11/19/2021 2:03 PM, André G. Isaak wrote:
>>>>>>> On 2021-11-19 12:26, olcott wrote:
>>>>>>>> On 11/19/2021 12:31 PM, André G. Isaak wrote:
>>>>>>>>> On 2021-11-19 11:06, olcott wrote:
>>>>>>>>>> On 11/19/2021 11:46 AM, André G. Isaak wrote:
>>>>>>>>>>> On 2021-11-19 10:32, olcott wrote:
>>>>>>>>>
>>>>>>>>>>>> The input to (H,P) never halts P(P) halts.
>>>>>>>>>>>> Here are the divergent execution sequences at the C level:
>>>>>>>>>>>>
>>>>>>>>>>>> int main(){ H(P,P); }
>>>>>>>>>>>> (1) main()
>>>>>>>>>>>> (2) calls H(P,P) that simulates the input to H(P,P)
>>>>>>>>>>>> (3) that calls H(P,P) which aborts its simulation of P(P)
>>>>>>>>>>>> and returns to
>>>>>>>>>>>> (4) main().
>>>>>>>>>>>>
>>>>>>>>>>>> int main(){ P(P); }
>>>>>>>>>>>> (a) main() calls P(P) that
>>>>>>>>>>>> (b) calls H(P,P) that simulates the input to H(P,P)
>>>>>>>>>>>> (c) that calls H(P,P) which aborts its simulation of P(P)
>>>>>>>>>>>> and returns to
>>>>>>>>>>>> (d) P(P) that returns to main()
>>>>>>>>>>>>
>>>>>>>>>>>> (1) diverges from (a) causing (4) to diverge from (d)
>>>>>>>>>>>
>>>>>>>>>>> And a halt decider is concerned only with the SECOND case,
>>>>>>>>>>> not the first.
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> The halt decider is concerned with the execution trace of a
>>>>>>>>>> sequence of instructions other than the actual execution trace
>>>>>>>>>> that is specified by actually executing or simulating its
>>>>>>>>>> actual input?
>>>>>>>>>
>>>>>>>>> Your question makes no sense.
>>>>>>>>
>>>>>>>>
>>>>>>>> It is proven that the execution trace of P(P) and the execution
>>>>>>>> trace of the input to H(P,P) are not the same and that this
>>>>>>>> difference results in different behavior.
>>>>>>>
>>>>>>> And the halting problem, BY DEFINITION, is concerned only with
>>>>>>> the former. The latter is not of interest to anyone.
>>>>>>>
>>>>>>
>>>>>> It may seem that way until you realize that any other case would
>>>>>> not be reporting on the actual behavior of the actual sequence of
>>>>>> instructions specified by the actual execution trace of the actual
>>>>>> simulation or execution of its actual input.
>>>>>
>>>>> The definition is what it is. A halt reporter reports on the
>>>>> behaviour of the computation described by its input when that
>>>>> computation is run as an independent computation; not when it is
>>>>> wrapped inside your H.
>>>>>
>>>>> Just because you don't like the definition doesn't mean you can
>>>>> change it.
>>>>
>>>> given the description of a Turing machine M and an input w, does M,
>>>> when started in the initial configuration q0 w, perform a
>>>> computation that eventually halts? (Linz:1990:317)
>>>>
>>>> In other words: Does UTM(M, w) halt?
>>>
>>> That definition makes no mention of UTMs, and he carefully
>>> distinguishes between the description of M (which he elsewhere
>>> notates as w_M).
>>>
>>> But yes, UTM(w_M, w) will halt if and only if M(w) halts.
>>>
>>
>> Because the behavior of the UTM simulation of the machine description
>> of TM X on input Y is defined to precisely correspond to the direct
>> execution of TM X on input Y we can also always rely on the following:
>>
>> If UTM U is adapted to become a halt decider H for a subset of inputs
>> Z such that it aborts the simulation of its input only when the
>> behavior of the pure simulation of this input conclusively proves that
>> this input would never reach its final state, then H can abort the
>> simulation of every element of Z and correctly report that its input
>> does not halt.
>
> The fact that UTM(M, w) and M(w) have the same halting status has no
> bearing on the definition of a halt decider and provides no
> justification for the above.
>
> The input to UTM(M, w) doesn't have a halting status anymore than the
> input to H does. Only actual computations have a halting status. So you
> can ask about whether UTM(M, w) halts, or about whether the computation
> described by its input halts, but not about whether the input halts.

> H(P, P) may or may not reach a final state. P(P) may or may not reach a
> final state. It is meaningless, though, to talk about the input to H(P,
> P) reaching a final state.
>
> André
>
>

Not when the [PSR set] if the basis for this claim:

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

PSR set: Combinations of H/P having pathological self-reference
For every possible H of H(P,P) invoked from main() where P(P) calls this
same H(P,P) and H simulates or executes its input and aborts or does not
abort its input P never reaches its last instruction.

PSR subset: Because we know that the input to H(P,P) never halts for the
whole PSR set and a subset of these H/P combinations aborts the
execution or simulation of its input then we know that for this entire
subset the input to H(P,P) never halts and H(P,P) halts.

When int main(void) { P(P); } is invoked on H/P elements of the above
PSR subset, then we have a cases where the input to H(P,P) never halts
and P(P) halts.

The above cases conclusively prove that when the input to H(P,P) never
halts and the same P(P) does halt that this does not form any
contradiction.

Decidable_PSR subset: The subset of the PSR subset where H returns 0 on
the basis that H correctly detects that P specifies infinite recursion
defines the decidable domain of function H.

H is a function that correctly maps every element of its domain to {0,1}
on the basis of whether or not these elements reach their final state
and halt. On this basis H is a halt decider.

--
Copyright 2021 Pete Olcott

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

Re: Concise refutation of halting problem proofs V21 [ precisely defined sets ]

<3sidnWLq68GPwQT8nZ2dnUU7-VHNnZ2d@giganews.com>

 copy mid

https://www.novabbs.com/computers/article-flat.php?id=7620&group=comp.ai.philosophy#7620

 copy link   Newsgroups: comp.theory comp.ai.philosophy sci.logic sci.math
Followup: comp.theory
Path: i2pn2.org!i2pn.org!paganini.bofh.team!news.dns-netz.com!news.freedyn.net!newsfeed.xs4all.nl!newsfeed9.news.xs4all.nl!tr3.eu1.usenetexpress.com!feeder.usenetexpress.com!tr2.iad1.usenetexpress.com!border1.nntp.dca1.giganews.com!nntp.giganews.com!buffer1.nntp.dca1.giganews.com!news.giganews.com.POSTED!not-for-mail
NNTP-Posting-Date: Sat, 20 Nov 2021 14:35:30 -0600
Date: Sat, 20 Nov 2021 14:35:28 -0600
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:91.0) Gecko/20100101 Thunderbird/91.3.2
Subject: Re: Concise refutation of halting problem proofs V21 [ precisely defined sets ]
Content-Language: en-US
Newsgroups: comp.theory,comp.ai.philosophy,sci.logic,sci.math
References: <OqOdnSk-es33vwr8nZ2dnUU7-VXNnZ2d@giganews.com> <0QFlJ.4132$aF1.1545@fx98.iad> <csednfY4fZugrQr8nZ2dnUU7-YnNnZ2d@giganews.com> <nSMlJ.92781$AJ2.12422@fx33.iad> <W96dnV1_X_P4JQr8nZ2dnUU7-QPNnZ2d@giganews.com> <sn8el5$a6k$1@dont-email.me> <MoGdna8BU9xUSQr8nZ2dnUU7-QvNnZ2d@giganews.com> <sn8l2e$sgf$1@dont-email.me> <6cydnTBU7YNYQgr8nZ2dnUU7-evNnZ2d@giganews.com> <sn8ntm$j1d$1@dont-email.me> <pLudnSyOj6cnegr8nZ2dnUU7-UPNnZ2d@giganews.com> <sn8qhq$7jn$1@dont-email.me> <wd2dnW1XgcfhZwr8nZ2dnUU7-VnNnZ2d@giganews.com> <sn8vv7$fqo$1@dont-email.me> <sn90hk$k4m$1@dont-email.me> <sn93ja$b5a$1@dont-email.me> <LbqdnVNler6IvwX8nZ2dnUU7-bHNnZ2d@giganews.com> <sn9c8i$522$1@dont-email.me> <fsKdneznstvwowX8nZ2dnUU7-XnNnZ2d@giganews.com> <sna68l$89c$1@dont-email.me> <KPmdnbIicsClqQT8nZ2dnUU7-cXNnZ2d@giganews.com> <snbk9q$s3k$1@dont-email.me>
From: NoO...@NoWhere.com (olcott)
Followup-To: comp.theory
In-Reply-To: <snbk9q$s3k$1@dont-email.me>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Message-ID: <3sidnWLq68GPwQT8nZ2dnUU7-VHNnZ2d@giganews.com>
Lines: 178
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-pt6YC9sZZ+l3/K0gQLTHIXmk6cq0anyXYpTNyC8d6ZTnZhueCiYp3AHSkQSi7a2Fu5kBccpFexUUYCw!EjI4wmBV0gSaqYiLYK16cqNChD3FCamTqumKaqhVx43FoDoU93D1dXTM+YFlzZDohJVy/PAEbyZ4!oQ==
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: 9544
 by: olcott - Sat, 20 Nov 2021 20:35 UTC

On 11/20/2021 2:03 PM, André G. Isaak wrote:
> On 2021-11-20 10:45, olcott wrote:
>> On 11/20/2021 12:57 AM, André G. Isaak wrote:
>>> On 2021-11-19 17:16, olcott wrote:
>>>> On 11/19/2021 5:33 PM, André G. Isaak wrote:
>>>>> On 2021-11-19 15:15, olcott wrote:
>>>>>> On 11/19/2021 3:05 PM, André G. Isaak wrote:
>>>>>>> On 2021-11-19 13:13, olcott wrote:
>>>>>>>> On 11/19/2021 2:03 PM, André G. Isaak wrote:
>>>>>>>>> On 2021-11-19 12:26, olcott wrote:
>>>>>>>>>> On 11/19/2021 12:31 PM, André G. Isaak wrote:
>>>>>>>>>>> On 2021-11-19 11:06, olcott wrote:
>>>>>>>>>>>> On 11/19/2021 11:46 AM, André G. Isaak wrote:
>>>>>>>>>>>>> On 2021-11-19 10:32, olcott wrote:
>>>>>>>>>>>
>>>>>>>>>>>>>> The input to (H,P) never halts P(P) halts.
>>>>>>>>>>>>>> Here are the divergent execution sequences at the C level:
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> int main(){ H(P,P); }
>>>>>>>>>>>>>> (1) main()
>>>>>>>>>>>>>> (2) calls H(P,P) that simulates the input to H(P,P)
>>>>>>>>>>>>>> (3) that calls H(P,P) which aborts its simulation of P(P)
>>>>>>>>>>>>>> and returns to
>>>>>>>>>>>>>> (4) main().
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> int main(){ P(P); }
>>>>>>>>>>>>>> (a) main() calls P(P) that
>>>>>>>>>>>>>> (b) calls H(P,P) that simulates the input to H(P,P)
>>>>>>>>>>>>>> (c) that calls H(P,P) which aborts its simulation of P(P)
>>>>>>>>>>>>>> and returns to
>>>>>>>>>>>>>> (d) P(P) that returns to main()
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> (1) diverges from (a) causing (4) to diverge from (d)
>>>>>>>>>>>>>
>>>>>>>>>>>>> And a halt decider is concerned only with the SECOND case,
>>>>>>>>>>>>> not the first.
>>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> The halt decider is concerned with the execution trace of a
>>>>>>>>>>>> sequence of instructions other than the actual execution
>>>>>>>>>>>> trace that is specified by actually executing or simulating
>>>>>>>>>>>> its actual input?
>>>>>>>>>>>
>>>>>>>>>>> Your question makes no sense.
>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> It is proven that the execution trace of P(P) and the
>>>>>>>>>> execution trace of the input to H(P,P) are not the same and
>>>>>>>>>> that this difference results in different behavior.
>>>>>>>>>
>>>>>>>>> And the halting problem, BY DEFINITION, is concerned only with
>>>>>>>>> the former. The latter is not of interest to anyone.
>>>>>>>>>
>>>>>>>>
>>>>>>>> It may seem that way until you realize that any other case would
>>>>>>>> not be reporting on the actual behavior of the actual sequence
>>>>>>>> of instructions specified by the actual execution trace of the
>>>>>>>> actual simulation or execution of its actual input.
>>>>>>>
>>>>>>> The definition is what it is. A halt reporter reports on the
>>>>>>> behaviour of the computation described by its input when that
>>>>>>> computation is run as an independent computation; not when it is
>>>>>>> wrapped inside your H.
>>>>>>>
>>>>>>> Just because you don't like the definition doesn't mean you can
>>>>>>> change it.
>>>>>>
>>>>>> given the description of a Turing machine M and an input w, does M,
>>>>>> when started in the initial configuration q0 w, perform a
>>>>>> computation that eventually halts? (Linz:1990:317)
>>>>>>
>>>>>> In other words: Does UTM(M, w) halt?
>>>>>
>>>>> That definition makes no mention of UTMs, and he carefully
>>>>> distinguishes between the description of M (which he elsewhere
>>>>> notates as w_M).
>>>>>
>>>>> But yes, UTM(w_M, w) will halt if and only if M(w) halts.
>>>>>
>>>>
>>>> Because the behavior of the UTM simulation of the machine
>>>> description of TM X on input Y is defined to precisely correspond to
>>>> the direct execution of TM X on input Y we can also always rely on
>>>> the following:
>>>>
>>>> If UTM U is adapted to become a halt decider H for a subset of
>>>> inputs Z such that it aborts the simulation of its input only when
>>>> the behavior of the pure simulation of this input conclusively
>>>> proves that this input would never reach its final state, then H can
>>>> abort the simulation of every element of Z and correctly report that
>>>> its input does not halt.
>>>
>>> The fact that UTM(M, w) and M(w) have the same halting status has no
>>> bearing on the definition of a halt decider and provides no
>>> justification for the above.
>>>
>>> The input to UTM(M, w) doesn't have a halting status anymore than the
>>> input to H does. Only actual computations have a halting status. So
>>> you can ask about whether UTM(M, w) halts, or about whether the
>>> computation described by its input halts, but not about whether the
>>> input halts.
>>
>>
>>
>>> H(P, P) may or may not reach a final state. P(P) may or may not reach
>>> a final state. It is meaningless, though, to talk about the input to
>>> H(P, P) reaching a final state.
>>>
>>> André
>>>
>>>
>>
>> Not when the [PSR set] if the basis for this claim:
>>
>> Computation that halts
>> a computation is said to halt whenever it enters a final state.
>> (Linz:1990:234)
>>
>> PSR set: Combinations of H/P having pathological self-reference
>> For every possible H of H(P,P) invoked from main() where P(P) calls
>> this same H(P,P) and H simulates or executes its input and aborts or
>> does not abort its input P never reaches its last instruction.
>>
>> PSR subset: Because we know that the input to H(P,P) never halts for
>> the whole PSR set and a subset of these H/P combinations aborts the
>> execution or simulation of its input then we know that for this entire
>> subset the input to H(P,P) never halts and H(P,P) halts.
>>
>> When int main(void) { P(P); } is invoked on H/P elements of the above
>> PSR subset, then we have a cases where the input to H(P,P) never halts
>> and P(P) halts.
>>
>> The above cases conclusively prove that when the input to H(P,P) never
>> halts and the same P(P) does halt that this does not form any
>> contradiction.
>
> Inputs neither halt nor don't halt. Your 'PSR set' included. Only
> Computions halt or don't halt.
>

Inputs specify a sequence of configurations that either reach a final
state or not.

> And, as I said, the definition of a Halt Decider is already defined.

Halt decider H maps elements of its domain specifying sequences of
configurations to {0,1}. Its decision basis is whether or not the
specified sequence of configurations ever reaches a final state.

> H(P, P), if it is a halt decider, must report whether P(P) called
> directly from main halts or not, so your meaningless claim that 'the

An actual mathematical function H can only map elements of its domain to
elements of its codomain.


Click here to read the complete article
Re: Concise refutation of halting problem proofs V21 [ precisely defined sets ]

<VM-dnWN8ofpTCgT8nZ2dnUU7-S_NnZ2d@giganews.com>

 copy mid

https://www.novabbs.com/computers/article-flat.php?id=7625&group=comp.ai.philosophy#7625

 copy link   Newsgroups: comp.theory comp.ai.philosophy sci.logic sci.math
Followup: comp.theory
Path: i2pn2.org!i2pn.org!weretis.net!feeder6.news.weretis.net!news.misty.com!border2.nntp.dca1.giganews.com!nntp.giganews.com!buffer2.nntp.dca1.giganews.com!news.giganews.com.POSTED!not-for-mail
NNTP-Posting-Date: Sat, 20 Nov 2021 18:50:22 -0600
Date: Sat, 20 Nov 2021 18:50:20 -0600
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:91.0) Gecko/20100101
Thunderbird/91.3.2
Subject: Re: Concise refutation of halting problem proofs V21 [ precisely
defined sets ]
Content-Language: en-US
Newsgroups: comp.theory,comp.ai.philosophy,sci.logic,sci.math
References: <OqOdnSk-es33vwr8nZ2dnUU7-VXNnZ2d@giganews.com>
<0QFlJ.4132$aF1.1545@fx98.iad>
<csednfY4fZugrQr8nZ2dnUU7-YnNnZ2d@giganews.com>
<nSMlJ.92781$AJ2.12422@fx33.iad>
<W96dnV1_X_P4JQr8nZ2dnUU7-QPNnZ2d@giganews.com> <sn8el5$a6k$1@dont-email.me>
<MoGdna8BU9xUSQr8nZ2dnUU7-QvNnZ2d@giganews.com> <sn8l2e$sgf$1@dont-email.me>
<6cydnTBU7YNYQgr8nZ2dnUU7-evNnZ2d@giganews.com> <sn8ntm$j1d$1@dont-email.me>
<pLudnSyOj6cnegr8nZ2dnUU7-UPNnZ2d@giganews.com> <sn8qhq$7jn$1@dont-email.me>
<wd2dnW1XgcfhZwr8nZ2dnUU7-VnNnZ2d@giganews.com> <sn8vv7$fqo$1@dont-email.me>
<sn90hk$k4m$1@dont-email.me> <sn93ja$b5a$1@dont-email.me>
<LbqdnVNler6IvwX8nZ2dnUU7-bHNnZ2d@giganews.com> <sn9c8i$522$1@dont-email.me>
<fsKdneznstvwowX8nZ2dnUU7-XnNnZ2d@giganews.com> <sna68l$89c$1@dont-email.me>
<KPmdnbIicsClqQT8nZ2dnUU7-cXNnZ2d@giganews.com> <snbk9q$s3k$1@dont-email.me>
<3sidnWLq68GPwQT8nZ2dnUU7-VHNnZ2d@giganews.com> <snc4pv$dfv$1@dont-email.me>
Followup-To: comp.theory
From: NoO...@NoWhere.com (olcott)
In-Reply-To: <snc4pv$dfv$1@dont-email.me>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Message-ID: <VM-dnWN8ofpTCgT8nZ2dnUU7-S_NnZ2d@giganews.com>
Lines: 188
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-Lv7Wcxbv/tL5aelsPQfVQRsacAZvPW1f2tifd4WZDOMb8pFZFAkJKbJpQq71CsoDbwjlLvOFCS7Iysg!XWa6GDHseS12NbMPHExWnMs+6qrBO0pSiJH6CnDVjSZA5Mlud3BLfdxGeVkzHO13ylMaAvJTwc/E!ZA==
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: 10424
 by: olcott - Sun, 21 Nov 2021 00:50 UTC

On 11/20/2021 6:44 PM, André G. Isaak wrote:
> On 2021-11-20 13:35, olcott wrote:
>> On 11/20/2021 2:03 PM, André G. Isaak wrote:
>>> On 2021-11-20 10:45, olcott wrote:
>>>> On 11/20/2021 12:57 AM, André G. Isaak wrote:
>>>>> On 2021-11-19 17:16, olcott wrote:
>>>>>> On 11/19/2021 5:33 PM, André G. Isaak wrote:
>>>>>>> On 2021-11-19 15:15, olcott wrote:
>>>>>>>> On 11/19/2021 3:05 PM, André G. Isaak wrote:
>>>>>>>>> On 2021-11-19 13:13, olcott wrote:
>>>>>>>>>> On 11/19/2021 2:03 PM, André G. Isaak wrote:
>>>>>>>>>>> On 2021-11-19 12:26, olcott wrote:
>>>>>>>>>>>> On 11/19/2021 12:31 PM, André G. Isaak wrote:
>>>>>>>>>>>>> On 2021-11-19 11:06, olcott wrote:
>>>>>>>>>>>>>> On 11/19/2021 11:46 AM, André G. Isaak wrote:
>>>>>>>>>>>>>>> On 2021-11-19 10:32, olcott wrote:
>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> The input to (H,P) never halts P(P) halts.
>>>>>>>>>>>>>>>> Here are the divergent execution sequences at the C level:
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> int main(){ H(P,P); }
>>>>>>>>>>>>>>>> (1) main()
>>>>>>>>>>>>>>>> (2) calls H(P,P) that simulates the input to H(P,P)
>>>>>>>>>>>>>>>> (3) that calls H(P,P) which aborts its simulation of
>>>>>>>>>>>>>>>> P(P) and returns to
>>>>>>>>>>>>>>>> (4) main().
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> int main(){ P(P); }
>>>>>>>>>>>>>>>> (a) main() calls P(P) that
>>>>>>>>>>>>>>>> (b) calls H(P,P) that simulates the input to H(P,P)
>>>>>>>>>>>>>>>> (c) that calls H(P,P) which aborts its simulation of
>>>>>>>>>>>>>>>> P(P) and returns to
>>>>>>>>>>>>>>>> (d) P(P) that returns to main()
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> (1) diverges from (a) causing (4) to diverge from (d)
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> And a halt decider is concerned only with the SECOND
>>>>>>>>>>>>>>> case, not the first.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> The halt decider is concerned with the execution trace of
>>>>>>>>>>>>>> a sequence of instructions other than the actual execution
>>>>>>>>>>>>>> trace that is specified by actually executing or
>>>>>>>>>>>>>> simulating its actual input?
>>>>>>>>>>>>>
>>>>>>>>>>>>> Your question makes no sense.
>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> It is proven that the execution trace of P(P) and the
>>>>>>>>>>>> execution trace of the input to H(P,P) are not the same and
>>>>>>>>>>>> that this difference results in different behavior.
>>>>>>>>>>>
>>>>>>>>>>> And the halting problem, BY DEFINITION, is concerned only
>>>>>>>>>>> with the former. The latter is not of interest to anyone.
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> It may seem that way until you realize that any other case
>>>>>>>>>> would not be reporting on the actual behavior of the actual
>>>>>>>>>> sequence of instructions specified by the actual execution
>>>>>>>>>> trace of the actual simulation or execution of its actual input.
>>>>>>>>>
>>>>>>>>> The definition is what it is. A halt reporter reports on the
>>>>>>>>> behaviour of the computation described by its input when that
>>>>>>>>> computation is run as an independent computation; not when it
>>>>>>>>> is wrapped inside your H.
>>>>>>>>>
>>>>>>>>> Just because you don't like the definition doesn't mean you can
>>>>>>>>> change it.
>>>>>>>>
>>>>>>>> given the description of a Turing machine M and an input w, does M,
>>>>>>>> when started in the initial configuration q0 w, perform a
>>>>>>>> computation that eventually halts? (Linz:1990:317)
>>>>>>>>
>>>>>>>> In other words: Does UTM(M, w) halt?
>>>>>>>
>>>>>>> That definition makes no mention of UTMs, and he carefully
>>>>>>> distinguishes between the description of M (which he elsewhere
>>>>>>> notates as w_M).
>>>>>>>
>>>>>>> But yes, UTM(w_M, w) will halt if and only if M(w) halts.
>>>>>>>
>>>>>>
>>>>>> Because the behavior of the UTM simulation of the machine
>>>>>> description of TM X on input Y is defined to precisely correspond
>>>>>> to the direct execution of TM X on input Y we can also always rely
>>>>>> on the following:
>>>>>>
>>>>>> If UTM U is adapted to become a halt decider H for a subset of
>>>>>> inputs Z such that it aborts the simulation of its input only when
>>>>>> the behavior of the pure simulation of this input conclusively
>>>>>> proves that this input would never reach its final state, then H
>>>>>> can abort the simulation of every element of Z and correctly
>>>>>> report that its input does not halt.
>>>>>
>>>>> The fact that UTM(M, w) and M(w) have the same halting status has
>>>>> no bearing on the definition of a halt decider and provides no
>>>>> justification for the above.
>>>>>
>>>>> The input to UTM(M, w) doesn't have a halting status anymore than
>>>>> the input to H does. Only actual computations have a halting
>>>>> status. So you can ask about whether UTM(M, w) halts, or about
>>>>> whether the computation described by its input halts, but not about
>>>>> whether the input halts.
>>>>
>>>>
>>>>
>>>>> H(P, P) may or may not reach a final state. P(P) may or may not
>>>>> reach a final state. It is meaningless, though, to talk about the
>>>>> input to H(P, P) reaching a final state.
>>>>>
>>>>> André
>>>>>
>>>>>
>>>>
>>>> Not when the [PSR set] if the basis for this claim:
>>>>
>>>> Computation that halts
>>>> a computation is said to halt whenever it enters a final state.
>>>> (Linz:1990:234)
>>>>
>>>> PSR set: Combinations of H/P having pathological self-reference
>>>> For every possible H of H(P,P) invoked from main() where P(P) calls
>>>> this same H(P,P) and H simulates or executes its input and aborts or
>>>> does not abort its input P never reaches its last instruction.
>>>>
>>>> PSR subset: Because we know that the input to H(P,P) never halts for
>>>> the whole PSR set and a subset of these H/P combinations aborts the
>>>> execution or simulation of its input then we know that for this
>>>> entire subset the input to H(P,P) never halts and H(P,P) halts.
>>>>
>>>> When int main(void) { P(P); } is invoked on H/P elements of the
>>>> above PSR subset, then we have a cases where the input to H(P,P)
>>>> never halts and P(P) halts.
>>>>
>>>> The above cases conclusively prove that when the input to H(P,P)
>>>> never halts and the same P(P) does halt that this does not form any
>>>> contradiction.
>>>
>>> Inputs neither halt nor don't halt. Your 'PSR set' included. Only
>>> Computions halt or don't halt.
>>>
>>
>> Inputs specify a sequence of configurations that either reach a final
>> state or not.
>>
>>> And, as I said, the definition of a Halt Decider is already defined.
>>
>> Halt decider H maps elements of its domain specifying sequences of
>> configurations to {0,1}. Its decision basis is whether or not the
>> specified sequence of configurations ever reaches a final state.
>>
>>> H(P, P), if it is a halt decider, must report whether P(P) called
>>> directly from main halts or not, so your meaningless claim that 'the
>>
>> An actual mathematical function H can only map elements of its domain
>> to elements of its codomain.
>>
>> In mathematics, a function from a set X to a set Y is an assignment of
>> an element of Y to each element of X. The set X is called the domain
>> of the function and the set Y is called the codomain of the function.
>> https://en.wikipedia.org/wiki/Function_(mathematics)
>>
>> Halt decider H can only map elements of its domain specifying
>> sequences of configurations to {0,1}.
>
> The domain of a halt decider is the set of computations (expressed by
> suitable representations)
>
> It maps that domain to 1 for exactly that set of computations which halt
> when run as independent computations and to 0 otherwise.
>
> Since P(P) halts, H(P, P) must map that input to 1.
>
> André
>


Click here to read the complete article
Re: Concise refutation of halting problem proofs V21 [ precisely defined sets ]

<ot2dnXPCwob8MQT8nZ2dnUU7-bnNnZ2d@giganews.com>

 copy mid

https://www.novabbs.com/computers/article-flat.php?id=7627&group=comp.ai.philosophy#7627

 copy link   Newsgroups: comp.theory comp.ai.philosophy sci.logic sci.math
Followup: comp.theory
Path: i2pn2.org!i2pn.org!weretis.net!feeder6.news.weretis.net!news.misty.com!border2.nntp.dca1.giganews.com!nntp.giganews.com!buffer2.nntp.dca1.giganews.com!buffer1.nntp.dca1.giganews.com!news.giganews.com.POSTED!not-for-mail
NNTP-Posting-Date: Sat, 20 Nov 2021 20:18:09 -0600
Date: Sat, 20 Nov 2021 20:18:08 -0600
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:91.0) Gecko/20100101
Thunderbird/91.3.2
Subject: Re: Concise refutation of halting problem proofs V21 [ precisely
defined sets ]
Content-Language: en-US
Newsgroups: comp.theory,comp.ai.philosophy,sci.logic,sci.math
References: <OqOdnSk-es33vwr8nZ2dnUU7-VXNnZ2d@giganews.com>
<sn8el5$a6k$1@dont-email.me> <MoGdna8BU9xUSQr8nZ2dnUU7-QvNnZ2d@giganews.com>
<sn8l2e$sgf$1@dont-email.me> <6cydnTBU7YNYQgr8nZ2dnUU7-evNnZ2d@giganews.com>
<sn8ntm$j1d$1@dont-email.me> <pLudnSyOj6cnegr8nZ2dnUU7-UPNnZ2d@giganews.com>
<sn8qhq$7jn$1@dont-email.me> <wd2dnW1XgcfhZwr8nZ2dnUU7-VnNnZ2d@giganews.com>
<sn8vv7$fqo$1@dont-email.me> <sn90hk$k4m$1@dont-email.me>
<sn93ja$b5a$1@dont-email.me> <LbqdnVNler6IvwX8nZ2dnUU7-bHNnZ2d@giganews.com>
<sn9c8i$522$1@dont-email.me> <fsKdneznstvwowX8nZ2dnUU7-XnNnZ2d@giganews.com>
<sna68l$89c$1@dont-email.me> <KPmdnbIicsClqQT8nZ2dnUU7-cXNnZ2d@giganews.com>
<snbk9q$s3k$1@dont-email.me> <3sidnWLq68GPwQT8nZ2dnUU7-VHNnZ2d@giganews.com>
<snc4pv$dfv$1@dont-email.me> <VM-dnWN8ofpTCgT8nZ2dnUU7-S_NnZ2d@giganews.com>
<snc5fl$hlj$1@dont-email.me> <Zsudne5u4LizBwT8nZ2dnUU7-XfNnZ2d@giganews.com>
<snc6el$nga$1@dont-email.me> <snc7o6$tme$1@dont-email.me>
<snc945$49e$1@dont-email.me>
From: NoO...@NoWhere.com (olcott)
Followup-To: comp.theory
In-Reply-To: <snc945$49e$1@dont-email.me>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Message-ID: <ot2dnXPCwob8MQT8nZ2dnUU7-bnNnZ2d@giganews.com>
Lines: 70
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-1ge1QxbiR5gfh/3JamcfgHgr1FuO2A5D5pk68/r0HJwDHWD94SGfuJPshuGixVglgvX8TwSJOf9ytub!VDayUfscR4BVwTLnItT84jdgmX30HbexIgwlLH7pjaqE5/fT9pZ8ZmF5uoLHgW15DpqiC15ARXD4!/w==
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: 4805
 by: olcott - Sun, 21 Nov 2021 02:18 UTC

On 11/20/2021 7:58 PM, André G. Isaak wrote:
> On 2021-11-20 18:35, olcott wrote:
>> On 11/20/2021 7:12 PM, André G. Isaak wrote:
>>> On 2021-11-20 18:00, olcott wrote:
>>>
>>>> How do you tell H that it is not allowed to determine the halt
>>>> status of its input on the basis of the actual behavior of this
>>>> actual input?
>>>
>>> The 'input' is a description of an independent computation.
>>> descriptions don't *have* behaviour. It is required to base its
>>> decision on the actual behaviour of the independent computation
>>> described by its input.
>>>
>>> This is really not that difficult.
>>>
>>
>> Inputs specify sequences of configurations.
>
> The input to a halt decider is a description of a computation, i.e. a
> description of a TM and an input string. If you want to call that a
> 'sequence of configurations', fine, but what's wrong with the standard
> terminology?
>
>>> To put this bluntly: Every single computer scientist on earth agrees
>>> on the definition of 'halt decider'. So does virtually every
>>> competent undergraduate who has taken a course on computation. That's
>>> because the definition is precisely defined with absolutely no
>>> ambiguity regarding how it is to be interpreted.
>>>
>>> To meet that definition, your H(P, P) *must* report on whether P(P)
>>> halts when called directly from main.
>>
>> Define the domain of the mathematical function H that says that.
>
> The domain of H is the set of pairs consisting of the description of a
> TM and an input string. I already answered that in another post.
>

H maps elements of its domain that specify sequences of configurations
to {0,1} on the basis of whether or not this element reaches its final
state.

Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn

> The domain of H is the set of pairs consisting of
> the description of a TM and an input string.

The sequence of configurations specified by ⟨Ĥ⟩ ⟨Ĥ⟩ never reaches its
final state.

> A TM *by definition* is an independent, self-contained entity, so there
> is no need to specify this. Translating that to C, it means an
> independent program (or the sole call inside main), not a function
> called from within some other program.
>
> The fact that you don't grasp this just reinforces the fact that you
> have no idea what a computation is.
>
> André
>

--
Copyright 2021 Pete Olcott

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

Re: Concise refutation of halting problem proofs V21 [ André is incorrect ]

<psidnbot64uqIAT8nZ2dnUU7-aHNnZ2d@giganews.com>

 copy mid

https://www.novabbs.com/computers/article-flat.php?id=7628&group=comp.ai.philosophy#7628

 copy link   Newsgroups: comp.theory comp.ai.philosophy sci.logic sci.math
Followup: comp.theory
Path: i2pn2.org!i2pn.org!weretis.net!feeder6.news.weretis.net!news.misty.com!border2.nntp.dca1.giganews.com!nntp.giganews.com!buffer2.nntp.dca1.giganews.com!buffer1.nntp.dca1.giganews.com!news.giganews.com.POSTED!not-for-mail
NNTP-Posting-Date: Sat, 20 Nov 2021 21:29:59 -0600
Date: Sat, 20 Nov 2021 21:29:57 -0600
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:91.0) Gecko/20100101
Thunderbird/91.3.2
Subject: Re:_Concise_refutation_of_halting_problem_proofs_V21_
[_André_is_incorrect_]
Content-Language: en-US
Newsgroups: comp.theory,comp.ai.philosophy,sci.logic,sci.math
References: <OqOdnSk-es33vwr8nZ2dnUU7-VXNnZ2d@giganews.com>
<sn8el5$a6k$1@dont-email.me> <MoGdna8BU9xUSQr8nZ2dnUU7-QvNnZ2d@giganews.com>
<sn8l2e$sgf$1@dont-email.me> <6cydnTBU7YNYQgr8nZ2dnUU7-evNnZ2d@giganews.com>
<sn8ntm$j1d$1@dont-email.me> <pLudnSyOj6cnegr8nZ2dnUU7-UPNnZ2d@giganews.com>
<sn8qhq$7jn$1@dont-email.me> <wd2dnW1XgcfhZwr8nZ2dnUU7-VnNnZ2d@giganews.com>
<sn8vv7$fqo$1@dont-email.me> <sn90hk$k4m$1@dont-email.me>
<sn93ja$b5a$1@dont-email.me> <LbqdnVNler6IvwX8nZ2dnUU7-bHNnZ2d@giganews.com>
<sn9c8i$522$1@dont-email.me> <fsKdneznstvwowX8nZ2dnUU7-XnNnZ2d@giganews.com>
<sna68l$89c$1@dont-email.me> <KPmdnbIicsClqQT8nZ2dnUU7-cXNnZ2d@giganews.com>
<snbk9q$s3k$1@dont-email.me> <3sidnWLq68GPwQT8nZ2dnUU7-VHNnZ2d@giganews.com>
<snc4pv$dfv$1@dont-email.me> <VM-dnWN8ofpTCgT8nZ2dnUU7-S_NnZ2d@giganews.com>
<snc5fl$hlj$1@dont-email.me> <Zsudne5u4LizBwT8nZ2dnUU7-XfNnZ2d@giganews.com>
<snc6el$nga$1@dont-email.me> <snc7o6$tme$1@dont-email.me>
<snc945$49e$1@dont-email.me>
From: NoO...@NoWhere.com (olcott)
Followup-To: comp.theory
In-Reply-To: <snc945$49e$1@dont-email.me>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Message-ID: <psidnbot64uqIAT8nZ2dnUU7-aHNnZ2d@giganews.com>
Lines: 79
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-AREkMI7ap6YvoJHKJq1sUQuM1SUn6W3tZgpOgigXoD7tJR2PxpaZynrr/oRbBsPKYfXJENx/SU4KuWO!gcHC4AGj37X3UIk9QHbW2BqFwL0yXSMxZ/uRXLrmCVKNi/8vz9xoFIS50n7g+gjT5j5cdvP3DQ8P!9A==
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: 5250
 by: olcott - Sun, 21 Nov 2021 03:29 UTC

On 11/20/2021 7:58 PM, André G. Isaak wrote:
> On 2021-11-20 18:35, olcott wrote:
>> On 11/20/2021 7:12 PM, André G. Isaak wrote:
>>> On 2021-11-20 18:00, olcott wrote:
>>>
>>>> How do you tell H that it is not allowed to determine the halt
>>>> status of its input on the basis of the actual behavior of this
>>>> actual input?
>>>
>>> The 'input' is a description of an independent computation.
>>> descriptions don't *have* behaviour. It is required to base its
>>> decision on the actual behaviour of the independent computation
>>> described by its input.
>>>
>>> This is really not that difficult.
>>>
>>
>> Inputs specify sequences of configurations.
>
> The input to a halt decider is a description of a computation, i.e. a
> description of a TM and an input string. If you want to call that a
> 'sequence of configurations', fine, but what's wrong with the standard
> terminology?
>
>>> To put this bluntly: Every single computer scientist on earth agrees
>>> on the definition of 'halt decider'. So does virtually every
>>> competent undergraduate who has taken a course on computation. That's
>>> because the definition is precisely defined with absolutely no
>>> ambiguity regarding how it is to be interpreted.
>>>
>>> To meet that definition, your H(P, P) *must* report on whether P(P)
>>> halts when called directly from main.
>>
>> Define the domain of the mathematical function H that says that.
>
> The domain of H is the set of pairs consisting of the description of a
> TM and an input string. I already answered that in another post.
>
> A TM *by definition* is an independent, self-contained entity, so there
> is no need to specify this. Translating that to C, it means an
> independent program (or the sole call inside main), not a function
> called from within some other program.
>

Mathematical function H
H maps elements of its domain that specify sequences of configurations
to {0,1} on the basis of whether or not this element reaches its final
state.

That view is incorrect. As long as H is a pure function then the
sequence of configurations specified by its input is its correct halt
deciding basis.

In computer programming, a pure function is a function that has the
following properties:

The function return values are identical for identical arguments (no
variation with local static variables, non-local variables, mutable
reference arguments or input streams).

The function application has no side effects (no mutation of local
static variables, non-local variables, mutable reference arguments or
input/output streams).

https://en.wikipedia.org/wiki/Pure_function

> The fact that you don't grasp this just reinforces the fact that you
> have no idea what a computation is.
>
> André
>

--
Copyright 2021 Pete Olcott

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

Re: Concise refutation of halting problem proofs V21 [ André is wrong ]

<CZ6dneFC5_xl8Af8nZ2dnUU7-N3NnZ2d@giganews.com>

 copy mid

https://www.novabbs.com/computers/article-flat.php?id=7629&group=comp.ai.philosophy#7629

 copy link   Newsgroups: comp.theory comp.ai.philosophy sci.math sci.logic
Followup: comp.theory
Path: i2pn2.org!i2pn.org!weretis.net!feeder6.news.weretis.net!news.misty.com!border2.nntp.dca1.giganews.com!nntp.giganews.com!buffer2.nntp.dca1.giganews.com!news.giganews.com.POSTED!not-for-mail
NNTP-Posting-Date: Sun, 21 Nov 2021 10:04:08 -0600
Date: Sun, 21 Nov 2021 10:04:06 -0600
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:91.0) Gecko/20100101
Thunderbird/91.3.2
Subject: Re:_Concise_refutation_of_halting_problem_proofs_V21_
[_André_is_wrong_]
Content-Language: en-US
Newsgroups: comp.theory,comp.ai.philosophy,sci.math,sci.logic
References: <OqOdnSk-es33vwr8nZ2dnUU7-VXNnZ2d@giganews.com>
<sn8qhq$7jn$1@dont-email.me> <wd2dnW1XgcfhZwr8nZ2dnUU7-VnNnZ2d@giganews.com>
<sn8vv7$fqo$1@dont-email.me> <sn90hk$k4m$1@dont-email.me>
<sn93ja$b5a$1@dont-email.me> <LbqdnVNler6IvwX8nZ2dnUU7-bHNnZ2d@giganews.com>
<sn9c8i$522$1@dont-email.me> <fsKdneznstvwowX8nZ2dnUU7-XnNnZ2d@giganews.com>
<sna68l$89c$1@dont-email.me> <KPmdnbIicsClqQT8nZ2dnUU7-cXNnZ2d@giganews.com>
<snbk9q$s3k$1@dont-email.me> <3sidnWLq68GPwQT8nZ2dnUU7-VHNnZ2d@giganews.com>
<snc4pv$dfv$1@dont-email.me> <VM-dnWN8ofpTCgT8nZ2dnUU7-S_NnZ2d@giganews.com>
<snc5fl$hlj$1@dont-email.me> <Zsudne5u4LizBwT8nZ2dnUU7-XfNnZ2d@giganews.com>
<snc6el$nga$1@dont-email.me> <snc7o6$tme$1@dont-email.me>
<snc945$49e$1@dont-email.me> <ot2dnXPCwob8MQT8nZ2dnUU7-bnNnZ2d@giganews.com>
<sncbb8$huh$1@dont-email.me> <gNWdnS5SfcK6JwT8nZ2dnUU7-VPNnZ2d@giganews.com>
<sncg69$8au$1@dont-email.me> <37ydnbV-mq1mVQT8nZ2dnUU7-S3NnZ2d@giganews.com>
<sndlot$qau$1@dont-email.me>
From: NoO...@NoWhere.com (olcott)
Followup-To: comp.theory
In-Reply-To: <sndlot$qau$1@dont-email.me>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Message-ID: <CZ6dneFC5_xl8Af8nZ2dnUU7-N3NnZ2d@giganews.com>
Lines: 135
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-J1dwx7WTK/SnnWjXdmlj/Rx7vkRk+OUHanIHRYL+4knDkCZzNvFx3AaDQk8yNqvnikUUd/GIQBUiSt5!zENK/FZ7ZJ5uEtBXYAUT7ccy7oSIB1E9uvsEkBQRIXjGSVVOY+tMnUEKuH2w1Y/UN7sE48hIfZ6y!0Q==
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: 7413
 by: olcott - Sun, 21 Nov 2021 16:04 UTC

On 11/21/2021 8:40 AM, André G. Isaak wrote:
> On 2021-11-20 21:20, olcott wrote:
>> On 11/20/2021 9:59 PM, André G. Isaak wrote:
>>> On 2021-11-20 20:16, olcott wrote:
>>>> On 11/20/2021 8:36 PM, André G. Isaak wrote:
>>>
>>>>> The "sequence of configurations specified by ⟨Ĥ⟩ ⟨Ĥ⟩" is simply the
>>>>> computation Ĥ(Ĥ). The INDEPENDENT computation Ĥ(Ĥ). And that
>>>>> computation halts.
>>>>
>>>> There is a one way dependency relationship of the behavior of P on
>>>> the return value of H that cannot simply be assumed away.
>>>>
>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>>>
>>>> There is a one way dependency relationship of the behavior of Ĥ on
>>>> the state transition of Ĥ.qx that cannot simply be assumed away.
>>>
>>> No one is assuming anything away. That dependency is precisely *why*
>>> H can never give the correct answer, which is the entire point of the
>>> Linz proof.
>>>
>>
>> It is a fallacy of equivocation error to assume that this dependency
>> does not cause different behavior between these two different instances.
>
> There is no equivocation here (do you even understand what that word
> means?)
>
> Yes, in your implementation the two instances act differently. But the
> halting problem is very clear about *which* instance your decider needs
> to answer about. It needs to describe the behaviour of P(P), not of the
> simulation inside your H.
>

That is not a proper mathematical function.
H maps specified sequences of configurations in its domain to {0,1}

int H(ptr x, ptr y)
H maps sequences of configurations specified by (x,y) to {0,1}

TM H
H maps specified sequences of configurations on its tape to {0,1}

>>>> This primary path of rebuttal is now closed:
>>>> I have concretely proven that the input to H(P,P) never halts and
>>>> the exact same P(P) halts for the PSR subset and the Decidable_PSR
>>>> subset in both cases H is a pure function.
>>>
>>> H(P, P) must answer about P(P) because that's what a halt decider does.
>>
>> No you are wrong.
>
> That's the DEFINITION of what a halt decider does.
>

That is your misinterpretation
Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞

Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ is not being asked about sequences of configurations of its
itself or the sequences of configurations of the computation that it is
contained in.

Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ is being asked about the sequences of configurations
specified on its tape.

>> Mathematical function  H
>> H maps elements of its domain that specify sequences of configurations
>> to {0,1} on the basis of whether or not this element reaches its final
>> state.
>
> The elements of the domain of H are computations. P(P) is a computation.
> It halts. Therefore it maps to 1.
>

That is incorrect some of the elements of the domain of H specify
computations some do not. In every case every element of the domain of H
specifies a sequence of configurations.

computation
The sequence of configurations leading to a halt state will be called a
computation. (Linz:1990:238)

>> This same thing applies to pure function int H(ptr x, ptr y)
>> it maps sequences of configurations specified by (x, y) to {0,1}.
>
> I already pointed this out in another post (which you ignored) but you
> seem to be confused about what 'domain' means (assuming I am
> understanding what it is that you are attempting to convey here).
>
> The fact that P(P) is outside the scope of H does not imply that it is
> outside the domain of H. Scope and domain are different things.
>
> André
>

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

Any very competent software engineer can verify all of the following
sets and subsets (no knowledge of computer science is needed):

PSR set: Combinations of H/P having pathological self-reference
Every H of H(P,P) invoked from main() where P(P) calls this same H(P,P)
and H simulates or executes its input and aborts or does not abort its
input P never reaches its last instruction.

PSR subset: Because we know that the input to H(P,P) never halts for the
whole PSR set and a subset of these H/P combinations aborts the
execution or simulation of its input then we know that for this entire
PSR subset the input to H(P,P) never halts and H(P,P) halts.

When int main(void) { P(P); } is invoked on H/P elements of the above
PSR subset, then we have cases where the input to H(P,P) never halts and
P(P) halts. The fact that the input to H(P,P) never halts is not
contradicted by the fact that P(P) halts in this subset.

Decidable_PSR subset: The subset of the PSR subset where H returns 0 on
the basis that H correctly detects that P specifies infinite recursion
defines the decidable domain of function H.

The domain of H is the Decidable_PSR subset of combinations of H/P.

--
Copyright 2021 Pete Olcott

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

Re: Concise refutation of halting problem proofs V21 [ André is wrong ]

<8Ledna3N87zUawf8nZ2dnUU7-LfNnZ2d@giganews.com>

 copy mid

https://www.novabbs.com/computers/article-flat.php?id=7633&group=comp.ai.philosophy#7633

 copy link   Newsgroups: comp.theory comp.ai.philosophy sci.logic sci.math
Followup: comp.theory
Path: i2pn2.org!i2pn.org!weretis.net!feeder6.news.weretis.net!news.misty.com!border2.nntp.dca1.giganews.com!nntp.giganews.com!buffer2.nntp.dca1.giganews.com!buffer1.nntp.dca1.giganews.com!news.giganews.com.POSTED!not-for-mail
NNTP-Posting-Date: Sun, 21 Nov 2021 19:45:45 -0600
Date: Sun, 21 Nov 2021 19:45:43 -0600
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:91.0) Gecko/20100101
Thunderbird/91.3.2
Subject: Re:_Concise_refutation_of_halting_problem_proofs_V21_
[_André_is_wrong_]
Content-Language: en-US
Newsgroups: comp.theory,comp.ai.philosophy,sci.logic,sci.math
References: <OqOdnSk-es33vwr8nZ2dnUU7-VXNnZ2d@giganews.com>
<sn9c8i$522$1@dont-email.me> <fsKdneznstvwowX8nZ2dnUU7-XnNnZ2d@giganews.com>
<sna68l$89c$1@dont-email.me> <KPmdnbIicsClqQT8nZ2dnUU7-cXNnZ2d@giganews.com>
<snbk9q$s3k$1@dont-email.me> <3sidnWLq68GPwQT8nZ2dnUU7-VHNnZ2d@giganews.com>
<snc4pv$dfv$1@dont-email.me> <VM-dnWN8ofpTCgT8nZ2dnUU7-S_NnZ2d@giganews.com>
<snc5fl$hlj$1@dont-email.me> <Zsudne5u4LizBwT8nZ2dnUU7-XfNnZ2d@giganews.com>
<snc6el$nga$1@dont-email.me> <snc7o6$tme$1@dont-email.me>
<snc945$49e$1@dont-email.me> <ot2dnXPCwob8MQT8nZ2dnUU7-bnNnZ2d@giganews.com>
<sncbb8$huh$1@dont-email.me> <gNWdnS5SfcK6JwT8nZ2dnUU7-VPNnZ2d@giganews.com>
<sncg69$8au$1@dont-email.me> <37ydnbV-mq1mVQT8nZ2dnUU7-S3NnZ2d@giganews.com>
<sndlot$qau$1@dont-email.me> <CZ6dneFC5_xl8Af8nZ2dnUU7-N3NnZ2d@giganews.com>
<sndu4l$lp6$1@dont-email.me> <bfCdndij-oL7NQf8nZ2dnUU7-f_NnZ2d@giganews.com>
<sneb1c$gf5$1@dont-email.me> <T6adnYv9oJQ_KAf8nZ2dnUU7-ffNnZ2d@giganews.com>
<snelu4$srg$1@dont-email.me>
From: NoO...@NoWhere.com (olcott)
Followup-To: comp.theory
In-Reply-To: <snelu4$srg$1@dont-email.me>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Message-ID: <8Ledna3N87zUawf8nZ2dnUU7-LfNnZ2d@giganews.com>
Lines: 300
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-sPQ611sJaGLrcMkuxKVB/6ptx96EdZty4Uu4ULHtJeM2MChGXYAn2liUb4Kg6X+DlX0wbsoV69WlMi+!nisVH640qMQBkn2mW3eVQyIFU94eV1cCKdQWmz0OlgHid9n+vaxoZ4b1h+cPJ4/d6A76AyhD9sXK!tw==
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: 14211
 by: olcott - Mon, 22 Nov 2021 01:45 UTC

On 11/21/2021 5:49 PM, André G. Isaak wrote:
> On 2021-11-21 14:09, olcott wrote:
>> On 11/21/2021 2:43 PM, André G. Isaak wrote:
>>> On 2021-11-21 13:13, olcott wrote:
>>>> On 11/21/2021 11:03 AM, André G. Isaak wrote:
>>>>> On 2021-11-21 09:04, olcott wrote:
>>>>>> On 11/21/2021 8:40 AM, André G. Isaak wrote:
>>>>>>> On 2021-11-20 21:20, olcott wrote:
>>>>>>>> On 11/20/2021 9:59 PM, André G. Isaak wrote:
>>>>>>>>> On 2021-11-20 20:16, olcott wrote:
>>>>>>>>>> On 11/20/2021 8:36 PM, André G. Isaak wrote:
>>>>>>>>>
>>>>>>>>>>> The "sequence of configurations specified by ⟨Ĥ⟩ ⟨Ĥ⟩" is
>>>>>>>>>>> simply the computation Ĥ(Ĥ). The INDEPENDENT computation
>>>>>>>>>>> Ĥ(Ĥ). And that computation halts.
>>>>>>>>>>
>>>>>>>>>> There is a one way dependency relationship of the behavior of
>>>>>>>>>> P on the return value of H that cannot simply be assumed away.
>>>>>>>>>>
>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>>>>>>>>>
>>>>>>>>>> There is a one way dependency relationship of the behavior of
>>>>>>>>>> Ĥ on the state transition of Ĥ.qx that cannot simply be
>>>>>>>>>> assumed away.
>>>>>>>>>
>>>>>>>>> No one is assuming anything away. That dependency is precisely
>>>>>>>>> *why* H can never give the correct answer, which is the entire
>>>>>>>>> point of the Linz proof.
>>>>>>>>>
>>>>>>>>
>>>>>>>> It is a fallacy of equivocation error to assume that this
>>>>>>>> dependency does not cause different behavior between these two
>>>>>>>> different instances.
>>>>>>>
>>>>>>> There is no equivocation here (do you even understand what that
>>>>>>> word means?)
>>>>>>>
>>>>>>> Yes, in your implementation the two instances act differently.
>>>>>>> But the halting problem is very clear about *which* instance your
>>>>>>> decider needs to answer about. It needs to describe the behaviour
>>>>>>> of P(P), not of the simulation inside your H.
>>>>>>>
>>>>>>
>>>>>> That is not a proper mathematical function.
>>>>>
>>>>> I don't think you're in a position to determine what is or is not a
>>>>> 'proper' mathematical function.
>>>>>
>>>>>> H maps specified sequences of configurations in its domain to {0,1}
>>>>>
>>>>> H maps computations to {0, 1} or it is not a halt decider. P(P) is
>>>>> a computation which halts. H therefore maps this to 1.
>>>>>
>>>>
>>>> If H maps sequences of configurations that specify computations then
>>>> according to the Linz definition of computation
>>>>
>>>> computation
>>>> The sequence of configurations leading to a halt state will be
>>>> called a computation.  (Linz:1990:238)
>>>>
>>>> Every input to H halts thus every H can simply say YES and be correct
>>>
>>> If you read the section of Linz on the halting problem you will note
>>> that Linz also talks about halting and non-halting computations.
>>> While 'computation' is often restricted to algorithms (i.e. things
>>> guaranteed to halt) this is not the case when talking about halt
>>> deciders.
>>>
>>> If it's less confusing for you, simply replace 'computation' with 'TM
>>> description + input string'
>>>
>>>> YOU REALLY NEED TO PAY CLOSER ATTENTION TO THESE DETAILS.
>>>>
>>>>> I have no idea how you are interpreting the expression 'sequence of
>>>>> configurations', but unless it is intended to mean a description of
>>>>> a TM and an input string, you are barking up the wrong tree.
>>>>>
>>>>
>>>> It includes a description of a TM and an input string and several
>>>> other things such as a pair of machine addresses of x86 code and a
>>>> pair of finite strings of x86 code.
>>>>
>>>>>> int H(ptr x, ptr y)
>>>>>> H maps sequences of configurations specified by (x,y) to {0,1}
>>>>>
>>>>> The same things apply here.
>>>>>
>>>>
>>>> The sequence of configurations specified by (x, y) are the basis of
>>>> the decision of H to accept or reject these inputs.
>>>>
>>>> All deciders accept or reject inputs, and have no other decision basis.
>>>>
>>>> computer science decider
>>>> Intuitively, a decider should be a Turing machine that given an
>>>> input, halts and either accepts or rejects, relaying its answer in
>>>> one of many equivalent ways, such as halting at an ACCEPT or REJECT
>>>> state, or leaving its answer on the output tape.
>>>> https://cs.stackexchange.com/questions/84433/what-is-decider
>>>>
>>>>
>>>>
>>>>>> TM H
>>>>>> H maps specified sequences of configurations on its tape to {0,1}
>>>>>>
>>>>>>
>>>>>>>>>> This primary path of rebuttal is now closed:
>>>>>>>>>> I have concretely proven that the input to H(P,P) never halts
>>>>>>>>>> and the exact same P(P) halts for the PSR subset and the
>>>>>>>>>> Decidable_PSR subset in both cases H is a pure function.
>>>>>>>>>
>>>>>>>>> H(P, P) must answer about P(P) because that's what a halt
>>>>>>>>> decider does.
>>>>>>>>
>>>>>>>> No you are wrong.
>>>>>>>
>>>>>>> That's the DEFINITION of what a halt decider does.
>>>>>>>
>>>>>>
>>>>>> That is your misinterpretation
>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>>>>>>
>>>>>> Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ is not being asked about sequences of configurations
>>>>>> of its itself or the sequences of configurations of the
>>>>>> computation that it is contained in.
>>>>>>
>>>>>> Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ is being asked about the sequences of configurations
>>>>>> specified on its tape.
>>>>>
>>>>> The symbols on the tape are a description of the independent
>>>>> computation Ĥ(⟨Ĥ⟩). Why is this so difficult for you to grasp?
>>>>>
>>>>
>>>> This is the crux of the most difficult last step that has prevented
>>>> everyone in the world from coming to the correct conclusion about
>>>> the halting theorem.
>>>>
>>>> There is no way to mathematically specify (to the halt decider) the
>>>> distinction between the behavior of the direct UTM simulation of
>>>> this input by the halt decider and the independent execution of this
>>>> same input at some other point in the execution trace outside of the
>>>> halt decider.
>>>
>>> Of course there is a way. The independent execution is specified as
>>> ⟨Ĥ⟩ ⟨Ĥ⟩. The simulation by a UTM would be ⟨UTM⟩ ⟨Ĥ⟩ ⟨Ĥ⟩. Those are
>>> two distinct computations.
>>>
>>> Your H doesn't even involve a UTM, so why you bring this up is beyond
>>> me.
>>>
>>> What you are failing to grasp is that when you run H ⟨Ĥ⟩ ⟨Ĥ⟩, the
>>> *only* computation which is actually occuring is H ⟨Ĥ⟩ ⟨Ĥ⟩. Even if H
>>> reaches its decision by partially simulating H ⟨Ĥ⟩, there is no
>>> computation H ⟨Ĥ⟩ taking place inside of the decider. The simulation
>>> is simply *part* of the steps involved in computing H ⟨Ĥ⟩ ⟨Ĥ⟩ and is
>>> not a computation itself, so it isn't even in the domain of the problem.
>>>
>>> Or, to put things in terms of your poor analogy below, there only
>>> *is* one window to choose from.
>>>
>>
>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>
>> You already chose the second window.
>>
>> H ⟨Ĥ⟩ ⟨Ĥ⟩ is one window like P(P)
>>
>> and Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ is entirely different window like H(P,P)
>
> What are you on about here? I am trying to explain to you what the
> definition of a *halt* decider is. Ĥ.qx is a single state inside of Ĥ.
> There is no such state inside H.
>


Click here to read the complete article
Re: Concise refutation of halting problem proofs V21 [ Richard is not technically competent ]

<puydnYpgqYTAWgb8nZ2dnUU7-TnNnZ2d@giganews.com>

 copy mid

https://www.novabbs.com/computers/article-flat.php?id=7634&group=comp.ai.philosophy#7634

 copy link   Newsgroups: comp.theory comp.ai.philosophy sci.logic sci.math
Followup: comp.theory
Path: i2pn2.org!i2pn.org!weretis.net!feeder6.news.weretis.net!news.misty.com!border2.nntp.dca1.giganews.com!nntp.giganews.com!buffer2.nntp.dca1.giganews.com!buffer1.nntp.dca1.giganews.com!news.giganews.com.POSTED!not-for-mail
NNTP-Posting-Date: Mon, 22 Nov 2021 10:37:49 -0600
Date: Mon, 22 Nov 2021 10:37:48 -0600
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:91.0) Gecko/20100101
Thunderbird/91.3.2
Subject: Re: Concise refutation of halting problem proofs V21 [ Richard is not
technically competent ]
Content-Language: en-US
Newsgroups: comp.theory,comp.ai.philosophy,sci.logic,sci.math
References: <OqOdnSk-es33vwr8nZ2dnUU7-VXNnZ2d@giganews.com>
<VM-dnWN8ofpTCgT8nZ2dnUU7-S_NnZ2d@giganews.com> <snc5fl$hlj$1@dont-email.me>
<Zsudne5u4LizBwT8nZ2dnUU7-XfNnZ2d@giganews.com> <snc6el$nga$1@dont-email.me>
<snc7o6$tme$1@dont-email.me> <snc945$49e$1@dont-email.me>
<ot2dnXPCwob8MQT8nZ2dnUU7-bnNnZ2d@giganews.com> <sncbb8$huh$1@dont-email.me>
<gNWdnS5SfcK6JwT8nZ2dnUU7-VPNnZ2d@giganews.com> <sncg69$8au$1@dont-email.me>
<37ydnbV-mq1mVQT8nZ2dnUU7-S3NnZ2d@giganews.com> <sndlot$qau$1@dont-email.me>
<CZ6dneFC5_xl8Af8nZ2dnUU7-N3NnZ2d@giganews.com> <sndu4l$lp6$1@dont-email.me>
<bfCdndij-oL7NQf8nZ2dnUU7-f_NnZ2d@giganews.com> <sneb1c$gf5$1@dont-email.me>
<T6adnYv9oJQ_KAf8nZ2dnUU7-ffNnZ2d@giganews.com> <snelu4$srg$1@dont-email.me>
<8Ledna3N87zUawf8nZ2dnUU7-LfNnZ2d@giganews.com>
<lXCmJ.34161$Ak2.2917@fx20.iad>
<wI6dnbU93IHUYwf8nZ2dnUU7-LXNnZ2d@giganews.com>
<619b8b02$0$28610$426a74cc@news.free.fr>
<WKWdnWlXh_G3Kgb8nZ2dnUU7-dXNnZ2d@giganews.com>
<WcPmJ.117070$IW4.24335@fx48.iad>
Followup-To: comp.theory
From: NoO...@NoWhere.com (olcott)
In-Reply-To: <WcPmJ.117070$IW4.24335@fx48.iad>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Message-ID: <puydnYpgqYTAWgb8nZ2dnUU7-TnNnZ2d@giganews.com>
Lines: 63
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-DI0KmxrARrZAh+xpfGGChV2DQPO52QcAlo/vLOp7BksNcOCic7oe2+ALNHkoGJMZyCDnov1fUo/ntKd!EW2G8A0jt//uxVZut0Yu9Y1RdQy+ZPm0QfSPtQlpQt599XkrY+A3xyR50+zhnhI1YWB5msBe2Xow!jw==
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: 3964
 by: olcott - Mon, 22 Nov 2021 16:37 UTC

On 11/22/2021 10:05 AM, Richard Damon wrote:
> On 11/22/21 10:28 AM, olcott wrote:
>> On 11/22/2021 6:20 AM, Python wrote:
>>> olcott wrote:
>>>> #include <stdint.h>
>>>> #include <stdio.h>
>>>> typedef int (*ptr)();
>>>>
>>>> int H(ptr x, ptr y)
>>>> {
>>>>    x(y); // direct execution of P(P)
>>>>    return 1;
>>>> }
>>>>
>>>> // Minimal essence of Linz(1990) Ĥ
>>>> // and Strachey(1965) P
>>>> int P(ptr x)
>>>> {
>>>>    H(x, x);
>>>>    return 1; // Give P a last instruction at the "c" level
>>>> }
>>>>
>>>> int main(void)
>>>> {
>>>>    H(P, P);
>>>> }
>>>
>>> $ ./olcott
>>> Segmentation fault: 11
>>
>>
>> Thus proving that H(P,P) never halts.
>>
>
> And if H(P,P) never halts, it isn't a valid decider.
>
> FAIL.

I take back that you are sufficiently technically competent to
comprehend any of the following, not even the Linz quote:

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

[PSR set] Combinations of H/P having pathological self-reference
Every H of H(P,P) invoked from main() where P(P) calls this same H(P,P)
and H simulates or executes its input and aborts or does not abort its
input P never reaches its last instruction.

[PSR subset] Because we know that the input to H(P,P) never halts for
the whole PSR set and a subset of these H/P combinations aborts the
execution or simulation of its input then we know that for this entire
PSR subset the input to H(P,P) never halts and H(P,P) halts.

--
Copyright 2021 Pete Olcott

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

1
server_pubkey.txt

rocksolid light 0.9.7
clearnet tor