Rocksolid Light

Welcome to novaBBS (click a section below)

mail  files  register  newsreader  groups  login

Message-ID:  

Life's the same, except for the shoes. -- The Cars


devel / comp.theory / Re: Concise refutation of halting problem proofs V18 [ strawman error ]

SubjectAuthor
* Concise refutation of halting problem proofs V18olcott
`* Concise refutation of halting problem proofs V18Richard Damon
 `* Concise refutation of halting problem proofs V18 [ strawman errorolcott
  `* Concise refutation of halting problem proofs V18 [ strawman errorRichard Damon
   +* Concise refutation of halting problem proofs V18 [ strawman errorolcott
   |+* Concise refutation of halting problem proofs V18 [ strawman errorAndré G. Isaak
   ||`* Concise refutation of halting problem proofs V18 [ strawman errorolcott
   || `* Concise refutation of halting problem proofs V18 [ strawman errorAndré G. Isaak
   ||  `* Concise refutation of halting problem proofs V18 [ strawman errorolcott
   ||   +* Concise refutation of halting problem proofs V18 [ strawman errorAndré G. Isaak
   ||   |`* Concise refutation of halting problem proofs V18 [ strawman error ]olcott
   ||   | +* Concise refutation of halting problem proofs V18 [ strawman errorAndré G. Isaak
   ||   | |`* Concise refutation of halting problem proofs V18 [ strawman error ]olcott
   ||   | | `* Concise refutation of halting problem proofs V18 [ strawman errorAndré G. Isaak
   ||   | |  `* Concise refutation of halting problem proofs V18 [ strawman errorolcott
   ||   | |   +* Concise refutation of halting problem proofs V18 [ strawman errorAndré G. Isaak
   ||   | |   |+* Concise refutation of halting problem proofs V18 [ strawman errorolcott
   ||   | |   ||+* Concise refutation of halting problem proofs V18 [ strawman errorAndré G. Isaak
   ||   | |   |||`* Concise refutation of halting problem proofs V18 [ strawman errorolcott
   ||   | |   ||| `- Concise refutation of halting problem proofs V18 [ strawman errorRichard Damon
   ||   | |   ||`- Concise refutation of halting problem proofs V18 [ strawman errorRichard Damon
   ||   | |   |`* Concise refutation of halting problem proofs V18 [ strawman errorolcott
   ||   | |   | `* Concise refutation of halting problem proofs V18 [ strawman errorAndré G. Isaak
   ||   | |   |  `* Concise refutation of halting problem proofs V18 [ strawman errorolcott
   ||   | |   |   +- Concise refutation of halting problem proofs V18 [ strawman errorRichard Damon
   ||   | |   |   `* Concise refutation of halting problem proofs V18 [ strawman errorAndré G. Isaak
   ||   | |   |    `* Concise refutation of halting problem proofs V21 [ preciselyolcott
   ||   | |   |     +* Concise refutation of halting problem proofs V21 [ preciselyAndré G. Isaak
   ||   | |   |     |`* Concise refutation of halting problem proofs V21 [ precisely defined sets ]olcott
   ||   | |   |     | `* Concise refutation of halting problem proofs V21 [ preciselyAndré G. Isaak
   ||   | |   |     |  `* Concise refutation of halting problem proofs V21 [ preciselyolcott
   ||   | |   |     |   `* Concise refutation of halting problem proofs V21 [ preciselyAndré G. Isaak
   ||   | |   |     |    `* Concise refutation of halting problem proofs V21 [ preciselyolcott
   ||   | |   |     |     +* Concise refutation of halting problem proofs V21 [ preciselyAndré G. Isaak
   ||   | |   |     |     |+* Concise refutation of halting problem proofs V21 [ preciselyolcott
   ||   | |   |     |     ||`* Concise refutation of halting problem proofs V21 [ preciselyAndré G. Isaak
   ||   | |   |     |     || +* Concise refutation of halting problem proofs V21 [ preciselyolcott
   ||   | |   |     |     || |+* Concise refutation of halting problem proofs V21 [ preciselyAndré G. Isaak
   ||   | |   |     |     || ||`* Concise refutation of halting problem proofs V21 [ preciselyolcott
   ||   | |   |     |     || || +* Concise refutation of halting problem proofs V21 [ preciselyRichard Damon
   ||   | |   |     |     || || |`* Concise refutation of halting problem proofs V21 [ preciselyolcott
   ||   | |   |     |     || || | +- Concise refutation of halting problem proofs V21 [ preciselyRichard Damon
   ||   | |   |     |     || || | `- Concise refutation of halting problem proofs V21 [ preciselyRichard Damon
   ||   | |   |     |     || || `* Concise refutation of halting problem proofs V21 [ preciselyAndré G. Isaak
   ||   | |   |     |     || ||  `* _Concise_refutation_of_halting_problem_proofs_V21_olcott
   ||   | |   |     |     || ||   +- _Concise_refutation_of_halting_problem_proofs_V21_Richard Damon
   ||   | |   |     |     || ||   `* _Concise_refutation_of_halting_problem_proofs_V21_André G. Isaak
   ||   | |   |     |     || ||    `* _Concise_refutation_of_halting_problem_proofs_V21_olcott
   ||   | |   |     |     || ||     `* _Concise_refutation_of_halting_problem_proofs_V21_André G. Isaak
   ||   | |   |     |     || ||      +* _Concise_refutation_of_halting_problem_proofs_V21_olcott
   ||   | |   |     |     || ||      |+* _Concise_refutation_of_halting_problem_proofs_V21_André G. Isaak
   ||   | |   |     |     || ||      ||`* _Concise_refutation_of_halting_problem_proofs_V21_olcott
   ||   | |   |     |     || ||      || `* _Concise_refutation_of_halting_problem_proofs_V21_André G. Isaak
   ||   | |   |     |     || ||      ||  +* _Concise_refutation_of_halting_problem_proofs_V21_olcott
   ||   | |   |     |     || ||      ||  |+- _Concise_refutation_of_halting_problem_proofs_V21_André G. Isaak
   ||   | |   |     |     || ||      ||  |+- _Concise_refutation_of_halting_problem_proofs_V21_Richard Damon
   ||   | |   |     |     || ||      ||  |`* _Concise_refutation_of_halting_problem_proofs_V21_[_André_is_wrong_]olcott
   ||   | |   |     |     || ||      ||  | `- _Concise_refutation_of_halting_problem_proofs_V21_Richard Damon
   ||   | |   |     |     || ||      ||  `* _Concise_refutation_of_halting_problem_proofs_V21_olcott
   ||   | |   |     |     || ||      ||   `* _Concise_refutation_of_halting_problem_proofs_V21_Richard Damon
   ||   | |   |     |     || ||      ||    `* _Concise_refutation_of_halting_problem_proofs_V21_olcott
   ||   | |   |     |     || ||      ||     +- _Concise_refutation_of_halting_problem_proofs_V21_Richard Damon
   ||   | |   |     |     || ||      ||     `* _Concise_refutation_of_halting_problem_proofs_V21_Python
   ||   | |   |     |     || ||      ||      `* _Concise_refutation_of_halting_problem_proofs_V21_olcott
   ||   | |   |     |     || ||      ||       +* _Concise_refutation_of_halting_problem_proofs_V21_Richard Damon
   ||   | |   |     |     || ||      ||       |`* Concise refutation of halting problem proofs V21 [ Richard is notolcott
   ||   | |   |     |     || ||      ||       | `- Concise refutation of halting problem proofs V21 [ Richard is notRichard Damon
   ||   | |   |     |     || ||      ||       `* _Concise_refutation_of_halting_problem_proofs_V21_Python
   ||   | |   |     |     || ||      ||        +- _Concise_refutation_of_halting_problem_proofs_V21_olcott
   ||   | |   |     |     || ||      ||        `* _Concise_refutation_of_halting_problem_proofs_V21_olcott
   ||   | |   |     |     || ||      ||         `- _Concise_refutation_of_halting_problem_proofs_V21_Richard Damon
   ||   | |   |     |     || ||      |`- _Concise_refutation_of_halting_problem_proofs_V21_Richard Damon
   ||   | |   |     |     || ||      `- _Concise_refutation_of_halting_problem_proofs_V21_olcott
   ||   | |   |     |     || |`- Concise refutation of halting problem proofs V21 [ preciselyRichard Damon
   ||   | |   |     |     || `* _Concise_refutation_of_halting_problem_proofs_V21_olcott
   ||   | |   |     |     ||  `- _Concise_refutation_of_halting_problem_proofs_V21_Richard Damon
   ||   | |   |     |     |`* Concise refutation of halting problem proofs V21 [ preciselyolcott
   ||   | |   |     |     | +- Concise refutation of halting problem proofs V21 [ preciselyAndré G. Isaak
   ||   | |   |     |     | `- Concise refutation of halting problem proofs V21 [ preciselyRichard Damon
   ||   | |   |     |     `* Concise refutation of halting problem proofs V21 [ preciselyRichard Damon
   ||   | |   |     |      `* Concise refutation of halting problem proofs V21 [ preciselyolcott
   ||   | |   |     |       `- Concise refutation of halting problem proofs V21 [ preciselyRichard Damon
   ||   | |   |     `- Concise refutation of halting problem proofs V21 [ preciselyRichard Damon
   ||   | |   `- Concise refutation of halting problem proofs V18 [ strawman errorRichard Damon
   ||   | `- Concise refutation of halting problem proofs V18 [ strawman errorRichard Damon
   ||   `- Concise refutation of halting problem proofs V18 [ strawman errorRichard Damon
   |`- Concise refutation of halting problem proofs V18 [ strawman errorRichard Damon
   `* Concise refutation of halting problem proofs V18 [ strawmanMr Flibble
    `- Concise refutation of halting problem proofs V18 [ strawman errorolcott

Pages:1234
Concise refutation of halting problem proofs V18

<OqOdnSk-es33vwr8nZ2dnUU7-VXNnZ2d@giganews.com>

 copy mid

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

 copy link   Newsgroups: comp.theory comp.ai.philosophy sci.logic sci.math
Followup: comp.theory
Path: i2pn2.org!i2pn.org!weretis.net!feeder6.news.weretis.net!news.misty.com!border2.nntp.dca1.giganews.com!nntp.giganews.com!buffer2.nntp.dca1.giganews.com!news.giganews.com.POSTED!not-for-mail
NNTP-Posting-Date: Thu, 18 Nov 2021 22:04:58 -0600
Date: Thu, 18 Nov 2021 22:04:56 -0600
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:91.0) Gecko/20100101
Thunderbird/91.3.1
Newsgroups: comp.theory,comp.ai.philosophy,sci.logic,sci.math
Content-Language: en-US
From: NoO...@NoWhere.com (olcott)
Subject: Concise refutation of halting problem proofs V18
Followup-To: comp.theory
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Message-ID: <OqOdnSk-es33vwr8nZ2dnUU7-VXNnZ2d@giganews.com>
Lines: 63
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-fvkNUNIYAT8KG0xabOvpIevC5xD4Kkzeov1RKsYRzRR165bCtL7BENF6r/pzf5CYcs+a4t22kNs624h!TGxyOCSAsVBlwa90PNFIv0Ms7ae9untbh6EMfiz/X5NLydnZPAUc4wEyN2xOD4t+sB7sPC8194Rb!PQ==
X-Complaints-To: abuse@giganews.com
X-DMCA-Notifications: http://www.giganews.com/info/dmca.html
X-Abuse-and-DMCA-Info: Please be sure to forward a copy of ALL headers
X-Abuse-and-DMCA-Info: Otherwise we will be unable to process your complaint properly
X-Postfilter: 1.3.40
X-Original-Bytes: 3075
 by: olcott - Fri, 19 Nov 2021 04:04 UTC

typedef void (*ptr)();

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

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

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

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

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

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

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

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

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

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

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

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

--
Copyright 2021 Pete Olcott

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

Re: Concise refutation of halting problem proofs V18

<0QFlJ.4132$aF1.1545@fx98.iad>

 copy mid

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

 copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!weretis.net!feeder8.news.weretis.net!news.dns-netz.com!news.freedyn.net!newsfeed.xs4all.nl!newsfeed8.news.xs4all.nl!feeder1.feed.usenet.farm!feed.usenet.farm!peer02.ams4!peer.am4.highwinds-media.com!peer03.iad!feed-me.highwinds-media.com!news.highwinds-media.com!fx98.iad.POSTED!not-for-mail
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:91.0)
Gecko/20100101 Thunderbird/91.3.1
Subject: Re: Concise refutation of halting problem proofs V18
Content-Language: en-US
Newsgroups: comp.theory
References: <OqOdnSk-es33vwr8nZ2dnUU7-VXNnZ2d@giganews.com>
From: Rich...@Damon-Family.org (Richard Damon)
In-Reply-To: <OqOdnSk-es33vwr8nZ2dnUU7-VXNnZ2d@giganews.com>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Lines: 108
Message-ID: <0QFlJ.4132$aF1.1545@fx98.iad>
X-Complaints-To: abuse@easynews.com
Organization: Forte - www.forteinc.com
X-Complaints-Info: Please be sure to forward a copy of ALL headers otherwise we will be unable to process your complaint properly.
Date: Thu, 18 Nov 2021 23:35:08 -0500
X-Received-Bytes: 4546
 by: Richard Damon - Fri, 19 Nov 2021 04:35 UTC

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

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.

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

<csednfY4fZugrQr8nZ2dnUU7-YnNnZ2d@giganews.com>

 copy mid

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

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

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

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

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

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

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

--
Copyright 2021 Pete Olcott

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

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

<nSMlJ.92781$AJ2.12422@fx33.iad>

 copy mid

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

 copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!weretis.net!feeder8.news.weretis.net!newsreader4.netcologne.de!news.netcologne.de!peer01.ams1!peer.ams1.xlned.com!news.xlned.com!peer01.iad!feed-me.highwinds-media.com!news.highwinds-media.com!fx33.iad.POSTED!not-for-mail
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; 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
References: <OqOdnSk-es33vwr8nZ2dnUU7-VXNnZ2d@giganews.com>
<0QFlJ.4132$aF1.1545@fx98.iad>
<csednfY4fZugrQr8nZ2dnUU7-YnNnZ2d@giganews.com>
From: Rich...@Damon-Family.org (Richard Damon)
In-Reply-To: <csednfY4fZugrQr8nZ2dnUU7-YnNnZ2d@giganews.com>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Lines: 189
Message-ID: <nSMlJ.92781$AJ2.12422@fx33.iad>
X-Complaints-To: abuse@easynews.com
Organization: Forte - www.forteinc.com
X-Complaints-Info: Please be sure to forward a copy of ALL headers otherwise we will be unable to process your complaint properly.
Date: Fri, 19 Nov 2021 07:35:32 -0500
X-Received-Bytes: 9319
 by: Richard Damon - Fri, 19 Nov 2021 12:35 UTC

On 11/19/21 12:03 AM, olcott wrote:
> 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.

Except that your 'PSR' set doesn't really mean anything. The 'self
reference' that happens in the problem is perfectly allowed by the
structure of the system.

It is required for H to possibly be a Halt Decider that H perform a
Mathematical Computation and thus be able to be made as a Turing
Machine. The principle of Computations and rules for building Turing
machines most definitely ALLOW for the form of reference that the H/H^
pairing creates. In fact, that sort of referencing is an innate property
of Mathematical logic.

Yes, you may find it inconvenient that it is allowed, but it is. And in
fact, due to how the logic system used in Mathematics is constructed is
one reason that the logic system YOU think is the only that should be
allowed doesn't work for the logic system of Mathematics.

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

Except that just calling something a 'Strawman' doesn't make it go away.
You SAY it isn;t the real subject, but the problem is that it exactly IS
the real subject and YOU are the one committing the Strawman Error.

Remember, the DEFINITION of the Halting Status of a Computation refers
to that Computation being directly run. That is what I say to do, and
you say that is the strawman.

Yes, you can show that the machine H can never reach in its
simulation/processing of its processing of its input, the final state of
that input, but that doesn't actually mean that this input represents a
non-halting computation by the actual definition of non-halting.

It is a fact, that if H tries to decide by just unconditionally
processing its input it will fail, because the inherent job of a Decider
is to figure in finite time what would otherwise take an infinite time
to see. Thus pure execution/simulation just fails at the job.

Once the decider has committed to not just using unconditional
execution/simulation to figure out what its input does, then it needs to
have the right 'smarts' to figure out what something will do without
just running it to see. It needs to be able to use valid logic to figure
out the behavior the input represents, and that includes figuring out
what a copy of itself will do that will be consistent with what itself
will do.

It also need to take into account that since it has abandoned the
unconditional execution/simulation model that once it does that, the
behavior it sees is no longer the 'defining' behavior of the input it is
processing.

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

Nope, Every technically competent person can easily see that my rebuttal
is EXACTLY correct, only you in your incompetence thinks the way you do.

(Who else agrees with your conclusion?)

To be technically competent you need to agree and be able to work within
the defined constraints of the system. There ARE definitions that apply
to things, and you need to use those things as defined.

Halting has a technical meaning in computation theory, as does being
non-halting. You seem to feel you can 'make up' your own version of the
meaning of words to match your world view, but since that world view is
not compatible with the world view embedded in the theory, you get
nonsensical results.

You have convinced yourself that you know something, and your mind just
rejects everything that disagrees with what you have decided on, no
matter how strongly the evidence points to you being wrong. There is a
word for this, and you won't like it, You are Delusional.

You will of course reject that idea, you will say that you can't be
wrong, you know your right and its just that others don't understand
this 'new truth' that you have discovered.

You seem to like the quote about Genius can hit the targets that others
can't see, but you miss the fact that the Deluded think they hit targets
that others can't see too. The difference is that the Genius, once they
have hit the target, can work out a path that shows to others how to see
that target. They understand the system so well they can explain it and
actually provide real proof of what they have done.

The deluded person can't do that. All they can do it point at what they
think is the target and say they hit it. And when people say that isn't
a target to hit, they don't have a real answer except to repeat what
they said before, maybe in different words.

The Genius can take the genius and break it down into simpler pieces
that others can understand.

For your 'idea' you can't do that, as if you try to break it down into
simpler pieces it just breaks and reveals that you are using the wrong
meaning of words.

You have failed. Your whole proof is really just a lie that you try to
hide by (mis)using fancy words.

Ultimately, Halting is a property of the Computation that says it is a
property of, and not something else. The Halting Property of the
Computation P(I) must be something that relates to JUST that P and that
I, and can't be based on anything the decider is doing. Thus the RIGHT
answer for a question like H(P,P) must be based on what P(P) actually
does when run independently of anything else (and that P will by
definition include the H that the P was built on).

Thus Looking at the execution trace inside H(P,P) instead of the actual
trace of running P(P) shows a fundamentaly lack of understanding of what
is being asked. Saying that H never sees the halting state is exactly
the Strawman error that you say the LIE about being in the looking at
the actual problem is.

FAIL.

It does seem that you really do need to seek professional help about
your mental state. Perhaps it may actually be too late now, but maybe
they could do something to help you in your last days to make them
actually worth something, and not be wasted like the last decade or more.

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

<W96dnV1_X_P4JQr8nZ2dnUU7-QPNnZ2d@giganews.com>

 copy mid

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

 copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!weretis.net!feeder6.news.weretis.net!news.misty.com!border2.nntp.dca1.giganews.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 08:44:53 -0600
Date: Fri, 19 Nov 2021 08:44: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
References: <OqOdnSk-es33vwr8nZ2dnUU7-VXNnZ2d@giganews.com>
<0QFlJ.4132$aF1.1545@fx98.iad>
<csednfY4fZugrQr8nZ2dnUU7-YnNnZ2d@giganews.com>
<nSMlJ.92781$AJ2.12422@fx33.iad>
From: NoO...@NoWhere.com (olcott)
In-Reply-To: <nSMlJ.92781$AJ2.12422@fx33.iad>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Message-ID: <W96dnV1_X_P4JQr8nZ2dnUU7-QPNnZ2d@giganews.com>
Lines: 111
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-C1N6+Ye0iyrfh006pESUgAhpAlGwSuDPUcXtaHFCBh3vc/Z8WuGcJ/OokvT/gNEy0GN51AYo6ZM3wV6!ceRj4gBTsWhWt1wzOVaDNDaLrDc3FhIuN8+gUVtkXWTJnWp7VIam6INq3Jz5iFZ4vd3a+rObK3C5!tA==
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: 5357
 by: olcott - Fri, 19 Nov 2021 14:44 UTC

On 11/19/2021 6:35 AM, Richard Damon wrote:
>
> On 11/19/21 12:03 AM, olcott wrote:
>> 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.
>
> Except that your 'PSR' set doesn't really mean anything. The 'self
> reference' that happens in the problem is perfectly allowed by the
> structure of the system.
>
> It is required for H to possibly be a Halt Decider that H perform a
> Mathematical Computation and thus be able to be made as a Turing
> Machine. The principle of Computations and rules for building Turing
> machines most definitely ALLOW for the form of reference that the H/H^
> pairing creates. In fact, that sort of referencing is an innate property
> of Mathematical logic.
>
> Yes, you may find it inconvenient that it is allowed, but it is. And in
> fact, due to how the logic system used in Mathematics is constructed is
> one reason that the logic system YOU think is the only that should be
> allowed doesn't work for the logic system of Mathematics.
>
>>
>> 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
>>
>
> 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.

Here is a simple example of the strawman error I clam to have a dog in
my living you and your rebuttal proves that I do not have a cat in my
living room.

--
Copyright 2021 Pete Olcott

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

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

<sn8el5$a6k$1@dont-email.me>

 copy mid

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

 copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!aioe.org!eternal-september.org!reader02.eternal-september.org!.POSTED!not-for-mail
From: agis...@gm.invalid (André G. Isaak)
Newsgroups: comp.theory
Subject: Re: Concise refutation of halting problem proofs V18 [ strawman error
]
Date: Fri, 19 Nov 2021 08:08:20 -0700
Organization: Christians and Atheists United Against Creeping Agnosticism
Lines: 25
Message-ID: <sn8el5$a6k$1@dont-email.me>
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>
Mime-Version: 1.0
Content-Type: text/plain; charset=utf-8; format=flowed
Content-Transfer-Encoding: 8bit
Injection-Date: Fri, 19 Nov 2021 15:08:21 -0000 (UTC)
Injection-Info: reader02.eternal-september.org; posting-host="0d26e3042e221a4513b773522dda2b48";
logging-data="10452"; mail-complaints-to="abuse@eternal-september.org"; posting-account="U2FsdGVkX1+YignMl2TjGAfZR7K+nzl7"
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.14; rv:78.0)
Gecko/20100101 Thunderbird/78.14.0
Cancel-Lock: sha1:rpYbOWSLvjvDrYeEjnNrV01wkgU=
In-Reply-To: <W96dnV1_X_P4JQr8nZ2dnUU7-QPNnZ2d@giganews.com>
Content-Language: en-US
 by: André G. Isaak - Fri, 19 Nov 2021 15:08 UTC

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

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

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

<20211119153955.00001cd8@reddwarf.jmc>

 copy mid

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

 copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!news.swapon.de!newsreader4.netcologne.de!news.netcologne.de!peer01.ams1!peer.ams1.xlned.com!news.xlned.com!peer02.ams4!peer.am4.highwinds-media.com!news.highwinds-media.com!fx14.ams4.POSTED!not-for-mail
From: flib...@reddwarf.jmc (Mr Flibble)
Newsgroups: comp.theory
Subject: Re: Concise refutation of halting problem proofs V18 [ strawman
error ]
Message-ID: <20211119153955.00001cd8@reddwarf.jmc>
References: <OqOdnSk-es33vwr8nZ2dnUU7-VXNnZ2d@giganews.com>
<0QFlJ.4132$aF1.1545@fx98.iad>
<csednfY4fZugrQr8nZ2dnUU7-YnNnZ2d@giganews.com>
<nSMlJ.92781$AJ2.12422@fx33.iad>
Organization: Jupiter Mining Corp
X-Newsreader: Claws Mail 3.17.8 (GTK+ 2.24.33; x86_64-w64-mingw32)
MIME-Version: 1.0
Content-Type: text/plain; charset=US-ASCII
Content-Transfer-Encoding: 7bit
Lines: 11
X-Complaints-To: abuse@eweka.nl
NNTP-Posting-Date: Fri, 19 Nov 2021 15:39:55 UTC
Date: Fri, 19 Nov 2021 15:39:55 +0000
X-Received-Bytes: 1160
 by: Mr Flibble - Fri, 19 Nov 2021 15:39 UTC

On Fri, 19 Nov 2021 07:35:32 -0500
Richard Damon <Richard@Damon-Family.org> wrote:

> It does seem that you really do need to seek professional help about
> your mental state.

You are not very good at this are you, dear? Attack the argument not
the person or shut the fuck up.

/Flibble

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

<MoGdna8BU9xUSQr8nZ2dnUU7-QvNnZ2d@giganews.com>

 copy mid

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

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

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

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

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

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

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

--
Copyright 2021 Pete Olcott

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

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

<MoGdna4BU9yISAr8nZ2dnUU7-QudnZ2d@giganews.com>

 copy mid

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

 copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!weretis.net!feeder6.news.weretis.net!news.misty.com!border2.nntp.dca1.giganews.com!nntp.giganews.com!buffer2.nntp.dca1.giganews.com!buffer1.nntp.dca1.giganews.com!news.giganews.com.POSTED!not-for-mail
NNTP-Posting-Date: Fri, 19 Nov 2021 10:47:17 -0600
Date: Fri, 19 Nov 2021 10:47:16 -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
References: <OqOdnSk-es33vwr8nZ2dnUU7-VXNnZ2d@giganews.com>
<0QFlJ.4132$aF1.1545@fx98.iad>
<csednfY4fZugrQr8nZ2dnUU7-YnNnZ2d@giganews.com>
<nSMlJ.92781$AJ2.12422@fx33.iad> <20211119153955.00001cd8@reddwarf.jmc>
From: NoO...@NoWhere.com (olcott)
In-Reply-To: <20211119153955.00001cd8@reddwarf.jmc>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 7bit
Message-ID: <MoGdna4BU9yISAr8nZ2dnUU7-QudnZ2d@giganews.com>
Lines: 21
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-9UjkIS61Nj79PwkTTqOFfQE4g2nwOV24ZfAxxAfG/asQsBh14mNLBIEijpCOkE6sISviwEZKJZsE4we!SXcju6JrEu/SWt5H3w8l6X1xCXvxCzqbSiDiAu32ruBcTFzsL1ZLfljyG8/RrEw1RThmLhyGDZgB!xg==
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: 1956
 by: olcott - Fri, 19 Nov 2021 16:47 UTC

On 11/19/2021 9:39 AM, Mr Flibble wrote:
> On Fri, 19 Nov 2021 07:35:32 -0500
> Richard Damon <Richard@Damon-Family.org> wrote:
>
>> It does seem that you really do need to seek professional help about
>> your mental state.
>
> You are not very good at this are you, dear? Attack the argument not
> the person or shut the fuck up.
>
> /Flibble
>

Ad hominem attacks are the first resort of clueless wonders.

--
Copyright 2021 Pete Olcott

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

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

<sn8l2e$sgf$1@dont-email.me>

 copy mid

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

 copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!eternal-september.org!reader02.eternal-september.org!.POSTED!not-for-mail
From: agis...@gm.invalid (André G. Isaak)
Newsgroups: comp.theory
Subject: Re: Concise refutation of halting problem proofs V18 [ strawman error
]
Date: Fri, 19 Nov 2021 09:57:48 -0700
Organization: Christians and Atheists United Against Creeping Agnosticism
Lines: 54
Message-ID: <sn8l2e$sgf$1@dont-email.me>
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>
Mime-Version: 1.0
Content-Type: text/plain; charset=utf-8; format=flowed
Content-Transfer-Encoding: 8bit
Injection-Date: Fri, 19 Nov 2021 16:57:50 -0000 (UTC)
Injection-Info: reader02.eternal-september.org; posting-host="0d26e3042e221a4513b773522dda2b48";
logging-data="29199"; mail-complaints-to="abuse@eternal-september.org"; posting-account="U2FsdGVkX194ByZZtLVguofRwJyjLfTd"
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.14; rv:78.0)
Gecko/20100101 Thunderbird/78.14.0
Cancel-Lock: sha1:Hpx45EfOh41bB7+fUwT7BLAXXsA=
In-Reply-To: <MoGdna8BU9xUSQr8nZ2dnUU7-QvNnZ2d@giganews.com>
Content-Language: en-US
 by: André G. Isaak - Fri, 19 Nov 2021 16:57 UTC

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); }

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é

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

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

<6cydnTBU7YNYQgr8nZ2dnUU7-evNnZ2d@giganews.com>

 copy mid

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

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

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

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

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

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

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

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

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

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

--
Copyright 2021 Pete Olcott

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

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

<sn8ntm$j1d$1@dont-email.me>

 copy mid

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

 copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!eternal-september.org!reader02.eternal-september.org!.POSTED!not-for-mail
From: agis...@gm.invalid (André G. Isaak)
Newsgroups: comp.theory
Subject: Re: Concise refutation of halting problem proofs V18 [ strawman error
]
Date: Fri, 19 Nov 2021 10:46:28 -0700
Organization: Christians and Atheists United Against Creeping Agnosticism
Lines: 98
Message-ID: <sn8ntm$j1d$1@dont-email.me>
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>
Mime-Version: 1.0
Content-Type: text/plain; charset=utf-8; format=flowed
Content-Transfer-Encoding: 8bit
Injection-Date: Fri, 19 Nov 2021 17:46:30 -0000 (UTC)
Injection-Info: reader02.eternal-september.org; posting-host="0d26e3042e221a4513b773522dda2b48";
logging-data="19501"; mail-complaints-to="abuse@eternal-september.org"; posting-account="U2FsdGVkX18V2d5cpDw3hCLURidXsACz"
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.14; rv:78.0)
Gecko/20100101 Thunderbird/78.14.0
Cancel-Lock: sha1:o2Up/lVqXl7y0w+x7h6Li52A0lk=
In-Reply-To: <6cydnTBU7YNYQgr8nZ2dnUU7-evNnZ2d@giganews.com>
Content-Language: en-US
 by: André G. Isaak - Fri, 19 Nov 2021 17:46 UTC

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.

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é

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

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

<pLudnSyOj6cnegr8nZ2dnUU7-UPNnZ2d@giganews.com>

 copy mid

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

 copy link   Newsgroups: comp.theory comp.ai.philosophy sci.logic sci.math
Followup: comp.theory
Path: i2pn2.org!i2pn.org!aioe.org!news.uzoreto.com!tr1.eu1.usenetexpress.com!feeder.usenetexpress.com!tr1.iad1.usenetexpress.com!border1.nntp.dca1.giganews.com!nntp.giganews.com!buffer1.nntp.dca1.giganews.com!news.giganews.com.POSTED!not-for-mail
NNTP-Posting-Date: Fri, 19 Nov 2021 12:06:50 -0600
Date: Fri, 19 Nov 2021 12:06:48 -0600
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:91.0) Gecko/20100101 Thunderbird/91.3.1
Subject: Re: Concise refutation of halting problem proofs V18 [ strawman error ]
Content-Language: en-US
Newsgroups: comp.theory,comp.ai.philosophy,sci.logic,sci.math
References: <OqOdnSk-es33vwr8nZ2dnUU7-VXNnZ2d@giganews.com> <0QFlJ.4132$aF1.1545@fx98.iad> <csednfY4fZugrQr8nZ2dnUU7-YnNnZ2d@giganews.com> <nSMlJ.92781$AJ2.12422@fx33.iad> <W96dnV1_X_P4JQr8nZ2dnUU7-QPNnZ2d@giganews.com> <sn8el5$a6k$1@dont-email.me> <MoGdna8BU9xUSQr8nZ2dnUU7-QvNnZ2d@giganews.com> <sn8l2e$sgf$1@dont-email.me> <6cydnTBU7YNYQgr8nZ2dnUU7-evNnZ2d@giganews.com> <sn8ntm$j1d$1@dont-email.me>
Followup-To: comp.theory
From: NoO...@NoWhere.com (olcott)
In-Reply-To: <sn8ntm$j1d$1@dont-email.me>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Message-ID: <pLudnSyOj6cnegr8nZ2dnUU7-UPNnZ2d@giganews.com>
Lines: 110
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-kfYwId4XC5nS/nMPEpEtvdZhaXMp3QzII1MDm6ONzJLV9h8j5X+Yg74YGWKwdsx+DUOvr21z8HOjJOE!PHmx+E/fgknMsEmYFwjfJBMcrifRaOFofPRMX+1rFpNcFOrkRQuZ0EbcMexG5ad3N8KhzEbSlzw3!vg==
X-Complaints-To: abuse@giganews.com
X-DMCA-Notifications: http://www.giganews.com/info/dmca.html
X-Abuse-and-DMCA-Info: Please be sure to forward a copy of ALL headers
X-Abuse-and-DMCA-Info: Otherwise we will be unable to process your complaint properly
X-Postfilter: 1.3.40
X-Original-Bytes: 5736
 by: olcott - Fri, 19 Nov 2021 18:06 UTC

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

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

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

--
Copyright 2021 Pete Olcott

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

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

<sn8qhq$7jn$1@dont-email.me>

 copy mid

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

 copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!eternal-september.org!reader02.eternal-september.org!.POSTED!not-for-mail
From: agis...@gm.invalid (André G. Isaak)
Newsgroups: comp.theory
Subject: Re: Concise refutation of halting problem proofs V18 [ strawman error
]
Date: Fri, 19 Nov 2021 11:31:21 -0700
Organization: Christians and Atheists United Against Creeping Agnosticism
Lines: 50
Message-ID: <sn8qhq$7jn$1@dont-email.me>
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>
Mime-Version: 1.0
Content-Type: text/plain; charset=utf-8; format=flowed
Content-Transfer-Encoding: 8bit
Injection-Date: Fri, 19 Nov 2021 18:31:22 -0000 (UTC)
Injection-Info: reader02.eternal-september.org; posting-host="0d26e3042e221a4513b773522dda2b48";
logging-data="7799"; mail-complaints-to="abuse@eternal-september.org"; posting-account="U2FsdGVkX18OgT6J6l4RZ62tjm/fznCZ"
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.14; rv:78.0)
Gecko/20100101 Thunderbird/78.14.0
Cancel-Lock: sha1:zqT56z0fr+odONjg6sMAF1zLldk=
In-Reply-To: <pLudnSyOj6cnegr8nZ2dnUU7-UPNnZ2d@giganews.com>
Content-Language: en-US
 by: André G. Isaak - Fri, 19 Nov 2021 18:31 UTC

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.

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é

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

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

<wd2dnW1XgcfhZwr8nZ2dnUU7-VnNnZ2d@giganews.com>

 copy mid

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

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

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

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

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

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

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

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

--
Copyright 2021 Pete Olcott

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

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

<sn8vv7$fqo$1@dont-email.me>

 copy mid

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

 copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!eternal-september.org!reader02.eternal-september.org!.POSTED!not-for-mail
From: agis...@gm.invalid (André G. Isaak)
Newsgroups: comp.theory
Subject: Re: Concise refutation of halting problem proofs V18 [ strawman error
]
Date: Fri, 19 Nov 2021 13:03:49 -0700
Organization: Christians and Atheists United Against Creeping Agnosticism
Lines: 85
Message-ID: <sn8vv7$fqo$1@dont-email.me>
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>
Mime-Version: 1.0
Content-Type: text/plain; charset=utf-8; format=flowed
Content-Transfer-Encoding: 8bit
Injection-Date: Fri, 19 Nov 2021 20:03:51 -0000 (UTC)
Injection-Info: reader02.eternal-september.org; posting-host="0d26e3042e221a4513b773522dda2b48";
logging-data="16216"; mail-complaints-to="abuse@eternal-september.org"; posting-account="U2FsdGVkX1/HcuCuRHf4hqzivCw5rT65"
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.14; rv:78.0)
Gecko/20100101 Thunderbird/78.14.0
Cancel-Lock: sha1:AbjdKIxmDxE23NXsSsw6v+CX19A=
In-Reply-To: <wd2dnW1XgcfhZwr8nZ2dnUU7-VnNnZ2d@giganews.com>
Content-Language: en-US
 by: André G. Isaak - Fri, 19 Nov 2021 20:03 UTC

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.

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

And the 'trace' a halt decider must analyze is that of the former, not
the latter. That's a simple matter of definition.

Since you're fond of analogies, consider the following: You are tasked
with writing a program X which is required to determine how much time
program Y will take to run on hardware Z. You decide to do this by
having X emulate Y running on Z.

Do you seriously believe that your employer is interested in knowing how
long the emulation of Y running on Z takes *inside* your X? No, of
course not. They want to know how long it takes to run the ACTUAL
program Y on the ACTUAL hardware Z. Knowing how it behaves inside your
specific emulator isn't information that would be of use to them or
pretty much anyone else.

Similarly with the halting problem people want to know about the
behaviour of the ACTUAL computation which they ask the halt decider
about, not about how it behaves *inside* a particular decider. That
information simply isn't useful for anything.

André

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

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

<sn90hk$k4m$1@dont-email.me>

 copy mid

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

 copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!eternal-september.org!reader02.eternal-september.org!.POSTED!not-for-mail
From: polco...@gmail.com (olcott)
Newsgroups: comp.theory
Subject: Re: Concise refutation of halting problem proofs V18 [ strawman error
]
Date: Fri, 19 Nov 2021 14:13:37 -0600
Organization: A noiseless patient Spider
Lines: 97
Message-ID: <sn90hk$k4m$1@dont-email.me>
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>
Mime-Version: 1.0
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Injection-Date: Fri, 19 Nov 2021 20:13:40 -0000 (UTC)
Injection-Info: reader02.eternal-september.org; posting-host="5a18311f76e4d88c60e4df94105a66a2";
logging-data="20630"; mail-complaints-to="abuse@eternal-september.org"; posting-account="U2FsdGVkX1/fHBEdU6ToToCmuOc/SJey"
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:91.0) Gecko/20100101
Thunderbird/91.3.1
Cancel-Lock: sha1:LJpP5kAJlf4NeuMDrOeLJJRDtk8=
In-Reply-To: <sn8vv7$fqo$1@dont-email.me>
Content-Language: en-US
 by: olcott - Fri, 19 Nov 2021 20:13 UTC

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.

When Bill Jones robs a liquor store people may get confused and arrest
his identical twin brother that is also named Bill Jones.

>> 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).
>
> And the 'trace' a halt decider must analyze is that of the former, not
> the latter. That's a simple matter of definition.
>
> Since you're fond of analogies, consider the following: You are tasked
> with writing a program X which is required to determine how much time
> program Y will take to run on hardware Z. You decide to do this by
> having X emulate Y running on Z.
>
> Do you seriously believe that your employer is interested in knowing how
> long the emulation of Y running on Z takes *inside* your X? No, of
> course not. They want to know how long it takes to run the ACTUAL
> program Y on the ACTUAL hardware Z. Knowing how it behaves inside your
> specific emulator isn't information that would be of use to them or
> pretty much anyone else.
>
> Similarly with the halting problem people want to know about the
> behaviour of the ACTUAL computation which they ask the halt decider
> about, not about how it behaves *inside* a particular decider. That
> information simply isn't useful for anything.
>
> André
>

--
Copyright 2021 Pete Olcott "Talent hits a target no one else can hit;
Genius hits a target no one else can see." Arthur Schopenhauer

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

<sn93ja$b5a$1@dont-email.me>

 copy mid

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

 copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!eternal-september.org!reader02.eternal-september.org!.POSTED!not-for-mail
From: agis...@gm.invalid (André G. Isaak)
Newsgroups: comp.theory
Subject: Re: Concise refutation of halting problem proofs V18 [ strawman error
]
Date: Fri, 19 Nov 2021 14:05:44 -0700
Organization: Christians and Atheists United Against Creeping Agnosticism
Lines: 68
Message-ID: <sn93ja$b5a$1@dont-email.me>
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>
Mime-Version: 1.0
Content-Type: text/plain; charset=utf-8; format=flowed
Content-Transfer-Encoding: 8bit
Injection-Date: Fri, 19 Nov 2021 21:05:46 -0000 (UTC)
Injection-Info: reader02.eternal-september.org; posting-host="9c5be56f8c770232df963887492d46ee";
logging-data="11434"; mail-complaints-to="abuse@eternal-september.org"; posting-account="U2FsdGVkX1/3jEJUixEqCveiIy5n8+kW"
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.14; rv:78.0)
Gecko/20100101 Thunderbird/78.14.0
Cancel-Lock: sha1:udWDPo/O5E29/t3cwynREhn6vm8=
In-Reply-To: <sn90hk$k4m$1@dont-email.me>
Content-Language: en-US
 by: André G. Isaak - Fri, 19 Nov 2021 21:05 UTC

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.

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

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

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

<-6udnelNUqLWgAX8nZ2dnUU7-SnNnZ2d@giganews.com>

 copy mid

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

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

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

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

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

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

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

--
Copyright 2021 Pete Olcott

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

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

<LbqdnVNler6IvwX8nZ2dnUU7-bHNnZ2d@giganews.com>

 copy mid

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

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

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

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

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

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

--
Copyright 2021 Pete Olcott

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

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

<sn9beg$al$1@dont-email.me>

 copy mid

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

 copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!eternal-september.org!reader02.eternal-september.org!.POSTED!not-for-mail
From: agis...@gm.invalid (André G. Isaak)
Newsgroups: comp.theory
Subject: Re: Concise refutation of halting problem proofs V18 [ strawman error
]
Date: Fri, 19 Nov 2021 16:19:43 -0700
Organization: Christians and Atheists United Against Creeping Agnosticism
Lines: 27
Message-ID: <sn9beg$al$1@dont-email.me>
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>
<-6udnelNUqLWgAX8nZ2dnUU7-SnNnZ2d@giganews.com>
Mime-Version: 1.0
Content-Type: text/plain; charset=utf-8; format=flowed
Content-Transfer-Encoding: 8bit
Injection-Date: Fri, 19 Nov 2021 23:19:44 -0000 (UTC)
Injection-Info: reader02.eternal-september.org; posting-host="2fe6260e90cb317760930677b2e71bbb";
logging-data="341"; mail-complaints-to="abuse@eternal-september.org"; posting-account="U2FsdGVkX18W02uxFYzb+l+ijs+IOVCh"
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.14; rv:78.0)
Gecko/20100101 Thunderbird/78.14.0
Cancel-Lock: sha1:NeoIFnRLIX0FcFC+t2/dYNzYVRg=
In-Reply-To: <-6udnelNUqLWgAX8nZ2dnUU7-SnNnZ2d@giganews.com>
Content-Language: en-US
 by: André G. Isaak - Fri, 19 Nov 2021 23:19 UTC

On 2021-11-19 14:55, olcott wrote:
> On 11/19/2021 3:05 PM, André G. Isaak wrote:

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

No academic definition of a halt decider resembles what you write above.
Which means that yes, they do contradict it.

André

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

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

<p5OdnfRZY5aOrwX8nZ2dnUU7-fudnZ2d@giganews.com>

 copy mid

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

 copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!weretis.net!feeder8.news.weretis.net!newsreader4.netcologne.de!news.netcologne.de!peer01.ams1!peer.ams1.xlned.com!news.xlned.com!peer03.iad!feed-me.highwinds-media.com!news.highwinds-media.com!border1.nntp.dca1.giganews.com!nntp.giganews.com!buffer1.nntp.dca1.giganews.com!buffer2.nntp.dca1.giganews.com!news.giganews.com.POSTED!not-for-mail
NNTP-Posting-Date: Fri, 19 Nov 2021 17:24:02 -0600
Date: Fri, 19 Nov 2021 17:24:01 -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
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>
<-6udnelNUqLWgAX8nZ2dnUU7-SnNnZ2d@giganews.com> <sn9beg$al$1@dont-email.me>
From: NoO...@NoWhere.com (olcott)
In-Reply-To: <sn9beg$al$1@dont-email.me>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Message-ID: <p5OdnfRZY5aOrwX8nZ2dnUU7-fudnZ2d@giganews.com>
Lines: 41
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-MPWYfNYqtgEmT8VFDPzo374AU5u8FBXZAjKEbLFc3yd/ny9VU1OZFLXZq9z5A2uivAF4Ilrir3FzdTv!DBgOemuLTxuwBZoh1Aw9Ce4ekTa3R7TaraBwV1QwwnnfnuY/VFI13cRtHWlZuLT+5W6bE6IjsAHp!2g==
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: 3196
X-Received-Bytes: 3406
 by: olcott - Fri, 19 Nov 2021 23:24 UTC

On 11/19/2021 5:19 PM, André G. Isaak wrote:
> On 2021-11-19 14:55, olcott wrote:
>> On 11/19/2021 3:05 PM, André G. Isaak wrote:
>
>>> 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.
>
>
> No academic definition of a halt decider resembles what you write above.
> Which means that yes, they do contradict it.
>
> André
>
>

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?

--
Copyright 2021 Pete Olcott

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

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

<sn9c8i$522$1@dont-email.me>

 copy mid

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

 copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!eternal-september.org!reader02.eternal-september.org!.POSTED!not-for-mail
From: agis...@gm.invalid (André G. Isaak)
Newsgroups: comp.theory
Subject: Re: Concise refutation of halting problem proofs V18 [ strawman error
]
Date: Fri, 19 Nov 2021 16:33:36 -0700
Organization: Christians and Atheists United Against Creeping Agnosticism
Lines: 84
Message-ID: <sn9c8i$522$1@dont-email.me>
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>
Mime-Version: 1.0
Content-Type: text/plain; charset=utf-8; format=flowed
Content-Transfer-Encoding: 8bit
Injection-Date: Fri, 19 Nov 2021 23:33:38 -0000 (UTC)
Injection-Info: reader02.eternal-september.org; posting-host="2fe6260e90cb317760930677b2e71bbb";
logging-data="5186"; mail-complaints-to="abuse@eternal-september.org"; posting-account="U2FsdGVkX18gla10nRi38OOqrtvUe3wt"
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.14; rv:78.0)
Gecko/20100101 Thunderbird/78.14.0
Cancel-Lock: sha1:rOUGt8pA/KZ5DbMUXz85bW8ZC/g=
In-Reply-To: <LbqdnVNler6IvwX8nZ2dnUU7-bHNnZ2d@giganews.com>
Content-Language: en-US
 by: André G. Isaak - Fri, 19 Nov 2021 23:33 UTC

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.

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é

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

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

<fsKdneznstvwowX8nZ2dnUU7-XnNnZ2d@giganews.com>

 copy mid

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

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

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

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

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

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

--
Copyright 2021 Pete Olcott

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

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

<HyYlJ.28796$bo.19059@fx18.iad>

 copy mid

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

 copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!weretis.net!feeder8.news.weretis.net!newsreader4.netcologne.de!news.netcologne.de!peer01.ams1!peer.ams1.xlned.com!news.xlned.com!peer01.iad!feed-me.highwinds-media.com!news.highwinds-media.com!fx18.iad.POSTED!not-for-mail
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; 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
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>
From: Rich...@Damon-Family.org (Richard Damon)
In-Reply-To: <W96dnV1_X_P4JQr8nZ2dnUU7-QPNnZ2d@giganews.com>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Lines: 143
Message-ID: <HyYlJ.28796$bo.19059@fx18.iad>
X-Complaints-To: abuse@easynews.com
Organization: Forte - www.forteinc.com
X-Complaints-Info: Please be sure to forward a copy of ALL headers otherwise we will be unable to process your complaint properly.
Date: Fri, 19 Nov 2021 20:53:42 -0500
X-Received-Bytes: 6256
 by: Richard Damon - Sat, 20 Nov 2021 01:53 UTC

On 11/19/21 9:44 AM, olcott wrote:
> On 11/19/2021 6:35 AM, Richard Damon wrote:
>>
>> On 11/19/21 12:03 AM, olcott wrote:
>>> 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.
>>
>> Except that your 'PSR' set doesn't really mean anything. The 'self
>> reference' that happens in the problem is perfectly allowed by the
>> structure of the system.
>>
>> It is required for H to possibly be a Halt Decider that H perform a
>> Mathematical Computation and thus be able to be made as a Turing
>> Machine. The principle of Computations and rules for building Turing
>> machines most definitely ALLOW for the form of reference that the H/H^
>> pairing creates. In fact, that sort of referencing is an innate
>> property of Mathematical logic.
>>
>> Yes, you may find it inconvenient that it is allowed, but it is. And
>> in fact, due to how the logic system used in Mathematics is
>> constructed is one reason that the logic system YOU think is the only
>> that should be allowed doesn't work for the logic system of Mathematics.
>>
>>>
>>> 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
>>>
>>
>> Except that just calling something a 'Strawman' doesn't make it go away.
>
> Yes it does make it go away.

Then, YOU ARGUEMENT IS A STRAWMAN!!!

Does that make YOU 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.
>

But P(P) IS the computation that we are concerned with.

Sounds like you don't understand WHAT a computation is, so the idea that
your H isn't actually a computation is probably correct, and thus H
doesn't even

> Here is a simple example of the strawman error I clam to have a dog in
> my living you and your rebuttal proves that I do not have a cat in my
> living room.
>

Except that isn't what I am doing, so you claim is just a strawman.

You make a claim that H(P,P) is giving the right answer for the Halting
Problem.

The DEFINITION of what the right answer would be is the behavior of the
computation whose representation has been given to the decider.

The Decider is H

The input is P,P which is a representaiton of P(P)

So, the RIGHT answer is based on the behavior of P(P).

YOU make the claim that the aborted simulation that H performs has the
right behavior.

YOU are the one claiming to have a dog in the living room, and then you
show that you only have a cat in the living room, since the aborted
simulation done by H is NOT the actual behavior of the computation
represented by the input.

This shows that you LIE and have FAILED.

Pages:1234
server_pubkey.txt

rocksolid light 0.9.7
clearnet tor