Rocksolid Light

Welcome to novaBBS (click a section below)

mail  files  register  newsreader  groups  login

Message-ID:  

"Even if you're on the right track, you'll get run over if you just sit there." -- Will Rogers


devel / comp.theory / Re: Concise refutation of halting problem proofs V17

SubjectAuthor
* Concise refutation of halting problem proofs V17olcott
`* Concise refutation of halting problem proofs V17Richard Damon
 `* Concise refutation of halting problem proofs V17olcott
  `* Concise refutation of halting problem proofs V17Richard Damon
   `* Concise refutation of halting problem proofs V17olcott
    `* Concise refutation of halting problem proofs V17Richard Damon
     +* Concise refutation of halting problem proofs V17Mr Flibble
     |+* Concise refutation of halting problem proofs V17olcott
     ||`- Concise refutation of halting problem proofs V17Richard Damon
     |+- Concise refutation of halting problem proofs V17olcott
     |`* Concise refutation of halting problem proofs V17Ben Bacarisse
     | +* Concise refutation of halting problem proofs V17olcott
     | |+* Concise refutation of halting problem proofs V17André G. Isaak
     | ||`* Concise refutation of halting problem proofs V17 [ pathologicalolcott
     | || +- Concise refutation of halting problem proofs V17 [ pathologicalRichard Damon
     | || `- Concise refutation of halting problem proofs V17 [ pathologicalRichard Damon
     | |`- Concise refutation of halting problem proofs V17Richard Damon
     | `* Concise refutation of halting problem proofs V17Mr Flibble
     |  +* Concise refutation of halting problem proofs V17Ben Bacarisse
     |  |`* Concise refutation of halting problem proofs V17olcott
     |  | `- Concise refutation of halting problem proofs V17Richard Damon
     |  `* Concise refutation of halting problem proofs V17olcott
     |   `- Concise refutation of halting problem proofs V17Richard Damon
     `* Concise refutation of halting problem proofs V17olcott
      `- Concise refutation of halting problem proofs V17Richard Damon

1
Concise refutation of halting problem proofs V17

<l8adnY-MOrqcMAj8nZ2dnUU7-Q3NnZ2d@giganews.com>

 copy mid

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

 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: Wed, 17 Nov 2021 19:31:45 -0600
Date: Wed, 17 Nov 2021 19:31:42 -0600
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:91.0) Gecko/20100101
Thunderbird/91.3.1
Newsgroups: comp.theory,comp.ai.philosophy,sci.logic,sci.math
Content-Language: en-US
Followup-To: comp.theory
From: NoO...@NoWhere.com (olcott)
Subject: Concise refutation of halting problem proofs V17
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Message-ID: <l8adnY-MOrqcMAj8nZ2dnUU7-Q3NnZ2d@giganews.com>
Lines: 42
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-lBQMOjJrPMkwBqD0ds/qLwCmq3KJvLS7vktFBXddFlYekvErtUq4M6yOV7cucaYbfFypqH38YfTVCG2!nQ+3HkEMICm/AYsKvSOI6bzuBgMW8L9fyl33ljP5J1kkIs6KKpv5TH3euAC+3rAsQyvDrpIaizWc!zg==
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: 2061
 by: olcott - Thu, 18 Nov 2021 01:31 UTC

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

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

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

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

For every possible H of H(P,P)
invoked from main() where P(P) calls this same H(P,P) and
H simulates or executes its input and
aborts or
does not abort its input
P never reaches its last instruction.

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

Of the infinite set of definitions of H specified above those that
return 0 are correct halt deciders for their 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 V17

<OHilJ.3007$aF1.1686@fx98.iad>

 copy mid

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

 copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!paganini.bofh.team!news.dns-netz.com!news.freedyn.net!newsfeed.xs4all.nl!newsfeed8.news.xs4all.nl!feeder1.feed.usenet.farm!feed.usenet.farm!peer02.ams4!peer.am4.highwinds-media.com!peer01.iad!feed-me.highwinds-media.com!news.highwinds-media.com!fx98.iad.POSTED!not-for-mail
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:91.0)
Gecko/20100101 Thunderbird/91.3.1
Subject: Re: Concise refutation of halting problem proofs V17
Content-Language: en-US
Newsgroups: comp.theory
References: <l8adnY-MOrqcMAj8nZ2dnUU7-Q3NnZ2d@giganews.com>
From: Rich...@Damon-Family.org (Richard Damon)
In-Reply-To: <l8adnY-MOrqcMAj8nZ2dnUU7-Q3NnZ2d@giganews.com>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Lines: 60
Message-ID: <OHilJ.3007$aF1.1686@fx98.iad>
X-Complaints-To: abuse@easynews.com
Organization: Forte - www.forteinc.com
X-Complaints-Info: Please be sure to forward a copy of ALL headers otherwise we will be unable to process your complaint properly.
Date: Wed, 17 Nov 2021 21:16:13 -0500
X-Received-Bytes: 2826
 by: Richard Damon - Thu, 18 Nov 2021 02:16 UTC

On 11/17/21 8:31 PM, olcott wrote:
> #include <stdint.h>
> typedef void (*ptr)();
>
> int H(ptr x, ptr y)
> {
>   x(y);  // direct execution of P(P)
>   return 1;
> }
>
> // Minimal essence of Linz(1990) Ĥ
> // and Strachey(1965) P
> int P(ptr x)
> {
>   H(x, x);
>   return 1;  // Give P a last instruction at the "c" level
> }
>
> int main(void)
> {
>   H(P, P);
> }
>
> For every possible H of H(P,P)
> invoked from main() where P(P) calls this same H(P,P) and
> H simulates or executes its input and
> aborts or
> does not abort its input
> P never reaches its last instruction.
>
> computation that halts
> a computation is said to halt whenever it enters a final state.
> (Linz:1990:234)
>
> Of the infinite set of definitions of H specified above those that
> return 0 are correct halt deciders for their input.
>

No, they are not, remember the DEFINITION of a Halt Decider is that it
is supposed to indicate the behavior of the machine its input refers to.

Thus the fact that a decider that aborts is simulation didn't reach and
end state is NOT proof that the input is non-halting, only actuallyl
running that machine at the input.

For ANY H that returns 0 from H(P,P) is can be easily shown that
directly running P(P) will call H(P,P) that H will do 'something' and
then in finite time return 0, at which point P will finish, and show it
is halting. PERIOD.

IF anything, your claim that you have proved that H also proves that
this P(P) is non-halting just proves that your logic system has gone
inconsistent, and thus is worthless.

You have also just proved, by the fact that this has been pointed out
repeatedly to you, and you have just ignored it that you are a
pathological liar, and you have utterly failed at your life's goal, and
thus you what wasted your life.

FAIL.

Re: Concise refutation of halting problem proofs V17

<VtudnfP5Zt3RIQj8nZ2dnUU7-KfNnZ2d@giganews.com>

 copy mid

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

 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: Wed, 17 Nov 2021 20:37:00 -0600
Date: Wed, 17 Nov 2021 20:36:58 -0600
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:91.0) Gecko/20100101
Thunderbird/91.3.1
Subject: Re: Concise refutation of halting problem proofs V17
Content-Language: en-US
Newsgroups: comp.theory
References: <l8adnY-MOrqcMAj8nZ2dnUU7-Q3NnZ2d@giganews.com>
<OHilJ.3007$aF1.1686@fx98.iad>
From: NoO...@NoWhere.com (olcott)
In-Reply-To: <OHilJ.3007$aF1.1686@fx98.iad>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Message-ID: <VtudnfP5Zt3RIQj8nZ2dnUU7-KfNnZ2d@giganews.com>
Lines: 85
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-BMv8EpEyVI501PDIzUnIu+DO8UPf3Fan0h6yGkBDttEiEny7afvO6Fk4qCFTyEG/wv1tSakJtPrS9zk!AtUHw3a9tiLtHK3ZLnm+gndxEVbenllsxEh2emar3DRw0Hj0a1Dq5Oq6AE7r3aSAK+4SS9EytKR9!bw==
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: 3900
 by: olcott - Thu, 18 Nov 2021 02:36 UTC

On 11/17/2021 8:16 PM, Richard Damon wrote:
> On 11/17/21 8:31 PM, olcott wrote:
>> #include <stdint.h>
>> typedef void (*ptr)();
>>
>> int H(ptr x, ptr y)
>> {
>>    x(y);  // direct execution of P(P)
>>    return 1;
>> }
>>
>> // Minimal essence of Linz(1990) Ĥ
>> // and Strachey(1965) P
>> int P(ptr x)
>> {
>>    H(x, x);
>>    return 1;  // Give P a last instruction at the "c" level
>> }
>>
>> int main(void)
>> {
>>    H(P, P);
>> }
>>
>> For every possible H of H(P,P)
>> invoked from main() where P(P) calls this same H(P,P) and
>> H simulates or executes its input and
>> aborts or
>> does not abort its input
>> P never reaches its last instruction.
>>
>> computation that halts
>> a computation is said to halt whenever it enters a final state.
>> (Linz:1990:234)
>>
>> Of the infinite set of definitions of H specified above those that
>> return 0 are correct halt deciders for their input.
>>
>
> No, they are not, remember the DEFINITION of a Halt Decider is that it
> is supposed to indicate the behavior of the machine its input refers to.
>

I am stipulating that H(P,P) must provide the halt status of the actual
behavior of the actual sequence of instructions specified by its actual
input.

If you are referring to any other sequence of instructions you are wrong.

> Thus the fact that a decider that aborts is simulation didn't reach and
> end state is NOT proof that the input is non-halting,

The fact that an input did not reach its final state does not prove that
the input has infinite behavior.

The fact that an input did not reach its final state does prove that the
input did not halt because halting is defined as reaching its final state.

> only actuallyl
> running that machine at the input.
>
> For ANY H that returns 0 from H(P,P) is can be easily shown that
> directly running P(P) will call H(P,P) that H will do 'something' and
> then in finite time return 0, at which point P will finish, and show it
> is halting. PERIOD.
>
> IF anything, your claim that you have proved that H also proves that
> this P(P) is non-halting just proves that your logic system has gone
> inconsistent, and thus is worthless.
>
> You have also just proved, by the fact that this has been pointed out
> repeatedly to you, and you have just ignored it that you are a
> pathological liar, and you have utterly failed at your life's goal, and
> thus you what wasted your life.
>
> FAIL.

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

<kJjlJ.44440$OB3.5879@fx06.iad>

 copy mid

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

 copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!paganini.bofh.team!news.dns-netz.com!news.freedyn.net!newsfeed.xs4all.nl!newsfeed7.news.xs4all.nl!feeder1.feed.usenet.farm!feed.usenet.farm!peer01.ams4!peer.am4.highwinds-media.com!peer01.iad!feed-me.highwinds-media.com!news.highwinds-media.com!fx06.iad.POSTED!not-for-mail
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:91.0)
Gecko/20100101 Thunderbird/91.3.1
Subject: Re: Concise refutation of halting problem proofs V17
Content-Language: en-US
Newsgroups: comp.theory
References: <l8adnY-MOrqcMAj8nZ2dnUU7-Q3NnZ2d@giganews.com>
<OHilJ.3007$aF1.1686@fx98.iad>
<VtudnfP5Zt3RIQj8nZ2dnUU7-KfNnZ2d@giganews.com>
From: Rich...@Damon-Family.org (Richard Damon)
In-Reply-To: <VtudnfP5Zt3RIQj8nZ2dnUU7-KfNnZ2d@giganews.com>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Lines: 121
Message-ID: <kJjlJ.44440$OB3.5879@fx06.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: Wed, 17 Nov 2021 22:26:08 -0500
X-Received-Bytes: 4565
 by: Richard Damon - Thu, 18 Nov 2021 03:26 UTC

On 11/17/21 9:36 PM, olcott wrote:
> On 11/17/2021 8:16 PM, Richard Damon wrote:
>> On 11/17/21 8:31 PM, olcott wrote:
>>> #include <stdint.h>
>>> typedef void (*ptr)();
>>>
>>> int H(ptr x, ptr y)
>>> {
>>>    x(y);  // direct execution of P(P)
>>>    return 1;
>>> }
>>>
>>> // Minimal essence of Linz(1990) Ĥ
>>> // and Strachey(1965) P
>>> int P(ptr x)
>>> {
>>>    H(x, x);
>>>    return 1;  // Give P a last instruction at the "c" level
>>> }
>>>
>>> int main(void)
>>> {
>>>    H(P, P);
>>> }
>>>
>>> For every possible H of H(P,P)
>>> invoked from main() where P(P) calls this same H(P,P) and
>>> H simulates or executes its input and
>>> aborts or
>>> does not abort its input
>>> P never reaches its last instruction.
>>>
>>> computation that halts
>>> a computation is said to halt whenever it enters a final state.
>>> (Linz:1990:234)
>>>
>>> Of the infinite set of definitions of H specified above those that
>>> return 0 are correct halt deciders for their input.
>>>
>>
>> No, they are not, remember the DEFINITION of a Halt Decider is that it
>> is supposed to indicate the behavior of the machine its input refers to.
>>
>
> I am stipulating that H(P,P) must provide the halt status of the actual
> behavior of the actual sequence of instructions specified by its actual
> input.
>
> If you are referring to any other sequence of instructions you are wrong.

I am refering to that input.

We are asking what does the input to H(P,P) do.

The input program is:

int P(ptr x)
{ H(x,x);
return 1;
}

Does this input halt? That is the question, right?

What is the definition of Halting, will this input if directly run halt
or not.

Let us run it, with the stipulation that H(P,P) will return 0.

1) Call P(P)
2) P will Call H(P,P)
3) you have said that H(P,P) will return 0 after finite time
4) Return 1;

Thus P(P) halted.

You keep on looking at what H sees the input does, but since H aborts
its processing, it doesn't actually become the valid definition of Halting.

>
>> Thus the fact that a decider that aborts is simulation didn't reach
>> and end state is NOT proof that the input is non-halting,
>
> The fact that an input did not reach its final state does not prove that
> the input has infinite behavior.

But it DOES when run per the definition.

FAIL.

>
> The fact that an input did not reach its final state does prove that the
> input did not halt because halting is defined as reaching its final state.

No, the input DOES reach the final state when run by the rules.

H just doesn't see that because H aborts its processing due to making a
mistake and gets the wrong answer.

>
>> only actuallyl running that machine at the input.
>>
>> For ANY H that returns 0 from H(P,P) is can be easily shown that
>> directly running P(P) will call H(P,P) that H will do 'something' and
>> then in finite time return 0, at which point P will finish, and show
>> it is halting. PERIOD.
>>
>> IF anything, your claim that you have proved that H also proves that
>> this P(P) is non-halting just proves that your logic system has gone
>> inconsistent, and thus is worthless.
>>
>> You have also just proved, by the fact that this has been pointed out
>> repeatedly to you, and you have just ignored it that you are a
>> pathological liar, and you have utterly failed at your life's goal,
>> and thus you what wasted your life.
>>
>> FAIL.
>
>

Re: Concise refutation of halting problem proofs V17

<5eqdnbJ9-8qzUAj8nZ2dnUU7-d_NnZ2d@giganews.com>

 copy mid

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

 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: Wed, 17 Nov 2021 21:49:02 -0600
Date: Wed, 17 Nov 2021 21:48:59 -0600
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:91.0) Gecko/20100101
Thunderbird/91.3.1
Subject: Re: Concise refutation of halting problem proofs V17
Content-Language: en-US
Newsgroups: comp.theory
References: <l8adnY-MOrqcMAj8nZ2dnUU7-Q3NnZ2d@giganews.com>
<OHilJ.3007$aF1.1686@fx98.iad>
<VtudnfP5Zt3RIQj8nZ2dnUU7-KfNnZ2d@giganews.com>
<kJjlJ.44440$OB3.5879@fx06.iad>
From: NoO...@NoWhere.com (olcott)
In-Reply-To: <kJjlJ.44440$OB3.5879@fx06.iad>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Message-ID: <5eqdnbJ9-8qzUAj8nZ2dnUU7-d_NnZ2d@giganews.com>
Lines: 71
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-KUdo4soXQkFaX+jdWjLaUPGCPbFUzlA3jygpCC5SCiWMwomiLwdu/IXoYvug+qsizTw8CN15mF8YB/B!kUtn8RytTVO/DT+Qe2mL+ZUC90Sggb4x54Go0X4TVLwEpePQ8SjEljPgUP49ax6COrfsNARHErVs!PA==
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: 3416
 by: olcott - Thu, 18 Nov 2021 03:48 UTC

On 11/17/2021 9:26 PM, Richard Damon wrote:
> On 11/17/21 9:36 PM, olcott wrote:
>> On 11/17/2021 8:16 PM, Richard Damon wrote:
>>> On 11/17/21 8:31 PM, olcott wrote:
>>>> #include <stdint.h>
>>>> typedef void (*ptr)();
>>>>
>>>> int H(ptr x, ptr y)
>>>> {
>>>>    x(y);  // direct execution of P(P)
>>>>    return 1;
>>>> }
>>>>
>>>> // Minimal essence of Linz(1990) Ĥ
>>>> // and Strachey(1965) P
>>>> int P(ptr x)
>>>> {
>>>>    H(x, x);
>>>>    return 1;  // Give P a last instruction at the "c" level
>>>> }
>>>>
>>>> int main(void)
>>>> {
>>>>    H(P, P);
>>>> }
>>>>
>>>> For every possible H of H(P,P)
>>>> invoked from main() where P(P) calls this same H(P,P) and
>>>> H simulates or executes its input and
>>>> aborts or
>>>> does not abort its input
>>>> P never reaches its last instruction.
>>>>
>>>> computation that halts
>>>> a computation is said to halt whenever it enters a final state.
>>>> (Linz:1990:234)
>>>>
>>>> Of the infinite set of definitions of H specified above those that
>>>> return 0 are correct halt deciders for their input.
>>>>
>>>
>>> No, they are not, remember the DEFINITION of a Halt Decider is that
>>> it is supposed to indicate the behavior of the machine its input
>>> refers to.
>>>
>>
>> I am stipulating that H(P,P) must provide the halt status of the
>> actual behavior of the actual sequence of instructions specified by
>> its actual input.
>>
>> If you are referring to any other sequence of instructions you are wrong.
>
> I am refering to that input.
>
> We are asking what does the input to H(P,P) do.
>

For every possible H of H(P,P) invoked from main() where P(P) calls this
same H(P,P) and H simulates or executes its input and aborts or does not
abort its input P never reaches its last instruction.

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

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

<pOqlJ.43485$3q9.38930@fx47.iad>

 copy mid

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

 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!peer01.ams1!peer.ams1.xlned.com!news.xlned.com!peer01.ams4!peer.am4.highwinds-media.com!peer02.iad!feed-me.highwinds-media.com!news.highwinds-media.com!fx47.iad.POSTED!not-for-mail
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:91.0)
Gecko/20100101 Thunderbird/91.3.1
Subject: Re: Concise refutation of halting problem proofs V17
Content-Language: en-US
Newsgroups: comp.theory
References: <l8adnY-MOrqcMAj8nZ2dnUU7-Q3NnZ2d@giganews.com>
<OHilJ.3007$aF1.1686@fx98.iad>
<VtudnfP5Zt3RIQj8nZ2dnUU7-KfNnZ2d@giganews.com>
<kJjlJ.44440$OB3.5879@fx06.iad>
<5eqdnbJ9-8qzUAj8nZ2dnUU7-d_NnZ2d@giganews.com>
From: Rich...@Damon-Family.org (Richard Damon)
In-Reply-To: <5eqdnbJ9-8qzUAj8nZ2dnUU7-d_NnZ2d@giganews.com>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 7bit
Lines: 42
Message-ID: <pOqlJ.43485$3q9.38930@fx47.iad>
X-Complaints-To: abuse@easynews.com
Organization: Forte - www.forteinc.com
X-Complaints-Info: Please be sure to forward a copy of ALL headers otherwise we will be unable to process your complaint properly.
Date: Thu, 18 Nov 2021 06:29:26 -0500
X-Received-Bytes: 2285
 by: Richard Damon - Thu, 18 Nov 2021 11:29 UTC

On 11/17/21 10:48 PM, olcott wrote:

> For every possible H of H(P,P) invoked from main() where P(P) calls this
> same H(P,P) and H simulates or executes its input and aborts or does not
> abort its input P never reaches its last instruction.
>
> computation that halts
> a computation is said to halt whenever it enters a final state.
> (Linz:1990:234)
>

No, you LIE.

Halting is DEFINED by the behavior of the actual computation.

H(P,P) is supposed to say what P(P) will do.

If H(P,P) returns 0, then P(P) will Halt. PERIOD.

If P(P) Halts then H(P,P) returning 0 is WRONG.

Your claim that H(P,P) returning 0 to be right is a LIE.

You have just PROVED that you are a moron, because you refuse to do
things by the rules.

You have doomed yourself to being a laughing stock of the logical
community.

Look at your quote:
Talent hits a target no one else can hit;
Genius hits a target no one else can see.
Arthur Schopenhauer

What is the person that can only hit a target that doesn't exist, but
claims to have hit a target that isn't there.

A LIAR and a FRAUD.

That is you.

Re: Concise refutation of halting problem proofs V17

<20211118130058.00004c6f@reddwarf.jmc>

 copy mid

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

 copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!paganini.bofh.team!news.dns-netz.com!news.freedyn.net!newsreader4.netcologne.de!news.netcologne.de!peer01.ams1!peer.ams1.xlned.com!news.xlned.com!peer03.ams4!peer.am4.highwinds-media.com!news.highwinds-media.com!fx10.ams4.POSTED!not-for-mail
From: flib...@reddwarf.jmc (Mr Flibble)
Newsgroups: comp.theory
Subject: Re: Concise refutation of halting problem proofs V17
Message-ID: <20211118130058.00004c6f@reddwarf.jmc>
References: <l8adnY-MOrqcMAj8nZ2dnUU7-Q3NnZ2d@giganews.com>
<OHilJ.3007$aF1.1686@fx98.iad>
<VtudnfP5Zt3RIQj8nZ2dnUU7-KfNnZ2d@giganews.com>
<kJjlJ.44440$OB3.5879@fx06.iad>
<5eqdnbJ9-8qzUAj8nZ2dnUU7-d_NnZ2d@giganews.com>
<pOqlJ.43485$3q9.38930@fx47.iad>
Organization: Jupiter Mining Corp
X-Newsreader: Claws Mail 3.17.8 (GTK+ 2.24.33; x86_64-w64-mingw32)
MIME-Version: 1.0
Content-Type: text/plain; charset=US-ASCII
Content-Transfer-Encoding: 7bit
Lines: 30
X-Complaints-To: abuse@eweka.nl
NNTP-Posting-Date: Thu, 18 Nov 2021 13:00:57 UTC
Date: Thu, 18 Nov 2021 13:00:58 +0000
X-Received-Bytes: 1748
 by: Mr Flibble - Thu, 18 Nov 2021 13:00 UTC

On Thu, 18 Nov 2021 06:29:26 -0500
Richard Damon <Richard@Damon-Family.org> wrote:

> On 11/17/21 10:48 PM, olcott wrote:
>
> > For every possible H of H(P,P) invoked from main() where P(P) calls
> > this same H(P,P) and H simulates or executes its input and aborts
> > or does not abort its input P never reaches its last instruction.
> >
> > computation that halts
> > a computation is said to halt whenever it enters a final state.
> > (Linz:1990:234)
> >
>
> No, you LIE.
>
> Halting is DEFINED by the behavior of the actual computation.
>
> H(P,P) is supposed to say what P(P) will do.

No,

H(P,I) is supposed to say what P(H(P(H(P(H(P(...

i.e. it is infinite recursion due to a category error; H(P,I) as
defined is INVALID. The halting problem as defined is INVALID.

/Flibble

Re: Concise refutation of halting problem proofs V17

<V7-dnXjUu-nU8wv8nZ2dnUU7-Y3NnZ2d@giganews.com>

 copy mid

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

 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: Thu, 18 Nov 2021 09:16:25 -0600
Date: Thu, 18 Nov 2021 09:16:24 -0600
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:91.0) Gecko/20100101
Thunderbird/91.3.1
Subject: Re: Concise refutation of halting problem proofs V17
Content-Language: en-US
Newsgroups: comp.theory,comp.ai.philosophy,sci.logic,sci.math
References: <l8adnY-MOrqcMAj8nZ2dnUU7-Q3NnZ2d@giganews.com>
<OHilJ.3007$aF1.1686@fx98.iad>
<VtudnfP5Zt3RIQj8nZ2dnUU7-KfNnZ2d@giganews.com>
<kJjlJ.44440$OB3.5879@fx06.iad>
<5eqdnbJ9-8qzUAj8nZ2dnUU7-d_NnZ2d@giganews.com>
<pOqlJ.43485$3q9.38930@fx47.iad> <20211118130058.00004c6f@reddwarf.jmc>
Followup-To: comp.theory
From: NoO...@NoWhere.com (olcott)
In-Reply-To: <20211118130058.00004c6f@reddwarf.jmc>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Message-ID: <V7-dnXjUu-nU8wv8nZ2dnUU7-Y3NnZ2d@giganews.com>
Lines: 78
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-6WjqxEHYhWa1PALLD23gg+53C3//gZwElERNR00C9a8hmFTcxu3wikYugGO4jvLEFE3DSUMflby3L3a!t0YsQbWgWP5xO6GCM8tVSGIcwcpQJtxKtyoAI+LwDOpy8ZwdHlR/7PpHxunZnpNnr3HFvfkeIXnW!Ng==
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: 3615
 by: olcott - Thu, 18 Nov 2021 15:16 UTC

On 11/18/2021 7:00 AM, Mr Flibble wrote:
> On Thu, 18 Nov 2021 06:29:26 -0500
> Richard Damon <Richard@Damon-Family.org> wrote:
>
>> On 11/17/21 10:48 PM, olcott wrote:
>>
>>> For every possible H of H(P,P) invoked from main() where P(P) calls
>>> this same H(P,P) and H simulates or executes its input and aborts
>>> or does not abort its input P never reaches its last instruction.
>>>
>>> computation that halts
>>> a computation is said to halt whenever it enters a final state.
>>> (Linz:1990:234)
>>>
>>
>> No, you LIE.
>>
>> Halting is DEFINED by the behavior of the actual computation.
>>
>> H(P,P) is supposed to say what P(P) will do.
>
> No,
>
> H(P,I) is supposed to say what P(H(P(H(P(H(P(...
>
> i.e. it is infinite recursion due to a category error; H(P,I) as
> defined is INVALID. The halting problem as defined is INVALID.
>
> /Flibble
>
>

I made the "impossible" inputs decidable.

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

(1) H(P,P) simply executes its input:
main() calls H(P,P) that calls P(P) that calls H(P,P)...
(2) H(P,P) simulates its input.
(3) H(P,P) executes its input** and aborts this execution at some point.
**(a debugger could be used).
(4) H(P,P) simulates its input and aborts this simulation at some point.

For every possible H of H(P,P) invoked from main() where P(P) calls this
same H(P,P) and H simulates or executes its input and aborts or does not
abort its input P never reaches its last instruction.

The above defines all of the combinations of H/P having pathological
self-reference.

Cases (3) and (4) define the subset of these where the behavior of
H(P,P) diverges for the behavior of P(P).

--
Copyright 2021 Pete Olcott

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

Re: Concise refutation of halting problem proofs V17

<IqKdndBPwrZ_7wv8nZ2dnUU7-QWdnZ2d@giganews.com>

 copy mid

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

 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: Thu, 18 Nov 2021 09:36:02 -0600
Date: Thu, 18 Nov 2021 09:36: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.1
Subject: Re: Concise refutation of halting problem proofs V17
Content-Language: en-US
Newsgroups: comp.theory
References: <l8adnY-MOrqcMAj8nZ2dnUU7-Q3NnZ2d@giganews.com>
<OHilJ.3007$aF1.1686@fx98.iad>
<VtudnfP5Zt3RIQj8nZ2dnUU7-KfNnZ2d@giganews.com>
<kJjlJ.44440$OB3.5879@fx06.iad>
<5eqdnbJ9-8qzUAj8nZ2dnUU7-d_NnZ2d@giganews.com>
<pOqlJ.43485$3q9.38930@fx47.iad>
From: NoO...@NoWhere.com (olcott)
In-Reply-To: <pOqlJ.43485$3q9.38930@fx47.iad>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 7bit
Message-ID: <IqKdndBPwrZ_7wv8nZ2dnUU7-QWdnZ2d@giganews.com>
Lines: 57
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-EV3FKqdwFuhi/CvbmNALTYSfoDMCPKixCRmTQAja21LEQLeU6APeTeguCc5OF/qfPob8sLxbgLz/zrR!OV+BMGe8y3ZViN1flQ6AKy2oHtyTM0YkXwVKwP65x93sonJKAzaujYjcn4/InBJJruCANvkLVir8!wQ==
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: 3023
 by: olcott - Thu, 18 Nov 2021 15:36 UTC

On 11/18/2021 5:29 AM, Richard Damon wrote:
>
> On 11/17/21 10:48 PM, olcott wrote:
>
>> For every possible H of H(P,P) invoked from main() where P(P) calls
>> this same H(P,P) and H simulates or executes its input and aborts or
>> does not abort its input P never reaches its last instruction.
>>
>> computation that halts
>> a computation is said to halt whenever it enters a final state.
>> (Linz:1990:234)
>>
>
> No, you LIE.
>
> Halting is DEFINED by the behavior of the actual computation.
>

The halt status of an input to a halt decider is the actual behavior of
the actual sequence of instruction specified by the actual input.

You keep specifying some other sequence of instructions somewhere else.

> H(P,P) is supposed to say what P(P) will do.
>
> If H(P,P) returns 0, then P(P) will Halt. PERIOD.
>
> If P(P) Halts then H(P,P) returning 0 is WRONG.
>
> Your claim that H(P,P) returning 0 to be right is a LIE.
>
> You have just PROVED that you are a moron, because you refuse to do
> things by the rules.
>
> You have doomed yourself to being a laughing stock of the logical
> community.
>
>
> Look at your quote:
> Talent hits a target no one else can hit;
> Genius hits a target no one else can see.
> Arthur Schopenhauer
>
> What is the person that can only hit a target that doesn't exist, but
> claims to have hit a target that isn't there.
>
> A LIAR and a FRAUD.
>
> That is you.

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

<DOGdnQdvtrRF5Av8nZ2dnUU7-IPNnZ2d@giganews.com>

 copy mid

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

 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: Thu, 18 Nov 2021 10:05:44 -0600
Date: Thu, 18 Nov 2021 10:05:43 -0600
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:91.0) Gecko/20100101
Thunderbird/91.3.1
Subject: Re: Concise refutation of halting problem proofs V17
Content-Language: en-US
Newsgroups: comp.theory,comp.ai.philosophy,sci.logic,sci.math
References: <l8adnY-MOrqcMAj8nZ2dnUU7-Q3NnZ2d@giganews.com>
<OHilJ.3007$aF1.1686@fx98.iad>
<VtudnfP5Zt3RIQj8nZ2dnUU7-KfNnZ2d@giganews.com>
<kJjlJ.44440$OB3.5879@fx06.iad>
<5eqdnbJ9-8qzUAj8nZ2dnUU7-d_NnZ2d@giganews.com>
<pOqlJ.43485$3q9.38930@fx47.iad> <20211118130058.00004c6f@reddwarf.jmc>
Followup-To: comp.theory
From: NoO...@NoWhere.com (olcott)
In-Reply-To: <20211118130058.00004c6f@reddwarf.jmc>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 7bit
Message-ID: <DOGdnQdvtrRF5Av8nZ2dnUU7-IPNnZ2d@giganews.com>
Lines: 56
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-uBrEV/g1i2jVUDpruklYkSsfdGhQhgGhaQtjJ5nhLkX63d5dXctpdzX/96fSoMFSupyxzTu7AdyjpRu!E6/5iB01a1WCNR7zn2ojmjQESDYdempPoBExbDx1QDAUUIB/u/X28zap22TAm+yx4x9Naymdun1w!Ew==
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: 3221
 by: olcott - Thu, 18 Nov 2021 16:05 UTC

On 11/18/2021 7:00 AM, Mr Flibble wrote:
> On Thu, 18 Nov 2021 06:29:26 -0500
> Richard Damon <Richard@Damon-Family.org> wrote:
>
>> On 11/17/21 10:48 PM, olcott wrote:
>>
>>> For every possible H of H(P,P) invoked from main() where P(P) calls
>>> this same H(P,P) and H simulates or executes its input and aborts
>>> or does not abort its input P never reaches its last instruction.
>>>
>>> computation that halts
>>> a computation is said to halt whenever it enters a final state.
>>> (Linz:1990:234)
>>>
>>
>> No, you LIE.
>>
>> Halting is DEFINED by the behavior of the actual computation.
>>
>> H(P,P) is supposed to say what P(P) will do.
>
> No,
>
> H(P,I) is supposed to say what P(H(P(H(P(H(P(...
>
> i.e. it is infinite recursion due to a category error; H(P,I) as
> defined is INVALID. The halting problem as defined is INVALID.
>
> /Flibble
>
>

It is not actually invalid, I used to think that back in 2004.
The HP has the same form of the Liar Paradox and the Liar Paradox is
invalid making it not a truth bearer.

[Halting Problem Final Conclusion]
comp.theory
Peter Olcott
Sep 5, 2004, 11:21:57 AM

The Liar Paradox can be shown to be nothing more than
a incorrectly formed statement because of its pathological
self-reference. The Halting Problem can only exist because
of this same sort of pathological self-reference.
https://groups.google.com/g/comp.theory/c/RO9Z9eCabeE/m/Ka8-xS2rdEEJ

The HP input is merely infinitely nested simulation that is correctly
decided as not halting.

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

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

 copy mid

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

 copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!eternal-september.org!reader02.eternal-september.org!.POSTED!not-for-mail
From: ben.use...@bsb.me.uk (Ben Bacarisse)
Newsgroups: comp.theory
Subject: Re: Concise refutation of halting problem proofs V17
Date: Thu, 18 Nov 2021 16:55:24 +0000
Organization: A noiseless patient Spider
Lines: 15
Message-ID: <87sfvtmmir.fsf@bsb.me.uk>
References: <l8adnY-MOrqcMAj8nZ2dnUU7-Q3NnZ2d@giganews.com>
<OHilJ.3007$aF1.1686@fx98.iad>
<VtudnfP5Zt3RIQj8nZ2dnUU7-KfNnZ2d@giganews.com>
<kJjlJ.44440$OB3.5879@fx06.iad>
<5eqdnbJ9-8qzUAj8nZ2dnUU7-d_NnZ2d@giganews.com>
<pOqlJ.43485$3q9.38930@fx47.iad>
<20211118130058.00004c6f@reddwarf.jmc>
Mime-Version: 1.0
Content-Type: text/plain
Injection-Info: reader02.eternal-september.org; posting-host="b6e96055cde3ec5785fc7fa92034678e";
logging-data="7380"; mail-complaints-to="abuse@eternal-september.org"; posting-account="U2FsdGVkX18dBKq/V1ClRBPt9ViRTU/LdHWFgNfDsQo="
Cancel-Lock: sha1:vSfwVl4yv2Xk9mFv5YuwkY/lN/0=
sha1:J0I8iyrh61Mr9Y6J1Vu4n7scZLc=
X-BSB-Auth: 1.260dc09cb4582f991955.20211118165524GMT.87sfvtmmir.fsf@bsb.me.uk
 by: Ben Bacarisse - Thu, 18 Nov 2021 16:55 UTC

Mr Flibble <flibble@reddwarf.jmc> writes:

> On Thu, 18 Nov 2021 06:29:26 -0500
> Richard Damon <Richard@Damon-Family.org> wrote:

>> H(P,P) is supposed to say what P(P) will do.
>
> No,

So what arguments does one pass to H to find out is P(P) halts? If it's
not P and P, what is it? (Of course it is P and P, that's why PO says
that H(P,P) == 0 is correct /despite/ the fact that P(P) halts.)

--
Ben.

Re: Concise refutation of halting problem proofs V17

<ArGdnQc-APqaEQv8nZ2dnUU7-cnNnZ2d@giganews.com>

 copy mid

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

 copy link   Newsgroups: comp.theory comp.ai.philosophy sci.logic sci.math
Followup: comp.theory
Path: i2pn2.org!i2pn.org!weretis.net!feeder6.news.weretis.net!news.misty.com!border2.nntp.dca1.giganews.com!nntp.giganews.com!buffer2.nntp.dca1.giganews.com!news.giganews.com.POSTED!not-for-mail
NNTP-Posting-Date: Thu, 18 Nov 2021 11:23:19 -0600
Date: Thu, 18 Nov 2021 11:23: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.1
Subject: Re: Concise refutation of halting problem proofs V17
Content-Language: en-US
Newsgroups: comp.theory,comp.ai.philosophy,sci.logic,sci.math
References: <l8adnY-MOrqcMAj8nZ2dnUU7-Q3NnZ2d@giganews.com>
<OHilJ.3007$aF1.1686@fx98.iad>
<VtudnfP5Zt3RIQj8nZ2dnUU7-KfNnZ2d@giganews.com>
<kJjlJ.44440$OB3.5879@fx06.iad>
<5eqdnbJ9-8qzUAj8nZ2dnUU7-d_NnZ2d@giganews.com>
<pOqlJ.43485$3q9.38930@fx47.iad> <20211118130058.00004c6f@reddwarf.jmc>
<87sfvtmmir.fsf@bsb.me.uk>
Followup-To: comp.theory
From: NoO...@NoWhere.com (olcott)
In-Reply-To: <87sfvtmmir.fsf@bsb.me.uk>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 7bit
Message-ID: <ArGdnQc-APqaEQv8nZ2dnUU7-cnNnZ2d@giganews.com>
Lines: 44
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-bUqCnE1BsFBzOD2uK5DxHG5qiC6F092011mSfzvrY97yQ+4YsV1J6j52MImpT1PMxQWm6ovuGsShCRu!3w3PfZmXXJgodbnCn6cgEuCDrFU78Jd/5Ec0mPfOvtKsD4cWLFna2iYdGtNsSyEAIpFHpOTGxI84!VQ==
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: 3022
 by: olcott - Thu, 18 Nov 2021 17:23 UTC

On 11/18/2021 10:55 AM, Ben Bacarisse wrote:
> Mr Flibble <flibble@reddwarf.jmc> writes:
>
>> On Thu, 18 Nov 2021 06:29:26 -0500
>> Richard Damon <Richard@Damon-Family.org> wrote:
>
>>> H(P,P) is supposed to say what P(P) will do.
>>
>> No,
>
> So what arguments does one pass to H to find out is P(P) halts?

This is the same code that you modified.

> If it's
> not P and P, what is it? (Of course it is P and P, that's why PO says
> that H(P,P) == 0 is correct /despite/ the fact that P(P) halts.)
>

P(P) is the strawman error in that it is an entirely different claim
than the one that I am making.

My claim only refers to the sets of sequences of x86 instructions
(defined below) such that the H/P combinations have pathological
self-reference relative to each other.

For every possible H of H(P,P) invoked from main() where P(P) calls this
same H(P,P) and H simulates or executes its input and aborts or does not
abort its input P never reaches its last instruction.

halt decider (Olcott 2021)
A halt decider accepts or rejects inputs on the basis of the actual
behavior of the direct execution or simulation of these inputs.

To create a halt decider H(P,P) H merely needs to see that P is calling
H with the same parameters that H was called with, thus specifying
infinite recursion.

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

<sn67uo$bpb$1@dont-email.me>

 copy mid

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

 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 V17
Date: Thu, 18 Nov 2021 12:01:42 -0700
Organization: Christians and Atheists United Against Creeping Agnosticism
Lines: 35
Message-ID: <sn67uo$bpb$1@dont-email.me>
References: <l8adnY-MOrqcMAj8nZ2dnUU7-Q3NnZ2d@giganews.com>
<OHilJ.3007$aF1.1686@fx98.iad>
<VtudnfP5Zt3RIQj8nZ2dnUU7-KfNnZ2d@giganews.com>
<kJjlJ.44440$OB3.5879@fx06.iad>
<5eqdnbJ9-8qzUAj8nZ2dnUU7-d_NnZ2d@giganews.com>
<pOqlJ.43485$3q9.38930@fx47.iad> <20211118130058.00004c6f@reddwarf.jmc>
<87sfvtmmir.fsf@bsb.me.uk> <ArGdnQc-APqaEQv8nZ2dnUU7-cnNnZ2d@giganews.com>
Mime-Version: 1.0
Content-Type: text/plain; charset=utf-8; format=flowed
Content-Transfer-Encoding: 8bit
Injection-Date: Thu, 18 Nov 2021 19:01:44 -0000 (UTC)
Injection-Info: reader02.eternal-september.org; posting-host="ee9595d2e9c22404a93107b6f42928d3";
logging-data="12075"; mail-complaints-to="abuse@eternal-september.org"; posting-account="U2FsdGVkX18XFmyd4MP50+pmQYt0YeK0"
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.14; rv:78.0)
Gecko/20100101 Thunderbird/78.14.0
Cancel-Lock: sha1:YXinygIBpOaMUthknPrp4Nm6ZUw=
In-Reply-To: <ArGdnQc-APqaEQv8nZ2dnUU7-cnNnZ2d@giganews.com>
Content-Language: en-US
 by: André G. Isaak - Thu, 18 Nov 2021 19:01 UTC

On 2021-11-18 10:23, olcott wrote:
> On 11/18/2021 10:55 AM, Ben Bacarisse wrote:
>> Mr Flibble <flibble@reddwarf.jmc> writes:
>>
>>> On Thu, 18 Nov 2021 06:29:26 -0500
>>> Richard Damon <Richard@Damon-Family.org> wrote:
>>
>>>> H(P,P) is supposed to say what P(P) will do.
>>>
>>> No,
>>
>> So what arguments does one pass to H to find out is P(P) halts?
>
> This is the same code that you modified.

???

How is that a response?

We have a computation, P(P), which you acknowledge halts.

We also have H which you claim to be a halt decider.

So let's say someone doesn't know whether P(P) halts. But they have your
halt decider H, and a halt decider should be able to answer this
question for them. That's what halt deciders are for, after all.

So what input do they give to H so that H will correctly tell them that
P(P) halts?

André

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

Re: Concise refutation of halting problem proofs V17 [ pathological self-reference precisely defined ]

<It2dnZOFI4NQKQv8nZ2dnUU7-YvNnZ2d@giganews.com>

 copy mid

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

 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: Thu, 18 Nov 2021 14:17:17 -0600
Date: Thu, 18 Nov 2021 14:17:16 -0600
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:91.0) Gecko/20100101
Thunderbird/91.3.1
Subject: Re: Concise refutation of halting problem proofs V17 [ pathological
self-reference precisely defined ]
Content-Language: en-US
Newsgroups: comp.theory,comp.ai.philosophy,sci.logic,sci.math
References: <l8adnY-MOrqcMAj8nZ2dnUU7-Q3NnZ2d@giganews.com>
<OHilJ.3007$aF1.1686@fx98.iad>
<VtudnfP5Zt3RIQj8nZ2dnUU7-KfNnZ2d@giganews.com>
<kJjlJ.44440$OB3.5879@fx06.iad>
<5eqdnbJ9-8qzUAj8nZ2dnUU7-d_NnZ2d@giganews.com>
<pOqlJ.43485$3q9.38930@fx47.iad> <20211118130058.00004c6f@reddwarf.jmc>
<87sfvtmmir.fsf@bsb.me.uk> <ArGdnQc-APqaEQv8nZ2dnUU7-cnNnZ2d@giganews.com>
<sn67uo$bpb$1@dont-email.me>
From: NoO...@NoWhere.com (olcott)
Followup-To: comp.theory
In-Reply-To: <sn67uo$bpb$1@dont-email.me>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Message-ID: <It2dnZOFI4NQKQv8nZ2dnUU7-YvNnZ2d@giganews.com>
Lines: 92
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-ONLeBvKZSVn1v4/txWg5Kh/5AlUp+toRqKfcLV2Ilz5YyB8S5MkK2GjufT+6dDoJiVpWXmZ9SzV1YGa!QqG/6SfzN/+/A2WPYDMtXAubFmBmHtc2LQWo3AOqRwWOZcae5LXTeA53TFBX8BvROWdb7jIqUsIN!ug==
X-Complaints-To: abuse@giganews.com
X-DMCA-Notifications: http://www.giganews.com/info/dmca.html
X-Abuse-and-DMCA-Info: Please be sure to forward a copy of ALL headers
X-Abuse-and-DMCA-Info: Otherwise we will be unable to process your complaint properly
X-Postfilter: 1.3.40
X-Original-Bytes: 4195
 by: olcott - Thu, 18 Nov 2021 20:17 UTC

On 11/18/2021 1:01 PM, André G. Isaak wrote:
> On 2021-11-18 10:23, olcott wrote:
>> On 11/18/2021 10:55 AM, Ben Bacarisse wrote:
>>> Mr Flibble <flibble@reddwarf.jmc> writes:
>>>
>>>> On Thu, 18 Nov 2021 06:29:26 -0500
>>>> Richard Damon <Richard@Damon-Family.org> wrote:
>>>
>>>>> H(P,P) is supposed to say what P(P) will do.
>>>>
>>>> No,
>>>
>>> So what arguments does one pass to H to find out is P(P) halts?
>>
>> This is the same code that you modified.
>
> ???
>
> How is that a response?
>

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

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

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

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

We can see the arguments passed to H prove that P never reaches its last
instruction.

> We have a computation, P(P), which you acknowledge halts.
>

We have a precisely defined set of sequences of x86 instructions as
combinations of H/P such that the relationship between H and P is always
pathological self-reference:

For every possible H of H(P,P) invoked from main() where P(P) calls this
same H(P,P) and H simulates or executes its input and aborts or does not
abort its input P never reaches its last instruction.

P(P) is not in this set thus a strawman error when used as a rebuttal to
the behavior of elements in the defined set.

> We also have H which you claim to be a halt decider.
>

I haven't gotten to that point yet, first I prove that the "impossible"
input is decidable, then after this is accepted then I show the trivial
step required for H to make this correct halt status decision.

> So let's say someone doesn't know whether P(P) halts. But they have your
> halt decider H, and a halt decider should be able to answer this
> question for them. That's what halt deciders are for, after all.
>

A simple bench check of the 21 lines of C code conclusively proves that
P never reaches its final instruction.

A more complex analysis proves that no element of the infinite
pathological self-reference set of H/P does P ever reach its final
instruction.

> So what input do they give to H so that H will correctly tell them that
> P(P) halts?
>
> 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 V17

<20211118215729.00000978@reddwarf.jmc>

 copy mid

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

 copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!aioe.org!news.uzoreto.com!newsreader4.netcologne.de!news.netcologne.de!peer01.ams1!peer.ams1.xlned.com!news.xlned.com!peer01.ams4!peer.am4.highwinds-media.com!news.highwinds-media.com!fx02.ams4.POSTED!not-for-mail
From: flib...@reddwarf.jmc (Mr Flibble)
Newsgroups: comp.theory
Subject: Re: Concise refutation of halting problem proofs V17
Message-ID: <20211118215729.00000978@reddwarf.jmc>
References: <l8adnY-MOrqcMAj8nZ2dnUU7-Q3NnZ2d@giganews.com>
<OHilJ.3007$aF1.1686@fx98.iad>
<VtudnfP5Zt3RIQj8nZ2dnUU7-KfNnZ2d@giganews.com>
<kJjlJ.44440$OB3.5879@fx06.iad>
<5eqdnbJ9-8qzUAj8nZ2dnUU7-d_NnZ2d@giganews.com>
<pOqlJ.43485$3q9.38930@fx47.iad>
<20211118130058.00004c6f@reddwarf.jmc>
<87sfvtmmir.fsf@bsb.me.uk>
Organization: Jupiter Mining Corp
X-Newsreader: Claws Mail 3.17.8 (GTK+ 2.24.33; x86_64-w64-mingw32)
MIME-Version: 1.0
Content-Type: text/plain; charset=US-ASCII
Content-Transfer-Encoding: 7bit
Lines: 22
X-Complaints-To: abuse@eweka.nl
NNTP-Posting-Date: Thu, 18 Nov 2021 21:57:29 UTC
Date: Thu, 18 Nov 2021 21:57:29 +0000
X-Received-Bytes: 1569
 by: Mr Flibble - Thu, 18 Nov 2021 21:57 UTC

On Thu, 18 Nov 2021 16:55:24 +0000
Ben Bacarisse <ben.usenet@bsb.me.uk> wrote:

> Mr Flibble <flibble@reddwarf.jmc> writes:
>
> > On Thu, 18 Nov 2021 06:29:26 -0500
> > Richard Damon <Richard@Damon-Family.org> wrote:
>
> >> H(P,P) is supposed to say what P(P) will do.
> >
> > No,
>
> So what arguments does one pass to H to find out is P(P) halts? If
> it's not P and P, what is it? (Of course it is P and P, that's why
> PO says that H(P,P) == 0 is correct /despite/ the fact that P(P)
> halts.)
>

Any P that doesn't reference H.

/Flibble

Re: Concise refutation of halting problem proofs V17

<878rxlksk2.fsf@bsb.me.uk>

 copy mid

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

 copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!eternal-september.org!reader02.eternal-september.org!.POSTED!not-for-mail
From: ben.use...@bsb.me.uk (Ben Bacarisse)
Newsgroups: comp.theory
Subject: Re: Concise refutation of halting problem proofs V17
Date: Thu, 18 Nov 2021 22:27:57 +0000
Organization: A noiseless patient Spider
Lines: 26
Message-ID: <878rxlksk2.fsf@bsb.me.uk>
References: <l8adnY-MOrqcMAj8nZ2dnUU7-Q3NnZ2d@giganews.com>
<OHilJ.3007$aF1.1686@fx98.iad>
<VtudnfP5Zt3RIQj8nZ2dnUU7-KfNnZ2d@giganews.com>
<kJjlJ.44440$OB3.5879@fx06.iad>
<5eqdnbJ9-8qzUAj8nZ2dnUU7-d_NnZ2d@giganews.com>
<pOqlJ.43485$3q9.38930@fx47.iad>
<20211118130058.00004c6f@reddwarf.jmc> <87sfvtmmir.fsf@bsb.me.uk>
<20211118215729.00000978@reddwarf.jmc>
Mime-Version: 1.0
Content-Type: text/plain
Injection-Info: reader02.eternal-september.org; posting-host="b6e96055cde3ec5785fc7fa92034678e";
logging-data="725"; mail-complaints-to="abuse@eternal-september.org"; posting-account="U2FsdGVkX1+iJBelwDJOlRvYJA45YZnfbFhh0uiwE2M="
Cancel-Lock: sha1:1f6t+/ZE5DMuuqRDI5aApNIBXek=
sha1:PaZe0qZ6Gacja+B9VV9jXffoCj4=
X-BSB-Auth: 1.00ae8fb251d5e77e35c6.20211118222757GMT.878rxlksk2.fsf@bsb.me.uk
 by: Ben Bacarisse - Thu, 18 Nov 2021 22:27 UTC

Mr Flibble <flibble@reddwarf.jmc> writes:

> On Thu, 18 Nov 2021 16:55:24 +0000
> Ben Bacarisse <ben.usenet@bsb.me.uk> wrote:
>
>> Mr Flibble <flibble@reddwarf.jmc> writes:
>>
>> > On Thu, 18 Nov 2021 06:29:26 -0500
>> > Richard Damon <Richard@Damon-Family.org> wrote:
>>
>> >> H(P,P) is supposed to say what P(P) will do.
>> >
>> > No,
>>
>> So what arguments does one pass to H to find out is P(P) halts? If
>> it's not P and P, what is it? (Of course it is P and P, that's why
>> PO says that H(P,P) == 0 is correct /despite/ the fact that P(P)
>> halts.)
>
> Any P that doesn't reference H.

Not an answer. What arguments does one pass to H to find out if P(P) --
that's the P that has been posted numerous times -- halts?

--
Ben.

Re: Concise refutation of halting problem proofs V17

<hbKdnZ70irsxQAv8nZ2dnUU7-WfNnZ2d@giganews.com>

 copy mid

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

 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: Thu, 18 Nov 2021 17:11:40 -0600
Date: Thu, 18 Nov 2021 17:11: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.1
Subject: Re: Concise refutation of halting problem proofs V17
Content-Language: en-US
Newsgroups: comp.theory,comp.ai.philosophy,sci.logic,sci.math
References: <l8adnY-MOrqcMAj8nZ2dnUU7-Q3NnZ2d@giganews.com>
<OHilJ.3007$aF1.1686@fx98.iad>
<VtudnfP5Zt3RIQj8nZ2dnUU7-KfNnZ2d@giganews.com>
<kJjlJ.44440$OB3.5879@fx06.iad>
<5eqdnbJ9-8qzUAj8nZ2dnUU7-d_NnZ2d@giganews.com>
<pOqlJ.43485$3q9.38930@fx47.iad> <20211118130058.00004c6f@reddwarf.jmc>
<87sfvtmmir.fsf@bsb.me.uk> <20211118215729.00000978@reddwarf.jmc>
From: NoO...@NoWhere.com (olcott)
Followup-To: comp.theory
In-Reply-To: <20211118215729.00000978@reddwarf.jmc>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 7bit
Message-ID: <hbKdnZ70irsxQAv8nZ2dnUU7-WfNnZ2d@giganews.com>
Lines: 50
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-FNw2HJmak6BMKwckXnYaXRcyAcF49If1KmKimfZkM4izIbp4KH/aMNw0s3GOV/wpMa//gVMAPKZ/lOI!MMyjft1/WDcHcv3XqUWLedCFFuyxEJC4hxJAF8gwunVPkCcDv/ZvHII9i70g4UFKORPOZIXphBPa!9Q==
X-Complaints-To: abuse@giganews.com
X-DMCA-Notifications: http://www.giganews.com/info/dmca.html
X-Abuse-and-DMCA-Info: Please be sure to forward a copy of ALL headers
X-Abuse-and-DMCA-Info: Otherwise we will be unable to process your complaint properly
X-Postfilter: 1.3.40
X-Original-Bytes: 3259
 by: olcott - Thu, 18 Nov 2021 23:11 UTC

On 11/18/2021 3:57 PM, Mr Flibble wrote:
> On Thu, 18 Nov 2021 16:55:24 +0000
> Ben Bacarisse <ben.usenet@bsb.me.uk> wrote:
>
>> Mr Flibble <flibble@reddwarf.jmc> writes:
>>
>>> On Thu, 18 Nov 2021 06:29:26 -0500
>>> Richard Damon <Richard@Damon-Family.org> wrote:
>>
>>>> H(P,P) is supposed to say what P(P) will do.
>>>
>>> No,
>>
>> So what arguments does one pass to H to find out is P(P) halts? If
>> it's not P and P, what is it? (Of course it is P and P, that's why
>> PO says that H(P,P) == 0 is correct /despite/ the fact that P(P)
>> halts.)
>>
>
> Any P that doesn't reference H.
>
> /Flibble
>

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

This is the halt deciding criteria that correctly decides that set:
halt decider (Olcott 2021) A halt decider accepts or rejects inputs on
the basis of the actual behavior of the direct execution or simulation
of these inputs.

It took me 16,000 hours since 2004 to boil it down to that.
All of my 18,459 messages are still out in comp.theory

My most recent paper on this subject (of four)
Halting problem undecidability and infinitely nested simulation (V2)
November 2021 PL Olcott

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

--
Copyright 2021 Pete Olcott

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

Re: Concise refutation of halting problem proofs V17

<g7KdnWFMhoqqQgv8nZ2dnUU7-TnNnZ2d@giganews.com>

 copy mid

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

 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: Thu, 18 Nov 2021 17:18:14 -0600
Date: Thu, 18 Nov 2021 17:18: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.1
Subject: Re: Concise refutation of halting problem proofs V17
Content-Language: en-US
Newsgroups: comp.theory,comp.ai.philosophy,sci.logic,sci.math
References: <l8adnY-MOrqcMAj8nZ2dnUU7-Q3NnZ2d@giganews.com>
<OHilJ.3007$aF1.1686@fx98.iad>
<VtudnfP5Zt3RIQj8nZ2dnUU7-KfNnZ2d@giganews.com>
<kJjlJ.44440$OB3.5879@fx06.iad>
<5eqdnbJ9-8qzUAj8nZ2dnUU7-d_NnZ2d@giganews.com>
<pOqlJ.43485$3q9.38930@fx47.iad> <20211118130058.00004c6f@reddwarf.jmc>
<87sfvtmmir.fsf@bsb.me.uk> <20211118215729.00000978@reddwarf.jmc>
<878rxlksk2.fsf@bsb.me.uk>
Followup-To: comp.theory
From: NoO...@NoWhere.com (olcott)
In-Reply-To: <878rxlksk2.fsf@bsb.me.uk>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 7bit
Message-ID: <g7KdnWFMhoqqQgv8nZ2dnUU7-TnNnZ2d@giganews.com>
Lines: 51
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-skoktItFYcm6F9nXW391vytnIZDYnRLtZzJ/hnhHcc7g4+9yEu9Rp3E9OmKaZ+jiolsyIqFhI67PNrQ!FmVpQqv4O1YOKn3J8uzRdAh0BSYbo4y/y27sohUXcTBIM+fVJLVPdPklT6oXFqmhzICHAKlJsDge!JQ==
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: 3301
 by: olcott - Thu, 18 Nov 2021 23:18 UTC

On 11/18/2021 4:27 PM, Ben Bacarisse wrote:
> Mr Flibble <flibble@reddwarf.jmc> writes:
>
>> On Thu, 18 Nov 2021 16:55:24 +0000
>> Ben Bacarisse <ben.usenet@bsb.me.uk> wrote:
>>
>>> Mr Flibble <flibble@reddwarf.jmc> writes:
>>>
>>>> On Thu, 18 Nov 2021 06:29:26 -0500
>>>> Richard Damon <Richard@Damon-Family.org> wrote:
>>>
>>>>> H(P,P) is supposed to say what P(P) will do.
>>>>
>>>> No,
>>>
>>> So what arguments does one pass to H to find out is P(P) halts? If
>>> it's not P and P, what is it? (Of course it is P and P, that's why
>>> PO says that H(P,P) == 0 is correct /despite/ the fact that P(P)
>>> halts.)
>>
>> Any P that doesn't reference H.
>
> Not an answer. What arguments does one pass to H to find out if P(P) --
> that's the P that has been posted numerous times -- halts?
>

Page(3) explains exactly how the set of pathological combinations of H/P
are correctly decided as not halting:

For every possible H of H(P,P) invoked from main() where P(P) calls this
same H(P,P) and H simulates or executes its input and aborts or does not
abort its input P never reaches its last instruction.

Halt Decider (Olcott 2021) A halt decider accepts or rejects inputs on
the basis of the actual behavior of the direct execution or simulation
of these inputs.

My most recent paper
Halting problem undecidability and infinitely nested simulation (V2)
November 2021 PL Olcott

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

--
Copyright 2021 Pete Olcott

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

Re: Concise refutation of halting problem proofs V17

<4qBlJ.15073$bn2.4192@fx12.iad>

 copy mid

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

 copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!paganini.bofh.team!news.dns-netz.com!news.freedyn.net!newsreader4.netcologne.de!news.netcologne.de!peer02.ams1!peer.ams1.xlned.com!news.xlned.com!peer02.iad!feed-me.highwinds-media.com!news.highwinds-media.com!fx12.iad.POSTED!not-for-mail
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:91.0)
Gecko/20100101 Thunderbird/91.3.1
Subject: Re: Concise refutation of halting problem proofs V17
Content-Language: en-US
Newsgroups: comp.theory
References: <l8adnY-MOrqcMAj8nZ2dnUU7-Q3NnZ2d@giganews.com>
<OHilJ.3007$aF1.1686@fx98.iad>
<VtudnfP5Zt3RIQj8nZ2dnUU7-KfNnZ2d@giganews.com>
<kJjlJ.44440$OB3.5879@fx06.iad>
<5eqdnbJ9-8qzUAj8nZ2dnUU7-d_NnZ2d@giganews.com>
<pOqlJ.43485$3q9.38930@fx47.iad> <20211118130058.00004c6f@reddwarf.jmc>
<87sfvtmmir.fsf@bsb.me.uk> <ArGdnQc-APqaEQv8nZ2dnUU7-cnNnZ2d@giganews.com>
From: Rich...@Damon-Family.org (Richard Damon)
In-Reply-To: <ArGdnQc-APqaEQv8nZ2dnUU7-cnNnZ2d@giganews.com>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Lines: 57
Message-ID: <4qBlJ.15073$bn2.4192@fx12.iad>
X-Complaints-To: abuse@easynews.com
Organization: Forte - www.forteinc.com
X-Complaints-Info: Please be sure to forward a copy of ALL headers otherwise we will be unable to process your complaint properly.
Date: Thu, 18 Nov 2021 18:34:24 -0500
X-Received-Bytes: 3321
 by: Richard Damon - Thu, 18 Nov 2021 23:34 UTC

On 11/18/21 12:23 PM, olcott wrote:
> On 11/18/2021 10:55 AM, Ben Bacarisse wrote:
>> Mr Flibble <flibble@reddwarf.jmc> writes:
>>
>>> On Thu, 18 Nov 2021 06:29:26 -0500
>>> Richard Damon <Richard@Damon-Family.org> wrote:
>>
>>>> H(P,P) is supposed to say what P(P) will do.
>>>
>>> No,
>>
>> So what arguments does one pass to H to find out is P(P) halts?
>
> This is the same code that you modified.
>
>> If it's
>> not P and P, what is it?  (Of course it is P and P, that's why PO says
>> that H(P,P) == 0 is correct /despite/ the fact that P(P) halts.)
>>
>
> P(P) is the strawman error in that it is an entirely different claim
> than the one that I am making.

Then YOUR claim is the strawman, as P(P) is PRECISELY the computation
that H(P,P) needs to answer about.

>
> My claim only refers to the sets of sequences of x86 instructions
> (defined below) such that the H/P combinations have pathological
> self-reference relative to each other.

Then either you setup doesn't match Linz, and thus doesn't actually
refute it or you have an error.

One big issue it seems is that you don't seem to be treating P as an
actual computation, as you don't seem to be including all of the code
for the COMPUTATATION of P in what you call P.

>
> For every possible H of H(P,P) invoked from main() where P(P) calls this
> same H(P,P) and H simulates or executes its input and aborts or does not
> abort its input P never reaches its last instruction.

Which the way you describe it is meaningless, as you seem to be focusing
only on the simulation of P inside H and not the actual machine P, so
your are just talking about POOP and not Halting.

>
> halt decider (Olcott 2021)
> A halt decider accepts or rejects inputs on the basis of the actual
> behavior of the direct execution or simulation of these inputs.
>
> To create a halt decider H(P,P) H merely needs to see that P is calling
> H with the same parameters that H was called with, thus specifying
> infinite recursion.
>

Re: Concise refutation of halting problem proofs V17

<JdElJ.45157$3q9.3150@fx47.iad>

 copy mid

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

 copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!aioe.org!news.uzoreto.com!newsfeed.xs4all.nl!newsfeed7.news.xs4all.nl!feeder1.feed.usenet.farm!feed.usenet.farm!peer03.ams4!peer.am4.highwinds-media.com!peer01.iad!feed-me.highwinds-media.com!news.highwinds-media.com!fx47.iad.POSTED!not-for-mail
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:91.0)
Gecko/20100101 Thunderbird/91.3.1
Subject: Re: Concise refutation of halting problem proofs V17
Content-Language: en-US
Newsgroups: comp.theory
References: <l8adnY-MOrqcMAj8nZ2dnUU7-Q3NnZ2d@giganews.com>
<OHilJ.3007$aF1.1686@fx98.iad>
<VtudnfP5Zt3RIQj8nZ2dnUU7-KfNnZ2d@giganews.com>
<kJjlJ.44440$OB3.5879@fx06.iad>
<5eqdnbJ9-8qzUAj8nZ2dnUU7-d_NnZ2d@giganews.com>
<pOqlJ.43485$3q9.38930@fx47.iad> <20211118130058.00004c6f@reddwarf.jmc>
<V7-dnXjUu-nU8wv8nZ2dnUU7-Y3NnZ2d@giganews.com>
From: Rich...@Damon-Family.org (Richard Damon)
In-Reply-To: <V7-dnXjUu-nU8wv8nZ2dnUU7-Y3NnZ2d@giganews.com>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Lines: 96
Message-ID: <JdElJ.45157$3q9.3150@fx47.iad>
X-Complaints-To: abuse@easynews.com
Organization: Forte - www.forteinc.com
X-Complaints-Info: Please be sure to forward a copy of ALL headers otherwise we will be unable to process your complaint properly.
Date: Thu, 18 Nov 2021 21:46:01 -0500
X-Received-Bytes: 4333
 by: Richard Damon - Fri, 19 Nov 2021 02:46 UTC

On 11/18/21 10:16 AM, olcott wrote:
> On 11/18/2021 7:00 AM, Mr Flibble wrote:
>> On Thu, 18 Nov 2021 06:29:26 -0500
>> Richard Damon <Richard@Damon-Family.org> wrote:
>>
>>> On 11/17/21 10:48 PM, olcott wrote:
>>>
>>>> For every possible H of H(P,P) invoked from main() where P(P) calls
>>>> this same H(P,P) and H simulates or executes its input and aborts
>>>> or does not abort its input P never reaches its last instruction.
>>>>
>>>> computation that halts
>>>> a computation is said to halt whenever it enters a final state.
>>>> (Linz:1990:234)
>>>
>>> No, you LIE.
>>>
>>> Halting is DEFINED by the behavior of the actual computation.
>>>
>>> H(P,P) is supposed to say what P(P) will do.
>>
>> No,
>>
>> H(P,I) is supposed to say what P(H(P(H(P(H(P(...
>>
>> i.e. it is infinite recursion due to a category error; H(P,I) as
>> defined is INVALID.  The halting problem as defined is INVALID.
>>
>> /Flibble
>>
>>
>
> I made the "impossible" inputs decidable.

No, you decided on the POOP problem, not the halting problem because you
refuse to test your H by the definition of the Halting Problem.

H(P,P) must indicate what P(P) (the computation its input represents) does.

You just lie about what you claim you are doing.

>
> 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);
> }
>
> (1) H(P,P) simply executes its input:
>     main() calls H(P,P) that calls P(P) that calls H(P,P)...
> (2) H(P,P) simulates its input.
> (3) H(P,P) executes its input** and aborts this execution at some point.
>     **(a debugger could be used).
> (4) H(P,P) simulates its input and aborts this simulation at some point.
>
> For every possible H of H(P,P) invoked from main() where P(P) calls this
> same H(P,P) and H simulates or executes its input and aborts or does not
> abort its input P never reaches its last instruction.

Except what you are saying is that H(P,P) never processes its input to
the point where it sees the input halting.

The 'Input' to H is the representation of P(P), and THAT halts, as you
have sometimes admited.

>
> The above defines all of the combinations of H/P having pathological
> self-reference.
>
> Cases (3) and (4) define the subset of these where the behavior of
> H(P,P) diverges for the behavior of P(P).
>

And while H(P,P) and P(P) were never computationally equivalent, since
that doesn't even apply here, the key point is that what you call the
input to H(P,P) in this case represents a different compuation than
P(P), which means that this problem has been setup wrong, and the claims
that you are working on the halting problem is just a lie.

By the meaning of the words, H(P,P) SHOULD be asking does the
computation P(P) halt, but that doesn't seem to be what you actually
mean by it.

Re: Concise refutation of halting problem proofs V17

<chElJ.45158$3q9.10992@fx47.iad>

 copy mid

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

 copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!aioe.org!news.uzoreto.com!newsreader4.netcologne.de!news.netcologne.de!peer03.ams1!peer.ams1.xlned.com!news.xlned.com!peer01.iad!feed-me.highwinds-media.com!news.highwinds-media.com!fx47.iad.POSTED!not-for-mail
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:91.0)
Gecko/20100101 Thunderbird/91.3.1
Subject: Re: Concise refutation of halting problem proofs V17
Content-Language: en-US
Newsgroups: comp.theory
References: <l8adnY-MOrqcMAj8nZ2dnUU7-Q3NnZ2d@giganews.com>
<OHilJ.3007$aF1.1686@fx98.iad>
<VtudnfP5Zt3RIQj8nZ2dnUU7-KfNnZ2d@giganews.com>
<kJjlJ.44440$OB3.5879@fx06.iad>
<5eqdnbJ9-8qzUAj8nZ2dnUU7-d_NnZ2d@giganews.com>
<pOqlJ.43485$3q9.38930@fx47.iad> <20211118130058.00004c6f@reddwarf.jmc>
<87sfvtmmir.fsf@bsb.me.uk> <20211118215729.00000978@reddwarf.jmc>
<hbKdnZ70irsxQAv8nZ2dnUU7-WfNnZ2d@giganews.com>
From: Rich...@Damon-Family.org (Richard Damon)
In-Reply-To: <hbKdnZ70irsxQAv8nZ2dnUU7-WfNnZ2d@giganews.com>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Lines: 60
Message-ID: <chElJ.45158$3q9.10992@fx47.iad>
X-Complaints-To: abuse@easynews.com
Organization: Forte - www.forteinc.com
X-Complaints-Info: Please be sure to forward a copy of ALL headers otherwise we will be unable to process your complaint properly.
Date: Thu, 18 Nov 2021 21:49:44 -0500
X-Received-Bytes: 3219
 by: Richard Damon - Fri, 19 Nov 2021 02:49 UTC

On 11/18/21 6:11 PM, olcott wrote:
> On 11/18/2021 3:57 PM, Mr Flibble wrote:
>> On Thu, 18 Nov 2021 16:55:24 +0000
>> Ben Bacarisse <ben.usenet@bsb.me.uk> wrote:
>>
>>> Mr Flibble <flibble@reddwarf.jmc> writes:
>>>
>>>> On Thu, 18 Nov 2021 06:29:26 -0500
>>>> Richard Damon <Richard@Damon-Family.org> wrote:
>>>
>>>>> H(P,P) is supposed to say what P(P) will do.
>>>>
>>>> No,
>>>
>>> So what arguments does one pass to H to find out is P(P) halts?  If
>>> it's not P and P, what is it?  (Of course it is P and P, that's why
>>> PO says that H(P,P) == 0 is correct /despite/ the fact that P(P)
>>> halts.)
>>>
>>
>> Any P that doesn't reference H.
>>
>> /Flibble
>>
>
> This is the pathological self-reference set of combinations of H/P:
> For every possible H of H(P,P) invoked from main() where P(P) calls this
> same H(P,P) and H simulates or executes its input and aborts or does not
> abort its input P never reaches its last instruction.
>
> This is the halt deciding criteria that correctly decides that set:
> halt decider (Olcott 2021) A halt decider accepts or rejects inputs on
> the basis of the actual behavior of the direct execution or simulation
> of these inputs.

Right, and H doesn't do that, so H's simulation doesn't count. PERIOD.
You don't seem to understand the definiton of that.

Directly executing P(P) when H aborts H(P,P) and returns 0 shows that
P(P) will halt.

FAIL

You Lie.

>
> It took me 16,000 hours since 2004 to boil it down to that.
> All of my 18,459 messages are still out in comp.theory

Wasted a lot of time didn't you.

>
> My most recent paper on this subject (of four)
> Halting problem undecidability and infinitely nested simulation (V2)
> November 2021 PL Olcott
>
> https://www.researchgate.net/publication/356105750_Halting_problem_undecidability_and_infinitely_nested_simulation_V2
>
>

Re: Concise refutation of halting problem proofs V17

<lqElJ.72277$Wkjc.41972@fx35.iad>

 copy mid

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

 copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!aioe.org!feeder1.feed.usenet.farm!feed.usenet.farm!peer02.ams4!peer.am4.highwinds-media.com!peer03.iad!feed-me.highwinds-media.com!news.highwinds-media.com!fx35.iad.POSTED!not-for-mail
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:91.0)
Gecko/20100101 Thunderbird/91.3.1
Subject: Re: Concise refutation of halting problem proofs V17
Content-Language: en-US
Newsgroups: comp.theory
References: <l8adnY-MOrqcMAj8nZ2dnUU7-Q3NnZ2d@giganews.com>
<OHilJ.3007$aF1.1686@fx98.iad>
<VtudnfP5Zt3RIQj8nZ2dnUU7-KfNnZ2d@giganews.com>
<kJjlJ.44440$OB3.5879@fx06.iad>
<5eqdnbJ9-8qzUAj8nZ2dnUU7-d_NnZ2d@giganews.com>
<pOqlJ.43485$3q9.38930@fx47.iad>
<IqKdndBPwrZ_7wv8nZ2dnUU7-QWdnZ2d@giganews.com>
From: Rich...@Damon-Family.org (Richard Damon)
In-Reply-To: <IqKdndBPwrZ_7wv8nZ2dnUU7-QWdnZ2d@giganews.com>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 7bit
Lines: 84
Message-ID: <lqElJ.72277$Wkjc.41972@fx35.iad>
X-Complaints-To: abuse@easynews.com
Organization: Forte - www.forteinc.com
X-Complaints-Info: Please be sure to forward a copy of ALL headers otherwise we will be unable to process your complaint properly.
Date: Thu, 18 Nov 2021 21:59:27 -0500
X-Received-Bytes: 3959
 by: Richard Damon - Fri, 19 Nov 2021 02:59 UTC

On 11/18/21 10:36 AM, olcott wrote:
> On 11/18/2021 5:29 AM, Richard Damon wrote:
>>
>> On 11/17/21 10:48 PM, olcott wrote:
>>
>>> For every possible H of H(P,P) invoked from main() where P(P) calls
>>> this same H(P,P) and H simulates or executes its input and aborts or
>>> does not abort its input P never reaches its last instruction.
>>>
>>> computation that halts
>>> a computation is said to halt whenever it enters a final state.
>>> (Linz:1990:234)
>>>
>>
>> No, you LIE.
>>
>> Halting is DEFINED by the behavior of the actual computation.
>>
>
> The halt status of an input to a halt decider is the actual behavior of
> the actual sequence of instruction specified by the actual input.

Right, INCLUDING the call to H and what H does.

The INPUT is just P(P). it doesn't include the outer call to H.

THe input does a call to H(P,P).

The H we are testing stops its simulate its input at this point (at
least your most recent version), but the ACTUAL input's direct execution
continues from here and beyond.

You havn't provided a copy of an H that actually does what you claim is
a correctly answering H, so we need to just look at what it is claimed
to do, which is simulate/debug step this copy of P(P) that it is given,
and after a bit decide that this will be non-halting, abort that
simuation/debug session and return a 0.

Then we are back at the P(P) that was the input to the H that we are
testing and then that halts.

Thus we see when we ACTUAL look at the ACTUAL behavior of the input, it
goes to a Halt. H just gave up too soon.

>
> You keep specifying some other sequence of instructions somewhere else.

Nope, just the sequence of instructions that the input specify.

YOU look at it under the processing of the wrong sort of machine. The
definition says to look at it under direct execution or pure simulation.
Since an H that aborts its processing is neither, you can't look at it
for the right answer.

>
>> H(P,P) is supposed to say what P(P) will do.
>>
>> If H(P,P) returns 0, then P(P) will Halt. PERIOD.
>>
>> If P(P) Halts then H(P,P) returning 0 is WRONG.
>>
>> Your claim that H(P,P) returning 0 to be right is a LIE.
>>
>> You have just PROVED that you are a moron, because you refuse to do
>> things by the rules.
>>
>> You have doomed yourself to being a laughing stock of the logical
>> community.
>>
>>
>> Look at your quote:
>> Talent hits a target no one else can hit;
>> Genius hits a target no one else can see.
>> Arthur Schopenhauer
>>
>> What is the person that can only hit a target that doesn't exist, but
>> claims to have hit a target that isn't there.
>>
>> A LIAR and a FRAUD.
>>
>> That is you.
>
>

Re: Concise refutation of halting problem proofs V17 [ pathological self-reference precisely defined ]

<WCElJ.27013$cW6.21752@fx08.iad>

 copy mid

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

 copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!aioe.org!feeder1.feed.usenet.farm!feed.usenet.farm!peer01.ams4!peer.am4.highwinds-media.com!peer02.iad!feed-me.highwinds-media.com!news.highwinds-media.com!fx08.iad.POSTED!not-for-mail
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:91.0)
Gecko/20100101 Thunderbird/91.3.1
Subject: Re: Concise refutation of halting problem proofs V17 [ pathological
self-reference precisely defined ]
Content-Language: en-US
Newsgroups: comp.theory
References: <l8adnY-MOrqcMAj8nZ2dnUU7-Q3NnZ2d@giganews.com>
<OHilJ.3007$aF1.1686@fx98.iad>
<VtudnfP5Zt3RIQj8nZ2dnUU7-KfNnZ2d@giganews.com>
<kJjlJ.44440$OB3.5879@fx06.iad>
<5eqdnbJ9-8qzUAj8nZ2dnUU7-d_NnZ2d@giganews.com>
<pOqlJ.43485$3q9.38930@fx47.iad> <20211118130058.00004c6f@reddwarf.jmc>
<87sfvtmmir.fsf@bsb.me.uk> <ArGdnQc-APqaEQv8nZ2dnUU7-cnNnZ2d@giganews.com>
<sn67uo$bpb$1@dont-email.me> <It2dnZOFI4NQKQv8nZ2dnUU7-YvNnZ2d@giganews.com>
From: Rich...@Damon-Family.org (Richard Damon)
In-Reply-To: <It2dnZOFI4NQKQv8nZ2dnUU7-YvNnZ2d@giganews.com>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Lines: 137
Message-ID: <WCElJ.27013$cW6.21752@fx08.iad>
X-Complaints-To: abuse@easynews.com
Organization: Forte - www.forteinc.com
X-Complaints-Info: Please be sure to forward a copy of ALL headers otherwise we will be unable to process your complaint properly.
Date: Thu, 18 Nov 2021 22:12:55 -0500
X-Received-Bytes: 5599
 by: Richard Damon - Fri, 19 Nov 2021 03:12 UTC

On 11/18/21 3:17 PM, olcott wrote:
> On 11/18/2021 1:01 PM, André G. Isaak wrote:
>> On 2021-11-18 10:23, olcott wrote:
>>> On 11/18/2021 10:55 AM, Ben Bacarisse wrote:
>>>> Mr Flibble <flibble@reddwarf.jmc> writes:
>>>>
>>>>> On Thu, 18 Nov 2021 06:29:26 -0500
>>>>> Richard Damon <Richard@Damon-Family.org> wrote:
>>>>
>>>>>> H(P,P) is supposed to say what P(P) will do.
>>>>>
>>>>> No,
>>>>
>>>> So what arguments does one pass to H to find out is P(P) halts?
>>>
>>> This is the same code that you modified.
>>
>> ???
>>
>> How is that a response?
>>
>
> #include <stdint.h>
> typedef void (*ptr)();
>
> int H(ptr x, ptr y)
> {
>   x(y);  // direct execution of P(P)
>   return 1;
> }
>
> // Minimal essence of Linz(1990) Ĥ
> // and Strachey(1965) P
> int P(ptr x)
> {
>   H(x, x);
>   return 1;  // Give P a last instruction at the "c" level
> }
>
> int main(void)
> {
>   H(P, P);
> }
>
> We can see the arguments passed to H prove that P never reaches its last
> instruction.

Well, for an H that never answers 0, maybe, but that H isn't correct.

Change H to be one of the cases that does answer 0, which does cause P
to change, (since the computation P includes H as part of its code), and
we see that P(P) will now halt.

You just like to LIE that it doesn't.

>
>> We have a computation, P(P), which you acknowledge halts.
>>
>
> We have a precisely defined set of sequences of x86 instructions as
> combinations of H/P such that the relationship between H and P is always
> pathological self-reference:

Which include the call to H and all the code of H. PERIOD (Definition).

>
> For every possible H of H(P,P) invoked from main() where P(P) calls this
> same H(P,P) and H simulates or executes its input and aborts or does not
> abort its input P never reaches its last instruction.

Excpet that if H(P,P) aborts its procesing and returns 0 then THE INPUT
(when directly run) will halt. Only the processing inside H, WHICH IS
NOT THE INPUT, but the operation of the Machine H, doesn't get the that
halting state but kills its processing based on unsound logic and is
eternally doomed to be caught in its lie and ends up being wrong.

>
> P(P) is not in this set thus a strawman error when used as a rebuttal to
> the behavior of elements in the defined set.

But P(P) IS the input. You LIE when you say it is a strawman error. YOU
case is the strawman.

READ THE DEFINITIONS.

>
>> We also have H which you claim to be a halt decider.
>>
>
> I haven't gotten to that point yet, first I prove that the "impossible"
> input is decidable, then after this is accepted then I show the trivial
> step required for H to make this correct halt status decision.

Ok, yes, for an H that NEVER answers 0, then for those incorrect
deciders then H(P,P) == 0 would be correct, but there is no H that
returns it.

THat is like saying if X > X+1 then 4 > 5.

You can claim all sorts of insaine stuff as being true if a false
premise is the pre-condition, but I thought you objected to that form of
logic.

>
>> So let's say someone doesn't know whether P(P) halts. But they have
>> your halt decider H, and a halt decider should be able to answer this
>> question for them. That's what halt deciders are for, after all.
>>
>
> A simple bench check of the 21 lines of C code conclusively proves that
> P never reaches its final instruction.

H never reaches that point, but as stated, the DEFINITION of the
behavior of the input is givng that input to something that directly
exectutes it or performs a pure simulation of it, and THOSE do show that
it halts.

You are just looking in the wrong place for the truth.

>
> A more complex analysis proves that no element of the infinite
> pathological self-reference set of H/P does P ever reach its final
> instruction.

WRONG. You have only shown that H never sees a P that halts, but that is
just the answer to your POOP, not the halting problem.

>
>> So what input do they give to H so that H will correctly tell them
>> that P(P) halts?
>>
>> André
>>
>
>

Re: Concise refutation of halting problem proofs V17 [ pathological self-reference precisely defined ]

<WCElJ.18000$Vt1.933@fx09.iad>

 copy mid

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

 copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!aioe.org!feeder1.feed.usenet.farm!feed.usenet.farm!peer03.ams4!peer.am4.highwinds-media.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.3.1
Subject: Re: Concise refutation of halting problem proofs V17 [ pathological
self-reference precisely defined ]
Content-Language: en-US
Newsgroups: comp.theory
References: <l8adnY-MOrqcMAj8nZ2dnUU7-Q3NnZ2d@giganews.com>
<OHilJ.3007$aF1.1686@fx98.iad>
<VtudnfP5Zt3RIQj8nZ2dnUU7-KfNnZ2d@giganews.com>
<kJjlJ.44440$OB3.5879@fx06.iad>
<5eqdnbJ9-8qzUAj8nZ2dnUU7-d_NnZ2d@giganews.com>
<pOqlJ.43485$3q9.38930@fx47.iad> <20211118130058.00004c6f@reddwarf.jmc>
<87sfvtmmir.fsf@bsb.me.uk> <ArGdnQc-APqaEQv8nZ2dnUU7-cnNnZ2d@giganews.com>
<sn67uo$bpb$1@dont-email.me> <It2dnZOFI4NQKQv8nZ2dnUU7-YvNnZ2d@giganews.com>
From: Rich...@Damon-Family.org (Richard Damon)
In-Reply-To: <It2dnZOFI4NQKQv8nZ2dnUU7-YvNnZ2d@giganews.com>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Lines: 137
Message-ID: <WCElJ.18000$Vt1.933@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: Thu, 18 Nov 2021 22:12:55 -0500
X-Received-Bytes: 5597
 by: Richard Damon - Fri, 19 Nov 2021 03:12 UTC

On 11/18/21 3:17 PM, olcott wrote:
> On 11/18/2021 1:01 PM, André G. Isaak wrote:
>> On 2021-11-18 10:23, olcott wrote:
>>> On 11/18/2021 10:55 AM, Ben Bacarisse wrote:
>>>> Mr Flibble <flibble@reddwarf.jmc> writes:
>>>>
>>>>> On Thu, 18 Nov 2021 06:29:26 -0500
>>>>> Richard Damon <Richard@Damon-Family.org> wrote:
>>>>
>>>>>> H(P,P) is supposed to say what P(P) will do.
>>>>>
>>>>> No,
>>>>
>>>> So what arguments does one pass to H to find out is P(P) halts?
>>>
>>> This is the same code that you modified.
>>
>> ???
>>
>> How is that a response?
>>
>
> #include <stdint.h>
> typedef void (*ptr)();
>
> int H(ptr x, ptr y)
> {
>   x(y);  // direct execution of P(P)
>   return 1;
> }
>
> // Minimal essence of Linz(1990) Ĥ
> // and Strachey(1965) P
> int P(ptr x)
> {
>   H(x, x);
>   return 1;  // Give P a last instruction at the "c" level
> }
>
> int main(void)
> {
>   H(P, P);
> }
>
> We can see the arguments passed to H prove that P never reaches its last
> instruction.

Well, for an H that never answers 0, maybe, but that H isn't correct.

Change H to be one of the cases that does answer 0, which does cause P
to change, (since the computation P includes H as part of its code), and
we see that P(P) will now halt.

You just like to LIE that it doesn't.

>
>> We have a computation, P(P), which you acknowledge halts.
>>
>
> We have a precisely defined set of sequences of x86 instructions as
> combinations of H/P such that the relationship between H and P is always
> pathological self-reference:

Which include the call to H and all the code of H. PERIOD (Definition).

>
> For every possible H of H(P,P) invoked from main() where P(P) calls this
> same H(P,P) and H simulates or executes its input and aborts or does not
> abort its input P never reaches its last instruction.

Excpet that if H(P,P) aborts its procesing and returns 0 then THE INPUT
(when directly run) will halt. Only the processing inside H, WHICH IS
NOT THE INPUT, but the operation of the Machine H, doesn't get the that
halting state but kills its processing based on unsound logic and is
eternally doomed to be caught in its lie and ends up being wrong.

>
> P(P) is not in this set thus a strawman error when used as a rebuttal to
> the behavior of elements in the defined set.

But P(P) IS the input. You LIE when you say it is a strawman error. YOU
case is the strawman.

READ THE DEFINITIONS.

>
>> We also have H which you claim to be a halt decider.
>>
>
> I haven't gotten to that point yet, first I prove that the "impossible"
> input is decidable, then after this is accepted then I show the trivial
> step required for H to make this correct halt status decision.

Ok, yes, for an H that NEVER answers 0, then for those incorrect
deciders then H(P,P) == 0 would be correct, but there is no H that
returns it.

THat is like saying if X > X+1 then 4 > 5.

You can claim all sorts of insaine stuff as being true if a false
premise is the pre-condition, but I thought you objected to that form of
logic.

>
>> So let's say someone doesn't know whether P(P) halts. But they have
>> your halt decider H, and a halt decider should be able to answer this
>> question for them. That's what halt deciders are for, after all.
>>
>
> A simple bench check of the 21 lines of C code conclusively proves that
> P never reaches its final instruction.

H never reaches that point, but as stated, the DEFINITION of the
behavior of the input is givng that input to something that directly
exectutes it or performs a pure simulation of it, and THOSE do show that
it halts.

You are just looking in the wrong place for the truth.

>
> A more complex analysis proves that no element of the infinite
> pathological self-reference set of H/P does P ever reach its final
> instruction.

WRONG. You have only shown that H never sees a P that halts, but that is
just the answer to your POOP, not the halting problem.

>
>> So what input do they give to H so that H will correctly tell them
>> that P(P) halts?
>>
>> André
>>
>
>

Re: Concise refutation of halting problem proofs V17

<0KElJ.61958$Ql5.37375@fx39.iad>

 copy mid

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

 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!peer01.iad!feed-me.highwinds-media.com!news.highwinds-media.com!fx39.iad.POSTED!not-for-mail
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:91.0)
Gecko/20100101 Thunderbird/91.3.1
Subject: Re: Concise refutation of halting problem proofs V17
Content-Language: en-US
Newsgroups: comp.theory
References: <l8adnY-MOrqcMAj8nZ2dnUU7-Q3NnZ2d@giganews.com>
<OHilJ.3007$aF1.1686@fx98.iad>
<VtudnfP5Zt3RIQj8nZ2dnUU7-KfNnZ2d@giganews.com>
<kJjlJ.44440$OB3.5879@fx06.iad>
<5eqdnbJ9-8qzUAj8nZ2dnUU7-d_NnZ2d@giganews.com>
<pOqlJ.43485$3q9.38930@fx47.iad> <20211118130058.00004c6f@reddwarf.jmc>
<87sfvtmmir.fsf@bsb.me.uk> <20211118215729.00000978@reddwarf.jmc>
<878rxlksk2.fsf@bsb.me.uk> <g7KdnWFMhoqqQgv8nZ2dnUU7-TnNnZ2d@giganews.com>
From: Rich...@Damon-Family.org (Richard Damon)
In-Reply-To: <g7KdnWFMhoqqQgv8nZ2dnUU7-TnNnZ2d@giganews.com>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Lines: 77
Message-ID: <0KElJ.61958$Ql5.37375@fx39.iad>
X-Complaints-To: abuse@easynews.com
Organization: Forte - www.forteinc.com
X-Complaints-Info: Please be sure to forward a copy of ALL headers otherwise we will be unable to process your complaint properly.
Date: Thu, 18 Nov 2021 22:20:28 -0500
X-Received-Bytes: 4091
 by: Richard Damon - Fri, 19 Nov 2021 03:20 UTC

On 11/18/21 6:18 PM, olcott wrote:
> On 11/18/2021 4:27 PM, Ben Bacarisse wrote:
>> Mr Flibble <flibble@reddwarf.jmc> writes:
>>
>>> On Thu, 18 Nov 2021 16:55:24 +0000
>>> Ben Bacarisse <ben.usenet@bsb.me.uk> wrote:
>>>
>>>> Mr Flibble <flibble@reddwarf.jmc> writes:
>>>>
>>>>> On Thu, 18 Nov 2021 06:29:26 -0500
>>>>> Richard Damon <Richard@Damon-Family.org> wrote:
>>>>
>>>>>> H(P,P) is supposed to say what P(P) will do.
>>>>>
>>>>> No,
>>>>
>>>> So what arguments does one pass to H to find out is P(P) halts?  If
>>>> it's not P and P, what is it?  (Of course it is P and P, that's why
>>>> PO says that H(P,P) == 0 is correct /despite/ the fact that P(P)
>>>> halts.)
>>>
>>> Any P that doesn't reference H.
>>
>> Not an answer.  What arguments does one pass to H to find out if P(P) --
>> that's the P that has been posted numerous times -- halts?
>>
>
> Page(3) explains exactly how the set of pathological combinations of H/P
> are correctly decided as not halting:
>
> For every possible H of H(P,P) invoked from main() where P(P) calls this
> same H(P,P) and H simulates or executes its input and aborts or does not
> abort its input P never reaches its last instruction.

Which shows that H is a correct POOP decider, but not a correct Halt
decider, since a Halt decider needs to match the behavior of the direct
execution of that input, which is what happens if main calls P(P) and we
obsever the results.

The Direct execution of P(P) shows that if H(P,P) does return 0, then
P(P) will Halt, and thus H was wrong.

And every case where P(P) never halts also corresponds to Hs that never
return an answer for H(P,P) and thus H fails to even be a decider.

>
> Halt Decider (Olcott 2021) A halt decider accepts or rejects inputs on
> the basis of the actual behavior of the direct execution or simulation
> of these inputs.

Right, ACTUAL BEHAVIOR OF THE DIRECT EXECUTION OR SIMULATION OF THOSE
INPUTS.

That is having main call P(P) or calling a pure simulator(P,P).

When H returns an answer (your H3 or H4) then when we look at the
behavior of the P based on it, ie P3 or P3 we can see:

H1(P3,P3), H2(P3,P3), H1(P4,P4), H2(P4,P4) all will halt, the we see
that H3(P3,P3) and H4(P4,P4) both were WRONG to say non-halting.

You seem to like to use the like of looking at things like H3(P1,P1) to
say that H3 got the right answer, but the case that matters is H3(P3,P3)
which it gets wrong.

>
>
> My most recent paper
> Halting problem undecidability and infinitely nested simulation (V2)
> November 2021 PL Olcott
>
> https://www.researchgate.net/publication/356105750_Halting_problem_undecidability_and_infinitely_nested_simulation_V2
>
>

1
server_pubkey.txt

rocksolid light 0.9.7
clearnet tor