Rocksolid Light

Welcome to novaBBS (click a section below)

mail  files  register  newsreader  groups  login

Message-ID:  

It's great to be smart 'cause then you know stuff.


devel / comp.theory / Refutation of [Strachey 1965] and Halting Problem associated proofs

SubjectAuthor
* Refutation of [Strachey 1965] and Halting Problem associated proofsMr Flibble
+* Refutation of [Strachey 1965] and Halting Problem associated proofsBen Bacarisse
|`* Refutation of [Strachey 1965] and Halting Problem associatedMr Flibble
| `* Refutation of [Strachey 1965] and Halting Problem associated proofsBen Bacarisse
|  +* Refutation of [Strachey 1965] and Halting Problem associatedolcott
|  |+* Refutation of [Strachey 1965] and Halting Problem associatedRichard Damon
|  ||`* Refutation of [Strachey 1965] and Halting Problem associatedMr Flibble
|  || `* Refutation of [Strachey 1965] and Halting Problem associatedolcott
|  ||  +- Refutation of [Strachey 1965] and Halting Problem associated proofsDennis Bush
|  ||  `- Refutation of [Strachey 1965] and Halting Problem associatedMr Flibble
|  |`- Refutation of [Strachey 1965] and Halting Problem associatedMr Flibble
|  `* Refutation of [Strachey 1965] and Halting Problem associatedMr Flibble
|   `- Refutation of [Strachey 1965] and Halting Problem associated proofsBen Bacarisse
`* Refutation of [Strachey 1965] and Halting Problem associated proofsSkep Dick
 `* Refutation of [Strachey 1965] and Halting Problem associatedMr Flibble
  `* Refutation of [Strachey 1965] and Halting Problem associatedRichard Damon
   `* Refutation of [Strachey 1965] and Halting Problem associatedMr Flibble
    `* Refutation of [Strachey 1965] and Halting Problem associatedRichard Damon
     `- Refutation of [Strachey 1965] and Halting Problem associatedMr Flibble

1
Refutation of [Strachey 1965] and Halting Problem associated proofs

<20220731011138.000034e4@reddwarf.jmc.corp>

 copy mid

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

 copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!aioe.org!feeder1.feed.usenet.farm!feed.usenet.farm!news-out.netnews.com!news.alt.net!fdc2.netnews.com!peer03.ams1!peer.ams1.xlned.com!news.xlned.com!peer02.ams4!peer.am4.highwinds-media.com!news.highwinds-media.com!fx01.ams4.POSTED!not-for-mail
From: flib...@reddwarf.jmc.corp (Mr Flibble)
Newsgroups: comp.theory
Subject: Refutation of [Strachey 1965] and Halting Problem associated proofs
Message-ID: <20220731011138.000034e4@reddwarf.jmc.corp>
Organization: Jupiter Mining Corporation
X-Newsreader: Claws Mail 4.1.0 (GTK 3.24.33; x86_64-w64-mingw32)
MIME-Version: 1.0
Content-Type: text/plain; charset=US-ASCII
Content-Transfer-Encoding: 7bit
Lines: 40
X-Complaints-To: abuse@eweka.nl
NNTP-Posting-Date: Sun, 31 Jul 2022 00:11:38 UTC
Date: Sun, 31 Jul 2022 01:11:38 +0100
X-Received-Bytes: 1748
 by: Mr Flibble - Sun, 31 Jul 2022 00:11 UTC

I have an idea for a simulating halt decider that forks the
simulation into two branches if the input calls the halt decider as
per [Strachey 1965]'s "Impossible Program":

void P(void (*x)())
{ if (H(x, x))
infinite_loop: goto infinite_loop;
return;
}

int main()
{ std::cout << "Input halts: " << H(P, P) << std::endl;
}

When the simulator detects the call to H in P it forks the simulation
into a non-halting branch (returning 0 to P) and a halting branch
(returning 1 to P) and continues the simulation of these two branches
in parallel.

If the non-halting branch is determined to halt AND the halting branch
is determined to not halt then pathology is detected and reported.

If EITHER branch is determined to be correctly decided then that will
be the decision of the halting decider.

Crucially this scheme will handle (and correctly decide) the
following case whereby the result of H is discarded by the input:

void Px(void (*x)())
{ (void) H(x, x);
return;
}

/Flibble

Copyright (c) 2022 Mr Flibble

Re: Refutation of [Strachey 1965] and Halting Problem associated proofs

<877d3u85cv.fsf@bsb.me.uk>

 copy mid

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

 copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!eternal-september.org!reader01.eternal-september.org!.POSTED!not-for-mail
From: ben.use...@bsb.me.uk (Ben Bacarisse)
Newsgroups: comp.theory
Subject: Re: Refutation of [Strachey 1965] and Halting Problem associated proofs
Date: Sun, 31 Jul 2022 01:59:12 +0100
Organization: A noiseless patient Spider
Lines: 11
Message-ID: <877d3u85cv.fsf@bsb.me.uk>
References: <20220731011138.000034e4@reddwarf.jmc.corp>
MIME-Version: 1.0
Content-Type: text/plain
Injection-Info: reader01.eternal-september.org; posting-host="0ef9a181c1082aee22bab9969b934578";
logging-data="28900"; mail-complaints-to="abuse@eternal-september.org"; posting-account="U2FsdGVkX18zvxiC7Luo16hdIIQj6Uv69Gkm5g60dTc="
User-Agent: Gnus/5.13 (Gnus v5.13) Emacs/27.1 (gnu/linux)
Cancel-Lock: sha1:1zH2dcNl6lXv9dn0WV+dakUVXZo=
sha1:ATfJq15qHeQTgnC1XwTkT/GBWNM=
X-BSB-Auth: 1.8752c21340d4f422e465.20220731015912BST.877d3u85cv.fsf@bsb.me.uk
 by: Ben Bacarisse - Sun, 31 Jul 2022 00:59 UTC

Mr Flibble <flibble@reddwarf.jmc.corp> writes:

> If the non-halting branch is determined to halt AND the halting branch
> is determined to not halt then pathology is detected and reported.

Thus H is not a decider in the technical sense of the word. Why is your
not-quite-a-decider any better than the ones half a dozen students come
up with every year when a class sees this problem for the first time?

--
Ben.

Re: Refutation of [Strachey 1965] and Halting Problem associated proofs

<20220731020805.00004ff0@reddwarf.jmc.corp>

 copy mid

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

 copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!weretis.net!feeder8.news.weretis.net!newsreader4.netcologne.de!news.netcologne.de!peer03.ams1!peer.ams1.xlned.com!news.xlned.com!peer02.ams4!peer.am4.highwinds-media.com!news.highwinds-media.com!fx02.ams4.POSTED!not-for-mail
From: flib...@reddwarf.jmc.corp (Mr Flibble)
Newsgroups: comp.theory
Subject: Re: Refutation of [Strachey 1965] and Halting Problem associated
proofs
Message-ID: <20220731020805.00004ff0@reddwarf.jmc.corp>
References: <20220731011138.000034e4@reddwarf.jmc.corp>
<877d3u85cv.fsf@bsb.me.uk>
Organization: Jupiter Mining Corporation
X-Newsreader: Claws Mail 4.1.0 (GTK 3.24.33; x86_64-w64-mingw32)
MIME-Version: 1.0
Content-Type: text/plain; charset=US-ASCII
Content-Transfer-Encoding: 7bit
Lines: 21
X-Complaints-To: abuse@eweka.nl
NNTP-Posting-Date: Sun, 31 Jul 2022 01:08:05 UTC
Date: Sun, 31 Jul 2022 02:08:05 +0100
X-Received-Bytes: 1516
 by: Mr Flibble - Sun, 31 Jul 2022 01:08 UTC

On Sun, 31 Jul 2022 01:59:12 +0100
Ben Bacarisse <ben.usenet@bsb.me.uk> wrote:

> Mr Flibble <flibble@reddwarf.jmc.corp> writes:
>
> > If the non-halting branch is determined to halt AND the halting
> > branch is determined to not halt then pathology is detected and
> > reported.
>
> Thus H is not a decider in the technical sense of the word. Why is
> your not-quite-a-decider any better than the ones half a dozen
> students come up with every year when a class sees this problem for
> the first time?

My solution is novel: it correctly decides non-pathological input
(including input that calls the decider) and signals an exception for
pathological input (which is the correct thing to do).

/Flibble

Re: Refutation of [Strachey 1965] and Halting Problem associated proofs

<871qu2827e.fsf@bsb.me.uk>

 copy mid

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

 copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!eternal-september.org!reader01.eternal-september.org!.POSTED!not-for-mail
From: ben.use...@bsb.me.uk (Ben Bacarisse)
Newsgroups: comp.theory
Subject: Re: Refutation of [Strachey 1965] and Halting Problem associated proofs
Date: Sun, 31 Jul 2022 03:07:17 +0100
Organization: A noiseless patient Spider
Lines: 31
Message-ID: <871qu2827e.fsf@bsb.me.uk>
References: <20220731011138.000034e4@reddwarf.jmc.corp>
<877d3u85cv.fsf@bsb.me.uk> <20220731020805.00004ff0@reddwarf.jmc.corp>
MIME-Version: 1.0
Content-Type: text/plain
Injection-Info: reader01.eternal-september.org; posting-host="0ef9a181c1082aee22bab9969b934578";
logging-data="131512"; mail-complaints-to="abuse@eternal-september.org"; posting-account="U2FsdGVkX18koor2sOajBFP55jZ93kYtRxJtoWSEuwE="
User-Agent: Gnus/5.13 (Gnus v5.13) Emacs/27.1 (gnu/linux)
Cancel-Lock: sha1:vtmLhwgM4lQ+f2QxMm3Z2d5P1RI=
sha1:GQptimn0YDjUc4DFqoumKwuPWB4=
X-BSB-Auth: 1.21a893a42e9c99f7f388.20220731030717BST.871qu2827e.fsf@bsb.me.uk
 by: Ben Bacarisse - Sun, 31 Jul 2022 02:07 UTC

Mr Flibble <flibble@reddwarf.jmc.corp> writes:

> On Sun, 31 Jul 2022 01:59:12 +0100
> Ben Bacarisse <ben.usenet@bsb.me.uk> wrote:
>
>> Mr Flibble <flibble@reddwarf.jmc.corp> writes:
>>
>> > If the non-halting branch is determined to halt AND the halting
>> > branch is determined to not halt then pathology is detected and
>> > reported.
>>
>> Thus H is not a decider in the technical sense of the word. Why is
>> your not-quite-a-decider any better than the ones half a dozen
>> students come up with every year when a class sees this problem for
>> the first time?
>
> My solution is novel: it correctly decides non-pathological input
> (including input that calls the decider) and signals an exception for
> pathological input (which is the correct thing to do).

Currently you have no algorithm, just an idea for an algorithm. When
you try to pin down the details you will have something that can't
detect all inputs that a functionally the same as the pathological cases
you think you want to spot. This is a hole every such proposed "almost
solution" falls into.

Just saying that you detect them all is not an algorithm. It's design
by wishful thinking.

--
Ben.

Re: Refutation of [Strachey 1965] and Halting Problem associated proofs

<y7KdnXwRDb49dHj_nZ2dnZfqlJxg4p2d@giganews.com>

 copy mid

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

 copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!weretis.net!feeder6.news.weretis.net!news.misty.com!border-2.nntp.ord.giganews.com!nntp.giganews.com!Xl.tags.giganews.com!local-1.nntp.ord.giganews.com!news.giganews.com.POSTED!not-for-mail
NNTP-Posting-Date: Sun, 31 Jul 2022 02:32:00 +0000
Date: Sat, 30 Jul 2022 21:32:09 -0500
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:91.0) Gecko/20100101
Thunderbird/91.11.0
Subject: Re: Refutation of [Strachey 1965] and Halting Problem associated
proofs
Content-Language: en-US
Newsgroups: comp.theory
References: <20220731011138.000034e4@reddwarf.jmc.corp>
<877d3u85cv.fsf@bsb.me.uk> <20220731020805.00004ff0@reddwarf.jmc.corp>
<871qu2827e.fsf@bsb.me.uk>
From: NoO...@NoWhere.com (olcott)
In-Reply-To: <871qu2827e.fsf@bsb.me.uk>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 7bit
Message-ID: <y7KdnXwRDb49dHj_nZ2dnZfqlJxg4p2d@giganews.com>
Lines: 39
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-BGqckNs7Q7Y+rbx8Tj0JQrVfhIz0cGh+akccb8s4BMrsgjxnGlB86m499uT6EIa6sgB/PqAGwmWEmbm!m+d0aS/YrhjTOHI/tCJo9IQTq5+X+HPZ0WwMVcCSxLC5eav9lpO6vH+FMm6HNUPA6VGkca++kJWY!Pg==
X-Complaints-To: abuse@giganews.com
X-DMCA-Notifications: http://www.giganews.com/info/dmca.html
X-Abuse-and-DMCA-Info: Please be sure to forward a copy of ALL headers
X-Abuse-and-DMCA-Info: Otherwise we will be unable to process your complaint properly
X-Postfilter: 1.3.40
 by: olcott - Sun, 31 Jul 2022 02:32 UTC

On 7/30/2022 9:07 PM, Ben Bacarisse wrote:
> Mr Flibble <flibble@reddwarf.jmc.corp> writes:
>
>> On Sun, 31 Jul 2022 01:59:12 +0100
>> Ben Bacarisse <ben.usenet@bsb.me.uk> wrote:
>>
>>> Mr Flibble <flibble@reddwarf.jmc.corp> writes:
>>>
>>>> If the non-halting branch is determined to halt AND the halting
>>>> branch is determined to not halt then pathology is detected and
>>>> reported.
>>>
>>> Thus H is not a decider in the technical sense of the word. Why is
>>> your not-quite-a-decider any better than the ones half a dozen
>>> students come up with every year when a class sees this problem for
>>> the first time?
>>
>> My solution is novel: it correctly decides non-pathological input
>> (including input that calls the decider) and signals an exception for
>> pathological input (which is the correct thing to do).
>
> Currently you have no algorithm, just an idea for an algorithm. When
> you try to pin down the details you will have something that can't
> detect all inputs that a functionally the same as the pathological cases
> you think you want to spot. This is a hole every such proposed "almost
> solution" falls into.
>
> Just saying that you detect them all is not an algorithm. It's design
> by wishful thinking.
>

I have been telling him that.

--
Copyright 2022 Pete Olcott

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

Re: Refutation of [Strachey 1965] and Halting Problem associated proofs

<xNtFK.601319$J0r9.535812@fx11.iad>

 copy mid

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

 copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!usenet.blueworldhosting.com!feed1.usenet.blueworldhosting.com!peer02.iad!feed-me.highwinds-media.com!news.highwinds-media.com!fx11.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.11.0
Subject: Re: Refutation of [Strachey 1965] and Halting Problem associated
proofs
Content-Language: en-US
Newsgroups: comp.theory
References: <20220731011138.000034e4@reddwarf.jmc.corp>
<877d3u85cv.fsf@bsb.me.uk> <20220731020805.00004ff0@reddwarf.jmc.corp>
<871qu2827e.fsf@bsb.me.uk> <y7KdnXwRDb49dHj_nZ2dnZfqlJxg4p2d@giganews.com>
From: Rich...@Damon-Family.org (Richard Damon)
In-Reply-To: <y7KdnXwRDb49dHj_nZ2dnZfqlJxg4p2d@giganews.com>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Lines: 38
Message-ID: <xNtFK.601319$J0r9.535812@fx11.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: Sun, 31 Jul 2022 07:34:53 -0400
X-Received-Bytes: 2484
 by: Richard Damon - Sun, 31 Jul 2022 11:34 UTC

On 7/30/22 10:32 PM, olcott wrote:
> On 7/30/2022 9:07 PM, Ben Bacarisse wrote:
>> Mr Flibble <flibble@reddwarf.jmc.corp> writes:
>>
>>> On Sun, 31 Jul 2022 01:59:12 +0100
>>> Ben Bacarisse <ben.usenet@bsb.me.uk> wrote:
>>>
>>>> Mr Flibble <flibble@reddwarf.jmc.corp> writes:
>>>>
>>>>> If the non-halting branch is determined to halt AND the halting
>>>>> branch is determined to not halt then pathology is detected and
>>>>> reported.
>>>>
>>>> Thus H is not a decider in the technical sense of the word.  Why is
>>>> your not-quite-a-decider any better than the ones half a dozen
>>>> students come up with every year when a class sees this problem for
>>>> the first time?
>>>
>>> My solution is novel: it correctly decides non-pathological input
>>> (including input that calls the decider) and signals an exception for
>>> pathological input (which is the correct thing to do).
>>
>> Currently you have no algorithm, just an idea for an algorithm.  When
>> you try to pin down the details you will have something that can't
>> detect all inputs that a functionally the same as the pathological cases
>> you think you want to spot.  This is a hole every such proposed "almost
>> solution" falls into.
>>
>> Just saying that you detect them all is not an algorithm.  It's design
>> by wishful thinking.
>>
>
> I have been telling him that.
>

POT - KETTLE - BLACK

Your "algroithm" has the exact same problem.

Re: Refutation of [Strachey 1965] and Halting Problem associated proofs

<20220731144101.000037ee@reddwarf.jmc.corp>

 copy mid

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

 copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!weretis.net!feeder8.news.weretis.net!newsreader4.netcologne.de!news.netcologne.de!peer03.ams1!peer.ams1.xlned.com!news.xlned.com!peer03.ams4!peer.am4.highwinds-media.com!news.highwinds-media.com!fx14.ams4.POSTED!not-for-mail
From: flib...@reddwarf.jmc.corp (Mr Flibble)
Newsgroups: comp.theory
Subject: Re: Refutation of [Strachey 1965] and Halting Problem associated
proofs
Message-ID: <20220731144101.000037ee@reddwarf.jmc.corp>
References: <20220731011138.000034e4@reddwarf.jmc.corp>
<877d3u85cv.fsf@bsb.me.uk>
<20220731020805.00004ff0@reddwarf.jmc.corp>
<871qu2827e.fsf@bsb.me.uk>
Organization: Jupiter Mining Corporation
X-Newsreader: Claws Mail 4.1.0 (GTK 3.24.33; x86_64-w64-mingw32)
MIME-Version: 1.0
Content-Type: text/plain; charset=US-ASCII
Content-Transfer-Encoding: 7bit
Lines: 40
X-Complaints-To: abuse@eweka.nl
NNTP-Posting-Date: Sun, 31 Jul 2022 13:41:03 UTC
Date: Sun, 31 Jul 2022 14:41:01 +0100
X-Received-Bytes: 2543
 by: Mr Flibble - Sun, 31 Jul 2022 13:41 UTC

On Sun, 31 Jul 2022 03:07:17 +0100
Ben Bacarisse <ben.usenet@bsb.me.uk> wrote:

> Mr Flibble <flibble@reddwarf.jmc.corp> writes:
>
> > On Sun, 31 Jul 2022 01:59:12 +0100
> > Ben Bacarisse <ben.usenet@bsb.me.uk> wrote:
> >
> >> Mr Flibble <flibble@reddwarf.jmc.corp> writes:
> >>
> >> > If the non-halting branch is determined to halt AND the halting
> >> > branch is determined to not halt then pathology is detected and
> >> > reported.
> >>
> >> Thus H is not a decider in the technical sense of the word. Why is
> >> your not-quite-a-decider any better than the ones half a dozen
> >> students come up with every year when a class sees this problem for
> >> the first time?
> >
> > My solution is novel: it correctly decides non-pathological input
> > (including input that calls the decider) and signals an exception
> > for pathological input (which is the correct thing to do).
>
> Currently you have no algorithm, just an idea for an algorithm. When
> you try to pin down the details you will have something that can't
> detect all inputs that a functionally the same as the pathological
> cases you think you want to spot. This is a hole every such proposed
> "almost solution" falls into.
>
> Just saying that you detect them all is not an algorithm. It's design
> by wishful thinking.

My proposal is sufficiently detailed to be classed as a high-level
design of an algorithm and I don't have to provide an implementation to
prove that my algorithm is correct. I believe have refuted [Strachey
1965] and associated Halting Problem proofs by providing a solution
that can handle the "Impossible Program".

/Flibble

Re: Refutation of [Strachey 1965] and Halting Problem associated proofs

<20220731144147.00000891@reddwarf.jmc.corp>

 copy mid

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

 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!peer02.ams1!peer.ams1.xlned.com!news.xlned.com!peer03.ams4!peer.am4.highwinds-media.com!news.highwinds-media.com!fx14.ams4.POSTED!not-for-mail
From: flib...@reddwarf.jmc.corp (Mr Flibble)
Newsgroups: comp.theory
Subject: Re: Refutation of [Strachey 1965] and Halting Problem associated
proofs
Message-ID: <20220731144147.00000891@reddwarf.jmc.corp>
References: <20220731011138.000034e4@reddwarf.jmc.corp>
<877d3u85cv.fsf@bsb.me.uk>
<20220731020805.00004ff0@reddwarf.jmc.corp>
<871qu2827e.fsf@bsb.me.uk>
<y7KdnXwRDb49dHj_nZ2dnZfqlJxg4p2d@giganews.com>
Organization: Jupiter Mining Corporation
X-Newsreader: Claws Mail 4.1.0 (GTK 3.24.33; x86_64-w64-mingw32)
MIME-Version: 1.0
Content-Type: text/plain; charset=US-ASCII
Content-Transfer-Encoding: 7bit
Lines: 41
X-Complaints-To: abuse@eweka.nl
NNTP-Posting-Date: Sun, 31 Jul 2022 13:41:49 UTC
Date: Sun, 31 Jul 2022 14:41:47 +0100
X-Received-Bytes: 2482
 by: Mr Flibble - Sun, 31 Jul 2022 13:41 UTC

On Sat, 30 Jul 2022 21:32:09 -0500
olcott <NoOne@NoWhere.com> wrote:

> On 7/30/2022 9:07 PM, Ben Bacarisse wrote:
> > Mr Flibble <flibble@reddwarf.jmc.corp> writes:
> >
> >> On Sun, 31 Jul 2022 01:59:12 +0100
> >> Ben Bacarisse <ben.usenet@bsb.me.uk> wrote:
> >>
> >>> Mr Flibble <flibble@reddwarf.jmc.corp> writes:
> >>>
> >>>> If the non-halting branch is determined to halt AND the halting
> >>>> branch is determined to not halt then pathology is detected and
> >>>> reported.
> >>>
> >>> Thus H is not a decider in the technical sense of the word. Why
> >>> is your not-quite-a-decider any better than the ones half a dozen
> >>> students come up with every year when a class sees this problem
> >>> for the first time?
> >>
> >> My solution is novel: it correctly decides non-pathological input
> >> (including input that calls the decider) and signals an exception
> >> for pathological input (which is the correct thing to do).
> >
> > Currently you have no algorithm, just an idea for an algorithm.
> > When you try to pin down the details you will have something that
> > can't detect all inputs that a functionally the same as the
> > pathological cases you think you want to spot. This is a hole
> > every such proposed "almost solution" falls into.
> >
> > Just saying that you detect them all is not an algorithm. It's
> > design by wishful thinking.
> >
>
> I have been telling him that.

It has likely been many years since the last time you told anyone
anything of value or substance.

/Flibble

Re: Refutation of [Strachey 1965] and Halting Problem associated proofs

<20220731144338.00003f08@reddwarf.jmc.corp>

 copy mid

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

 copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!usenet.blueworldhosting.com!feed1.usenet.blueworldhosting.com!peer01.iad!feed-me.highwinds-media.com!peer02.ams4!peer.am4.highwinds-media.com!news.highwinds-media.com!fx14.ams4.POSTED!not-for-mail
From: flib...@reddwarf.jmc.corp (Mr Flibble)
Newsgroups: comp.theory
Subject: Re: Refutation of [Strachey 1965] and Halting Problem associated
proofs
Message-ID: <20220731144338.00003f08@reddwarf.jmc.corp>
References: <20220731011138.000034e4@reddwarf.jmc.corp>
<877d3u85cv.fsf@bsb.me.uk>
<20220731020805.00004ff0@reddwarf.jmc.corp>
<871qu2827e.fsf@bsb.me.uk>
<y7KdnXwRDb49dHj_nZ2dnZfqlJxg4p2d@giganews.com>
<xNtFK.601319$J0r9.535812@fx11.iad>
Organization: Jupiter Mining Corporation
X-Newsreader: Claws Mail 4.1.0 (GTK 3.24.33; x86_64-w64-mingw32)
MIME-Version: 1.0
Content-Type: text/plain; charset=ISO-8859-1
Content-Transfer-Encoding: quoted-printable
Lines: 47
X-Complaints-To: abuse@eweka.nl
NNTP-Posting-Date: Sun, 31 Jul 2022 13:43:40 UTC
Date: Sun, 31 Jul 2022 14:43:38 +0100
X-Received-Bytes: 2750
 by: Mr Flibble - Sun, 31 Jul 2022 13:43 UTC

On Sun, 31 Jul 2022 07:34:53 -0400
Richard Damon <Richard@Damon-Family.org> wrote:

> On 7/30/22 10:32 PM, olcott wrote:
> > On 7/30/2022 9:07 PM, Ben Bacarisse wrote:
> >> Mr Flibble <flibble@reddwarf.jmc.corp> writes:
> >>
> >>> On Sun, 31 Jul 2022 01:59:12 +0100
> >>> Ben Bacarisse <ben.usenet@bsb.me.uk> wrote:
> >>>
> >>>> Mr Flibble <flibble@reddwarf.jmc.corp> writes:
> >>>>
> >>>>> If the non-halting branch is determined to halt AND the halting
> >>>>> branch is determined to not halt then pathology is detected and
> >>>>> reported.
> >>>>
> >>>> Thus H is not a decider in the technical sense of the word.  Why
> >>>> is your not-quite-a-decider any better than the ones half a dozen
> >>>> students come up with every year when a class sees this problem
> >>>> for the first time?
> >>>
> >>> My solution is novel: it correctly decides non-pathological input
> >>> (including input that calls the decider) and signals an exception
> >>> for pathological input (which is the correct thing to do).
> >>
> >> Currently you have no algorithm, just an idea for an algorithm.
> >> When you try to pin down the details you will have something that
> >> can't detect all inputs that a functionally the same as the
> >> pathological cases you think you want to spot.  This is a hole
> >> every such proposed "almost solution" falls into.
> >>
> >> Just saying that you detect them all is not an algorithm.  It's
> >> design by wishful thinking.
> >>
> >
> > I have been telling him that.
> >
>
> POT - KETTLE - BLACK
>
> Your "algroithm" has the exact same problem.

No, Olcott's algorithm is demonstrably wrong; my algorithm isn't so
they do not have "the exact same problem".

/Flibble

Re: Refutation of [Strachey 1965] and Halting Problem associated proofs

<RN-dnSL_yoSXEHv_nZ2dnZfqlJzNnZ2d@giganews.com>

 copy mid

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

 copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!weretis.net!feeder6.news.weretis.net!news.misty.com!border-2.nntp.ord.giganews.com!nntp.giganews.com!Xl.tags.giganews.com!local-1.nntp.ord.giganews.com!news.giganews.com.POSTED!not-for-mail
NNTP-Posting-Date: Sun, 31 Jul 2022 14:09:14 +0000
Date: Sun, 31 Jul 2022 09:09:22 -0500
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:91.0) Gecko/20100101
Thunderbird/91.11.0
Subject: Re: Refutation of [Strachey 1965] and Halting Problem associated
proofs
Content-Language: en-US
Newsgroups: comp.theory
References: <20220731011138.000034e4@reddwarf.jmc.corp>
<877d3u85cv.fsf@bsb.me.uk> <20220731020805.00004ff0@reddwarf.jmc.corp>
<871qu2827e.fsf@bsb.me.uk> <y7KdnXwRDb49dHj_nZ2dnZfqlJxg4p2d@giganews.com>
<xNtFK.601319$J0r9.535812@fx11.iad>
<20220731144338.00003f08@reddwarf.jmc.corp>
From: NoO...@NoWhere.com (olcott)
In-Reply-To: <20220731144338.00003f08@reddwarf.jmc.corp>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Message-ID: <RN-dnSL_yoSXEHv_nZ2dnZfqlJzNnZ2d@giganews.com>
Lines: 100
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-nw8vrxd74QmYzKkVqXzmFdwiilqx1pszt9pgCiRwX3jYqji1Qjo+Wqjj9CI+9xVpFAeSwzElWh1J3Bn!sUusbILUr6FaUVEMF+Kkp6zbKU3G9Nkr+ZHX078wQkOpcQYx9EornTV/Nl+I+ZCm4Hj3st0u1S61!MQ==
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
 by: olcott - Sun, 31 Jul 2022 14:09 UTC

On 7/31/2022 8:43 AM, Mr Flibble wrote:
> On Sun, 31 Jul 2022 07:34:53 -0400
> Richard Damon <Richard@Damon-Family.org> wrote:
>
>> On 7/30/22 10:32 PM, olcott wrote:
>>> On 7/30/2022 9:07 PM, Ben Bacarisse wrote:
>>>> Mr Flibble <flibble@reddwarf.jmc.corp> writes:
>>>>
>>>>> On Sun, 31 Jul 2022 01:59:12 +0100
>>>>> Ben Bacarisse <ben.usenet@bsb.me.uk> wrote:
>>>>>
>>>>>> Mr Flibble <flibble@reddwarf.jmc.corp> writes:
>>>>>>
>>>>>>> If the non-halting branch is determined to halt AND the halting
>>>>>>> branch is determined to not halt then pathology is detected and
>>>>>>> reported.
>>>>>>
>>>>>> Thus H is not a decider in the technical sense of the word.  Why
>>>>>> is your not-quite-a-decider any better than the ones half a dozen
>>>>>> students come up with every year when a class sees this problem
>>>>>> for the first time?
>>>>>
>>>>> My solution is novel: it correctly decides non-pathological input
>>>>> (including input that calls the decider) and signals an exception
>>>>> for pathological input (which is the correct thing to do).
>>>>
>>>> Currently you have no algorithm, just an idea for an algorithm.
>>>> When you try to pin down the details you will have something that
>>>> can't detect all inputs that a functionally the same as the
>>>> pathological cases you think you want to spot.  This is a hole
>>>> every such proposed "almost solution" falls into.
>>>>
>>>> Just saying that you detect them all is not an algorithm.  It's
>>>> design by wishful thinking.
>>>>
>>>
>>> I have been telling him that.
>>>
>>
>> POT - KETTLE - BLACK
>>
>> Your "algroithm" has the exact same problem.
>
> No, Olcott's algorithm is demonstrably wrong; my algorithm isn't so
> they do not have "the exact same problem".
>
> /Flibble
>

Your algorithm has never been presented.

void Infinite_Recursion(int N)
{ Infinite_Recursion(N);
}

int main()
{ Output("Input_Halts = ", H(Infinite_Recursion, 0x777));
}

This is my algorithm and it does work correctly on infinite
recursion.

H: Begin Simulation Execution Trace Stored at:111b61
machine stack stack machine assembly
address address data code language
======== ======== ======== ========= =============
[0000101e][00111b4d][00111b51] 55 push ebp
[0000101f][00111b4d][00111b51] 8bec mov ebp,esp
[00001021][00111b4d][00111b51] 8b4508 mov eax,[ebp+08]
[00001024][00111b49][00000777] 50 push eax
[00001025][00111b45][0000102a] e8f4ffffff call 0000101e
[0000101e][00111b41][00111b4d] 55 push ebp
[0000101f][00111b41][00111b4d] 8bec mov ebp,esp
[00001021][00111b41][00111b4d] 8b4508 mov eax,[ebp+08]
[00001024][00111b3d][00000777] 50 push eax
[00001025][00111b39][0000102a] e8f4ffffff call 0000101e
H: Infinite Recursion Detected Simulation Stopped

The state of the virtual machine that repeats is:
(a) EIP register value = 00000f9b
(b) The top two stack values = 00000f8f
(c) The call address target is 00000c9f

We also must make sure that there are no control flow
instructions between the invocation of P() and its call
to H(P,P) or P could be counting down a static variable
that could stop the repetition.

--
Copyright 2022 Pete Olcott

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

Re: Refutation of [Strachey 1965] and Halting Problem associated proofs

<36a604f6-bad2-49e9-8b48-a4e62c449e75n@googlegroups.com>

 copy mid

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

 copy link   Newsgroups: comp.theory
X-Received: by 2002:a0c:e185:0:b0:474:7ab8:1eaf with SMTP id p5-20020a0ce185000000b004747ab81eafmr11088788qvl.76.1659277138685;
Sun, 31 Jul 2022 07:18:58 -0700 (PDT)
X-Received: by 2002:a0d:dfcc:0:b0:322:f812:f379 with SMTP id
i195-20020a0ddfcc000000b00322f812f379mr9918811ywe.172.1659277138440; Sun, 31
Jul 2022 07:18:58 -0700 (PDT)
Path: i2pn2.org!i2pn.org!usenet.blueworldhosting.com!feed1.usenet.blueworldhosting.com!peer02.iad!feed-me.highwinds-media.com!news.highwinds-media.com!news-out.google.com!nntp.google.com!postnews.google.com!google-groups.googlegroups.com!not-for-mail
Newsgroups: comp.theory
Date: Sun, 31 Jul 2022 07:18:58 -0700 (PDT)
In-Reply-To: <RN-dnSL_yoSXEHv_nZ2dnZfqlJzNnZ2d@giganews.com>
Injection-Info: google-groups.googlegroups.com; posting-host=98.110.86.97; posting-account=ejFcQgoAAACAt5i0VbkATkR2ACWdgADD
NNTP-Posting-Host: 98.110.86.97
References: <20220731011138.000034e4@reddwarf.jmc.corp> <877d3u85cv.fsf@bsb.me.uk>
<20220731020805.00004ff0@reddwarf.jmc.corp> <871qu2827e.fsf@bsb.me.uk>
<y7KdnXwRDb49dHj_nZ2dnZfqlJxg4p2d@giganews.com> <xNtFK.601319$J0r9.535812@fx11.iad>
<20220731144338.00003f08@reddwarf.jmc.corp> <RN-dnSL_yoSXEHv_nZ2dnZfqlJzNnZ2d@giganews.com>
User-Agent: G2/1.0
MIME-Version: 1.0
Message-ID: <36a604f6-bad2-49e9-8b48-a4e62c449e75n@googlegroups.com>
Subject: Re: Refutation of [Strachey 1965] and Halting Problem associated proofs
From: dbush.mo...@gmail.com (Dennis Bush)
Injection-Date: Sun, 31 Jul 2022 14:18:58 +0000
Content-Type: text/plain; charset="UTF-8"
Content-Transfer-Encoding: quoted-printable
X-Received-Bytes: 6023
 by: Dennis Bush - Sun, 31 Jul 2022 14:18 UTC

On Sunday, July 31, 2022 at 10:09:31 AM UTC-4, olcott wrote:
> On 7/31/2022 8:43 AM, Mr Flibble wrote:
> > On Sun, 31 Jul 2022 07:34:53 -0400
> > Richard Damon <Ric...@Damon-Family.org> wrote:
> >
> >> On 7/30/22 10:32 PM, olcott wrote:
> >>> On 7/30/2022 9:07 PM, Ben Bacarisse wrote:
> >>>> Mr Flibble <fli...@reddwarf.jmc.corp> writes:
> >>>>
> >>>>> On Sun, 31 Jul 2022 01:59:12 +0100
> >>>>> Ben Bacarisse <ben.u...@bsb.me.uk> wrote:
> >>>>>
> >>>>>> Mr Flibble <fli...@reddwarf.jmc.corp> writes:
> >>>>>>
> >>>>>>> If the non-halting branch is determined to halt AND the halting
> >>>>>>> branch is determined to not halt then pathology is detected and
> >>>>>>> reported.
> >>>>>>
> >>>>>> Thus H is not a decider in the technical sense of the word. Why
> >>>>>> is your not-quite-a-decider any better than the ones half a dozen
> >>>>>> students come up with every year when a class sees this problem
> >>>>>> for the first time?
> >>>>>
> >>>>> My solution is novel: it correctly decides non-pathological input
> >>>>> (including input that calls the decider) and signals an exception
> >>>>> for pathological input (which is the correct thing to do).
> >>>>
> >>>> Currently you have no algorithm, just an idea for an algorithm.
> >>>> When you try to pin down the details you will have something that
> >>>> can't detect all inputs that a functionally the same as the
> >>>> pathological cases you think you want to spot. This is a hole
> >>>> every such proposed "almost solution" falls into.
> >>>>
> >>>> Just saying that you detect them all is not an algorithm. It's
> >>>> design by wishful thinking.
> >>>>
> >>>
> >>> I have been telling him that.
> >>>
> >>
> >> POT - KETTLE - BLACK
> >>
> >> Your "algroithm" has the exact same problem.
> >
> > No, Olcott's algorithm is demonstrably wrong; my algorithm isn't so
> > they do not have "the exact same problem".
> >
> > /Flibble
> >
> Your algorithm has never been presented.
>
> void Infinite_Recursion(int N)
> {
> Infinite_Recursion(N);
> }
>
> int main()
> {
> Output("Input_Halts = ", H(Infinite_Recursion, 0x777));
> }
>
> This is my algorithm and it does work correctly on infinite
> recursion.

Maybe in this case, but not in the general case. It also doesn't help that you're answering the wrong question and think that H(P,P)==0 is correct despite the *definition* stating otherwise.

>
> H: Begin Simulation Execution Trace Stored at:111b61
> machine stack stack machine assembly
> address address data code language
> ======== ======== ======== ========= =============
> [0000101e][00111b4d][00111b51] 55 push ebp
> [0000101f][00111b4d][00111b51] 8bec mov ebp,esp
> [00001021][00111b4d][00111b51] 8b4508 mov eax,[ebp+08]
> [00001024][00111b49][00000777] 50 push eax
> [00001025][00111b45][0000102a] e8f4ffffff call 0000101e
> [0000101e][00111b41][00111b4d] 55 push ebp
> [0000101f][00111b41][00111b4d] 8bec mov ebp,esp
> [00001021][00111b41][00111b4d] 8b4508 mov eax,[ebp+08]
> [00001024][00111b3d][00000777] 50 push eax
> [00001025][00111b39][0000102a] e8f4ffffff call 0000101e
> H: Infinite Recursion Detected Simulation Stopped
>
> The state of the virtual machine that repeats is:
> (a) EIP register value = 00000f9b
> (b) The top two stack values = 00000f8f
> (c) The call address target is 00000c9f
>
> We also must make sure that there are no control flow
> instructions between the invocation of P() and its call
> to H(P,P) or P could be counting down a static variable
> that could stop the repetition.

No control flow instructions *between successive calls to H*, not just in the function P before the call to H. And there are *many* such instructions in Pa(Pa), specifically all of the instructions in Ha and the functions that it calls that check for its abort condition.

Ha(Pa,Pa) must decide the halt status of Pa(Pa), not Pn(Pn) as you claim:

On Saturday, July 30, 2022 at 4:09:34 PM UTC-4, olcott wrote:
> H(P,P) is asking would the input that I correctly emulate ever reach its
> "ret" instruction (final state) if I never stopped emulating it?

Re: Refutation of [Strachey 1965] and Halting Problem associated proofs

<20220731152422.00007ccb@reddwarf.jmc.corp>

 copy mid

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

 copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!weretis.net!feeder8.news.weretis.net!newsreader4.netcologne.de!news.netcologne.de!peer03.ams1!peer.ams1.xlned.com!news.xlned.com!peer02.ams4!peer.am4.highwinds-media.com!news.highwinds-media.com!fx01.ams4.POSTED!not-for-mail
From: flib...@reddwarf.jmc.corp (Mr Flibble)
Newsgroups: comp.theory
Subject: Re: Refutation of [Strachey 1965] and Halting Problem associated
proofs
Message-ID: <20220731152422.00007ccb@reddwarf.jmc.corp>
References: <20220731011138.000034e4@reddwarf.jmc.corp>
<877d3u85cv.fsf@bsb.me.uk>
<20220731020805.00004ff0@reddwarf.jmc.corp>
<871qu2827e.fsf@bsb.me.uk>
<y7KdnXwRDb49dHj_nZ2dnZfqlJxg4p2d@giganews.com>
<xNtFK.601319$J0r9.535812@fx11.iad>
<20220731144338.00003f08@reddwarf.jmc.corp>
<RN-dnSL_yoSXEHv_nZ2dnZfqlJzNnZ2d@giganews.com>
Organization: Jupiter Mining Corporation
X-Newsreader: Claws Mail 4.1.0 (GTK 3.24.33; x86_64-w64-mingw32)
MIME-Version: 1.0
Content-Type: text/plain; charset=ISO-8859-1
Content-Transfer-Encoding: quoted-printable
Lines: 113
X-Complaints-To: abuse@eweka.nl
NNTP-Posting-Date: Sun, 31 Jul 2022 14:24:22 UTC
Date: Sun, 31 Jul 2022 15:24:22 +0100
X-Received-Bytes: 5231
 by: Mr Flibble - Sun, 31 Jul 2022 14:24 UTC

On Sun, 31 Jul 2022 09:09:22 -0500
olcott <NoOne@NoWhere.com> wrote:

> On 7/31/2022 8:43 AM, Mr Flibble wrote:
> > On Sun, 31 Jul 2022 07:34:53 -0400
> > Richard Damon <Richard@Damon-Family.org> wrote:
> >
> >> On 7/30/22 10:32 PM, olcott wrote:
> >>> On 7/30/2022 9:07 PM, Ben Bacarisse wrote:
> >>>> Mr Flibble <flibble@reddwarf.jmc.corp> writes:
> >>>>
> >>>>> On Sun, 31 Jul 2022 01:59:12 +0100
> >>>>> Ben Bacarisse <ben.usenet@bsb.me.uk> wrote:
> >>>>>
> >>>>>> Mr Flibble <flibble@reddwarf.jmc.corp> writes:
> >>>>>>
> >>>>>>> If the non-halting branch is determined to halt AND the
> >>>>>>> halting branch is determined to not halt then pathology is
> >>>>>>> detected and reported.
> >>>>>>
> >>>>>> Thus H is not a decider in the technical sense of the word.
> >>>>>> Why is your not-quite-a-decider any better than the ones half
> >>>>>> a dozen students come up with every year when a class sees
> >>>>>> this problem for the first time?
> >>>>>
> >>>>> My solution is novel: it correctly decides non-pathological
> >>>>> input (including input that calls the decider) and signals an
> >>>>> exception for pathological input (which is the correct thing to
> >>>>> do).
> >>>>
> >>>> Currently you have no algorithm, just an idea for an algorithm.
> >>>> When you try to pin down the details you will have something that
> >>>> can't detect all inputs that a functionally the same as the
> >>>> pathological cases you think you want to spot.  This is a hole
> >>>> every such proposed "almost solution" falls into.
> >>>>
> >>>> Just saying that you detect them all is not an algorithm.  It's
> >>>> design by wishful thinking.
> >>>>
> >>>
> >>> I have been telling him that.
> >>>
> >>
> >> POT - KETTLE - BLACK
> >>
> >> Your "algroithm" has the exact same problem.
> >
> > No, Olcott's algorithm is demonstrably wrong; my algorithm isn't so
> > they do not have "the exact same problem".
> >
> > /Flibble
> >
>
> Your algorithm has never been presented.

I have presented the high level design of an algorithm and I do not
have to provide an implementation to prove it is correct, to prove that
it does what it says on the tin.

>
> void Infinite_Recursion(int N)
> {
> Infinite_Recursion(N);
> }
>
> int main()
> {
> Output("Input_Halts = ", H(Infinite_Recursion, 0x777));
> }
>
> This is my algorithm and it does work correctly on infinite
> recursion.
>
> H: Begin Simulation Execution Trace Stored at:111b61
> machine stack stack machine assembly
> address address data code language
> ======== ======== ======== ========= ============> [0000101e][00111b4d][00111b51] 55 push ebp
> [0000101f][00111b4d][00111b51] 8bec mov ebp,esp
> [00001021][00111b4d][00111b51] 8b4508 mov eax,[ebp+08]
> [00001024][00111b49][00000777] 50 push eax
> [00001025][00111b45][0000102a] e8f4ffffff call 0000101e
> [0000101e][00111b41][00111b4d] 55 push ebp
> [0000101f][00111b41][00111b4d] 8bec mov ebp,esp
> [00001021][00111b41][00111b4d] 8b4508 mov eax,[ebp+08]
> [00001024][00111b3d][00000777] 50 push eax
> [00001025][00111b39][0000102a] e8f4ffffff call 0000101e
> H: Infinite Recursion Detected Simulation Stopped
>
> The state of the virtual machine that repeats is:
> (a) EIP register value = 00000f9b
> (b) The top two stack values = 00000f8f
> (c) The call address target is 00000c9f
>
> We also must make sure that there are no control flow
> instructions between the invocation of P() and its call
> to H(P,P) or P could be counting down a static variable
> that could stop the repetition.

That is a trivial case to recognize; your decider gets the following
wrong however:

void Px()
{ (void) H(Px, Px);
}

Px always halts and yet your decider returns a result of non-halting
which is INCORRECT.

/Flibble

Re: Refutation of [Strachey 1965] and Halting Problem associated proofs

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

 copy mid

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

 copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!eternal-september.org!reader01.eternal-september.org!.POSTED!not-for-mail
From: ben.use...@bsb.me.uk (Ben Bacarisse)
Newsgroups: comp.theory
Subject: Re: Refutation of [Strachey 1965] and Halting Problem associated proofs
Date: Sun, 31 Jul 2022 19:33:10 +0100
Organization: A noiseless patient Spider
Lines: 50
Message-ID: <87h72x6sk9.fsf@bsb.me.uk>
References: <20220731011138.000034e4@reddwarf.jmc.corp>
<877d3u85cv.fsf@bsb.me.uk> <20220731020805.00004ff0@reddwarf.jmc.corp>
<871qu2827e.fsf@bsb.me.uk> <20220731144101.000037ee@reddwarf.jmc.corp>
MIME-Version: 1.0
Content-Type: text/plain
Injection-Info: reader01.eternal-september.org; posting-host="0ef9a181c1082aee22bab9969b934578";
logging-data="495884"; mail-complaints-to="abuse@eternal-september.org"; posting-account="U2FsdGVkX19t7QdXU/FyWHueGC9O11tsqW1olyYNzbU="
User-Agent: Gnus/5.13 (Gnus v5.13) Emacs/27.1 (gnu/linux)
Cancel-Lock: sha1:boCfBn+/pfXRHBOMr3wVB0EDzY8=
sha1:Sz3tfdwvi19QtkDTp/PcspPgUSE=
X-BSB-Auth: 1.90e42f2b92781400769c.20220731193310BST.87h72x6sk9.fsf@bsb.me.uk
 by: Ben Bacarisse - Sun, 31 Jul 2022 18:33 UTC

Mr Flibble <flibble@reddwarf.jmc.corp> writes:

> On Sun, 31 Jul 2022 03:07:17 +0100
> Ben Bacarisse <ben.usenet@bsb.me.uk> wrote:
>
>> Mr Flibble <flibble@reddwarf.jmc.corp> writes:
>>
>> > On Sun, 31 Jul 2022 01:59:12 +0100
>> > Ben Bacarisse <ben.usenet@bsb.me.uk> wrote:
>> >
>> >> Mr Flibble <flibble@reddwarf.jmc.corp> writes:
>> >>
>> >> > If the non-halting branch is determined to halt AND the halting
>> >> > branch is determined to not halt then pathology is detected and
>> >> > reported.
>> >>
>> >> Thus H is not a decider in the technical sense of the word. Why is
>> >> your not-quite-a-decider any better than the ones half a dozen
>> >> students come up with every year when a class sees this problem for
>> >> the first time?
>> >
>> > My solution is novel: it correctly decides non-pathological input
>> > (including input that calls the decider) and signals an exception
>> > for pathological input (which is the correct thing to do).
>>
>> Currently you have no algorithm, just an idea for an algorithm. When
>> you try to pin down the details you will have something that can't
>> detect all inputs that a functionally the same as the pathological
>> cases you think you want to spot. This is a hole every such proposed
>> "almost solution" falls into.
>>
>> Just saying that you detect them all is not an algorithm. It's design
>> by wishful thinking.
>
> My proposal is sufficiently detailed to be classed as a high-level
> design of an algorithm and I don't have to provide an implementation to
> prove that my algorithm is correct.

So you can move on then. If you think there is nothing more that needs
to be said, there is no need to keep posting about it.

> I believe have refuted [Strachey
> 1965] and associated Halting Problem proofs by providing a solution
> that can handle the "Impossible Program".

Uou were clear that your algorithm was not a halt decider. What has it
got to do with proof about halt deciders?

--
Ben.

Re: Refutation of [Strachey 1965] and Halting Problem associated proofs

<85c2a48a-f4d5-4fbf-8b1d-14cdcee27160n@googlegroups.com>

 copy mid

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

 copy link   Newsgroups: comp.theory
X-Received: by 2002:ac8:5a84:0:b0:31e:f60e:3449 with SMTP id c4-20020ac85a84000000b0031ef60e3449mr11599584qtc.57.1659308558085;
Sun, 31 Jul 2022 16:02:38 -0700 (PDT)
X-Received: by 2002:a25:e6cd:0:b0:675:8f5d:60a6 with SMTP id
d196-20020a25e6cd000000b006758f5d60a6mr8658341ybh.389.1659308557858; Sun, 31
Jul 2022 16:02:37 -0700 (PDT)
Path: i2pn2.org!i2pn.org!usenet.blueworldhosting.com!feed1.usenet.blueworldhosting.com!peer03.iad!feed-me.highwinds-media.com!news.highwinds-media.com!news-out.google.com!nntp.google.com!postnews.google.com!google-groups.googlegroups.com!not-for-mail
Newsgroups: comp.theory
Date: Sun, 31 Jul 2022 16:02:37 -0700 (PDT)
In-Reply-To: <20220731011138.000034e4@reddwarf.jmc.corp>
Injection-Info: google-groups.googlegroups.com; posting-host=2001:470:1f23:2:a065:ad91:371a:fb8c;
posting-account=ZZETkAoAAACd4T-hRBh8m6HZV7_HBvWo
NNTP-Posting-Host: 2001:470:1f23:2:a065:ad91:371a:fb8c
References: <20220731011138.000034e4@reddwarf.jmc.corp>
User-Agent: G2/1.0
MIME-Version: 1.0
Message-ID: <85c2a48a-f4d5-4fbf-8b1d-14cdcee27160n@googlegroups.com>
Subject: Re: Refutation of [Strachey 1965] and Halting Problem associated proofs
From: skepdic...@gmail.com (Skep Dick)
Injection-Date: Sun, 31 Jul 2022 23:02:38 +0000
Content-Type: text/plain; charset="UTF-8"
X-Received-Bytes: 2815
 by: Skep Dick - Sun, 31 Jul 2022 23:02 UTC

On Sunday, 31 July 2022 at 02:11:41 UTC+2, Mr Flibble wrote:
> I have an idea for a simulating halt decider that forks the
> simulation into two branches if the input calls the halt decider as
> per [Strachey 1965]'s "Impossible Program":
>
> void P(void (*x)())
> {
> if (H(x, x))
> infinite_loop: goto infinite_loop;
> return;
> }
>
> int main()
> {
> std::cout << "Input halts: " << H(P, P) << std::endl;
> }
>
> When the simulator detects the call to H in P it forks the simulation
> into a non-halting branch (returning 0 to P) and a halting branch
> (returning 1 to P) and continues the simulation of these two branches
> in parallel.
>
> If the non-halting branch is determined to halt AND the halting branch
> is determined to not halt then pathology is detected and reported.
>
> If EITHER branch is determined to be correctly decided then that will
> be the decision of the halting decider.
>
> Crucially this scheme will handle (and correctly decide) the
> following case whereby the result of H is discarded by the input:
>
> void Px(void (*x)())
> {
> (void) H(x, x);
> return;
> }
>
> /Flibble
>
> Copyright (c) 2022 Mr Flibble

Game theory 101 is the strategy-stealing strategy. Any strategy available to H against P is also available to P against H.

When H simulates P (simulating H(simulating P ))) the simulated H throws an exception. P catches the exception and enters an infinite loop.

Thus making top-level H enter an infinite loop also.

You and olcott should hang out more often. Your psychologies epitomize the pathological P.

Re: Refutation of [Strachey 1965] and Halting Problem associated proofs

<20220801005402.00005567@reddwarf.jmc.corp>

 copy mid

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

 copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!usenet.blueworldhosting.com!feed1.usenet.blueworldhosting.com!peer03.iad!feed-me.highwinds-media.com!peer03.ams1!peer.ams1.xlned.com!news.xlned.com!peer03.ams4!peer.am4.highwinds-media.com!news.highwinds-media.com!fx11.ams4.POSTED!not-for-mail
From: flib...@reddwarf.jmc.corp (Mr Flibble)
Newsgroups: comp.theory
Subject: Re: Refutation of [Strachey 1965] and Halting Problem associated
proofs
Message-ID: <20220801005402.00005567@reddwarf.jmc.corp>
References: <20220731011138.000034e4@reddwarf.jmc.corp>
<85c2a48a-f4d5-4fbf-8b1d-14cdcee27160n@googlegroups.com>
Organization: Jupiter Mining Corporation
X-Newsreader: Claws Mail 4.1.0 (GTK 3.24.33; x86_64-w64-mingw32)
MIME-Version: 1.0
Content-Type: text/plain; charset=US-ASCII
Content-Transfer-Encoding: 7bit
Lines: 62
X-Complaints-To: abuse@eweka.nl
NNTP-Posting-Date: Sun, 31 Jul 2022 23:54:03 UTC
Date: Mon, 1 Aug 2022 00:54:02 +0100
X-Received-Bytes: 2788
 by: Mr Flibble - Sun, 31 Jul 2022 23:54 UTC

On Sun, 31 Jul 2022 16:02:37 -0700 (PDT)
Skep Dick <skepdick22@gmail.com> wrote:

> On Sunday, 31 July 2022 at 02:11:41 UTC+2, Mr Flibble wrote:
> > I have an idea for a simulating halt decider that forks the
> > simulation into two branches if the input calls the halt decider as
> > per [Strachey 1965]'s "Impossible Program":
> >
> > void P(void (*x)())
> > {
> > if (H(x, x))
> > infinite_loop: goto infinite_loop;
> > return;
> > }
> >
> > int main()
> > {
> > std::cout << "Input halts: " << H(P, P) << std::endl;
> > }
> >
> > When the simulator detects the call to H in P it forks the
> > simulation into a non-halting branch (returning 0 to P) and a
> > halting branch (returning 1 to P) and continues the simulation of
> > these two branches in parallel.
> >
> > If the non-halting branch is determined to halt AND the halting
> > branch is determined to not halt then pathology is detected and
> > reported.
> >
> > If EITHER branch is determined to be correctly decided then that
> > will be the decision of the halting decider.
> >
> > Crucially this scheme will handle (and correctly decide) the
> > following case whereby the result of H is discarded by the input:
> >
> > void Px(void (*x)())
> > {
> > (void) H(x, x);
> > return;
> > }
> >
> > /Flibble
> >
> > Copyright (c) 2022 Mr Flibble
>
> Game theory 101 is the strategy-stealing strategy. Any strategy
> available to H against P is also available to P against H.
>
> When H simulates P (simulating H(simulating P ))) the simulated H
> throws an exception. P catches the exception and enters an infinite
> loop.
>
> Thus making top-level H enter an infinite loop also.
>
> You and olcott should hang out more often. Your psychologies
> epitomize the pathological P.

Nope, the exception is not visible to simulated P and there is no
simulated H.

/Flibble

Re: Refutation of [Strachey 1965] and Halting Problem associated proofs

<1JEFK.68846$mY1.16139@fx01.iad>

 copy mid

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

 copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!usenet.blueworldhosting.com!feed1.usenet.blueworldhosting.com!peer03.iad!feed-me.highwinds-media.com!news.highwinds-media.com!fx01.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.11.0
Subject: Re: Refutation of [Strachey 1965] and Halting Problem associated
proofs
Content-Language: en-US
Newsgroups: comp.theory
References: <20220731011138.000034e4@reddwarf.jmc.corp>
<85c2a48a-f4d5-4fbf-8b1d-14cdcee27160n@googlegroups.com>
<20220801005402.00005567@reddwarf.jmc.corp>
From: Rich...@Damon-Family.org (Richard Damon)
In-Reply-To: <20220801005402.00005567@reddwarf.jmc.corp>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 7bit
Lines: 75
Message-ID: <1JEFK.68846$mY1.16139@fx01.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: Sun, 31 Jul 2022 20:01:00 -0400
X-Received-Bytes: 3449
 by: Richard Damon - Mon, 1 Aug 2022 00:01 UTC

On 7/31/22 7:54 PM, Mr Flibble wrote:
> On Sun, 31 Jul 2022 16:02:37 -0700 (PDT)
> Skep Dick <skepdick22@gmail.com> wrote:
>
>> On Sunday, 31 July 2022 at 02:11:41 UTC+2, Mr Flibble wrote:
>>> I have an idea for a simulating halt decider that forks the
>>> simulation into two branches if the input calls the halt decider as
>>> per [Strachey 1965]'s "Impossible Program":
>>>
>>> void P(void (*x)())
>>> {
>>> if (H(x, x))
>>> infinite_loop: goto infinite_loop;
>>> return;
>>> }
>>>
>>> int main()
>>> {
>>> std::cout << "Input halts: " << H(P, P) << std::endl;
>>> }
>>>
>>> When the simulator detects the call to H in P it forks the
>>> simulation into a non-halting branch (returning 0 to P) and a
>>> halting branch (returning 1 to P) and continues the simulation of
>>> these two branches in parallel.
>>>
>>> If the non-halting branch is determined to halt AND the halting
>>> branch is determined to not halt then pathology is detected and
>>> reported.
>>>
>>> If EITHER branch is determined to be correctly decided then that
>>> will be the decision of the halting decider.
>>>
>>> Crucially this scheme will handle (and correctly decide) the
>>> following case whereby the result of H is discarded by the input:
>>>
>>> void Px(void (*x)())
>>> {
>>> (void) H(x, x);
>>> return;
>>> }
>>>
>>> /Flibble
>>>
>>> Copyright (c) 2022 Mr Flibble
>>
>> Game theory 101 is the strategy-stealing strategy. Any strategy
>> available to H against P is also available to P against H.
>>
>> When H simulates P (simulating H(simulating P ))) the simulated H
>> throws an exception. P catches the exception and enters an infinite
>> loop.
>>
>> Thus making top-level H enter an infinite loop also.
>>
>> You and olcott should hang out more often. Your psychologies
>> epitomize the pathological P.
>
> Nope, the exception is not visible to simulated P and there is no
> simulated H.
>
> /Flibble
>

Unfortunately, that means that H can't be the equivalent of a Turing
Machine.

Your "Blue Screen of Death" answer of pathological is NOT a valid
response for a true Computation, so i might allow you to define an
answer in some side system of Computation that is close to, but not the
same as, that used in Computation Theory.

The problem is you are defining some "priveldge" state of your decider
that other Computations don't have access to and thus your system
becomes non-Turing Complete.

Re: Refutation of [Strachey 1965] and Halting Problem associated proofs

<20220801011626.00007fcf@reddwarf.jmc.corp>

 copy mid

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

 copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!weretis.net!feeder8.news.weretis.net!news.uzoreto.com!news-out.netnews.com!news.alt.net!fdc2.netnews.com!peer02.ams1!peer.ams1.xlned.com!news.xlned.com!peer02.ams4!peer.am4.highwinds-media.com!news.highwinds-media.com!fx05.ams4.POSTED!not-for-mail
From: flib...@reddwarf.jmc.corp (Mr Flibble)
Newsgroups: comp.theory
Subject: Re: Refutation of [Strachey 1965] and Halting Problem associated
proofs
Message-ID: <20220801011626.00007fcf@reddwarf.jmc.corp>
References: <20220731011138.000034e4@reddwarf.jmc.corp>
<85c2a48a-f4d5-4fbf-8b1d-14cdcee27160n@googlegroups.com>
<20220801005402.00005567@reddwarf.jmc.corp>
<1JEFK.68846$mY1.16139@fx01.iad>
Organization: Jupiter Mining Corporation
X-Newsreader: Claws Mail 4.1.0 (GTK 3.24.33; x86_64-w64-mingw32)
MIME-Version: 1.0
Content-Type: text/plain; charset=US-ASCII
Content-Transfer-Encoding: 7bit
Lines: 84
X-Complaints-To: abuse@eweka.nl
NNTP-Posting-Date: Mon, 01 Aug 2022 00:16:27 UTC
Date: Mon, 1 Aug 2022 01:16:26 +0100
X-Received-Bytes: 3745
 by: Mr Flibble - Mon, 1 Aug 2022 00:16 UTC

On Sun, 31 Jul 2022 20:01:00 -0400
Richard Damon <Richard@Damon-Family.org> wrote:

> On 7/31/22 7:54 PM, Mr Flibble wrote:
> > On Sun, 31 Jul 2022 16:02:37 -0700 (PDT)
> > Skep Dick <skepdick22@gmail.com> wrote:
> >
> >> On Sunday, 31 July 2022 at 02:11:41 UTC+2, Mr Flibble wrote:
> >>> I have an idea for a simulating halt decider that forks the
> >>> simulation into two branches if the input calls the halt decider
> >>> as per [Strachey 1965]'s "Impossible Program":
> >>>
> >>> void P(void (*x)())
> >>> {
> >>> if (H(x, x))
> >>> infinite_loop: goto infinite_loop;
> >>> return;
> >>> }
> >>>
> >>> int main()
> >>> {
> >>> std::cout << "Input halts: " << H(P, P) << std::endl;
> >>> }
> >>>
> >>> When the simulator detects the call to H in P it forks the
> >>> simulation into a non-halting branch (returning 0 to P) and a
> >>> halting branch (returning 1 to P) and continues the simulation of
> >>> these two branches in parallel.
> >>>
> >>> If the non-halting branch is determined to halt AND the halting
> >>> branch is determined to not halt then pathology is detected and
> >>> reported.
> >>>
> >>> If EITHER branch is determined to be correctly decided then that
> >>> will be the decision of the halting decider.
> >>>
> >>> Crucially this scheme will handle (and correctly decide) the
> >>> following case whereby the result of H is discarded by the input:
> >>>
> >>> void Px(void (*x)())
> >>> {
> >>> (void) H(x, x);
> >>> return;
> >>> }
> >>>
> >>> /Flibble
> >>>
> >>> Copyright (c) 2022 Mr Flibble
> >>
> >> Game theory 101 is the strategy-stealing strategy. Any strategy
> >> available to H against P is also available to P against H.
> >>
> >> When H simulates P (simulating H(simulating P ))) the simulated H
> >> throws an exception. P catches the exception and enters an infinite
> >> loop.
> >>
> >> Thus making top-level H enter an infinite loop also.
> >>
> >> You and olcott should hang out more often. Your psychologies
> >> epitomize the pathological P.
> >
> > Nope, the exception is not visible to simulated P and there is no
> > simulated H.
> >
> > /Flibble
> >
>
> Unfortunately, that means that H can't be the equivalent of a Turing
> Machine.
>
> Your "Blue Screen of Death" answer of pathological is NOT a valid
> response for a true Computation, so i might allow you to define an
> answer in some side system of Computation that is close to, but not
> the same as, that used in Computation Theory.
>
> The problem is you are defining some "priveldge" state of your
> decider that other Computations don't have access to and thus your
> system becomes non-Turing Complete.

FALSE. The exception is visible to whatever is calling H outside of
the simulation. It is entirely Turing Complete.

/Flibble

Re: Refutation of [Strachey 1965] and Halting Problem associated proofs

<q3FFK.656108$5fVf.259228@fx09.iad>

 copy mid

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

 copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!usenet.blueworldhosting.com!feed1.usenet.blueworldhosting.com!peer03.iad!feed-me.highwinds-media.com!news.highwinds-media.com!fx09.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.11.0
Subject: Re: Refutation of [Strachey 1965] and Halting Problem associated
proofs
Content-Language: en-US
Newsgroups: comp.theory
References: <20220731011138.000034e4@reddwarf.jmc.corp>
<85c2a48a-f4d5-4fbf-8b1d-14cdcee27160n@googlegroups.com>
<20220801005402.00005567@reddwarf.jmc.corp> <1JEFK.68846$mY1.16139@fx01.iad>
<20220801011626.00007fcf@reddwarf.jmc.corp>
From: Rich...@Damon-Family.org (Richard Damon)
In-Reply-To: <20220801011626.00007fcf@reddwarf.jmc.corp>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 7bit
Lines: 91
Message-ID: <q3FFK.656108$5fVf.259228@fx09.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: Sun, 31 Jul 2022 20:24:54 -0400
X-Received-Bytes: 4207
 by: Richard Damon - Mon, 1 Aug 2022 00:24 UTC

On 7/31/22 8:16 PM, Mr Flibble wrote:
> On Sun, 31 Jul 2022 20:01:00 -0400
> Richard Damon <Richard@Damon-Family.org> wrote:
>
>> On 7/31/22 7:54 PM, Mr Flibble wrote:
>>> On Sun, 31 Jul 2022 16:02:37 -0700 (PDT)
>>> Skep Dick <skepdick22@gmail.com> wrote:
>>>
>>>> On Sunday, 31 July 2022 at 02:11:41 UTC+2, Mr Flibble wrote:
>>>>> I have an idea for a simulating halt decider that forks the
>>>>> simulation into two branches if the input calls the halt decider
>>>>> as per [Strachey 1965]'s "Impossible Program":
>>>>>
>>>>> void P(void (*x)())
>>>>> {
>>>>> if (H(x, x))
>>>>> infinite_loop: goto infinite_loop;
>>>>> return;
>>>>> }
>>>>>
>>>>> int main()
>>>>> {
>>>>> std::cout << "Input halts: " << H(P, P) << std::endl;
>>>>> }
>>>>>
>>>>> When the simulator detects the call to H in P it forks the
>>>>> simulation into a non-halting branch (returning 0 to P) and a
>>>>> halting branch (returning 1 to P) and continues the simulation of
>>>>> these two branches in parallel.
>>>>>
>>>>> If the non-halting branch is determined to halt AND the halting
>>>>> branch is determined to not halt then pathology is detected and
>>>>> reported.
>>>>>
>>>>> If EITHER branch is determined to be correctly decided then that
>>>>> will be the decision of the halting decider.
>>>>>
>>>>> Crucially this scheme will handle (and correctly decide) the
>>>>> following case whereby the result of H is discarded by the input:
>>>>>
>>>>> void Px(void (*x)())
>>>>> {
>>>>> (void) H(x, x);
>>>>> return;
>>>>> }
>>>>>
>>>>> /Flibble
>>>>>
>>>>> Copyright (c) 2022 Mr Flibble
>>>>
>>>> Game theory 101 is the strategy-stealing strategy. Any strategy
>>>> available to H against P is also available to P against H.
>>>>
>>>> When H simulates P (simulating H(simulating P ))) the simulated H
>>>> throws an exception. P catches the exception and enters an infinite
>>>> loop.
>>>>
>>>> Thus making top-level H enter an infinite loop also.
>>>>
>>>> You and olcott should hang out more often. Your psychologies
>>>> epitomize the pathological P.
>>>
>>> Nope, the exception is not visible to simulated P and there is no
>>> simulated H.
>>>
>>> /Flibble
>>>
>>
>> Unfortunately, that means that H can't be the equivalent of a Turing
>> Machine.
>>
>> Your "Blue Screen of Death" answer of pathological is NOT a valid
>> response for a true Computation, so i might allow you to define an
>> answer in some side system of Computation that is close to, but not
>> the same as, that used in Computation Theory.
>>
>> The problem is you are defining some "priveldge" state of your
>> decider that other Computations don't have access to and thus your
>> system becomes non-Turing Complete.
>
> FALSE. The exception is visible to whatever is calling H outside of
> the simulation. It is entirely Turing Complete.
>
> /Flibble
>

So, your saying I can wrote a program P that I directly write that calls
H(P,P) and it will get the Conflicting answer, and thus H doesn't
simulate that behavior of P?

That indicates that H doesn't do a correct simulation of P.

Re: Refutation of [Strachey 1965] and Halting Problem associated proofs

<20220801012634.000042a1@reddwarf.jmc.corp>

 copy mid

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

 copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!usenet.blueworldhosting.com!feed1.usenet.blueworldhosting.com!peer01.iad!feed-me.highwinds-media.com!peer01.ams4!peer.am4.highwinds-media.com!news.highwinds-media.com!fx09.ams4.POSTED!not-for-mail
From: flib...@reddwarf.jmc.corp (Mr Flibble)
Newsgroups: comp.theory
Subject: Re: Refutation of [Strachey 1965] and Halting Problem associated
proofs
Message-ID: <20220801012634.000042a1@reddwarf.jmc.corp>
References: <20220731011138.000034e4@reddwarf.jmc.corp>
<85c2a48a-f4d5-4fbf-8b1d-14cdcee27160n@googlegroups.com>
<20220801005402.00005567@reddwarf.jmc.corp>
<1JEFK.68846$mY1.16139@fx01.iad>
<20220801011626.00007fcf@reddwarf.jmc.corp>
<q3FFK.656108$5fVf.259228@fx09.iad>
Organization: Jupiter Mining Corporation
X-Newsreader: Claws Mail 4.1.0 (GTK 3.24.33; x86_64-w64-mingw32)
MIME-Version: 1.0
Content-Type: text/plain; charset=US-ASCII
Content-Transfer-Encoding: 7bit
Lines: 101
X-Complaints-To: abuse@eweka.nl
NNTP-Posting-Date: Mon, 01 Aug 2022 00:26:36 UTC
Date: Mon, 1 Aug 2022 01:26:34 +0100
X-Received-Bytes: 4532
 by: Mr Flibble - Mon, 1 Aug 2022 00:26 UTC

On Sun, 31 Jul 2022 20:24:54 -0400
Richard Damon <Richard@Damon-Family.org> wrote:

> On 7/31/22 8:16 PM, Mr Flibble wrote:
> > On Sun, 31 Jul 2022 20:01:00 -0400
> > Richard Damon <Richard@Damon-Family.org> wrote:
> >
> >> On 7/31/22 7:54 PM, Mr Flibble wrote:
> >>> On Sun, 31 Jul 2022 16:02:37 -0700 (PDT)
> >>> Skep Dick <skepdick22@gmail.com> wrote:
> >>>
> >>>> On Sunday, 31 July 2022 at 02:11:41 UTC+2, Mr Flibble wrote:
> >>>>> I have an idea for a simulating halt decider that forks the
> >>>>> simulation into two branches if the input calls the halt decider
> >>>>> as per [Strachey 1965]'s "Impossible Program":
> >>>>>
> >>>>> void P(void (*x)())
> >>>>> {
> >>>>> if (H(x, x))
> >>>>> infinite_loop: goto infinite_loop;
> >>>>> return;
> >>>>> }
> >>>>>
> >>>>> int main()
> >>>>> {
> >>>>> std::cout << "Input halts: " << H(P, P) << std::endl;
> >>>>> }
> >>>>>
> >>>>> When the simulator detects the call to H in P it forks the
> >>>>> simulation into a non-halting branch (returning 0 to P) and a
> >>>>> halting branch (returning 1 to P) and continues the simulation
> >>>>> of these two branches in parallel.
> >>>>>
> >>>>> If the non-halting branch is determined to halt AND the halting
> >>>>> branch is determined to not halt then pathology is detected and
> >>>>> reported.
> >>>>>
> >>>>> If EITHER branch is determined to be correctly decided then that
> >>>>> will be the decision of the halting decider.
> >>>>>
> >>>>> Crucially this scheme will handle (and correctly decide) the
> >>>>> following case whereby the result of H is discarded by the
> >>>>> input:
> >>>>>
> >>>>> void Px(void (*x)())
> >>>>> {
> >>>>> (void) H(x, x);
> >>>>> return;
> >>>>> }
> >>>>>
> >>>>> /Flibble
> >>>>>
> >>>>> Copyright (c) 2022 Mr Flibble
> >>>>
> >>>> Game theory 101 is the strategy-stealing strategy. Any strategy
> >>>> available to H against P is also available to P against H.
> >>>>
> >>>> When H simulates P (simulating H(simulating P ))) the simulated
> >>>> H throws an exception. P catches the exception and enters an
> >>>> infinite loop.
> >>>>
> >>>> Thus making top-level H enter an infinite loop also.
> >>>>
> >>>> You and olcott should hang out more often. Your psychologies
> >>>> epitomize the pathological P.
> >>>
> >>> Nope, the exception is not visible to simulated P and there is no
> >>> simulated H.
> >>>
> >>> /Flibble
> >>>
> >>
> >> Unfortunately, that means that H can't be the equivalent of a
> >> Turing Machine.
> >>
> >> Your "Blue Screen of Death" answer of pathological is NOT a valid
> >> response for a true Computation, so i might allow you to define an
> >> answer in some side system of Computation that is close to, but not
> >> the same as, that used in Computation Theory.
> >>
> >> The problem is you are defining some "priveldge" state of your
> >> decider that other Computations don't have access to and thus your
> >> system becomes non-Turing Complete.
> >
> > FALSE. The exception is visible to whatever is calling H outside of
> > the simulation. It is entirely Turing Complete.
> >
> > /Flibble
> >
>
> So, your saying I can wrote a program P that I directly write that
> calls H(P,P) and it will get the Conflicting answer, and thus H
> doesn't simulate that behavior of P?
>
> That indicates that H doesn't do a correct simulation of P.

We have been over this: it is no concern of my decider what programs do
outside of calling H.

/Flibble

1
server_pubkey.txt

rocksolid light 0.9.7
clearnet tor