Rocksolid Light

Welcome to novaBBS (click a section below)

mail  files  register  nodelist  faq  login

A Fortran compiler is the hobgoblin of little minis.


computers / comp.ai.philosophy / Re: Concise refutation of halting problem proofs V21 [ precisely defined sets ]

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 solcott
         `* 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_V21_olcott
          | `* Re: _Concise_refutation_of_halting_problem_proofs_V21_olcott
          |  `- Re: Concise refutation of halting problem proofs V21 [ Richard is notolcott
          `- Re: _Concise_refutation_of_halting_problem_proofs_V21_olcott

1
Subject: Concise refutation of halting problem proofs V18
From: olcott
Newsgroups: comp.theory, comp.ai.philosophy, sci.logic, sci.math
Followup: comp.theory
Date: Fri, 19 Nov 2021 04:04 UTC
Path: i2pn2.org!i2pn.org!weretis.net!feeder6.news.weretis.net!news.misty.com!border2.nntp.dca1.giganews.com!nntp.giganews.com!buffer2.nntp.dca1.giganews.com!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
View all headers
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


Subject: Re: Concise refutation of halting problem proofs V18 [ strawman error ]
From: olcott
Newsgroups: comp.theory, comp.ai.philosophy, sci.logic, sci.math
Followup: comp.theory
Date: Fri, 19 Nov 2021 05:03 UTC
References: 1 2
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
View all headers
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


Subject: Re: Concise refutation of halting problem proofs V18 [ strawman error ]
From: olcott
Newsgroups: comp.theory, comp.ai.philosophy, sci.logic, sci.math
Followup: comp.theory
Date: Fri, 19 Nov 2021 16:45 UTC
References: 1 2 3 4 5 6
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
View all headers
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


Subject: Re: Concise refutation of halting problem proofs V18 [ strawman error ]
From: olcott
Newsgroups: comp.theory, comp.ai.philosophy, sci.logic, sci.math
Followup: comp.theory
Date: Fri, 19 Nov 2021 17:32 UTC
References: 1 2 3 4 5 6 7 8
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
View all headers
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


Subject: Re: Concise refutation of halting problem proofs V18 [ strawman error ]
From: olcott
Newsgroups: comp.theory, comp.ai.philosophy, sci.logic, sci.math
Followup: comp.theory
Date: Fri, 19 Nov 2021 18:06 UTC
References: 1 2 3 4 5 6 7 8 9 10
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
View all headers
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


Subject: Re: Concise refutation of halting problem proofs V18 [ strawman error ]
From: olcott
Newsgroups: comp.theory, comp.ai.philosophy, sci.philosophy, sci.math.symbolic
Followup: comp.theory
Date: Fri, 19 Nov 2021 19:26 UTC
References: 1 2 3 4 5 6 7 8 9 10 11 12
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
View all headers
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


Subject: Re: Concise refutation of halting problem proofs V18 [ strawman error ]
From: olcott
Newsgroups: comp.theory, comp.ai.philosophy, sci.logic, sci.math
Followup: comp.theory
Date: Fri, 19 Nov 2021 21:55 UTC
References: 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16
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
View all headers
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


Subject: Re: Concise refutation of halting problem proofs V18 [ strawman error ]
From: olcott
Newsgroups: comp.theory, comp.ai.philosophy, sci.logic, sci.math
Followup: comp.theory
Date: Fri, 19 Nov 2021 22:15 UTC
References: 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16
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
View all headers
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


Subject: Re: Concise refutation of halting problem proofs V18 [ strawman error ]
From: olcott
Newsgroups: comp.theory, comp.ai.philosophy, sci.logic, sci.math
Followup: comp.theory
Date: Sat, 20 Nov 2021 00:16 UTC
References: 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18
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
View all headers
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


Subject: Re: Concise refutation of halting problem proofs V21 [ precisely defined sets ]
From: olcott
Newsgroups: comp.theory, comp.ai.philosophy, sci.logic, sci.math
Followup: comp.theory
Date: Sat, 20 Nov 2021 17:45 UTC
References: 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20
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
View all headers
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


Subject: Re: Concise refutation of halting problem proofs V21 [ precisely defined sets ]
From: olcott
Newsgroups: comp.theory, comp.ai.philosophy, sci.logic, sci.math
Followup: comp.theory
Date: Sat, 20 Nov 2021 20:35 UTC
References: 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22
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
View all headers
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}.


input to H(P, P) never halts' even though P(P) does halt is just a feeble attempt on your part to rationalize the fact that your H gives the wrong answer.

André



--
Copyright 2021 Pete Olcott

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


Subject: Re: Concise refutation of halting problem proofs V21 [ precisely defined sets ]
From: olcott
Newsgroups: comp.theory, comp.ai.philosophy, sci.logic, sci.math
Followup: comp.theory
Date: Sun, 21 Nov 2021 00:50 UTC
References: 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24
Path: i2pn2.org!i2pn.org!weretis.net!feeder6.news.weretis.net!news.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
View all headers
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é


How do you tell a mathematical function that it is not allowed to base its halt status decision on the sequence of configurations specified by (P, I) and instead must base its halt status decision on P(I) [when run independently] ???


--
Copyright 2021 Pete Olcott

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


Subject: Re: Concise refutation of halting problem proofs V21 [ precisely defined sets ]
From: olcott
Newsgroups: comp.theory, comp.ai.philosophy, sci.logic, sci.math
Followup: comp.theory
Date: Sun, 21 Nov 2021 02:18 UTC
References: 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26
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
View all headers
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


Subject: Re:_Concise_refutation_of_halting_problem_proofs_V21_[_André_is_incorrect_]
From: olcott
Newsgroups: comp.theory, comp.ai.philosophy, sci.logic, sci.math
Followup: comp.theory
Date: Sun, 21 Nov 2021 03:29 UTC
References: 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26
Path: i2pn2.org!i2pn.org!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
View all headers
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


Subject: Re:_Concise_refutation_of_halting_problem_proofs_V21_[_André_is_wrong_]
From: olcott
Newsgroups: comp.theory, comp.ai.philosophy, sci.math, sci.logic
Followup: comp.theory
Date: Sun, 21 Nov 2021 16:04 UTC
References: 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26
Path: i2pn2.org!i2pn.org!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
View all headers
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


Subject: Re:_Concise_refutation_of_halting_problem_proofs_V21_[_André_is_wrong_]
From: olcott
Newsgroups: comp.theory, comp.ai.philosophy, sci.logic, sci.math
Followup: comp.theory
Date: Mon, 22 Nov 2021 01:45 UTC
References: 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26
Path: i2pn2.org!i2pn.org!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
View all headers
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.


Ĥ.qx is not a single state it is the first state of Ĥ where the copy of H begins.

H ⟨M) w evaluates whether M w halts.


If you ask me to look out my window to see if it is raining I can tell you a definite and correct answer.

If you ask me to look out my window to see if it is raining when looking out Ben's window in Florida then the answer based on looking out my window would be incorrect.

And if I give a Halt decider the input string ⟨Ĥ⟩ ⟨Ĥ⟩, that tells it to evaluate the behaviour of computation H ⟨Ĥ⟩.

There are no H's to be found in
Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn

And so what? I explaining what a halt decider must do. That would be H, not Ĥ.


We must figure out what Ĥ.qx would do and what H would do and it is common sense that they must do the same thing none-the-less they do not do the same thing.

So now you are looking outside of a window that does not exist.

It does not tell it to look evaluate the behaviour of some internal simulation.

Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
does tell Ĥ.qx to evaluate the behavior of Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩

Ĥ.qx is simply a single state. It doesn't evaluate anything. And I have no idea what it means for something to evaluate the behaviour of Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩.


Ĥ.qx  IS NOT a single state it is the point in Ĥ where its copy of H begins.

But since I am talking about H, this is all irrelevant.


I am not talking about H. I am talking about the behavior of the copy of H at Ĥ.qx


It can make use of such a simulation as part of its analysis, but unless the answer corresponds to the actual behaviour of H ⟨Ĥ⟩ then its analysuis is wrong.

H ⟨Ĥ⟩ ⟨Ĥ⟩ bases its decision on the actual behavior of Ĥ ⟨Ĥ⟩

Yes, the *actual* behaviour of Ĥ ⟨Ĥ⟩. The actual behaviour of Ĥ ⟨Ĥ⟩ is that it halts.


The copy of H at Ĥ.qx cannot simply wait for itself to decide what itself is going to do. Whereas H can wait so see what ⟨Ĥ⟩ ⟨Ĥ⟩ does.


That your 'simulation' doesn't match the behaviour of this independent computation indicates a problem with your simulator; it doesn't impact the actual meaning of the input string.


That it is not raining outside of my window has zero predictive value for the presence or absence of rain looking out Ben's window.

Similarly, looking at anything other than the behaviour of the independent computation Ĥ ⟨Ĥ⟩ has zero predictive value for determining the halting status of Ĥ ⟨Ĥ⟩. Your decider is looking out the wrong window.

So Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ must base its analysis on what the behavior of its input would be if Ĥ.qx was H, How is Ĥ.qx supposed to know that ?

I cannot for the life of me even figure out what you are trying to claim here.


This can only be properly understood in terms of the four precisely defined sets on half a page of page 3.

The first two sets are easy for any competent software engineer:

The existence of the third set conclusively proves that the input to H(P,P) never halts and P(P) halts for the exact same H and P.

Understanding this is the key to understanding that Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩

Click here to read the complete article
Subject: Re: Concise refutation of halting problem proofs V21 [ Richard is not technically competent ]
From: olcott
Newsgroups: comp.theory, comp.ai.philosophy, sci.logic, sci.math
Followup: comp.theory
Date: Mon, 22 Nov 2021 16:37 UTC
References: 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25
Path: i2pn2.org!i2pn.org!weretis.net!feeder6.news.weretis.net!news.misty.com!border2.nntp.dca1.giganews.com!nntp.giganews.com!buffer2.nntp.dca1.giganews.com!buffer1.nntp.dca1.giganews.com!news.giganews.com.POSTED!not-for-mail
NNTP-Posting-Date: 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
View all headers
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
rocksolid light 0.7.2
clearneti2ptor