Rocksolid Light

Welcome to novaBBS (click a section below)

mail  files  register  newsreader  groups  login

Message-ID:  

There's coffee in that nebula! -- Capt. Kathryn Janeway, Star Trek: Voyager, "The Cloud"


devel / comp.theory / Re: Concise refutation of halting problem proofs V27 [ finally mathematically precise ]( simpler syntax)

SubjectAuthor
* Concise refutation of halting problem proofs V27 [ finallyolcott
+* Concise refutation of halting problem proofs V27 [ finallyolcott
|`* Concise refutation of halting problem proofs V27 [ finallyAndré G. Isaak
| `* Concise refutation of halting problem proofs V27 [ finallyolcott
|  +- Concise refutation of halting problem proofs V27 [ finallyAndré G. Isaak
|  `* Concise refutation of halting problem proofs V27 [ finallyRichard Damon
|   `* Concise refutation of halting problem proofs V27 [ finallyAndré G. Isaak
|    +* Concise refutation of halting problem proofs V27 [ finallyolcott
|    |`* Concise refutation of halting problem proofs V27 [ finallyAndré G. Isaak
|    | `* Concise refutation of halting problem proofs V27 [ finallyolcott
|    |  +* Concise refutation of halting problem proofs V27 [ finallyRichard Damon
|    |  |`* Concise refutation of halting problem proofs V27 [ finallyolcott
|    |  | `- Concise refutation of halting problem proofs V27 [ finallyRichard Damon
|    |  `* Concise refutation of halting problem proofs V27 [ finallyAndré G. Isaak
|    |   `* Concise refutation of halting problem proofs V27 [ finallyolcott
|    |    +* Concise refutation of halting problem proofs V27 [ finallyAndré G. Isaak
|    |    |`* Concise refutation of halting problem proofs V27 [ finallyolcott
|    |    | +* Concise refutation of halting problem proofs V27 [ finallyAndré G. Isaak
|    |    | |`* Concise refutation of halting problem proofs V27 [ finallyolcott
|    |    | | +* Concise refutation of halting problem proofs V27 [ finallyolcott
|    |    | | |+* Concise refutation of halting problem proofs V27 [ finallyAndré G. Isaak
|    |    | | ||+* Concise refutation of halting problem proofs V27 [ finallyMalcolm McLean
|    |    | | |||`* Concise refutation of halting problem proofs V27 [ finally mathematically precisBen Bacarisse
|    |    | | ||| `* Concise refutation of halting problem proofs V27 [ finallyolcott
|    |    | | |||  `* Concise refutation of halting problem proofs V27 [ finallyAndré G. Isaak
|    |    | | |||   `* Concise refutation of halting problem proofs V27 [ finallyolcott
|    |    | | |||    `- Concise refutation of halting problem proofs V27 [ finallyRichard Damon
|    |    | | ||`* Concise refutation of halting problem proofs V27 [ finallyolcott
|    |    | | || +- Concise refutation of halting problem proofs V27 [ finallyRichard Damon
|    |    | | || `* Concise refutation of halting problem proofs V27 [ finallyAndré G. Isaak
|    |    | | ||  `* Concise refutation of halting problem proofs V27 [ finallyolcott
|    |    | | ||   +* Concise refutation of halting problem proofs V27 [ finallyAndré G. Isaak
|    |    | | ||   |`* Concise refutation of halting problem proofs V27 [ finallyolcott
|    |    | | ||   | +- Concise refutation of halting problem proofs V27 [ finallyRichard Damon
|    |    | | ||   | `- Concise refutation of halting problem proofs V27 [ finallyAndré G. Isaak
|    |    | | ||   `- Concise refutation of halting problem proofs V27 [ finallyRichard Damon
|    |    | | |`- Concise refutation of halting problem proofs V27 [ finallyRichard Damon
|    |    | | +* Concise refutation of halting problem proofs V27 [ finallyAndré G. Isaak
|    |    | | |`* Concise refutation of halting problem proofs V27 [ finallyolcott
|    |    | | | +- Concise refutation of halting problem proofs V27 [ finallyRichard Damon
|    |    | | | `* Concise refutation of halting problem proofs V27 [ finallyAndré G. Isaak
|    |    | | |  `* Concise refutation of halting problem proofs V27 [ finallyolcott
|    |    | | |   +* Concise refutation of halting problem proofs V27 [ finallyAndré G. Isaak
|    |    | | |   |`* Concise refutation of halting problem proofs V27 [ finallyolcott
|    |    | | |   | +- Concise refutation of halting problem proofs V27 [ finallyRichard Damon
|    |    | | |   | `* Concise refutation of halting problem proofs V27 [ finallyAndré G. Isaak
|    |    | | |   |  `* Concise refutation of halting problem proofs V27 [ finally mathematically precisolcott
|    |    | | |   |   +* Concise refutation of halting problem proofs V27 [ finallyAndré G. Isaak
|    |    | | |   |   |`* Concise refutation of halting problem proofs V27 [ finallyolcott
|    |    | | |   |   | +- Concise refutation of halting problem proofs V27 [ finallyRichard Damon
|    |    | | |   |   | `* Concise refutation of halting problem proofs V27 [ finallyAndré G. Isaak
|    |    | | |   |   |  `* Concise refutation of halting problem proofs V27 [ finallyolcott
|    |    | | |   |   |   +* Concise refutation of halting problem proofs V27 [ finallyAndré G. Isaak
|    |    | | |   |   |   |`* Concise refutation of halting problem proofs V27 [ finallyolcott
|    |    | | |   |   |   | +- Concise refutation of halting problem proofs V27 [ finallyRichard Damon
|    |    | | |   |   |   | `* Concise refutation of halting problem proofs V27 [ finallyAndré G. Isaak
|    |    | | |   |   |   |  +* Concise refutation of halting problem proofs V27 [ finallyolcott
|    |    | | |   |   |   |  |+- Concise refutation of halting problem proofs V27 [ finallyolcott
|    |    | | |   |   |   |  |+- Concise refutation of halting problem proofs V27 [ finallyAndré G. Isaak
|    |    | | |   |   |   |  |`- Concise refutation of halting problem proofs V27 [ finallyRichard Damon
|    |    | | |   |   |   |  `* Concise refutation of halting problem proofs V27 [ input is notolcott
|    |    | | |   |   |   |   +* Concise refutation of halting problem proofs V27 [ input is notAndré G. Isaak
|    |    | | |   |   |   |   |`* Concise refutation of halting problem proofs V27 [ input is notolcott
|    |    | | |   |   |   |   | +- Concise refutation of halting problem proofs V27 [ input is notRichard Damon
|    |    | | |   |   |   |   | `* Concise refutation of halting problem proofs V27 [ input is notAndré G. Isaak
|    |    | | |   |   |   |   |  +* Concise refutation of halting problem proofs V27 [ input is notolcott
|    |    | | |   |   |   |   |  |+* Concise refutation of halting problem proofs V27 [ input is notAndré G. Isaak
|    |    | | |   |   |   |   |  ||`* Concise refutation of halting problem proofs V27 [ input is notolcott
|    |    | | |   |   |   |   |  || +* Concise refutation of halting problem proofs V27 [ input is notAndré G. Isaak
|    |    | | |   |   |   |   |  || |+* Concise refutation of halting problem proofs V27 [ input is notolcott
|    |    | | |   |   |   |   |  || ||+- Concise refutation of halting problem proofs V27 [ input is notAndré G. Isaak
|    |    | | |   |   |   |   |  || ||`- Concise refutation of halting problem proofs V27 [ input is notRichard Damon
|    |    | | |   |   |   |   |  || |`* Concise refutation of halting problem proofs V27 [ input is notolcott
|    |    | | |   |   |   |   |  || | `- Concise refutation of halting problem proofs V27 [ input is notRichard Damon
|    |    | | |   |   |   |   |  || `- Concise refutation of halting problem proofs V27 [ input is notRichard Damon
|    |    | | |   |   |   |   |  |`- Concise refutation of halting problem proofs V27 [ input is notRichard Damon
|    |    | | |   |   |   |   |  `* Concise refutation of halting problem proofs V27 [ input is not in domain ]Ben Bacarisse
|    |    | | |   |   |   |   |   +* Concise refutation of halting problem proofs V27 [ input is not in domain ]Ben Bacarisse
|    |    | | |   |   |   |   |   |+- Concise refutation of halting problem proofs V27 [ input is notolcott
|    |    | | |   |   |   |   |   |`- Concise refutation of halting problem proofs V27 [ input is not in domain ]Ben Bacarisse
|    |    | | |   |   |   |   |   `- Concise refutation of halting problem proofs V27 [ input is notolcott
|    |    | | |   |   |   |   `- Concise refutation of halting problem proofs V27 [ input is notRichard Damon
|    |    | | |   |   |   `- Concise refutation of halting problem proofs V27 [ finallyRichard Damon
|    |    | | |   |   `- Concise refutation of halting problem proofs V27 [ finallyRichard Damon
|    |    | | |   `- Concise refutation of halting problem proofs V27 [ finallyRichard Damon
|    |    | | `- Concise refutation of halting problem proofs V27 [ finallyRichard Damon
|    |    | `- Concise refutation of halting problem proofs V27 [ finallyRichard Damon
|    |    `- Concise refutation of halting problem proofs V27 [ finallyRichard Damon
|    `- Concise refutation of halting problem proofs V27 [ finallyRichard Damon
`- Concise refutation of halting problem proofs V27 [ finallyRichard Damon

Pages:1234
Concise refutation of halting problem proofs V27 [ finally mathematically precise ]

<5-2dncs2MNPqYwb8nZ2dnUU7-KvNnZ2d@giganews.com>

 copy mid

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

 copy link   Newsgroups: comp.theory comp.ai.philosophy sci.logic sci.math
Followup: comp.theory
Path: i2pn2.org!i2pn.org!weretis.net!feeder6.news.weretis.net!news.misty.com!border2.nntp.dca1.giganews.com!nntp.giganews.com!buffer2.nntp.dca1.giganews.com!buffer1.nntp.dca1.giganews.com!news.giganews.com.POSTED!not-for-mail
NNTP-Posting-Date: Mon, 22 Nov 2021 14:32:55 -0600
Date: Mon, 22 Nov 2021 14:32:54 -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
Newsgroups: comp.theory,comp.ai.philosophy,sci.logic,sci.math
Content-Language: en-US
Followup-To: comp.theory
From: NoO...@NoWhere.com (olcott)
Subject: Concise refutation of halting problem proofs V27 [ finally
mathematically precise ]
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Message-ID: <5-2dncs2MNPqYwb8nZ2dnUU7-KvNnZ2d@giganews.com>
Lines: 59
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-135M95SDSjK1g+PI2+QjZ6z4RTZn1/5CmXmhSXOcSZptKE89Z6ufpN9jCS8tnzrdW5j4D0r/ap4vE6I!UT+y52JcmxU2G8GXqvKm8bQXhXA/D4Bx1htVwVhBfZY+sv8l6gF8RzCrMLffS/VbbKwxm+krSfl7!SA==
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: 2959
 by: olcott - Mon, 22 Nov 2021 20:32 UTC

#include <stdint.h>
#include <stdio.h>
typedef int (*ptr)();

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

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

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

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

[PSR_set] Combinations of H/P having pathological self-reference
For every H of H(P,P) where P(P) calls this same H(P,P) and H simulates
or executes its input and aborts or does not abort its input.
∀H ∊ PSR_set ∀P ∊ PSR_set (Input_Never_Halts(H(P,P)))
[PSR_subset_A] ∃H ∊ PSR_set ∃P ∊ PSR_set (Halts( H(P,P) ))
[PSR_subset_B] ∃H ∊ PSR_set ∃P ∊ PSR_set (Halts( P(P) ))

[PSR_subset_C] The subset of the PSR_subset_A where H returns 0 on the
basis that H correctly detects that its input never halts (reaches its
final instruction). H could detect that its simulated P is calling
H(P,P) with the same parameters that it was called with, thus specifying
infinite recursion.

H is a computable function that accepts or rejects inputs in its domain
on the basis that these inputs specify a sequence of configurations that
reach their final state.
H is a correct decider and H has a correct halt deciding basis.

*(see page 3)*
Halting problem undecidability and infinitely nested simulation V2

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 V27 [ finally mathematically precise ]( simpler syntax)

<NvednQUyFr32mQH8nZ2dnUU7-IGdnZ2d@giganews.com>

 copy mid

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

 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: Mon, 22 Nov 2021 14:58:19 -0600
Date: Mon, 22 Nov 2021 14:58:18 -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 V27 [ finally
mathematically precise ]( simpler syntax)
Content-Language: en-US
Newsgroups: comp.theory
References: <5-2dncs2MNPqYwb8nZ2dnUU7-KvNnZ2d@giganews.com>
From: NoO...@NoWhere.com (olcott)
In-Reply-To: <5-2dncs2MNPqYwb8nZ2dnUU7-KvNnZ2d@giganews.com>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Message-ID: <NvednQUyFr32mQH8nZ2dnUU7-IGdnZ2d@giganews.com>
Lines: 64
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-U1H/4e5HitgHT1Jdm8jttMuuu3zE2uXwORAXcosHVMsgZ8on6k/P7CtMh2/0yNP69TQgQW8NNgsQZlT!JjKnnKYcTiNV5mQdMrVnx80WQo4bdpQdpgg3K6EuiSz54Z9Phz+ehUJPT1G2Ce4NrPVu7GC+HSS9!bA==
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: 3165
 by: olcott - Mon, 22 Nov 2021 20:58 UTC

On 11/22/2021 2:32 PM, olcott wrote:
> #include <stdint.h>
> #include <stdio.h>
> typedef int (*ptr)();
>
> int H(ptr x, ptr y)
> {
>   x(y); // direct execution of P(P)
>   return 1;
> }
>
> // Minimal essence of Linz(1990) Ĥ
> // and Strachey(1965) P
> int P(ptr x)
> {
>   H(x, x);
>   return 1; // Give P a last instruction at the "c" level
> }
>
> int main(void)
> {
>   H(P, P);
> }
>
> Computation that halts
> a computation is said to halt whenever it enters a final state.
> (Linz:1990:234)
>
> [PSR_set] Combinations of H/P having pathological self-reference
> For every H of H(P,P) where P(P) calls this same H(P,P) and H simulates
> or executes its input and aborts or does not abort its input.

[PSR_set] ∀{H,P} ∊ PSR_set (Input_Never_Halts( H(P,P) ))
[PSR_subset_A] ∃{H,P} ∊ PSR_set (Halts( H(P,P) ))
[PSR_subset_B] ∃{H,P} ∊ PSR_set (Halts( P(P) ))

> [PSR_subset_C] The subset of the PSR_subset_A where H returns 0 on the
> basis that H correctly detects that its input never halts (reaches its
> final instruction). H could detect that its simulated P is calling
> H(P,P) with the same parameters that it was called with, thus specifying
> infinite recursion.
>
> H is a computable function that accepts or rejects inputs in its domain
> on the basis that these inputs specify a sequence of configurations that
> reach their final state.
> H is a correct decider and H has a correct halt deciding basis.
>
> *(see page 3)*
> Halting problem undecidability and infinitely nested simulation V2
>
> 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 V27 [ finally mathematically precise ]( simpler syntax)

<snh212$mup$1@dont-email.me>

 copy mid

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

 copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!weretis.net!feeder8.news.weretis.net!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 V27 [ finally
mathematically precise ]( simpler syntax)
Date: Mon, 22 Nov 2021 14:28:01 -0700
Organization: Christians and Atheists United Against Creeping Agnosticism
Lines: 13
Message-ID: <snh212$mup$1@dont-email.me>
References: <5-2dncs2MNPqYwb8nZ2dnUU7-KvNnZ2d@giganews.com>
<NvednQUyFr32mQH8nZ2dnUU7-IGdnZ2d@giganews.com>
Mime-Version: 1.0
Content-Type: text/plain; charset=utf-8; format=flowed
Content-Transfer-Encoding: 8bit
Injection-Date: Mon, 22 Nov 2021 21:28:02 -0000 (UTC)
Injection-Info: reader02.eternal-september.org; posting-host="614f80d04cf7af6f35f3f568e1201dce";
logging-data="23513"; mail-complaints-to="abuse@eternal-september.org"; posting-account="U2FsdGVkX1+KpY0FTiannYoU+1eCIj5Y"
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.14; rv:78.0)
Gecko/20100101 Thunderbird/78.14.0
Cancel-Lock: sha1:/BxwmX1/774HW0Ca2kaKfEmAkbk=
In-Reply-To: <NvednQUyFr32mQH8nZ2dnUU7-IGdnZ2d@giganews.com>
Content-Language: en-US
 by: André G. Isaak - Mon, 22 Nov 2021 21:28 UTC

On 2021-11-22 13:58, olcott wrote:

> [PSR_set] ∀{H,P} ∊ PSR_set (Input_Never_Halts(  H(P,P)  ))
> [PSR_subset_A] ∃{H,P} ∊ PSR_set  (Halts(  H(P,P)  ))
> [PSR_subset_B] ∃{H,P} ∊ PSR_set  (Halts(  P(P)  ))

Do you honestly think the above three lines actually mean something?

André

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

Re: Concise refutation of halting problem proofs V27 [ finally mathematically precise ]

<3%TmJ.117081$IW4.83647@fx48.iad>

 copy mid

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

 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!peer02.iad!feed-me.highwinds-media.com!news.highwinds-media.com!fx48.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 V27 [ finally
mathematically precise ]
Content-Language: en-US
Newsgroups: comp.theory
References: <5-2dncs2MNPqYwb8nZ2dnUU7-KvNnZ2d@giganews.com>
From: Rich...@Damon-Family.org (Richard Damon)
In-Reply-To: <5-2dncs2MNPqYwb8nZ2dnUU7-KvNnZ2d@giganews.com>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Lines: 113
Message-ID: <3%TmJ.117081$IW4.83647@fx48.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: Mon, 22 Nov 2021 16:31:36 -0500
X-Received-Bytes: 4847
X-Original-Bytes: 4714
 by: Richard Damon - Mon, 22 Nov 2021 21:31 UTC

First comment, This is absolutely NOT a proof, just a bunch of claims
with NO actual proof.

On 11/22/21 3:32 PM, olcott wrote:
> #include <stdint.h>
> #include <stdio.h>
> typedef int (*ptr)();
>
> int H(ptr x, ptr y)
> {
>   x(y); // direct execution of P(P)
>   return 1;
> }
>
> // Minimal essence of Linz(1990) Ĥ
> // and Strachey(1965) P
> int P(ptr x)
> {
>   H(x, x);
>   return 1; // Give P a last instruction at the "c" level
> }
>
> int main(void)
> {
>   H(P, P);
> }
>
> Computation that halts
> a computation is said to halt whenever it enters a final state.
> (Linz:1990:234)

See other commments for clarification of this.

>
> [PSR_set] Combinations of H/P having pathological self-reference
> For every H of H(P,P) where P(P) calls this same H(P,P) and H simulates
> or executes its input and aborts or does not abort its input.
> ∀H ∊ PSR_set ∀P ∊ PSR_set (Input_Never_Halts(H(P,P)))
> [PSR_subset_A] ∃H ∊ PSR_set ∃P ∊ PSR_set (Halts(  H(P,P)  ))
> [PSR_subset_B] ∃H ∊ PSR_set ∃P ∊ PSR_set (Halts(  P(P)  ))

So, what is Halts? Seems undefined. If it does NOT mean EXACTLY that it
is True if the computation given as a parameter will halt in finite
time, and will NEVER halt if the compuation is allowed to run for
unbounded time, it is worthless.

Note, for the Halting Problem refutation, you need to be working with
MATCHED H and P, not arbitrary H and P that might be unreleted (looking
at a P that isn't based on THAT H),

Note also, we have confirmed, and you have even aggreed that if H(P,P)
returns 0, then that actual computation P(P) will Halt.

Since, THAT is what the CORRECT answer to the halting problem refers to,
No H that returns 0 for H(P,P) is correct about P(P).

>
> [PSR_subset_C] The subset of the PSR_subset_A where H returns 0 on the
> basis that H correctly detects that its input never halts (reaches its
> final instruction). H could detect that its simulated P is calling
> H(P,P) with the same parameters that it was called with, thus specifying
> infinite recursion.

Except this is by definition EMPTY as if H(P,P) aborts its processing,
then P calling H(P,P) can NOT be infinitely recursive, as that H will
not support infinite recursion.

Maybe you can have elements if you are looking at the full cross of all
possible Hs with all possible Ps then there are some Hi(Pj,Pj) that can
be correct in saying Pj(Pj) is non-halting when Hi(Pj,Pj) returns 0, but
this will NEVER be the case if i == j, so FAIL.

There is no finite time t that H can simulate that also allows its
calling function to run for an infinite time to be infinitely recursive.
This is an absolute impossibility. There is not finite number that is
greater than an unbounded value.

The fact that the called H WILL abort its processing of P(P) means that
there is no infinite recursion, and H has done incorrect reasoning in
coming to that conclusion.

Your error is that H makes the FALSE assumption that the H inside P will
not abort its simulation, but since the ONLY pairing that matter are
when we look at a P

>
> H is a computable function that accepts or rejects inputs in its domain
> on the basis that these inputs specify a sequence of configurations that
> reach their final state.
> H is a correct decider and H has a correct halt deciding basis.

Maybe H is a correct POOP decider, but it failed at being a correct Halt
Decider.

DEFINITION: H(P,P) asks if the computation P(P) will Halt when run as a
computation.

If H(P,P) returns 0, we can by simple inspection see that this P(P) will
halt.

FAIL.

>
> *(see page 3)*
> Halting problem undecidability and infinitely nested simulation V2
>
> https://www.researchgate.net/publication/356105750_Halting_problem_undecidability_and_infinitely_nested_simulation_V2)
>
>
>
>

Re: Concise refutation of halting problem proofs V27 [ finally mathematically precise ]( simpler syntax)

<MpydnY7JbLEWkgH8nZ2dnUU7-SHNnZ2d@giganews.com>

 copy mid

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

 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: Mon, 22 Nov 2021 15:45:47 -0600
Date: Mon, 22 Nov 2021 15:45:46 -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 V27 [ finally
mathematically precise ]( simpler syntax)
Content-Language: en-US
Newsgroups: comp.theory
References: <5-2dncs2MNPqYwb8nZ2dnUU7-KvNnZ2d@giganews.com>
<NvednQUyFr32mQH8nZ2dnUU7-IGdnZ2d@giganews.com> <snh212$mup$1@dont-email.me>
From: NoO...@NoWhere.com (olcott)
In-Reply-To: <snh212$mup$1@dont-email.me>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Message-ID: <MpydnY7JbLEWkgH8nZ2dnUU7-SHNnZ2d@giganews.com>
Lines: 26
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-4fM29ppaNDvC82RDeLBNLHKNCQlEbaDVRX9sWoTFfOEUsbw4UKkMiCLFbkkurrPDBqFWC0QxycDZeVF!s9ONhBBJLzzBWE+x2zEBwlKTPpAH851grF38wzHMDU2nyk2BOUIDUdLjq8VCyfAW4bD/J/WaBqqn!Gg==
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: 2103
 by: olcott - Mon, 22 Nov 2021 21:45 UTC

On 11/22/2021 3:28 PM, André G. Isaak wrote:
> On 2021-11-22 13:58, olcott wrote:
>
>> [PSR_set] ∀(H,P) ∊ PSR_set (Input_Never_Halts(  H(P,P)  ))
>> [PSR_subset_A] ∃(H,P) ∊ PSR_set  (Halts(  H(P,P)  ))
>> [PSR_subset_B] ∃(H,P) ∊ PSR_set  (Halts(  P(P)  ))
>
> Do you honestly think the above three lines actually mean something?
>
> André
>

Certainly not what you erase their set definition:
Every unordered pair of combinations of H/P such that:

(a) H simulates or executes its input and aborts or does not abort its
input.

(b) P(P) calls this same H(P,P) with itself as input.

--
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 V27 [ finally mathematically precise ]( simpler syntax)

<snh3n4$36t$1@dont-email.me>

 copy mid

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

 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 V27 [ finally
mathematically precise ]( simpler syntax)
Date: Mon, 22 Nov 2021 14:56:50 -0700
Organization: Christians and Atheists United Against Creeping Agnosticism
Lines: 36
Message-ID: <snh3n4$36t$1@dont-email.me>
References: <5-2dncs2MNPqYwb8nZ2dnUU7-KvNnZ2d@giganews.com>
<NvednQUyFr32mQH8nZ2dnUU7-IGdnZ2d@giganews.com> <snh212$mup$1@dont-email.me>
<MpydnY7JbLEWkgH8nZ2dnUU7-SHNnZ2d@giganews.com>
Mime-Version: 1.0
Content-Type: text/plain; charset=utf-8; format=flowed
Content-Transfer-Encoding: 8bit
Injection-Date: Mon, 22 Nov 2021 21:56:52 -0000 (UTC)
Injection-Info: reader02.eternal-september.org; posting-host="614f80d04cf7af6f35f3f568e1201dce";
logging-data="3293"; mail-complaints-to="abuse@eternal-september.org"; posting-account="U2FsdGVkX1++2cyZc7xw2IZu+R13wLuI"
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.14; rv:78.0)
Gecko/20100101 Thunderbird/78.14.0
Cancel-Lock: sha1:I5aa3RytNJgSZFtYA39IHa0TqJ4=
In-Reply-To: <MpydnY7JbLEWkgH8nZ2dnUU7-SHNnZ2d@giganews.com>
Content-Language: en-US
 by: André G. Isaak - Mon, 22 Nov 2021 21:56 UTC

On 2021-11-22 14:45, olcott wrote:
> On 11/22/2021 3:28 PM, André G. Isaak wrote:
>> On 2021-11-22 13:58, olcott wrote:
>>
>>> [PSR_set] ∀(H,P) ∊ PSR_set (Input_Never_Halts(  H(P,P)  ))
>>> [PSR_subset_A] ∃(H,P) ∊ PSR_set  (Halts(  H(P,P)  ))
>>> [PSR_subset_B] ∃(H,P) ∊ PSR_set  (Halts(  P(P)  ))
>>
>> Do you honestly think the above three lines actually mean something?
>>
>> André
>>
>
> Certainly not what you erase their set definition:

As usual, you are entirely missing my point. The above three statements
are utter gibberish. They do not conform to the syntax of any notation
used in computer science or logic. Missing definitions aren't the issue.

> Every unordered pair of combinations of H/P such that:
> (a) H simulates or executes its input and aborts or does not abort its
> input.
>
> (b) P(P) calls this same H(P,P) with itself as input.

Your (a) and (b) above do absolutely nothing to help makie your
stream-of-consciousness notation coherent.

If you don't even grasp the basics of logical notation, how can you
possibly understand any of the definitions which Linz gives?

André

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

Re: Concise refutation of halting problem proofs V27 [ finally mathematically precise ]( simpler syntax)

<TtUmJ.126712$831.100143@fx40.iad>

 copy mid

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

 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!fx40.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 V27 [ finally
mathematically precise ]( simpler syntax)
Content-Language: en-US
Newsgroups: comp.theory
References: <5-2dncs2MNPqYwb8nZ2dnUU7-KvNnZ2d@giganews.com>
<NvednQUyFr32mQH8nZ2dnUU7-IGdnZ2d@giganews.com> <snh212$mup$1@dont-email.me>
<MpydnY7JbLEWkgH8nZ2dnUU7-SHNnZ2d@giganews.com>
From: Rich...@Damon-Family.org (Richard Damon)
In-Reply-To: <MpydnY7JbLEWkgH8nZ2dnUU7-SHNnZ2d@giganews.com>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Lines: 44
Message-ID: <TtUmJ.126712$831.100143@fx40.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: Mon, 22 Nov 2021 17:04:27 -0500
X-Received-Bytes: 2599
 by: Richard Damon - Mon, 22 Nov 2021 22:04 UTC

On 11/22/21 4:45 PM, olcott wrote:
> On 11/22/2021 3:28 PM, André G. Isaak wrote:
>> On 2021-11-22 13:58, olcott wrote:
>>
>>> [PSR_set] ∀(H,P) ∊ PSR_set (Input_Never_Halts(  H(P,P)  ))
>>> [PSR_subset_A] ∃(H,P) ∊ PSR_set  (Halts(  H(P,P)  ))
>>> [PSR_subset_B] ∃(H,P) ∊ PSR_set  (Halts(  P(P)  ))
>>
>> Do you honestly think the above three lines actually mean something?
>>
>> André
>>
>
> Certainly not what you erase their set definition:
> Every unordered pair of combinations of H/P such that:
>
> (a) H simulates or executes its input and aborts or does not abort its
> input.
>
> (b) P(P) calls this same H(P,P) with itself as input.
>

But the term 'Halts', used as a function, has not been defined.

Also we KNOW that:

If H is of the side of the set that does NOT abort its processing of
H(P,P), then it fails to be a proper halt decider because it fails to
answer the question H(P,P).

If H is of the side of the set that DOES abort its processing of H(P,pP)
and return 0, then H is incorrect as P(P) will Halt. (As admitted by you).

Thus none of our PSR subsets include ANY correct halt deciders.

You confuse the Halting property of the computation whose representation
is given to H (that is P(P) ) with the incomplete tracing that H does of
that Computation.

You H looks out the wrong window and gets the wrong results.

You LIE about this, and thus are shown to be a FRAUD.

Re: Concise refutation of halting problem proofs V27 [ finally mathematically precise ]( simpler syntax)

<snh4jm$a0i$1@dont-email.me>

 copy mid

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

 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 V27 [ finally
mathematically precise ]( simpler syntax)
Date: Mon, 22 Nov 2021 15:12:05 -0700
Organization: Christians and Atheists United Against Creeping Agnosticism
Lines: 43
Message-ID: <snh4jm$a0i$1@dont-email.me>
References: <5-2dncs2MNPqYwb8nZ2dnUU7-KvNnZ2d@giganews.com>
<NvednQUyFr32mQH8nZ2dnUU7-IGdnZ2d@giganews.com> <snh212$mup$1@dont-email.me>
<MpydnY7JbLEWkgH8nZ2dnUU7-SHNnZ2d@giganews.com>
<TtUmJ.126712$831.100143@fx40.iad>
Mime-Version: 1.0
Content-Type: text/plain; charset=utf-8; format=flowed
Content-Transfer-Encoding: 8bit
Injection-Date: Mon, 22 Nov 2021 22:12:06 -0000 (UTC)
Injection-Info: reader02.eternal-september.org; posting-host="614f80d04cf7af6f35f3f568e1201dce";
logging-data="10258"; mail-complaints-to="abuse@eternal-september.org"; posting-account="U2FsdGVkX1+KgTxxJfVMqGocZNJUz5HB"
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.14; rv:78.0)
Gecko/20100101 Thunderbird/78.14.0
Cancel-Lock: sha1:au7rK4pK/9cygD+Y2UMU9Oz7SRA=
In-Reply-To: <TtUmJ.126712$831.100143@fx40.iad>
Content-Language: en-US
 by: André G. Isaak - Mon, 22 Nov 2021 22:12 UTC

On 2021-11-22 15:04, Richard Damon wrote:
> On 11/22/21 4:45 PM, olcott wrote:
>> On 11/22/2021 3:28 PM, André G. Isaak wrote:
>>> On 2021-11-22 13:58, olcott wrote:
>>>
>>>> [PSR_set] ∀(H,P) ∊ PSR_set (Input_Never_Halts(  H(P,P)  ))
>>>> [PSR_subset_A] ∃(H,P) ∊ PSR_set  (Halts(  H(P,P)  ))
>>>> [PSR_subset_B] ∃(H,P) ∊ PSR_set  (Halts(  P(P)  ))
>>>
>>> Do you honestly think the above three lines actually mean something?
>>>
>>> André
>>>
>>
>> Certainly not what you erase their set definition:
>> Every unordered pair of combinations of H/P such that:
>>
>> (a) H simulates or executes its input and aborts or does not abort its
>> input.
>>
>> (b) P(P) calls this same H(P,P) with itself as input.
>>
>
> But the term 'Halts', used as a function, has not been defined.

Nor, for that matter, has his use of square brackets.

And I have no idea what ∀(H,P) is supposed to mean. It that the same as
∀H∀P? And if so, what does ∀P even mean given that every H has its *own*
P since P is derived from H via a transformation (or at least it is if
his P is supposed to correspond to Linz's H_Hat). Ditto for ∃(H,P).

His text suggests that (H, P) is an unordered pair, which is strange
given that if it tries to express the relation between H and H_Hat it
would need to be an *ordered* pair. But a quantifier is normally
followed by a variable name, not by an (un)ordered pair, so who knows
what is actually intended here.

André

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

Re: Concise refutation of halting problem proofs V27 [ finally mathematically precise ]( simpler syntax)

<cNKdnX6ckqwSvAH8nZ2dnUU7-WXNnZ2d@giganews.com>

 copy mid

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

 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!news.giganews.com.POSTED!not-for-mail
NNTP-Posting-Date: Mon, 22 Nov 2021 17:02:39 -0600
Date: Mon, 22 Nov 2021 17:02:37 -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 V27 [ finally
mathematically precise ]( simpler syntax)
Content-Language: en-US
Newsgroups: comp.theory
References: <5-2dncs2MNPqYwb8nZ2dnUU7-KvNnZ2d@giganews.com>
<NvednQUyFr32mQH8nZ2dnUU7-IGdnZ2d@giganews.com> <snh212$mup$1@dont-email.me>
<MpydnY7JbLEWkgH8nZ2dnUU7-SHNnZ2d@giganews.com>
<TtUmJ.126712$831.100143@fx40.iad> <snh4jm$a0i$1@dont-email.me>
From: NoO...@NoWhere.com (olcott)
In-Reply-To: <snh4jm$a0i$1@dont-email.me>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Message-ID: <cNKdnX6ckqwSvAH8nZ2dnUU7-WXNnZ2d@giganews.com>
Lines: 77
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-G95uqUH+Gop80jfQVsPw7SktAjGrioXakeo8fpg7wVnmuEK76VNI0zt/HVWuiPZ/rfRxVLtQczLOSsg!Rdf/zZTa5/wXH+xKtEiifTo7+PWWItGuuVTpXBVxnxIpaGVKGUPKzT/CNXqpqcY1CvA0ZtGK3BPg!7w==
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: 3986
 by: olcott - Mon, 22 Nov 2021 23:02 UTC

On 11/22/2021 4:12 PM, André G. Isaak wrote:
> On 2021-11-22 15:04, Richard Damon wrote:
>> On 11/22/21 4:45 PM, olcott wrote:
>>> On 11/22/2021 3:28 PM, André G. Isaak wrote:
>>>> On 2021-11-22 13:58, olcott wrote:
>>>>
>>>>> [PSR_set] ∀(H,P) ∊ PSR_set (Input_Never_Halts(  H(P,P)  ))
>>>>> [PSR_subset_A] ∃(H,P) ∊ PSR_set  (Halts(  H(P,P)  ))
>>>>> [PSR_subset_B] ∃(H,P) ∊ PSR_set  (Halts(  P(P)  ))
>>>>
>>>> Do you honestly think the above three lines actually mean something?
>>>>
>>>> André
>>>>
>>>
>>> Certainly not what you erase their set definition:
>>> Every unordered pair of combinations of H/P such that:
>>>
>>> (a) H simulates or executes its input and aborts or does not abort
>>> its input.
>>>
>>> (b) P(P) calls this same H(P,P) with itself as input.
>>>
>>
>> But the term 'Halts', used as a function, has not been defined.
>
> Nor, for that matter, has his use of square brackets.
>

My use of square brackets substitutes for bold
> And I have no idea what ∀(H,P) is supposed to mean. It that the same as

Combinations (not permutations) of H/P having pathological self-reference.

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

> ∀H∀P? And if so, what does ∀P even mean given that every H has its *own*
> P since P is derived from H via a transformation (or at least it is if
> his P is supposed to correspond to Linz's H_Hat). Ditto for ∃(H,P).
>
> His text suggests that (H, P) is an unordered pair, which is strange
> given that if it tries to express the relation between H and H_Hat it
> would need to be an *ordered* pair. But a quantifier is normally
> followed by a variable name, not by an (un)ordered pair, so who knows
> what is actually intended here.
>
> André
>

Combinations of H/P having pathological self-reference (PSR)
H simulates or executes its input and aborts or does
not abort its input and P(P) calls this same H(P,P)

PSR_subset_A ⊆ PSR set
PSR_subset_B ⊆ PSR set

PSR_set: for n = 0 to ∞
{ (Input_Never_Halts( Hn(Pn,Pn) ))
(Sometimes_Halts( Hn(Pn,Pn) ))
(Sometimes_Halts( Pn(Pn) ))
}

--
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 V27 [ finally mathematically precise ]( simpler syntax)

<glVmJ.58212$np6.47543@fx46.iad>

 copy mid

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

 copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!aioe.org!news.uzoreto.com!newsfeed.xs4all.nl!newsfeed9.news.xs4all.nl!news-out.netnews.com!news.alt.net!fdc2.netnews.com!peer03.ams1!peer.ams1.xlned.com!news.xlned.com!peer02.iad!feed-me.highwinds-media.com!news.highwinds-media.com!fx46.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 V27 [ finally
mathematically precise ]( simpler syntax)
Content-Language: en-US
Newsgroups: comp.theory
References: <5-2dncs2MNPqYwb8nZ2dnUU7-KvNnZ2d@giganews.com>
<NvednQUyFr32mQH8nZ2dnUU7-IGdnZ2d@giganews.com> <snh212$mup$1@dont-email.me>
<MpydnY7JbLEWkgH8nZ2dnUU7-SHNnZ2d@giganews.com>
<TtUmJ.126712$831.100143@fx40.iad> <snh4jm$a0i$1@dont-email.me>
From: Rich...@Damon-Family.org (Richard Damon)
In-Reply-To: <snh4jm$a0i$1@dont-email.me>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Lines: 55
Message-ID: <glVmJ.58212$np6.47543@fx46.iad>
X-Complaints-To: abuse@easynews.com
Organization: Forte - www.forteinc.com
X-Complaints-Info: Please be sure to forward a copy of ALL headers otherwise we will be unable to process your complaint properly.
Date: Mon, 22 Nov 2021 18:03:33 -0500
X-Received-Bytes: 3396
 by: Richard Damon - Mon, 22 Nov 2021 23:03 UTC

On 11/22/21 5:12 PM, André G. Isaak wrote:
> On 2021-11-22 15:04, Richard Damon wrote:
>> On 11/22/21 4:45 PM, olcott wrote:
>>> On 11/22/2021 3:28 PM, André G. Isaak wrote:
>>>> On 2021-11-22 13:58, olcott wrote:
>>>>
>>>>> [PSR_set] ∀(H,P) ∊ PSR_set (Input_Never_Halts(  H(P,P)  ))
>>>>> [PSR_subset_A] ∃(H,P) ∊ PSR_set  (Halts(  H(P,P)  ))
>>>>> [PSR_subset_B] ∃(H,P) ∊ PSR_set  (Halts(  P(P)  ))
>>>>
>>>> Do you honestly think the above three lines actually mean something?
>>>>
>>>> André
>>>>
>>>
>>> Certainly not what you erase their set definition:
>>> Every unordered pair of combinations of H/P such that:
>>>
>>> (a) H simulates or executes its input and aborts or does not abort
>>> its input.
>>>
>>> (b) P(P) calls this same H(P,P) with itself as input.
>>>
>>
>> But the term 'Halts', used as a function, has not been defined.
>
> Nor, for that matter, has his use of square brackets.

I thought he once introduced that as a way to mark a 'phrase' as an atom
of meaning to be taken together, but since the contents are already just
a single atom having been combined by _ it wouldn't be need
>
> And I have no idea what ∀(H,P) is supposed to mean. It that the same as
> ∀H∀P? And if so, what does ∀P even mean given that every H has its *own*
> P since P is derived from H via a transformation (or at least it is if
> his P is supposed to correspond to Linz's H_Hat). Ditto for ∃(H,P).
>

My assuption here is that we have H,P pairs (as every H has a SPECIFIC
P, and every P has a SPECIFIC H that it is paired with, so all(H,P)
would mean for all H and the corresponding P built on that H, but he
doesn't really seem consistent with that, since H seems to assume that
the H in P is really just is ultra dumb direct execution H (and thus he
treats P as the wrong P).

> His text suggests that (H, P) is an unordered pair, which is strange
> given that if it tries to express the relation between H and H_Hat it
> would need to be an *ordered* pair. But a quantifier is normally
> followed by a variable name, not by an (un)ordered pair, so who knows
> what is actually intended here.
>
> André
>

Re: Concise refutation of halting problem proofs V27 [ finally mathematically precise ]( simpler syntax)

<snh8d4$4t1$1@dont-email.me>

 copy mid

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

 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 V27 [ finally
mathematically precise ]( simpler syntax)
Date: Mon, 22 Nov 2021 16:16:51 -0700
Organization: Christians and Atheists United Against Creeping Agnosticism
Lines: 77
Message-ID: <snh8d4$4t1$1@dont-email.me>
References: <5-2dncs2MNPqYwb8nZ2dnUU7-KvNnZ2d@giganews.com>
<NvednQUyFr32mQH8nZ2dnUU7-IGdnZ2d@giganews.com> <snh212$mup$1@dont-email.me>
<MpydnY7JbLEWkgH8nZ2dnUU7-SHNnZ2d@giganews.com>
<TtUmJ.126712$831.100143@fx40.iad> <snh4jm$a0i$1@dont-email.me>
<cNKdnX6ckqwSvAH8nZ2dnUU7-WXNnZ2d@giganews.com>
Mime-Version: 1.0
Content-Type: text/plain; charset=utf-8; format=flowed
Content-Transfer-Encoding: 8bit
Injection-Date: Mon, 22 Nov 2021 23:16:53 -0000 (UTC)
Injection-Info: reader02.eternal-september.org; posting-host="49b13d9d5e2a82410bb5befc4a1eb4ad";
logging-data="5025"; mail-complaints-to="abuse@eternal-september.org"; posting-account="U2FsdGVkX1+dTPdihWNNtqiiaLrg7m7S"
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.14; rv:78.0)
Gecko/20100101 Thunderbird/78.14.0
Cancel-Lock: sha1:g/c1MqG4E0JqkKNDgzhauQl4xC4=
In-Reply-To: <cNKdnX6ckqwSvAH8nZ2dnUU7-WXNnZ2d@giganews.com>
Content-Language: en-US
 by: André G. Isaak - Mon, 22 Nov 2021 23:16 UTC

On 2021-11-22 16:02, olcott wrote:
> On 11/22/2021 4:12 PM, André G. Isaak wrote:
>> On 2021-11-22 15:04, Richard Damon wrote:
>>> On 11/22/21 4:45 PM, olcott wrote:
>>>> On 11/22/2021 3:28 PM, André G. Isaak wrote:
>>>>> On 2021-11-22 13:58, olcott wrote:
>>>>>
>>>>>> [PSR_set] ∀(H,P) ∊ PSR_set (Input_Never_Halts(  H(P,P)  ))
>>>>>> [PSR_subset_A] ∃(H,P) ∊ PSR_set  (Halts(  H(P,P)  ))
>>>>>> [PSR_subset_B] ∃(H,P) ∊ PSR_set  (Halts(  P(P)  ))
>>>>>
>>>>> Do you honestly think the above three lines actually mean something?
>>>>>
>>>>> André
>>>>>
>>>>
>>>> Certainly not what you erase their set definition:
>>>> Every unordered pair of combinations of H/P such that:
>>>>
>>>> (a) H simulates or executes its input and aborts or does not abort
>>>> its input.
>>>>
>>>> (b) P(P) calls this same H(P,P) with itself as input.
>>>>
>>>
>>> But the term 'Halts', used as a function, has not been defined.
>>
>> Nor, for that matter, has his use of square brackets.
>>
>
> My use of square brackets substitutes for bold

And bold means what?

>> And I have no idea what ∀(H,P) is supposed to mean. It that the same as
>
> Combinations (not permutations) of H/P having pathological self-reference.

Which isn't what ∀(H,P) means since ∀(H,P) doesn't mean anything at all.
it is simply ill-formed.

And what does "Combinations (not permutations) of H/P" mean?

What would be an example of a combination of H/P?
What would be an example of a permutation of H/P?

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

And what does "Every H of H(P,P)" mean?

You may think that some of these things are meaningful or that your
notation makes sense but they really do not. I'd stick with plain
ordinary English if I were you.

I'd also reflect on the fact that if you can't form coherent sentences
using particular terminology or coherent formulae using a particular
notation then you also cannot possibly expect to understand their use by
others either.

And this bit is particularly mystifying:

> PSR_set: for n = 0 to ∞
> {
> (Input_Never_Halts( Hn(Pn,Pn) ))
> (Sometimes_Halts( Hn(Pn,Pn) ))
> (Sometimes_Halts( Pn(Pn) ))
> }

André

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

Re: Concise refutation of halting problem proofs V27 [ finally mathematically precise ]( simpler syntax)

<xdmdndTsRo2SrwH8nZ2dnUU7-dfNnZ2d@giganews.com>

 copy mid

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

 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!news.giganews.com.POSTED!not-for-mail
NNTP-Posting-Date: Mon, 22 Nov 2021 18:13:03 -0600
Date: Mon, 22 Nov 2021 18:13: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 V27 [ finally
mathematically precise ]( simpler syntax)
Content-Language: en-US
Newsgroups: comp.theory
References: <5-2dncs2MNPqYwb8nZ2dnUU7-KvNnZ2d@giganews.com>
<NvednQUyFr32mQH8nZ2dnUU7-IGdnZ2d@giganews.com> <snh212$mup$1@dont-email.me>
<MpydnY7JbLEWkgH8nZ2dnUU7-SHNnZ2d@giganews.com>
<TtUmJ.126712$831.100143@fx40.iad> <snh4jm$a0i$1@dont-email.me>
<cNKdnX6ckqwSvAH8nZ2dnUU7-WXNnZ2d@giganews.com> <snh8d4$4t1$1@dont-email.me>
From: NoO...@NoWhere.com (olcott)
In-Reply-To: <snh8d4$4t1$1@dont-email.me>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Message-ID: <xdmdndTsRo2SrwH8nZ2dnUU7-dfNnZ2d@giganews.com>
Lines: 86
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-NehA6E181z4yyBAQb+c0g3jSifZhnKMIy9gpJUQqFCktYcnJyLFDyDBAdo8YIFWCD8KUppPeZ5HCQ+m!0y7xwfXFWxDZOXmD3tfniLrAYwmISdmASXvW66/b332CuhHJ8c3gs8j5uyIGpjHQ5xFEoE4x3KcE!UA==
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: 4470
 by: olcott - Tue, 23 Nov 2021 00:13 UTC

On 11/22/2021 5:16 PM, André G. Isaak wrote:
> On 2021-11-22 16:02, olcott wrote:
>> On 11/22/2021 4:12 PM, André G. Isaak wrote:
>>> On 2021-11-22 15:04, Richard Damon wrote:
>>>> On 11/22/21 4:45 PM, olcott wrote:
>>>>> On 11/22/2021 3:28 PM, André G. Isaak wrote:
>>>>>> On 2021-11-22 13:58, olcott wrote:
>>>>>>
>>>>>>> [PSR_set] ∀(H,P) ∊ PSR_set (Input_Never_Halts(  H(P,P)  ))
>>>>>>> [PSR_subset_A] ∃(H,P) ∊ PSR_set  (Halts(  H(P,P)  ))
>>>>>>> [PSR_subset_B] ∃(H,P) ∊ PSR_set  (Halts(  P(P)  ))
>>>>>>
>>>>>> Do you honestly think the above three lines actually mean something?
>>>>>>
>>>>>> André
>>>>>>
>>>>>
>>>>> Certainly not what you erase their set definition:
>>>>> Every unordered pair of combinations of H/P such that:
>>>>>
>>>>> (a) H simulates or executes its input and aborts or does not abort
>>>>> its input.
>>>>>
>>>>> (b) P(P) calls this same H(P,P) with itself as input.
>>>>>
>>>>
>>>> But the term 'Halts', used as a function, has not been defined.
>>>
>>> Nor, for that matter, has his use of square brackets.
>>>
>>
>> My use of square brackets substitutes for bold
>
> And bold means what?
>
>>> And I have no idea what ∀(H,P) is supposed to mean. It that the same as
>>
>> Combinations (not permutations) of H/P having pathological
>> self-reference.
>
> Which isn't what ∀(H,P) means since ∀(H,P) doesn't mean anything at all.
> it is simply ill-formed.
>
> And what does "Combinations (not permutations) of H/P" mean?
>
> What would be an example of a combination of H/P?
> What would be an example of a permutation of H/P?
>
>> [PSR_set] Combinations of H/P having pathological self-reference
>> Every H of H(P,P) invoked from main() where P(P) calls this same
>> H(P,P) and H simulates or executes its input and aborts or does not
>> abort its input P never reaches its last instruction.
>
> And what does "Every H of H(P,P)" mean?
>
> You may think that some of these things are meaningful or that your
> notation makes sense but they really do not. I'd stick with plain
> ordinary English if I were you.
>
> I'd also reflect on the fact that if you can't form coherent sentences
> using particular terminology or coherent formulae using a particular
> notation then you also cannot possibly expect to understand their use by
> others either.
>
> And this bit is particularly mystifying:
>
> > PSR_set: for n = 0 to ∞
> > {
> >    (Input_Never_Halts(  Hn(Pn,Pn)  ))
> >    (Sometimes_Halts(  Hn(Pn,Pn)  ))
> >    (Sometimes_Halts(   Pn(Pn)  ))
> > }
>
> André
>
>

Numbered elements of the infinite set of finite string C encodings of H
and P. The source-code that I provided is the (H0, P0) element.

--
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 V27 [ finally mathematically precise ]( simpler syntax)

<YsWmJ.117214$IW4.14459@fx48.iad>

 copy mid

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

 copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!aioe.org!news.uzoreto.com!news-out.netnews.com!news.alt.net!fdc2.netnews.com!peer03.ams1!peer.ams1.xlned.com!news.xlned.com!peer02.iad!feed-me.highwinds-media.com!news.highwinds-media.com!fx48.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 V27 [ finally
mathematically precise ]( simpler syntax)
Content-Language: en-US
Newsgroups: comp.theory
References: <5-2dncs2MNPqYwb8nZ2dnUU7-KvNnZ2d@giganews.com>
<NvednQUyFr32mQH8nZ2dnUU7-IGdnZ2d@giganews.com> <snh212$mup$1@dont-email.me>
<MpydnY7JbLEWkgH8nZ2dnUU7-SHNnZ2d@giganews.com>
<TtUmJ.126712$831.100143@fx40.iad> <snh4jm$a0i$1@dont-email.me>
<cNKdnX6ckqwSvAH8nZ2dnUU7-WXNnZ2d@giganews.com> <snh8d4$4t1$1@dont-email.me>
<xdmdndTsRo2SrwH8nZ2dnUU7-dfNnZ2d@giganews.com>
From: Rich...@Damon-Family.org (Richard Damon)
In-Reply-To: <xdmdndTsRo2SrwH8nZ2dnUU7-dfNnZ2d@giganews.com>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Lines: 87
Message-ID: <YsWmJ.117214$IW4.14459@fx48.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: Mon, 22 Nov 2021 19:20:01 -0500
X-Received-Bytes: 4468
 by: Richard Damon - Tue, 23 Nov 2021 00:20 UTC

On 11/22/21 7:13 PM, olcott wrote:
> On 11/22/2021 5:16 PM, André G. Isaak wrote:
>> On 2021-11-22 16:02, olcott wrote:
>>> On 11/22/2021 4:12 PM, André G. Isaak wrote:
>>>> On 2021-11-22 15:04, Richard Damon wrote:
>>>>> On 11/22/21 4:45 PM, olcott wrote:
>>>>>> On 11/22/2021 3:28 PM, André G. Isaak wrote:
>>>>>>> On 2021-11-22 13:58, olcott wrote:
>>>>>>>
>>>>>>>> [PSR_set] ∀(H,P) ∊ PSR_set (Input_Never_Halts(  H(P,P)  ))
>>>>>>>> [PSR_subset_A] ∃(H,P) ∊ PSR_set  (Halts(  H(P,P)  ))
>>>>>>>> [PSR_subset_B] ∃(H,P) ∊ PSR_set  (Halts(  P(P)  ))
>>>>>>>
>>>>>>> Do you honestly think the above three lines actually mean something?
>>>>>>>
>>>>>>> André
>>>>>>>
>>>>>>
>>>>>> Certainly not what you erase their set definition:
>>>>>> Every unordered pair of combinations of H/P such that:
>>>>>>
>>>>>> (a) H simulates or executes its input and aborts or does not abort
>>>>>> its input.
>>>>>>
>>>>>> (b) P(P) calls this same H(P,P) with itself as input.
>>>>>>
>>>>>
>>>>> But the term 'Halts', used as a function, has not been defined.
>>>>
>>>> Nor, for that matter, has his use of square brackets.
>>>>
>>>
>>> My use of square brackets substitutes for bold
>>
>> And bold means what?
>>
>>>> And I have no idea what ∀(H,P) is supposed to mean. It that the same as
>>>
>>> Combinations (not permutations) of H/P having pathological
>>> self-reference.
>>
>> Which isn't what ∀(H,P) means since ∀(H,P) doesn't mean anything at
>> all. it is simply ill-formed.
>>
>> And what does "Combinations (not permutations) of H/P" mean?
>>
>> What would be an example of a combination of H/P?
>> What would be an example of a permutation of H/P?
>>
>>> [PSR_set] Combinations of H/P having pathological self-reference
>>> Every H of H(P,P) invoked from main() where P(P) calls this same
>>> H(P,P) and H simulates or executes its input and aborts or does not
>>> abort its input P never reaches its last instruction.
>>
>> And what does "Every H of H(P,P)" mean?
>>
>> You may think that some of these things are meaningful or that your
>> notation makes sense but they really do not. I'd stick with plain
>> ordinary English if I were you.
>>
>> I'd also reflect on the fact that if you can't form coherent sentences
>> using particular terminology or coherent formulae using a particular
>> notation then you also cannot possibly expect to understand their use
>> by others either.
>>
>> And this bit is particularly mystifying:
>>
>>  > PSR_set: for n = 0 to ∞
>>  > {
>>  >    (Input_Never_Halts(  Hn(Pn,Pn)  ))
>>  >    (Sometimes_Halts(  Hn(Pn,Pn)  ))
>>  >    (Sometimes_Halts(   Pn(Pn)  ))
>>  > }
>>
>> André
>>
>>
>
> Numbered elements of the infinite set of finite string C encodings of H
> and P. The source-code that I provided is the (H0, P0) element.
>

And will you define what you mean by Input_Never_Hatls( Hn(Pn,Pn) )
and Sometimes_Halts( Hn(Pn,Pn) )

Especially how you can get a 'Sometimes' as a given exact coding should
always behave the same way every time it is run.

Re: Concise refutation of halting problem proofs V27 [ finally mathematically precise ]( simpler syntax)

<1YqdnaV2f80UpgH8nZ2dnUU7-Y-dnZ2d@giganews.com>

 copy mid

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

 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!news.giganews.com.POSTED!not-for-mail
NNTP-Posting-Date: Mon, 22 Nov 2021 18:53:29 -0600
Date: Mon, 22 Nov 2021 18:53:29 -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 V27 [ finally
mathematically precise ]( simpler syntax)
Content-Language: en-US
Newsgroups: comp.theory
References: <5-2dncs2MNPqYwb8nZ2dnUU7-KvNnZ2d@giganews.com>
<NvednQUyFr32mQH8nZ2dnUU7-IGdnZ2d@giganews.com> <snh212$mup$1@dont-email.me>
<MpydnY7JbLEWkgH8nZ2dnUU7-SHNnZ2d@giganews.com>
<TtUmJ.126712$831.100143@fx40.iad> <snh4jm$a0i$1@dont-email.me>
<cNKdnX6ckqwSvAH8nZ2dnUU7-WXNnZ2d@giganews.com> <snh8d4$4t1$1@dont-email.me>
<xdmdndTsRo2SrwH8nZ2dnUU7-dfNnZ2d@giganews.com>
<YsWmJ.117214$IW4.14459@fx48.iad>
From: NoO...@NoWhere.com (olcott)
In-Reply-To: <YsWmJ.117214$IW4.14459@fx48.iad>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Message-ID: <1YqdnaV2f80UpgH8nZ2dnUU7-Y-dnZ2d@giganews.com>
Lines: 102
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-cVs+ENvovBtLgWTtttEcpkTxeZywEgq7jYOtpSqF2pEQIASv65AlOde7Lqt4cQsu11MojTFMF3AoHlH!fN7f5wMCrAmuRTtregj/2uALxCVp+WPKs5qGKxyRFz2gOgh0uhjS4S3Rp4YD9JhdRIsHmfJQBWTY!qw==
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: 5196
 by: olcott - Tue, 23 Nov 2021 00:53 UTC

On 11/22/2021 6:20 PM, Richard Damon wrote:
> On 11/22/21 7:13 PM, olcott wrote:
>> On 11/22/2021 5:16 PM, André G. Isaak wrote:
>>> On 2021-11-22 16:02, olcott wrote:
>>>> On 11/22/2021 4:12 PM, André G. Isaak wrote:
>>>>> On 2021-11-22 15:04, Richard Damon wrote:
>>>>>> On 11/22/21 4:45 PM, olcott wrote:
>>>>>>> On 11/22/2021 3:28 PM, André G. Isaak wrote:
>>>>>>>> On 2021-11-22 13:58, olcott wrote:
>>>>>>>>
>>>>>>>>> [PSR_set] ∀(H,P) ∊ PSR_set (Input_Never_Halts(  H(P,P)  ))
>>>>>>>>> [PSR_subset_A] ∃(H,P) ∊ PSR_set  (Halts(  H(P,P)  ))
>>>>>>>>> [PSR_subset_B] ∃(H,P) ∊ PSR_set  (Halts(  P(P)  ))
>>>>>>>>
>>>>>>>> Do you honestly think the above three lines actually mean
>>>>>>>> something?
>>>>>>>>
>>>>>>>> André
>>>>>>>>
>>>>>>>
>>>>>>> Certainly not what you erase their set definition:
>>>>>>> Every unordered pair of combinations of H/P such that:
>>>>>>>
>>>>>>> (a) H simulates or executes its input and aborts or does not
>>>>>>> abort its input.
>>>>>>>
>>>>>>> (b) P(P) calls this same H(P,P) with itself as input.
>>>>>>>
>>>>>>
>>>>>> But the term 'Halts', used as a function, has not been defined.
>>>>>
>>>>> Nor, for that matter, has his use of square brackets.
>>>>>
>>>>
>>>> My use of square brackets substitutes for bold
>>>
>>> And bold means what?
>>>
>>>>> And I have no idea what ∀(H,P) is supposed to mean. It that the
>>>>> same as
>>>>
>>>> Combinations (not permutations) of H/P having pathological
>>>> self-reference.
>>>
>>> Which isn't what ∀(H,P) means since ∀(H,P) doesn't mean anything at
>>> all. it is simply ill-formed.
>>>
>>> And what does "Combinations (not permutations) of H/P" mean?
>>>
>>> What would be an example of a combination of H/P?
>>> What would be an example of a permutation of H/P?
>>>
>>>> [PSR_set] Combinations of H/P having pathological self-reference
>>>> Every H of H(P,P) invoked from main() where P(P) calls this same
>>>> H(P,P) and H simulates or executes its input and aborts or does not
>>>> abort its input P never reaches its last instruction.
>>>
>>> And what does "Every H of H(P,P)" mean?
>>>
>>> You may think that some of these things are meaningful or that your
>>> notation makes sense but they really do not. I'd stick with plain
>>> ordinary English if I were you.
>>>
>>> I'd also reflect on the fact that if you can't form coherent
>>> sentences using particular terminology or coherent formulae using a
>>> particular notation then you also cannot possibly expect to
>>> understand their use by others either.
>>>
>>> And this bit is particularly mystifying:
>>>
>>>  > PSR_set: for n = 0 to ∞
>>>  > {
>>>  >    (Input_Never_Halts(  Hn(Pn,Pn)  ))
>>>  >    (Sometimes_Halts(  Hn(Pn,Pn)  ))
>>>  >    (Sometimes_Halts(   Pn(Pn)  ))
>>>  > }
>>>
>>> André
>>>
>>>
>>
>> Numbered elements of the infinite set of finite string C encodings of
>> H and P. The source-code that I provided is the (H0, P0) element.
>>
>
> And will you define what you mean by Input_Never_Hatls( Hn(Pn,Pn) )

By Input_Never_Halts I must mean that the input jumps up and down
yelling and screaming before eating a bowl of ice cream.

> and Sometimes_Halts( Hn(Pn,Pn) )
>
> Especially how you can get a 'Sometimes' as a given exact coding should
> always behave the same way every time it is run.

--
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 V27 [ finally mathematically precise ]( simpler syntax)

<B2XmJ.92826$ya3.720@fx38.iad>

 copy mid

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

 copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!aioe.org!feeder1.feed.usenet.farm!feed.usenet.farm!newsfeed.xs4all.nl!newsfeed9.news.xs4all.nl!news-out.netnews.com!news.alt.net!fdc2.netnews.com!peer03.ams1!peer.ams1.xlned.com!news.xlned.com!peer02.iad!feed-me.highwinds-media.com!news.highwinds-media.com!fx38.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 V27 [ finally
mathematically precise ]( simpler syntax)
Content-Language: en-US
Newsgroups: comp.theory
References: <5-2dncs2MNPqYwb8nZ2dnUU7-KvNnZ2d@giganews.com>
<NvednQUyFr32mQH8nZ2dnUU7-IGdnZ2d@giganews.com> <snh212$mup$1@dont-email.me>
<MpydnY7JbLEWkgH8nZ2dnUU7-SHNnZ2d@giganews.com>
<TtUmJ.126712$831.100143@fx40.iad> <snh4jm$a0i$1@dont-email.me>
<cNKdnX6ckqwSvAH8nZ2dnUU7-WXNnZ2d@giganews.com> <snh8d4$4t1$1@dont-email.me>
<xdmdndTsRo2SrwH8nZ2dnUU7-dfNnZ2d@giganews.com>
<YsWmJ.117214$IW4.14459@fx48.iad>
<1YqdnaV2f80UpgH8nZ2dnUU7-Y-dnZ2d@giganews.com>
From: Rich...@Damon-Family.org (Richard Damon)
In-Reply-To: <1YqdnaV2f80UpgH8nZ2dnUU7-Y-dnZ2d@giganews.com>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Lines: 107
Message-ID: <B2XmJ.92826$ya3.720@fx38.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: Mon, 22 Nov 2021 20:00:09 -0500
X-Received-Bytes: 5368
 by: Richard Damon - Tue, 23 Nov 2021 01:00 UTC

On 11/22/21 7:53 PM, olcott wrote:
> On 11/22/2021 6:20 PM, Richard Damon wrote:
>> On 11/22/21 7:13 PM, olcott wrote:
>>> On 11/22/2021 5:16 PM, André G. Isaak wrote:
>>>> On 2021-11-22 16:02, olcott wrote:
>>>>> On 11/22/2021 4:12 PM, André G. Isaak wrote:
>>>>>> On 2021-11-22 15:04, Richard Damon wrote:
>>>>>>> On 11/22/21 4:45 PM, olcott wrote:
>>>>>>>> On 11/22/2021 3:28 PM, André G. Isaak wrote:
>>>>>>>>> On 2021-11-22 13:58, olcott wrote:
>>>>>>>>>
>>>>>>>>>> [PSR_set] ∀(H,P) ∊ PSR_set (Input_Never_Halts(  H(P,P)  ))
>>>>>>>>>> [PSR_subset_A] ∃(H,P) ∊ PSR_set  (Halts(  H(P,P)  ))
>>>>>>>>>> [PSR_subset_B] ∃(H,P) ∊ PSR_set  (Halts(  P(P)  ))
>>>>>>>>>
>>>>>>>>> Do you honestly think the above three lines actually mean
>>>>>>>>> something?
>>>>>>>>>
>>>>>>>>> André
>>>>>>>>>
>>>>>>>>
>>>>>>>> Certainly not what you erase their set definition:
>>>>>>>> Every unordered pair of combinations of H/P such that:
>>>>>>>>
>>>>>>>> (a) H simulates or executes its input and aborts or does not
>>>>>>>> abort its input.
>>>>>>>>
>>>>>>>> (b) P(P) calls this same H(P,P) with itself as input.
>>>>>>>>
>>>>>>>
>>>>>>> But the term 'Halts', used as a function, has not been defined.
>>>>>>
>>>>>> Nor, for that matter, has his use of square brackets.
>>>>>>
>>>>>
>>>>> My use of square brackets substitutes for bold
>>>>
>>>> And bold means what?
>>>>
>>>>>> And I have no idea what ∀(H,P) is supposed to mean. It that the
>>>>>> same as
>>>>>
>>>>> Combinations (not permutations) of H/P having pathological
>>>>> self-reference.
>>>>
>>>> Which isn't what ∀(H,P) means since ∀(H,P) doesn't mean anything at
>>>> all. it is simply ill-formed.
>>>>
>>>> And what does "Combinations (not permutations) of H/P" mean?
>>>>
>>>> What would be an example of a combination of H/P?
>>>> What would be an example of a permutation of H/P?
>>>>
>>>>> [PSR_set] Combinations of H/P having pathological self-reference
>>>>> Every H of H(P,P) invoked from main() where P(P) calls this same
>>>>> H(P,P) and H simulates or executes its input and aborts or does not
>>>>> abort its input P never reaches its last instruction.
>>>>
>>>> And what does "Every H of H(P,P)" mean?
>>>>
>>>> You may think that some of these things are meaningful or that your
>>>> notation makes sense but they really do not. I'd stick with plain
>>>> ordinary English if I were you.
>>>>
>>>> I'd also reflect on the fact that if you can't form coherent
>>>> sentences using particular terminology or coherent formulae using a
>>>> particular notation then you also cannot possibly expect to
>>>> understand their use by others either.
>>>>
>>>> And this bit is particularly mystifying:
>>>>
>>>>  > PSR_set: for n = 0 to ∞
>>>>  > {
>>>>  >    (Input_Never_Halts(  Hn(Pn,Pn)  ))
>>>>  >    (Sometimes_Halts(  Hn(Pn,Pn)  ))
>>>>  >    (Sometimes_Halts(   Pn(Pn)  ))
>>>>  > }
>>>>
>>>> André
>>>>
>>>>
>>>
>>> Numbered elements of the infinite set of finite string C encodings of
>>> H and P. The source-code that I provided is the (H0, P0) element.
>>>
>>
>> And will you define what you mean by Input_Never_Hatls( Hn(Pn,Pn) )
>
> By Input_Never_Halts I must mean that the input jumps up and down
> yelling and screaming before eating a bowl of ice cream.

Ok, we will go by that definition unless you later admit to being a liar.

Asking because you have currently defined the syntax of name(parms) to
be an algorithmic call of a procedure with parameters, and there is a
problem if you mean that, as using a 'Never Halts' algorithm before you
have actually proved the existance of such a thing invalidates you whole
arguement.

>
>> and Sometimes_Halts( Hn(Pn,Pn) )
>>
>> Especially how you can get a 'Sometimes' as a given exact coding
>> should always behave the same way every time it is run.
>
>

Re: Concise refutation of halting problem proofs V27 [ finally mathematically precise ]( simpler syntax)

<snhes8$c1c$1@dont-email.me>

 copy mid

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

 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 V27 [ finally
mathematically precise ]( simpler syntax)
Date: Mon, 22 Nov 2021 18:07:19 -0700
Organization: Christians and Atheists United Against Creeping Agnosticism
Lines: 36
Message-ID: <snhes8$c1c$1@dont-email.me>
References: <5-2dncs2MNPqYwb8nZ2dnUU7-KvNnZ2d@giganews.com>
<NvednQUyFr32mQH8nZ2dnUU7-IGdnZ2d@giganews.com> <snh212$mup$1@dont-email.me>
<MpydnY7JbLEWkgH8nZ2dnUU7-SHNnZ2d@giganews.com>
<TtUmJ.126712$831.100143@fx40.iad> <snh4jm$a0i$1@dont-email.me>
<cNKdnX6ckqwSvAH8nZ2dnUU7-WXNnZ2d@giganews.com> <snh8d4$4t1$1@dont-email.me>
<xdmdndTsRo2SrwH8nZ2dnUU7-dfNnZ2d@giganews.com>
Mime-Version: 1.0
Content-Type: text/plain; charset=utf-8; format=flowed
Content-Transfer-Encoding: 8bit
Injection-Date: Tue, 23 Nov 2021 01:07:20 -0000 (UTC)
Injection-Info: reader02.eternal-september.org; posting-host="49b13d9d5e2a82410bb5befc4a1eb4ad";
logging-data="12332"; mail-complaints-to="abuse@eternal-september.org"; posting-account="U2FsdGVkX1+YR/PRAyu06WOsZk8GJ8ty"
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.14; rv:78.0)
Gecko/20100101 Thunderbird/78.14.0
Cancel-Lock: sha1:y1rcTofNl7O02PeljpWLz3HVQas=
In-Reply-To: <xdmdndTsRo2SrwH8nZ2dnUU7-dfNnZ2d@giganews.com>
Content-Language: en-US
 by: André G. Isaak - Tue, 23 Nov 2021 01:07 UTC

On 2021-11-22 17:13, olcott wrote:
> On 11/22/2021 5:16 PM, André G. Isaak wrote:

>> And this bit is particularly mystifying:
>>
>>  > PSR_set: for n = 0 to ∞
>>  > {
>>  >    (Input_Never_Halts(  Hn(Pn,Pn)  ))
>>  >    (Sometimes_Halts(  Hn(Pn,Pn)  ))
>>  >    (Sometimes_Halts(   Pn(Pn)  ))
>>  > }
>>
>> André
>>
>>
>
> Numbered elements of the infinite set of finite string C encodings of H
> and P. The source-code that I provided is the (H0, P0) element.

That wasn't the mystifying part despite it being a strange abuse of
syntax. I assumed this was just a deranged way of writing ∀n rather than
being a syntactically ill-formed C program, though why you continuously
insist on inventing your own undefined notation is beyond me.

How can the input of Hn(Pn, Pn) never halt when Pn(Pn) sometimes halt?

And if Hn is a halt decider, how can it only sometimes halt?

And what does it even mean for something to sometimes halt? For any
given value of n it either halts or it doesn't.

André

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

Re: Concise refutation of halting problem proofs V27 [ finally mathematically precise ]( simpler syntax)

<LZSdnSHg28173QH8nZ2dnUU7-dfNnZ2d@giganews.com>

 copy mid

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

 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!news.giganews.com.POSTED!not-for-mail
NNTP-Posting-Date: Mon, 22 Nov 2021 19:16:22 -0600
Date: Mon, 22 Nov 2021 19:16: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.2
Subject: Re: Concise refutation of halting problem proofs V27 [ finally
mathematically precise ]( simpler syntax)
Content-Language: en-US
Newsgroups: comp.theory
References: <5-2dncs2MNPqYwb8nZ2dnUU7-KvNnZ2d@giganews.com>
<NvednQUyFr32mQH8nZ2dnUU7-IGdnZ2d@giganews.com> <snh212$mup$1@dont-email.me>
<MpydnY7JbLEWkgH8nZ2dnUU7-SHNnZ2d@giganews.com>
<TtUmJ.126712$831.100143@fx40.iad> <snh4jm$a0i$1@dont-email.me>
<cNKdnX6ckqwSvAH8nZ2dnUU7-WXNnZ2d@giganews.com> <snh8d4$4t1$1@dont-email.me>
<xdmdndTsRo2SrwH8nZ2dnUU7-dfNnZ2d@giganews.com> <snhes8$c1c$1@dont-email.me>
From: NoO...@NoWhere.com (olcott)
In-Reply-To: <snhes8$c1c$1@dont-email.me>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Message-ID: <LZSdnSHg28173QH8nZ2dnUU7-dfNnZ2d@giganews.com>
Lines: 53
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-LBAWz0SNNO4pb2J8DJ2z5l/TeeVYI3p1+f3EpVsjP1/qFnAyLAmSGzbSnmikwYRrbfNbH/KR9Qsi5ww!mme1o+wYuNpq+jxa0lin4QFtVWEsNRN61Blp07sy53F8GMEk9t1uIFYrOu6L7oYSd13aW6NuQlLT!Kw==
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: 3296
 by: olcott - Tue, 23 Nov 2021 01:16 UTC

On 11/22/2021 7:07 PM, André G. Isaak wrote:
> On 2021-11-22 17:13, olcott wrote:
>> On 11/22/2021 5:16 PM, André G. Isaak wrote:
>
>>> And this bit is particularly mystifying:
>>>
>>>  > PSR_set: for n = 0 to ∞
>>>  > {
>>>  >    (Input_Never_Halts(  Hn(Pn,Pn)  ))
>>>  >    (Sometimes_Halts(  Hn(Pn,Pn)  ))
>>>  >    (Sometimes_Halts(   Pn(Pn)  ))
>>>  > }
>>>
>>> André
>>>
>>>
>>
>> Numbered elements of the infinite set of finite string C encodings of
>> H and P. The source-code that I provided is the (H0, P0) element.
>
> That wasn't the mystifying part despite it being a strange abuse of
> syntax. I assumed this was just a deranged way of writing ∀n rather than
> being a syntactically ill-formed C program, though why you continuously
> insist on inventing your own undefined notation is beyond me.
>
> How can the input of Hn(Pn, Pn) never halt when Pn(Pn) sometimes halt?

The input to Hn(Pn,Pn) never reaches its final state.
For some of these exact same Pn(Pn) P does reach its final state.

> And if Hn is a halt decider, how can it only sometimes halt?
>

I am using categorically exhaustive reasoning examining the behavior of
every possible Hn(Pn,Pn) by examining the categories of possible behavior.

Only a subset of Hn(Pn,Pn) is H a decider and in only a subset of these
is H a correct halt decider.

> And what does it even mean for something to sometimes halt? For any
> given value of n it either halts or it doesn't.
>
> 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 V27 [ finally mathematically precise ]( simpler syntax)

<snhh1j$nre$1@dont-email.me>

 copy mid

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

 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 V27 [ finally
mathematically precise ]( simpler syntax)
Date: Mon, 22 Nov 2021 18:44:17 -0700
Organization: Christians and Atheists United Against Creeping Agnosticism
Lines: 69
Message-ID: <snhh1j$nre$1@dont-email.me>
References: <5-2dncs2MNPqYwb8nZ2dnUU7-KvNnZ2d@giganews.com>
<NvednQUyFr32mQH8nZ2dnUU7-IGdnZ2d@giganews.com> <snh212$mup$1@dont-email.me>
<MpydnY7JbLEWkgH8nZ2dnUU7-SHNnZ2d@giganews.com>
<TtUmJ.126712$831.100143@fx40.iad> <snh4jm$a0i$1@dont-email.me>
<cNKdnX6ckqwSvAH8nZ2dnUU7-WXNnZ2d@giganews.com> <snh8d4$4t1$1@dont-email.me>
<xdmdndTsRo2SrwH8nZ2dnUU7-dfNnZ2d@giganews.com> <snhes8$c1c$1@dont-email.me>
<LZSdnSHg28173QH8nZ2dnUU7-dfNnZ2d@giganews.com>
Mime-Version: 1.0
Content-Type: text/plain; charset=utf-8; format=flowed
Content-Transfer-Encoding: 8bit
Injection-Date: Tue, 23 Nov 2021 01:44:19 -0000 (UTC)
Injection-Info: reader02.eternal-september.org; posting-host="49b13d9d5e2a82410bb5befc4a1eb4ad";
logging-data="24430"; mail-complaints-to="abuse@eternal-september.org"; posting-account="U2FsdGVkX1+fRUQsaSe+p8YJYEVg0cW0"
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.14; rv:78.0)
Gecko/20100101 Thunderbird/78.14.0
Cancel-Lock: sha1:QenuIfz8shnq7RLTpjYB4TvFuWg=
In-Reply-To: <LZSdnSHg28173QH8nZ2dnUU7-dfNnZ2d@giganews.com>
Content-Language: en-US
 by: André G. Isaak - Tue, 23 Nov 2021 01:44 UTC

On 2021-11-22 18:16, olcott wrote:
> On 11/22/2021 7:07 PM, André G. Isaak wrote:
>> On 2021-11-22 17:13, olcott wrote:
>>> On 11/22/2021 5:16 PM, André G. Isaak wrote:
>>
>>>> And this bit is particularly mystifying:
>>>>
>>>>  > PSR_set: for n = 0 to ∞
>>>>  > {
>>>>  >    (Input_Never_Halts(  Hn(Pn,Pn)  ))
>>>>  >    (Sometimes_Halts(  Hn(Pn,Pn)  ))
>>>>  >    (Sometimes_Halts(   Pn(Pn)  ))
>>>>  > }
>>>>
>>>> André
>>>>
>>>>
>>>
>>> Numbered elements of the infinite set of finite string C encodings of
>>> H and P. The source-code that I provided is the (H0, P0) element.
>>
>> That wasn't the mystifying part despite it being a strange abuse of
>> syntax. I assumed this was just a deranged way of writing ∀n rather
>> than being a syntactically ill-formed C program, though why you
>> continuously insist on inventing your own undefined notation is beyond
>> me.
>>
>> How can the input of Hn(Pn, Pn) never halt when Pn(Pn) sometimes halt?
>
> The input to Hn(Pn,Pn) never reaches its final state.
> For some of these exact same Pn(Pn) P does reach its final state.

Which goes back to Richard's question which you refused to answer: What
does Input_Never_Halts mean?

The input to a halt decider is a *string*. The input can't halt. It also
can't not halt. Only the computation which it describes has a halting
status, and in the case of Hn(Pn, Pn) the input describes the
computation Pn(Pn).

You keep talking about what the 'input' does, but unless by 'input' you
mean 'the computation described by the input' this is a completely
undefined and, as far as I can tell, meaningless notion. Halting is a
property of *computations*, not of strings.

So what does Input_Never_Halts mean?

What does it mean for an input to halt or not halt?

>
>> And if Hn is a halt decider, how can it only sometimes halt?
>>
>
> I am using categorically exhaustive reasoning examining the behavior of
> every possible Hn(Pn,Pn) by examining the categories of possible behavior.
>
> Only a subset of Hn(Pn,Pn) is H a decider and in only a subset of these
> is H a correct halt decider.
>
>> And what does it even mean for something to sometimes halt? For any
>> given value of n it either halts or it doesn't.

Not going to answer this, I take it?

André

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

Re: Concise refutation of halting problem proofs V27 [ finally mathematically precise ]( simpler syntax)

<eqYmJ.14705$G996.3705@fx31.iad>

 copy mid

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

 copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!usenet.goja.nl.eu.org!3.eu.feeder.erje.net!feeder.erje.net!newsfeed.xs4all.nl!newsfeed8.news.xs4all.nl!news-out.netnews.com!news.alt.net!fdc2.netnews.com!peer02.ams1!peer.ams1.xlned.com!news.xlned.com!peer03.iad!feed-me.highwinds-media.com!news.highwinds-media.com!fx31.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 V27 [ finally
mathematically precise ]( simpler syntax)
Content-Language: en-US
Newsgroups: comp.theory
References: <5-2dncs2MNPqYwb8nZ2dnUU7-KvNnZ2d@giganews.com>
<NvednQUyFr32mQH8nZ2dnUU7-IGdnZ2d@giganews.com> <snh212$mup$1@dont-email.me>
<MpydnY7JbLEWkgH8nZ2dnUU7-SHNnZ2d@giganews.com>
<TtUmJ.126712$831.100143@fx40.iad> <snh4jm$a0i$1@dont-email.me>
<cNKdnX6ckqwSvAH8nZ2dnUU7-WXNnZ2d@giganews.com> <snh8d4$4t1$1@dont-email.me>
<xdmdndTsRo2SrwH8nZ2dnUU7-dfNnZ2d@giganews.com> <snhes8$c1c$1@dont-email.me>
<LZSdnSHg28173QH8nZ2dnUU7-dfNnZ2d@giganews.com>
From: Rich...@Damon-Family.org (Richard Damon)
In-Reply-To: <LZSdnSHg28173QH8nZ2dnUU7-dfNnZ2d@giganews.com>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Lines: 68
Message-ID: <eqYmJ.14705$G996.3705@fx31.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: Mon, 22 Nov 2021 21:33:38 -0500
X-Received-Bytes: 3828
 by: Richard Damon - Tue, 23 Nov 2021 02:33 UTC

On 11/22/21 8:16 PM, olcott wrote:
> On 11/22/2021 7:07 PM, André G. Isaak wrote:
>> On 2021-11-22 17:13, olcott wrote:
>>> On 11/22/2021 5:16 PM, André G. Isaak wrote:
>>
>>>> And this bit is particularly mystifying:
>>>>
>>>>  > PSR_set: for n = 0 to ∞
>>>>  > {
>>>>  >    (Input_Never_Halts(  Hn(Pn,Pn)  ))
>>>>  >    (Sometimes_Halts(  Hn(Pn,Pn)  ))
>>>>  >    (Sometimes_Halts(   Pn(Pn)  ))
>>>>  > }
>>>>
>>>> André
>>>>
>>>>
>>>
>>> Numbered elements of the infinite set of finite string C encodings of
>>> H and P. The source-code that I provided is the (H0, P0) element.
>>
>> That wasn't the mystifying part despite it being a strange abuse of
>> syntax. I assumed this was just a deranged way of writing ∀n rather
>> than being a syntactically ill-formed C program, though why you
>> continuously insist on inventing your own undefined notation is beyond
>> me.
>>
>> How can the input of Hn(Pn, Pn) never halt when Pn(Pn) sometimes halt?
>
> The input to Hn(Pn,Pn) never reaches its final state.
> For some of these exact same Pn(Pn) P does reach its final state.
>
>
>> And if Hn is a halt decider, how can it only sometimes halt?
>>
>
> I am using categorically exhaustive reasoning examining the behavior of
> every possible Hn(Pn,Pn) by examining the categories of possible behavior.
>
> Only a subset of Hn(Pn,Pn) is H a decider and in only a subset of these
> is H a correct halt decider.

And that subset is empty (at least if you restore P to having the
structure dictated by Linz).

This is because if Hn(Pn,Pn) returns 0, then when we execute Pn(Pn) we
can see that it WILL halt, and if Hn(Pn,Pn) returns 1, then when we
execute Pn(Pn) we can see that it will loop forever.

Remember, the CORRECT answer for the Halt Decider is based on the
independent running of the computation that the input represents.

It doesn't matter what what the partial simulation of the input does
inside the decider, it is the INDEPENDENT COMPUTATION that matters.

By the requriements of Linz, if Hn(Pn,Pn) returns 0, then Pn will
immediately Halt, so Hn will be wrong, and if Hn(Pn,Pn) returns 1, then
Pn will go into an infinite loop, so Hn will be wrong.

>
>> And what does it even mean for something to sometimes halt? For any
>> given value of n it either halts or it doesn't.
>>
>> André
>>
>
>

Re: Concise refutation of halting problem proofs V27 [ finally mathematically precise ]

<V92dnfjztvyO-gH8nZ2dnUU7-enNnZ2d@giganews.com>

 copy mid

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

 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: Mon, 22 Nov 2021 21:59:15 -0600
Date: Mon, 22 Nov 2021 21:59:13 -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 V27 [ finally
mathematically precise ]
Content-Language: en-US
Newsgroups: comp.theory,comp.ai.philosophy,sci.logic,sci.math
References: <5-2dncs2MNPqYwb8nZ2dnUU7-KvNnZ2d@giganews.com>
<NvednQUyFr32mQH8nZ2dnUU7-IGdnZ2d@giganews.com> <snh212$mup$1@dont-email.me>
<MpydnY7JbLEWkgH8nZ2dnUU7-SHNnZ2d@giganews.com>
<TtUmJ.126712$831.100143@fx40.iad> <snh4jm$a0i$1@dont-email.me>
<cNKdnX6ckqwSvAH8nZ2dnUU7-WXNnZ2d@giganews.com> <snh8d4$4t1$1@dont-email.me>
<xdmdndTsRo2SrwH8nZ2dnUU7-dfNnZ2d@giganews.com> <snhes8$c1c$1@dont-email.me>
<LZSdnSHg28173QH8nZ2dnUU7-dfNnZ2d@giganews.com> <snhh1j$nre$1@dont-email.me>
From: NoO...@NoWhere.com (olcott)
Followup-To: comp.theory
In-Reply-To: <snhh1j$nre$1@dont-email.me>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Message-ID: <V92dnfjztvyO-gH8nZ2dnUU7-enNnZ2d@giganews.com>
Lines: 97
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-u9B40TXJCwtbb56GNNQ0pqrj3T7TRTLjuvKYT1fmjuITL44CirJvVudQ/mcV/v6HaKoG+FLU9eTWOBt!HEibx3/aP4E7wDkdlY7sSy/CuPUcwBOm5weoBwH1tfXp/LEzpghdzFC2X9AUMITn2zlclLtgcLVU!hw==
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: 5154
 by: olcott - Tue, 23 Nov 2021 03:59 UTC

On 11/22/2021 7:44 PM, André G. Isaak wrote:
> On 2021-11-22 18:16, olcott wrote:
>> On 11/22/2021 7:07 PM, André G. Isaak wrote:
>>> On 2021-11-22 17:13, olcott wrote:
>>>> On 11/22/2021 5:16 PM, André G. Isaak wrote:
>>>
>>>>> And this bit is particularly mystifying:
>>>>>
>>>>>  > PSR_set: for n = 0 to ∞
>>>>>  > {
>>>>>  >    (Input_Never_Halts(  Hn(Pn,Pn)  ))
>>>>>  >    (Sometimes_Halts(  Hn(Pn,Pn)  ))
>>>>>  >    (Sometimes_Halts(   Pn(Pn)  ))
>>>>>  > }
>>>>>
>>>>> André
>>>>>
>>>>>
>>>>
>>>> Numbered elements of the infinite set of finite string C encodings
>>>> of H and P. The source-code that I provided is the (H0, P0) element.
>>>
>>> That wasn't the mystifying part despite it being a strange abuse of
>>> syntax. I assumed this was just a deranged way of writing ∀n rather
>>> than being a syntactically ill-formed C program, though why you
>>> continuously insist on inventing your own undefined notation is
>>> beyond me.
>>>
>>> How can the input of Hn(Pn, Pn) never halt when Pn(Pn) sometimes halt?
>>
>> The input to Hn(Pn,Pn) never reaches its final state.
>> For some of these exact same Pn(Pn) P does reach its final state.
>
> Which goes back to Richard's question which you refused to answer: What
> does Input_Never_Halts mean?
>
> The input to a halt decider is a *string*. The input can't halt. It also
> can't not halt. Only the computation which it describes has a halting
> status, and in the case of Hn(Pn, Pn) the input describes the
> computation Pn(Pn).
>
> You keep talking about what the 'input' does, but unless by 'input' you
> mean 'the computation described by the input' this is a completely
> undefined and, as far as I can tell, meaningless notion. Halting is a
> property of *computations*, not of strings.
>
> So what does Input_Never_Halts mean?
>
> What does it mean for an input to halt or not halt?
>

It turns out that the independent execution of P(P) actually means an
input to H(P,P) that *is not* an input to H(P,P).

It turns out that the independent execution of P(P) means that main()
directly executes P(P) without H being involved.

No deciders can actually work that way. All deciders either accept or
reject finite string inputs.

H is a computable function that accepts or rejects inputs in its domain
on the basis that these inputs specify a sequence of configurations that
reach their final state.

What all you guys have been asking for is for H to have an input that
*is not* its input.

The x86 equivalent of a TM description and its input is an x86 machine
language string and some other finite string or references to these.

>>
>>> And if Hn is a halt decider, how can it only sometimes halt?
>>>
>>
>> I am using categorically exhaustive reasoning examining the behavior
>> of every possible Hn(Pn,Pn) by examining the categories of possible
>> behavior.
>>
>> Only a subset of Hn(Pn,Pn) is H a decider and in only a subset of
>> these is H a correct halt decider.
>>
>>> And what does it even mean for something to sometimes halt? For any
>>> given value of n it either halts or it doesn't.
>
> Not going to answer this, I take it?
>
> 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 V27 [ finally mathematically precise ]

<snhq6t$9bg$1@dont-email.me>

 copy mid

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

 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 V27 [ finally
mathematically precise ]
Date: Mon, 22 Nov 2021 21:20:44 -0700
Organization: Christians and Atheists United Against Creeping Agnosticism
Lines: 94
Message-ID: <snhq6t$9bg$1@dont-email.me>
References: <5-2dncs2MNPqYwb8nZ2dnUU7-KvNnZ2d@giganews.com>
<NvednQUyFr32mQH8nZ2dnUU7-IGdnZ2d@giganews.com> <snh212$mup$1@dont-email.me>
<MpydnY7JbLEWkgH8nZ2dnUU7-SHNnZ2d@giganews.com>
<TtUmJ.126712$831.100143@fx40.iad> <snh4jm$a0i$1@dont-email.me>
<cNKdnX6ckqwSvAH8nZ2dnUU7-WXNnZ2d@giganews.com> <snh8d4$4t1$1@dont-email.me>
<xdmdndTsRo2SrwH8nZ2dnUU7-dfNnZ2d@giganews.com> <snhes8$c1c$1@dont-email.me>
<LZSdnSHg28173QH8nZ2dnUU7-dfNnZ2d@giganews.com> <snhh1j$nre$1@dont-email.me>
<V92dnfjztvyO-gH8nZ2dnUU7-enNnZ2d@giganews.com>
Mime-Version: 1.0
Content-Type: text/plain; charset=utf-8; format=flowed
Content-Transfer-Encoding: 8bit
Injection-Date: Tue, 23 Nov 2021 04:20:46 -0000 (UTC)
Injection-Info: reader02.eternal-september.org; posting-host="49b13d9d5e2a82410bb5befc4a1eb4ad";
logging-data="9584"; mail-complaints-to="abuse@eternal-september.org"; posting-account="U2FsdGVkX1/m+jDYBUNoRdZ/T58mRFZl"
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.14; rv:78.0)
Gecko/20100101 Thunderbird/78.14.0
Cancel-Lock: sha1:jKU8kwDnAS7z1U/Rb4DRZZhXPJA=
In-Reply-To: <V92dnfjztvyO-gH8nZ2dnUU7-enNnZ2d@giganews.com>
Content-Language: en-US
 by: André G. Isaak - Tue, 23 Nov 2021 04:20 UTC

On 2021-11-22 20:59, olcott wrote:
> On 11/22/2021 7:44 PM, André G. Isaak wrote:
>> On 2021-11-22 18:16, olcott wrote:
>>> On 11/22/2021 7:07 PM, André G. Isaak wrote:
>>>> On 2021-11-22 17:13, olcott wrote:
>>>>> On 11/22/2021 5:16 PM, André G. Isaak wrote:
>>>>
>>>>>> And this bit is particularly mystifying:
>>>>>>
>>>>>>  > PSR_set: for n = 0 to ∞
>>>>>>  > {
>>>>>>  >    (Input_Never_Halts(  Hn(Pn,Pn)  ))
>>>>>>  >    (Sometimes_Halts(  Hn(Pn,Pn)  ))
>>>>>>  >    (Sometimes_Halts(   Pn(Pn)  ))
>>>>>>  > }
>>>>>>
>>>>>> André
>>>>>>
>>>>>>
>>>>>
>>>>> Numbered elements of the infinite set of finite string C encodings
>>>>> of H and P. The source-code that I provided is the (H0, P0) element.
>>>>
>>>> That wasn't the mystifying part despite it being a strange abuse of
>>>> syntax. I assumed this was just a deranged way of writing ∀n rather
>>>> than being a syntactically ill-formed C program, though why you
>>>> continuously insist on inventing your own undefined notation is
>>>> beyond me.
>>>>
>>>> How can the input of Hn(Pn, Pn) never halt when Pn(Pn) sometimes halt?
>>>
>>> The input to Hn(Pn,Pn) never reaches its final state.
>>> For some of these exact same Pn(Pn) P does reach its final state.
>>
>> Which goes back to Richard's question which you refused to answer:
>> What does Input_Never_Halts mean?
>>
>> The input to a halt decider is a *string*. The input can't halt. It
>> also can't not halt. Only the computation which it describes has a
>> halting status, and in the case of Hn(Pn, Pn) the input describes the
>> computation Pn(Pn).
>>
>> You keep talking about what the 'input' does, but unless by 'input'
>> you mean 'the computation described by the input' this is a completely
>> undefined and, as far as I can tell, meaningless notion. Halting is a
>> property of *computations*, not of strings.
>>
>> So what does Input_Never_Halts mean?
>>
>> What does it mean for an input to halt or not halt?
>>
>
> It turns out that the independent execution of P(P) actually means an
> input to H(P,P) that *is not* an input to H(P,P).

Which is a meaningless statement. How can X be an input to Y that is not
an input to Y?

> It turns out that the independent execution of P(P) means that main()
> directly executes P(P) without H being involved.

And that's what the halting problem is about. Determining whether an
independent computation halts. Unless H is part of the input string why
on earth would H be involved in the independent execution?

> No deciders can actually work that way. All deciders either accept or
> reject finite string inputs.

And they reject them based on whether the independent computation
described by those strings halt or not. Why would this be a problem?

The fact that *your* H doesn't work correctly hardly indicates that no
decider can work the way that it is supposed to work. (A universal halt
decider obviously cannot, but that's because a universal halt decider
cannot exist).

And you still haven't actually answered my question:

What does it *mean* for the 'input', something which is not a
computation, to halt?

That's claiming that the *string* "123456" is even as opposed to the
integer which that string represents. It has no sensible interpretation.

And you still have not answered the other question I asked:

what does it even mean for something to *sometimes* halt? For any given
value of n it either halts or it doesn't.

André

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

Re: Concise refutation of halting problem proofs V27 [ finally mathematically precise ]

<r9_mJ.6886$1d1.6160@fx99.iad>

 copy mid

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

 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!peer03.iad!feed-me.highwinds-media.com!news.highwinds-media.com!fx99.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 V27 [ finally
mathematically precise ]
Content-Language: en-US
Newsgroups: comp.theory
References: <5-2dncs2MNPqYwb8nZ2dnUU7-KvNnZ2d@giganews.com>
<NvednQUyFr32mQH8nZ2dnUU7-IGdnZ2d@giganews.com> <snh212$mup$1@dont-email.me>
<MpydnY7JbLEWkgH8nZ2dnUU7-SHNnZ2d@giganews.com>
<TtUmJ.126712$831.100143@fx40.iad> <snh4jm$a0i$1@dont-email.me>
<cNKdnX6ckqwSvAH8nZ2dnUU7-WXNnZ2d@giganews.com> <snh8d4$4t1$1@dont-email.me>
<xdmdndTsRo2SrwH8nZ2dnUU7-dfNnZ2d@giganews.com> <snhes8$c1c$1@dont-email.me>
<LZSdnSHg28173QH8nZ2dnUU7-dfNnZ2d@giganews.com> <snhh1j$nre$1@dont-email.me>
<V92dnfjztvyO-gH8nZ2dnUU7-enNnZ2d@giganews.com>
From: Rich...@Damon-Family.org (Richard Damon)
In-Reply-To: <V92dnfjztvyO-gH8nZ2dnUU7-enNnZ2d@giganews.com>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Lines: 132
Message-ID: <r9_mJ.6886$1d1.6160@fx99.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: Mon, 22 Nov 2021 23:32:14 -0500
X-Received-Bytes: 6328
X-Original-Bytes: 6195
 by: Richard Damon - Tue, 23 Nov 2021 04:32 UTC

On 11/22/21 10:59 PM, olcott wrote:
> On 11/22/2021 7:44 PM, André G. Isaak wrote:
>> On 2021-11-22 18:16, olcott wrote:
>>> On 11/22/2021 7:07 PM, André G. Isaak wrote:
>>>> On 2021-11-22 17:13, olcott wrote:
>>>>> On 11/22/2021 5:16 PM, André G. Isaak wrote:
>>>>
>>>>>> And this bit is particularly mystifying:
>>>>>>
>>>>>>  > PSR_set: for n = 0 to ∞
>>>>>>  > {
>>>>>>  >    (Input_Never_Halts(  Hn(Pn,Pn)  ))
>>>>>>  >    (Sometimes_Halts(  Hn(Pn,Pn)  ))
>>>>>>  >    (Sometimes_Halts(   Pn(Pn)  ))
>>>>>>  > }
>>>>>>
>>>>>> André
>>>>>>
>>>>>>
>>>>>
>>>>> Numbered elements of the infinite set of finite string C encodings
>>>>> of H and P. The source-code that I provided is the (H0, P0) element.
>>>>
>>>> That wasn't the mystifying part despite it being a strange abuse of
>>>> syntax. I assumed this was just a deranged way of writing ∀n rather
>>>> than being a syntactically ill-formed C program, though why you
>>>> continuously insist on inventing your own undefined notation is
>>>> beyond me.
>>>>
>>>> How can the input of Hn(Pn, Pn) never halt when Pn(Pn) sometimes halt?
>>>
>>> The input to Hn(Pn,Pn) never reaches its final state.
>>> For some of these exact same Pn(Pn) P does reach its final state.
>>
>> Which goes back to Richard's question which you refused to answer:
>> What does Input_Never_Halts mean?
>>
>> The input to a halt decider is a *string*. The input can't halt. It
>> also can't not halt. Only the computation which it describes has a
>> halting status, and in the case of Hn(Pn, Pn) the input describes the
>> computation Pn(Pn).
>>
>> You keep talking about what the 'input' does, but unless by 'input'
>> you mean 'the computation described by the input' this is a completely
>> undefined and, as far as I can tell, meaningless notion. Halting is a
>> property of *computations*, not of strings.
>>
>> So what does Input_Never_Halts mean?
>>
>> What does it mean for an input to halt or not halt?
>>
>
> It turns out that the independent execution of P(P) actually means an
> input to H(P,P) that *is not* an input to H(P,P).

WRONG. You just don't understand the problem.

You FIRST create the code for your H, and FREEZE it. H needs to have its
complete algorithm created (and 'get the right answer' is NOT an algorithm)

You then create by the Linz formulat, an algorithm P. This is simple
given the frozen defintion of H.

You then create a representation of this computaton (this might be your
x86 code)

You then give H the two copies of this code, and compare it to the
behavior of giving P one copy of this code (which will dupilcate it and
call H with those two copies and do the opposite of what H says it will do).

>
> It turns out that the independent execution of P(P) means that main()
> directly executes P(P) without H being involved.

Right.

>
> No deciders can actually work that way. All deciders either accept or
> reject finite string inputs.

Right, the decider DECIDES on the finite string, but the answer they
gives needs to match the behavior of something they don't get to
directly control. The computaiton that this string represents.

There is no contradiction in this, it is just a hard problenm.

If it was easy, it wouldn't mean much.

>
> H is a computable function that accepts or rejects inputs in its domain
> on the basis that these inputs specify a sequence of configurations that
> reach their final state.
>

Right, H computes and answer.

It is the job of the DESIGNER (in this case, that means YOU) to develope
an algorithm that gets the right answer.

'Get the right answer' is NOT an algorithm

> What all you guys have been asking for is for H to have an input that
> *is not* its input.

WRONG. The representation of the computation P(P) is the input to H.

What is your problem with that?

The key you miss is that H needs to tell us what that program P(P) will
do when it is run.

Yes, H can not directly see that, because P will call H so if H tries to
just directly simulate it get stuck in an infinite recursion, and fail
to be a decider, so H MUST do something different, but still get the
right answer.

Linz proves that it can not succeed, and this is ok, it just proves that
there can not be a universally correct halt decider.

>
> The x86 equivalent of a TM description and its input is an x86 machine
> language string and some other finite string or references to these.
>

The x86 code could be an acceptable description in your case. Note that
in needs to be not just the assembly code for the function 'P', but also
include ALL the x86 code that this function calls, and anything that
calls and so on.

Then your decider needs to predict what will happen if we just run the
program that has this description on the description we just made.

Re: Concise refutation of halting problem proofs V27 [ finally mathematically precise ]

<ru6dnRcSxdCo4gH8nZ2dnUU7-f3NnZ2d@giganews.com>

 copy mid

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

 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: Mon, 22 Nov 2021 23:42:13 -0600
Date: Mon, 22 Nov 2021 23:42:12 -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 V27 [ finally
mathematically precise ]
Content-Language: en-US
Newsgroups: comp.theory
References: <5-2dncs2MNPqYwb8nZ2dnUU7-KvNnZ2d@giganews.com>
<NvednQUyFr32mQH8nZ2dnUU7-IGdnZ2d@giganews.com> <snh212$mup$1@dont-email.me>
<MpydnY7JbLEWkgH8nZ2dnUU7-SHNnZ2d@giganews.com>
<TtUmJ.126712$831.100143@fx40.iad> <snh4jm$a0i$1@dont-email.me>
<cNKdnX6ckqwSvAH8nZ2dnUU7-WXNnZ2d@giganews.com> <snh8d4$4t1$1@dont-email.me>
<xdmdndTsRo2SrwH8nZ2dnUU7-dfNnZ2d@giganews.com> <snhes8$c1c$1@dont-email.me>
<LZSdnSHg28173QH8nZ2dnUU7-dfNnZ2d@giganews.com> <snhh1j$nre$1@dont-email.me>
<V92dnfjztvyO-gH8nZ2dnUU7-enNnZ2d@giganews.com> <snhq6t$9bg$1@dont-email.me>
From: NoO...@NoWhere.com (olcott)
In-Reply-To: <snhq6t$9bg$1@dont-email.me>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Message-ID: <ru6dnRcSxdCo4gH8nZ2dnUU7-f3NnZ2d@giganews.com>
Lines: 108
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-5nLOXDkBRehiG78g6lLMGiLYaaod5UmVHLlpsIVmbgwTjEJ445gXAZA6qSQ4GvIzSgGm7NVWdhr1Mfo!FdshkbvhIKI/7FFeJEdtdkud3iGCfc0pMN3AJHKD9nEX6mSScbHoqquU3WydGRw8yCInN5diOp8W!KA==
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: 5867
 by: olcott - Tue, 23 Nov 2021 05:42 UTC

On 11/22/2021 10:20 PM, André G. Isaak wrote:
> On 2021-11-22 20:59, olcott wrote:
>> On 11/22/2021 7:44 PM, André G. Isaak wrote:
>>> On 2021-11-22 18:16, olcott wrote:
>>>> On 11/22/2021 7:07 PM, André G. Isaak wrote:
>>>>> On 2021-11-22 17:13, olcott wrote:
>>>>>> On 11/22/2021 5:16 PM, André G. Isaak wrote:
>>>>>
>>>>>>> And this bit is particularly mystifying:
>>>>>>>
>>>>>>>  > PSR_set: for n = 0 to ∞
>>>>>>>  > {
>>>>>>>  >    (Input_Never_Halts(  Hn(Pn,Pn)  ))
>>>>>>>  >    (Sometimes_Halts(  Hn(Pn,Pn)  ))
>>>>>>>  >    (Sometimes_Halts(   Pn(Pn)  ))
>>>>>>>  > }
>>>>>>>
>>>>>>> André
>>>>>>>
>>>>>>>
>>>>>>
>>>>>> Numbered elements of the infinite set of finite string C encodings
>>>>>> of H and P. The source-code that I provided is the (H0, P0) element.
>>>>>
>>>>> That wasn't the mystifying part despite it being a strange abuse of
>>>>> syntax. I assumed this was just a deranged way of writing ∀n rather
>>>>> than being a syntactically ill-formed C program, though why you
>>>>> continuously insist on inventing your own undefined notation is
>>>>> beyond me.
>>>>>
>>>>> How can the input of Hn(Pn, Pn) never halt when Pn(Pn) sometimes halt?
>>>>
>>>> The input to Hn(Pn,Pn) never reaches its final state.
>>>> For some of these exact same Pn(Pn) P does reach its final state.
>>>
>>> Which goes back to Richard's question which you refused to answer:
>>> What does Input_Never_Halts mean?
>>>
>>> The input to a halt decider is a *string*. The input can't halt. It
>>> also can't not halt. Only the computation which it describes has a
>>> halting status, and in the case of Hn(Pn, Pn) the input describes the
>>> computation Pn(Pn).
>>>
>>> You keep talking about what the 'input' does, but unless by 'input'
>>> you mean 'the computation described by the input' this is a
>>> completely undefined and, as far as I can tell, meaningless notion.
>>> Halting is a property of *computations*, not of strings.
>>>
>>> So what does Input_Never_Halts mean?
>>>
>>> What does it mean for an input to halt or not halt?
>>>
>>
>> It turns out that the independent execution of P(P) actually means an
>> input to H(P,P) that *is not* an input to H(P,P).
>
> Which is a meaningless statement. How can X be an input to Y that is not
> an input to Y?
>
>> It turns out that the independent execution of P(P) means that main()
>> directly executes P(P) without H being involved.
>
> And that's what the halting problem is about. Determining whether an
> independent computation halts. Unless H is part of the input string why
> on earth would H be involved in the independent execution?
>
>> No deciders can actually work that way. All deciders either accept or
>> reject finite string inputs.
>
> And they reject them based on whether the independent computation
> described by those strings halt or not. Why would this be a problem?
>

You can't correctly pass anything to H besides the pair of finite
strings or references to the machine language of P.

Its inputs are not allowed to have the extra criteria that you assume,
thus have no basis to apply it.

> The fact that *your* H doesn't work correctly hardly indicates that no
> decider can work the way that it is supposed to work. (A universal halt
> decider obviously cannot, but that's because a universal halt decider
> cannot exist).
>
> And you still haven't actually answered my question:
>
> What does it *mean* for the 'input', something which is not a
> computation, to halt?
>
> That's claiming that the *string* "123456" is even as opposed to the
> integer which that string represents. It has no sensible interpretation.
>
> And you still have not answered the other question I asked:
>
> what does it even mean for something to *sometimes* halt? For any given
> value of n it either halts or it doesn't.
>
> 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 V27 [ finally mathematically precise ]

<Ha-dnQk9NNCoGAH8nZ2dnUU7-cXNnZ2d@giganews.com>

 copy mid

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

 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: Tue, 23 Nov 2021 00:07:49 -0600
Date: Tue, 23 Nov 2021 00:07: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 V27 [ finally
mathematically precise ]
Content-Language: en-US
Newsgroups: comp.theory
References: <5-2dncs2MNPqYwb8nZ2dnUU7-KvNnZ2d@giganews.com>
<NvednQUyFr32mQH8nZ2dnUU7-IGdnZ2d@giganews.com> <snh212$mup$1@dont-email.me>
<MpydnY7JbLEWkgH8nZ2dnUU7-SHNnZ2d@giganews.com>
<TtUmJ.126712$831.100143@fx40.iad> <snh4jm$a0i$1@dont-email.me>
<cNKdnX6ckqwSvAH8nZ2dnUU7-WXNnZ2d@giganews.com> <snh8d4$4t1$1@dont-email.me>
<xdmdndTsRo2SrwH8nZ2dnUU7-dfNnZ2d@giganews.com> <snhes8$c1c$1@dont-email.me>
<LZSdnSHg28173QH8nZ2dnUU7-dfNnZ2d@giganews.com> <snhh1j$nre$1@dont-email.me>
<V92dnfjztvyO-gH8nZ2dnUU7-enNnZ2d@giganews.com> <snhq6t$9bg$1@dont-email.me>
<ru6dnRcSxdCo4gH8nZ2dnUU7-f3NnZ2d@giganews.com>
From: NoO...@NoWhere.com (olcott)
In-Reply-To: <ru6dnRcSxdCo4gH8nZ2dnUU7-f3NnZ2d@giganews.com>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Message-ID: <Ha-dnQk9NNCoGAH8nZ2dnUU7-cXNnZ2d@giganews.com>
Lines: 121
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-yLRFL0QQhmH2cn75SlBRMmkDSQqDBvkxTIZg4wyNeDq+Dejyn+Qtx/8kvZYPyx7mD1IQFsVylIkIm/s!m6PUKG8yvQ0yVd3E/5pjkIbUdMgVKfxQzoQTggwltshM6V0BfnBLb+1zx2iypno7TBmF8LEEzXHy!pw==
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: 6376
 by: olcott - Tue, 23 Nov 2021 06:07 UTC

On 11/22/2021 11:42 PM, olcott wrote:
> On 11/22/2021 10:20 PM, André G. Isaak wrote:
>> On 2021-11-22 20:59, olcott wrote:
>>> On 11/22/2021 7:44 PM, André G. Isaak wrote:
>>>> On 2021-11-22 18:16, olcott wrote:
>>>>> On 11/22/2021 7:07 PM, André G. Isaak wrote:
>>>>>> On 2021-11-22 17:13, olcott wrote:
>>>>>>> On 11/22/2021 5:16 PM, André G. Isaak wrote:
>>>>>>
>>>>>>>> And this bit is particularly mystifying:
>>>>>>>>
>>>>>>>>  > PSR_set: for n = 0 to ∞
>>>>>>>>  > {
>>>>>>>>  >    (Input_Never_Halts(  Hn(Pn,Pn)  ))
>>>>>>>>  >    (Sometimes_Halts(  Hn(Pn,Pn)  ))
>>>>>>>>  >    (Sometimes_Halts(   Pn(Pn)  ))
>>>>>>>>  > }
>>>>>>>>
>>>>>>>> André
>>>>>>>>
>>>>>>>>
>>>>>>>
>>>>>>> Numbered elements of the infinite set of finite string C
>>>>>>> encodings of H and P. The source-code that I provided is the (H0,
>>>>>>> P0) element.
>>>>>>
>>>>>> That wasn't the mystifying part despite it being a strange abuse
>>>>>> of syntax. I assumed this was just a deranged way of writing ∀n
>>>>>> rather than being a syntactically ill-formed C program, though why
>>>>>> you continuously insist on inventing your own undefined notation
>>>>>> is beyond me.
>>>>>>
>>>>>> How can the input of Hn(Pn, Pn) never halt when Pn(Pn) sometimes
>>>>>> halt?
>>>>>
>>>>> The input to Hn(Pn,Pn) never reaches its final state.
>>>>> For some of these exact same Pn(Pn) P does reach its final state.
>>>>
>>>> Which goes back to Richard's question which you refused to answer:
>>>> What does Input_Never_Halts mean?
>>>>
>>>> The input to a halt decider is a *string*. The input can't halt. It
>>>> also can't not halt. Only the computation which it describes has a
>>>> halting status, and in the case of Hn(Pn, Pn) the input describes
>>>> the computation Pn(Pn).
>>>>
>>>> You keep talking about what the 'input' does, but unless by 'input'
>>>> you mean 'the computation described by the input' this is a
>>>> completely undefined and, as far as I can tell, meaningless notion.
>>>> Halting is a property of *computations*, not of strings.
>>>>
>>>> So what does Input_Never_Halts mean?
>>>>
>>>> What does it mean for an input to halt or not halt?
>>>>
>>>
>>> It turns out that the independent execution of P(P) actually means an
>>> input to H(P,P) that *is not* an input to H(P,P).
>>
>> Which is a meaningless statement. How can X be an input to Y that is
>> not an input to Y?
>>
>>> It turns out that the independent execution of P(P) means that main()
>>> directly executes P(P) without H being involved.
>>
>> And that's what the halting problem is about. Determining whether an
>> independent computation halts. Unless H is part of the input string
>> why on earth would H be involved in the independent execution?
>>
>>> No deciders can actually work that way. All deciders either accept or
>>> reject finite string inputs.
>>
>> And they reject them based on whether the independent computation
>> described by those strings halt or not. Why would this be a problem?
>>
>
> You can't correctly pass anything to H besides the pair of finite
> strings or references to the machine language of P.
>
> Its inputs are not allowed to have the extra criteria that you assume,
> thus have no basis to apply it.
>
>
>> The fact that *your* H doesn't work correctly hardly indicates that no
>> decider can work the way that it is supposed to work. (A universal
>> halt decider obviously cannot, but that's because a universal halt
>> decider cannot exist).
>>
>> And you still haven't actually answered my question:
>>
>> What does it *mean* for the 'input', something which is not a
>> computation, to halt?
>>

In my first example the input is directly executed so you are still
basing your comments on what you think that I must saying instead of
what I am actually saying.

I threw direct execution the mix to quell the nutty baseless statements
about incorrect simulation.

>> That's claiming that the *string* "123456" is even as opposed to the
>> integer which that string represents. It has no sensible interpretation.
>>
>> And you still have not answered the other question I asked:
>>
>> what does it even mean for something to *sometimes* halt? For any
>> given value of n it either halts or it doesn't.
>>
>> 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 V27 [ finally mathematically precise ]

<sni0pq$54o$1@dont-email.me>

 copy mid

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

 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 V27 [ finally
mathematically precise ]
Date: Mon, 22 Nov 2021 23:13:12 -0700
Organization: Christians and Atheists United Against Creeping Agnosticism
Lines: 30
Message-ID: <sni0pq$54o$1@dont-email.me>
References: <5-2dncs2MNPqYwb8nZ2dnUU7-KvNnZ2d@giganews.com>
<NvednQUyFr32mQH8nZ2dnUU7-IGdnZ2d@giganews.com> <snh212$mup$1@dont-email.me>
<MpydnY7JbLEWkgH8nZ2dnUU7-SHNnZ2d@giganews.com>
<TtUmJ.126712$831.100143@fx40.iad> <snh4jm$a0i$1@dont-email.me>
<cNKdnX6ckqwSvAH8nZ2dnUU7-WXNnZ2d@giganews.com> <snh8d4$4t1$1@dont-email.me>
<xdmdndTsRo2SrwH8nZ2dnUU7-dfNnZ2d@giganews.com> <snhes8$c1c$1@dont-email.me>
<LZSdnSHg28173QH8nZ2dnUU7-dfNnZ2d@giganews.com> <snhh1j$nre$1@dont-email.me>
<V92dnfjztvyO-gH8nZ2dnUU7-enNnZ2d@giganews.com> <snhq6t$9bg$1@dont-email.me>
<ru6dnRcSxdCo4gH8nZ2dnUU7-f3NnZ2d@giganews.com>
Mime-Version: 1.0
Content-Type: text/plain; charset=utf-8; format=flowed
Content-Transfer-Encoding: 8bit
Injection-Date: Tue, 23 Nov 2021 06:13:14 -0000 (UTC)
Injection-Info: reader02.eternal-september.org; posting-host="49b13d9d5e2a82410bb5befc4a1eb4ad";
logging-data="5272"; mail-complaints-to="abuse@eternal-september.org"; posting-account="U2FsdGVkX18smlAaEHX/jPwlXkEap7S3"
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.14; rv:78.0)
Gecko/20100101 Thunderbird/78.14.0
Cancel-Lock: sha1:vaRI5J9/WLC+180DP6DEuWgLQ6Y=
In-Reply-To: <ru6dnRcSxdCo4gH8nZ2dnUU7-f3NnZ2d@giganews.com>
Content-Language: en-US
 by: André G. Isaak - Tue, 23 Nov 2021 06:13 UTC

On 2021-11-22 22:42, olcott wrote:
> On 11/22/2021 10:20 PM, André G. Isaak wrote:

>> And that's what the halting problem is about. Determining whether an
>> independent computation halts. Unless H is part of the input string
>> why on earth would H be involved in the independent execution?
>>
>>> No deciders can actually work that way. All deciders either accept or
>>> reject finite string inputs.
>>
>> And they reject them based on whether the independent computation
>> described by those strings halt or not. Why would this be a problem?
>>
>
> You can't correctly pass anything to H besides the pair of finite
> strings or references to the machine language of P.
>
> Its inputs are not allowed to have the extra criteria that you assume,
> thus have no basis to apply it.

Which 'extra criteria'? The inputs to a halt decider are nothing more
than a finite string exactly as specified in the definition of 'halt
decider'.

André

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

Pages:1234
server_pubkey.txt

rocksolid light 0.9.7
clearnet tor