Rocksolid Light

Welcome to novaBBS (click a section below)

mail  files  register  newsreader  groups  login

Message-ID:  

Remember the good old days, when CPU was singular?

devel / comp.theory / Re: Here is what a computer scientist that has been published in CACM said about my work [competence?]

SubjectAuthor
* Here is what a computer scientist that has been published in CACMolcott
+* Here is what a computer scientist that has been published inMr Flibble
|`* Here is what a computer scientist that has been published in CACMolcott
| `* Here is what a computer scientist that has been published inMr Flibble
|  `* Here is what a computer scientist that has been published in CACMolcott
|   +* Here is what a computer scientist that has been published inMr Flibble
|   |`* Here is what a computer scientist that has been published in CACMolcott
|   | `* Here is what a computer scientist that has been published inMr Flibble
|   |  `* Here is what a computer scientist that has been published in CACMolcott
|   |   `- Here is what a computer scientist that has been published inMr Flibble
|   `* Here is what a computer scientist that has been published in CACMRichard Damon
|    `* Here is what a computer scientist that has been published in CACMolcott
|     `* Here is what a computer scientist that has been published in CACMRichard Damon
|      `* Here is what a computer scientist that has been published in CACMolcott
|       `* Here is what a computer scientist that has been published in CACMRichard Damon
|        `* Here is what a computer scientist that has been published in CACMolcott
|         `- Here is what a computer scientist that has been published in CACMRichard Damon
+* Here is what a computer scientist that has been published in CACMd thiebaud
|`* Here is what a computer scientist that has been published in CACMolcott
| +* Here is what a computer scientist that has been published inMr Flibble
| |`* Here is what a computer scientist that has been published in CACMolcott
| | `- Here is what a computer scientist that has been published in CACMRichard Damon
| `* Here is what a computer scientist that has been published in CACMSkep Dick
|  `- Here is what a computer scientist that has been published in CACMolcott
+* Here is what a computer scientist that has been published in CACMRichard Harnden
|`- Here is what a computer scientist that has been published in CACMolcott
`* Here is what a computer scientist that has been published inMr Flibble
 `* Here is what a computer scientist that has been published in CACMolcott
  `* Here is what a computer scientist that has been published inMr Flibble
   +* Here is what a computer scientist that has been published inolcott
   |`* Here is what a computer scientist that has been published in CACMRichard Damon
   | `* Here is what a computer scientist that has been published in CACMolcott
   |  `* Here is what a computer scientist that has been published in CACMRichard Damon
   |   `* Here is what a computer scientist that has been published in CACMolcott
   |    `* Here is what a computer scientist that has been published in CACMRichard Damon
   |     `* Here is what a computer scientist that has been published in CACMolcott
   |      `* Here is what a computer scientist that has been published in CACMRichard Damon
   |       `* Here is what a computer scientist that has been published in CACMolcott
   |        `* Here is what a computer scientist that has been published in CACMRichard Damon
   |         `* Here is what a computer scientist that has been published in CACMolcott
   |          `* Here is what a computer scientist that has been published in CACMRichard Damon
   |           `* Here is what a computer scientist that has been published in CACMolcott
   |            `* Here is what a computer scientist that has been published in CACMRichard Damon
   |             `* Here is what a computer scientist that has been published in CACMolcott
   |              `* Here is what a computer scientist that has been published in CACMRichard Damon
   |               `* Here is what a computer scientist that has been published in CACMolcott
   |                `* Here is what a computer scientist that has been published in CACMRichard Damon
   |                 `* Here is what a computer scientist that has been published in CACMolcott
   |                  `* Here is what a computer scientist that has been published in CACMRichard Damon
   |                   `* Here is what a computer scientist that has been published in CACMolcott
   |                    `* Here is what a computer scientist that has been published in CACMRichard Damon
   |                     `* Here is what a computer scientist that has been published in CACMolcott
   |                      `* Here is what a computer scientist that has been published in CACMRichard Damon
   |                       `* Here is what a computer scientist that has been published in CACMolcott
   |                        `* Here is what a computer scientist that has been published in CACMRichard Damon
   |                         +* Here is what a computer scientist that has been published in CACMolcott
   |                         |+- Here is what a computer scientist that has been published in CACMRichard Damon
   |                         |`* Here is what a computer scientist that has been published in CACMSkep Dick
   |                         | +- Here is what a computer scientist that has been published in CACMolcott
   |                         | `* Here is what a computer scientist that has been published in CACMSkep Dick
   |                         |  +* Here is what a computer scientist that has been published in CACMolcott
   |                         |  |`* Here is what a computer scientist that has been published in CACMRichard Damon
   |                         |  | +* Here is what a computer scientist that has been published in CACMolcott
   |                         |  | |`* Here is what a computer scientist that has been published in CACMRichard Damon
   |                         |  | | +* Here is what a computer scientist that has been published in CACMolcott
   |                         |  | | |`- Here is what a computer scientist that has been published in CACMRichard Damon
   |                         |  | | `* Here is what a computer scientist that has been published in CACMolcott
   |                         |  | |  +* Here is what a computer scientist that has been published in CACMDennis Bush
   |                         |  | |  |+- Here is what a computer scientist that has been published in CACMolcott
   |                         |  | |  |`* Here is what a computer scientist that has been published in CACMDennis Bush
   |                         |  | |  | +- Here is what a computer scientist that has been published in CACMolcott
   |                         |  | |  | `* Here is what a computer scientist that has been published in CACMDennis Bush
   |                         |  | |  |  +- Here is what a computer scientist that has been published in CACMolcott
   |                         |  | |  |  `* Here is what a computer scientist that has been published in CACMDennis Bush
   |                         |  | |  |   +- Here is what a computer scientist that has been published in CACMolcott
   |                         |  | |  |   `* Here is what a computer scientist that has been published in CACMDennis Bush
   |                         |  | |  |    +- Here is what a computer scientist that has been published in CACMolcott
   |                         |  | |  |    `* Here is what a computer scientist that has been published in CACMDennis Bush
   |                         |  | |  |     `* Here is what a computer scientist that has been published in CACM said about my olcott
   |                         |  | |  |      `* Here is what a computer scientist that has been published in CACMDennis Bush
   |                         |  | |  |       `* Here is what a computer scientist that has been published in CACM said about my olcott
   |                         |  | |  |        `* Here is what a computer scientist that has been published in CACMDennis Bush
   |                         |  | |  |         +- Here is what a computer scientist that has been published in CACMolcott
   |                         |  | |  |         `* Here is what a computer scientist that has been published in CACMDennis Bush
   |                         |  | |  |          +- Here is what a computer scientist that has been published in CACMolcott
   |                         |  | |  |          `* Here is what a computer scientist that has been published in CACMDennis Bush
   |                         |  | |  |           +- Here is what a computer scientist that has been published in CACM said about my olcott
   |                         |  | |  |           `* Here is what a computer scientist that has been published in CACMDennis Bush
   |                         |  | |  |            +* Here is what a computer scientist that has been published in CACMolcott
   |                         |  | |  |            |`* Here is what a computer scientist that has been published inMr Flibble
   |                         |  | |  |            | `* Here is what a computer scientist that has been published in CACMolcott
   |                         |  | |  |            |  `* Here is what a computer scientist that has been published inMr Flibble
   |                         |  | |  |            |   +- Here is what a computer scientist that has been published in CACMolcott
   |                         |  | |  |            |   `- Here is what a computer scientist that has been published inMr Flibble
   |                         |  | |  |            +* Here is what a computer scientist that has been published in CACMolcott
   |                         |  | |  |            |`* Here is what a computer scientist that has been published inMr Flibble
   |                         |  | |  |            | `* Here is what a computer scientist that has been published in CACMolcott
   |                         |  | |  |            |  `* Here is what a computer scientist that has been published inMr Flibble
   |                         |  | |  |            |   `* Here is what a computer scientist that has been published in CACMolcott
   |                         |  | |  |            |    `* Here is what a computer scientist that has been published inMr Flibble
   |                         |  | |  |            |     `* Here is what a computer scientist that has been published in CACMolcott
   |                         |  | |  |            +- Here is what a computer scientist that has been published in CACMDennis Bush
   |                         |  | |  |            `- Here is what a computer scientist that has been published in CACMDennis Bush
   |                         |  | |  `* Here is what a computer scientist that has been published in CACMRichard Damon
   |                         |  | `* Here is what a computer scientist that has been published in CACMdklei...@gmail.com
   |                         |  `* Here is what a computer scientist that has been published in CACMSkep Dick
   |                         `* Here is what a computer scientist that has been published in CACMolcott
   `- Here is what a computer scientist that has been published in CACMolcott

Pages:12345678910
Re: Here is what a computer scientist that has been published in CACM said about my work [competence?]

<LLednYl9W7ET12T_nZ2dnZfqlJzNnZ2d@giganews.com>

  copy mid

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

  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!border-1.nntp.ord.giganews.com!nntp.giganews.com!Xl.tags.giganews.com!local-2.nntp.ord.giganews.com!news.giganews.com.POSTED!not-for-mail
NNTP-Posting-Date: Sun, 14 Aug 2022 19:18:38 +0000
Date: Sun, 14 Aug 2022 14:18:53 -0500
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:91.0) Gecko/20100101
Thunderbird/91.12.0
Subject: Re: Here is what a computer scientist that has been published in CACM
said about my work [competence?]
Content-Language: en-US
Newsgroups: comp.theory
References: <VUmdneqWu_jdjGT_nZ2dnZfqlJ_NnZ2d@giganews.com>
<20220814201431.00002067@reddwarf.jmc.corp>
From: NoO...@NoWhere.com (olcott)
In-Reply-To: <20220814201431.00002067@reddwarf.jmc.corp>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 7bit
Message-ID: <LLednYl9W7ET12T_nZ2dnZfqlJzNnZ2d@giganews.com>
Lines: 59
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-12sM9m1wdz1t6dVnK/i2U22r0lsuW2r/HwPSdMbDCMpTaFEPSOEAqr5tz5rPycOyFAlyRav8PEkFU/b!QaPFBe1pVKw+L/5Q1mpOXa30wLfD7Wu4m6YKvx7HiJ3UO7p3smgL01W/FCIpm5o70mfgfp4976E=
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, 14 Aug 2022 19:18 UTC

On 8/14/2022 2:14 PM, Mr Flibble wrote:
> On Sun, 14 Aug 2022 10:14:28 -0500
> olcott <NoOne@NoWhere.com> wrote:
>
>> *This is refers to H(P,P)==0 where H and P are functions in C*
>>
>> I believe I have learned something valuable from you:
>> that by simulation, and by simulations within simulations,
>> non-halting can sometimes be detected, and in particular,
>> it can be detected in the program used in the classical
>> proof of incomputability.
>>
>> *Halting problem proofs refuted on the basis of software engineering*
>> ?
>>
>> https://www.researchgate.net/publication/361701808_Halting_problem_proofs_refuted_on_the_basis_of_software_engineering
>>
>
> I am also a computer scientist and I am telling you that your halting
> decider reporting non-halting when it enters "infinite recursion" is an
> ERROR. There is no infinite recursion in the HP proofs you are
> attempting to refute.
>
> /Flibble
>

void P(ptr x)
{ int Halt_Status = H(x, x);
if (Halt_Status)
HERE: goto HERE;
return;
}

int main()
{ Output("Input_Halts = ", H(P, P));
}

If it was true that you are a computer scientist then you would
understand that this execution trace is correct:

(a) H(P,P) simulates P(P) that calls a simulated H(P,P)
(b) that simulates P(P) that calls a simulated H(P,P)
(c) that simulates P(P) that calls a simulated H(P,P)
(d) that simulates P(P) that calls a simulated H(P,P)...
*Until H aborts its simulation*

If you do not understand that the above execution trace is correct then
this proves that you are not as much as a sufficiently competent
software engineer.

--
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: Here is what a computer scientist that has been published in CACM said about my work

<dFCdnduYPvKN0mT_nZ2dnZfqlJ_NnZ2d@giganews.com>

  copy mid

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

  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!border-1.nntp.ord.giganews.com!nntp.giganews.com!Xl.tags.giganews.com!local-2.nntp.ord.giganews.com!news.giganews.com.POSTED!not-for-mail
NNTP-Posting-Date: Sun, 14 Aug 2022 19:37:52 +0000
Date: Sun, 14 Aug 2022 14:38:12 -0500
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:91.0) Gecko/20100101
Thunderbird/91.12.0
Subject: Re: Here is what a computer scientist that has been published in CACM
said about my work
Content-Language: en-US
Newsgroups: comp.theory
References: <VUmdneqWu_jdjGT_nZ2dnZfqlJ_NnZ2d@giganews.com>
<20220814162208.000028a7@reddwarf.jmc.corp>
<Z9GdnfI_ou5kimT_nZ2dnZfqlJxh4p2d@giganews.com>
<20220814165151.0000563d@reddwarf.jmc.corp>
<vBmdne8a49KLuGT_nZ2dnZfqlJ_NnZ2d@giganews.com>
<MZaKK.714562$5fVf.88551@fx09.iad>
<iracneL3RfIQomT_nZ2dnZfqlJ_NnZ2d@giganews.com>
<GzbKK.672111$vAW9.112470@fx10.iad>
<O7-dndaszZ0r22T_nZ2dnZfqlJ9g4p2d@giganews.com>
<aKbKK.714565$5fVf.433277@fx09.iad>
From: NoO...@NoWhere.com (olcott)
In-Reply-To: <aKbKK.714565$5fVf.433277@fx09.iad>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Message-ID: <dFCdnduYPvKN0mT_nZ2dnZfqlJ_NnZ2d@giganews.com>
Lines: 124
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-zfHQF0c+n25w1aAVQy3xHCnoWVBrk33/FF4dR1YbZ87LMz5jswgE/9K5NgfB5wu3bR/eVYXrsSsWPBb!+3hJyTqC/Tt5PTsoERpAAJSDJ60FeD49rhnX38ZQ/fRtVHwYQKay3ZwlThUuxAzLjwrpFUTg6sw=
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, 14 Aug 2022 19:38 UTC

On 8/14/2022 2:07 PM, Richard Damon wrote:
> On 8/14/22 3:02 PM, olcott wrote:
>> On 8/14/2022 1:56 PM, Richard Damon wrote:
>>>
>>> On 8/14/22 2:32 PM, olcott wrote:
>>>> On 8/14/2022 1:16 PM, Richard Damon wrote:
>>>>> On 8/14/22 12:39 PM, olcott wrote:
>>>>>> On 8/14/2022 10:51 AM, Mr Flibble wrote:
>>>>>>> On Sun, 14 Aug 2022 10:43:04 -0500
>>>>>>> olcott <NoOne@NoWhere.com> wrote:
>>>>>>>
>>>>>>>> On 8/14/2022 10:22 AM, Mr Flibble wrote:
>>>>>>>>> On Sun, 14 Aug 2022 10:14:28 -0500
>>>>>>>>> olcott <NoOne@NoWhere.com> wrote:
>>>>>>>>>> *This is refers to H(P,P)==0 where H and P are functions in C*
>>>>>>>>>>
>>>>>>>>>>        I believe I have learned something valuable from you:
>>>>>>>>>>        that by simulation, and by simulations within simulations,
>>>>>>>>>>        non-halting can sometimes be detected, and in particular,
>>>>>>>>>>        it can be detected in the program used in the classical
>>>>>>>>>>        proof of incomputability.
>>>>>>>>>>
>>>>>>>>>> *Halting problem proofs refuted on the basis of software
>>>>>>>>>> engineering* ?
>>>>>>>>>>
>>>>>>>>>> https://www.researchgate.net/publication/361701808_Halting_problem_proofs_refuted_on_the_basis_of_software_engineering
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> I am also a computer scientist and I am telling you that your
>>>>>>>>> halting decider reporting non-halting when it enters "infinite
>>>>>>>>> recursion" is an ERROR.  There is no infinite recursion in the HP
>>>>>>>>> proofs you are attempting to refute.
>>>>>>>>>
>>>>>>>>> /Flibble
>>>>>>>>
>>>>>>>> Anyone (especially those that use fake names) can call themselves a
>>>>>>>> "computer scientist". To get published in CACM is a whole other
>>>>>>>> ballgame.
>>>>>>>>
>>>>>>>
>>>>>>> Using fake names on Usenet is quite common, dear.  Also,
>>>>>>> publishing to
>>>>>>> the CACM does not qualify you as a computer scientist.
>>>>>>>
>>>>>>> This computer scientists has pointed out the flaws in your
>>>>>>> "simulating
>>>>>>> halt decider" multiple times and you have yet to address those
>>>>>>> flaws,
>>>>>>> you simply copy/paste/edit the same old shit over and over and over
>>>>>>> again.
>>>>>>>
>>>>>>> /Flibble
>>>>>>>
>>>>>>
>>>>>> There are no flaws in the software engineering of my halt decider,
>>>>>> H(P,P) does correctly determine that its input specifies a
>>>>>> non-terminating sequence of instructions.
>>>>>>
>>>>>> All of the so-called "flaws" were only instances of the *straw
>>>>>> man* deception in that they referred to something besides the
>>>>>> actual behavior of the actual input as measured by the correct x86
>>>>>> emulation of the first argument to H(P,P) by H.
>>>>>>
>>>>>> *straw man*
>>>>>> An intentionally misrepresented proposition that is set up because
>>>>>> it is easier to defeat than an opponent's real argument.
>>>>>> https://www.lexico.com/en/definition/straw_man
>>>>>>
>>>>>>
>>>>>
>>>>> No, your proof is invalid first because it answers to a Strawman,
>>>>> and not the ACTUAL halting question,
>>>>
>>>> It <is> correct software engineering in that H(P,P) does correctly
>>>> determine that its correct x86 emulation of its first argument does
>>>> specify a non-halting sequence of instructions.
>>>
>>> Nope. First arguement represents a HALTING computation, because H is
>>> wrong about it.
>>>
>> "represents" is a weak relationship is not the same as "specifies".
>> The cross symbol "represents" Christ, it is not Christ himself.
>>
>
> RED HERRING.
>
>
> The first arguement also SPECIFED a HALTING COMPUTATION as it is exactly
> the algorithm of P which when applied to the input P will halt when run.
>
>
> You still show you don't know what "correct" means.

I have shown what correct means dozens of times.

The fact that the line-by-line execution trace of the simulation of P
exactly matches the x86 sour-code of P proves that this trace is correct.

The fact that the line-by-line execution trace of the simulation of P
exactly matches the x86 sour-code of P proves that this trace is correct.

The fact that the line-by-line execution trace of the simulation of P
exactly matches the x86 sour-code of P proves that this trace is correct.

The fact that the line-by-line execution trace of the simulation of P
exactly matches the x86 sour-code of P proves that this trace is correct.

The fact that the line-by-line execution trace of the simulation of P
exactly matches the x86 sour-code of P proves that this trace is correct.

The fact that the line-by-line execution trace of the simulation of P
exactly matches the x86 sour-code of P proves that this trace is correct.

I repeated it to halt your ADD mind will notice that I said it at least
once. This may take a few hundred more replies before your ADD mind
notices that I said it at least once.

--
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: Here is what a computer scientist that has been published in CACM said about my work

<bocKK.266895$vZ1.248152@fx04.iad>

  copy mid

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

  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!fx04.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.12.0
Subject: Re: Here is what a computer scientist that has been published in CACM
said about my work
Content-Language: en-US
Newsgroups: comp.theory
References: <VUmdneqWu_jdjGT_nZ2dnZfqlJ_NnZ2d@giganews.com>
<20220814162208.000028a7@reddwarf.jmc.corp>
<Z9GdnfI_ou5kimT_nZ2dnZfqlJxh4p2d@giganews.com>
<20220814165151.0000563d@reddwarf.jmc.corp>
<vBmdne8a49KLuGT_nZ2dnZfqlJ_NnZ2d@giganews.com>
<MZaKK.714562$5fVf.88551@fx09.iad>
<iracneL3RfIQomT_nZ2dnZfqlJ_NnZ2d@giganews.com>
<GzbKK.672111$vAW9.112470@fx10.iad>
<O7-dndaszZ0r22T_nZ2dnZfqlJ9g4p2d@giganews.com>
<aKbKK.714565$5fVf.433277@fx09.iad>
<dFCdnduYPvKN0mT_nZ2dnZfqlJ_NnZ2d@giganews.com>
From: Rich...@Damon-Family.org (Richard Damon)
In-Reply-To: <dFCdnduYPvKN0mT_nZ2dnZfqlJ_NnZ2d@giganews.com>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Lines: 131
Message-ID: <bocKK.266895$vZ1.248152@fx04.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, 14 Aug 2022 15:52:38 -0400
X-Received-Bytes: 6775
 by: Richard Damon - Sun, 14 Aug 2022 19:52 UTC

On 8/14/22 3:38 PM, olcott wrote:
> On 8/14/2022 2:07 PM, Richard Damon wrote:
>> On 8/14/22 3:02 PM, olcott wrote:
>>> On 8/14/2022 1:56 PM, Richard Damon wrote:
>>>>
>>>> On 8/14/22 2:32 PM, olcott wrote:
>>>>> On 8/14/2022 1:16 PM, Richard Damon wrote:
>>>>>> On 8/14/22 12:39 PM, olcott wrote:
>>>>>>> On 8/14/2022 10:51 AM, Mr Flibble wrote:
>>>>>>>> On Sun, 14 Aug 2022 10:43:04 -0500
>>>>>>>> olcott <NoOne@NoWhere.com> wrote:
>>>>>>>>
>>>>>>>>> On 8/14/2022 10:22 AM, Mr Flibble wrote:
>>>>>>>>>> On Sun, 14 Aug 2022 10:14:28 -0500
>>>>>>>>>> olcott <NoOne@NoWhere.com> wrote:
>>>>>>>>>>> *This is refers to H(P,P)==0 where H and P are functions in C*
>>>>>>>>>>>
>>>>>>>>>>>        I believe I have learned something valuable from you:
>>>>>>>>>>>        that by simulation, and by simulations within
>>>>>>>>>>> simulations,
>>>>>>>>>>>        non-halting can sometimes be detected, and in particular,
>>>>>>>>>>>        it can be detected in the program used in the classical
>>>>>>>>>>>        proof of incomputability.
>>>>>>>>>>>
>>>>>>>>>>> *Halting problem proofs refuted on the basis of software
>>>>>>>>>>> engineering* ?
>>>>>>>>>>>
>>>>>>>>>>> https://www.researchgate.net/publication/361701808_Halting_problem_proofs_refuted_on_the_basis_of_software_engineering
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> I am also a computer scientist and I am telling you that your
>>>>>>>>>> halting decider reporting non-halting when it enters "infinite
>>>>>>>>>> recursion" is an ERROR.  There is no infinite recursion in the HP
>>>>>>>>>> proofs you are attempting to refute.
>>>>>>>>>>
>>>>>>>>>> /Flibble
>>>>>>>>>
>>>>>>>>> Anyone (especially those that use fake names) can call
>>>>>>>>> themselves a
>>>>>>>>> "computer scientist". To get published in CACM is a whole other
>>>>>>>>> ballgame.
>>>>>>>>>
>>>>>>>>
>>>>>>>> Using fake names on Usenet is quite common, dear.  Also,
>>>>>>>> publishing to
>>>>>>>> the CACM does not qualify you as a computer scientist.
>>>>>>>>
>>>>>>>> This computer scientists has pointed out the flaws in your
>>>>>>>> "simulating
>>>>>>>> halt decider" multiple times and you have yet to address those
>>>>>>>> flaws,
>>>>>>>> you simply copy/paste/edit the same old shit over and over and over
>>>>>>>> again.
>>>>>>>>
>>>>>>>> /Flibble
>>>>>>>>
>>>>>>>
>>>>>>> There are no flaws in the software engineering of my halt
>>>>>>> decider, H(P,P) does correctly determine that its input specifies
>>>>>>> a non-terminating sequence of instructions.
>>>>>>>
>>>>>>> All of the so-called "flaws" were only instances of the *straw
>>>>>>> man* deception in that they referred to something besides the
>>>>>>> actual behavior of the actual input as measured by the correct
>>>>>>> x86 emulation of the first argument to H(P,P) by H.
>>>>>>>
>>>>>>> *straw man*
>>>>>>> An intentionally misrepresented proposition that is set up
>>>>>>> because it is easier to defeat than an opponent's real argument.
>>>>>>> https://www.lexico.com/en/definition/straw_man
>>>>>>>
>>>>>>>
>>>>>>
>>>>>> No, your proof is invalid first because it answers to a Strawman,
>>>>>> and not the ACTUAL halting question,
>>>>>
>>>>> It <is> correct software engineering in that H(P,P) does correctly
>>>>> determine that its correct x86 emulation of its first argument does
>>>>> specify a non-halting sequence of instructions.
>>>>
>>>> Nope. First arguement represents a HALTING computation, because H is
>>>> wrong about it.
>>>>
>>> "represents" is a weak relationship is not the same as "specifies".
>>> The cross symbol "represents" Christ, it is not Christ himself.
>>>
>>
>> RED HERRING.
>>
>>
>> The first arguement also SPECIFED a HALTING COMPUTATION as it is
>> exactly the algorithm of P which when applied to the input P will halt
>> when run.
>>
>>
>> You still show you don't know what "correct" means.
>
> I have shown what correct means dozens of times.
>
> The fact that the line-by-line execution trace of the simulation of P
> exactly matches the x86 sour-code of P proves that this trace is correct.
>
> The fact that the line-by-line execution trace of the simulation of P
> exactly matches the x86 sour-code of P proves that this trace is correct.
>
> The fact that the line-by-line execution trace of the simulation of P
> exactly matches the x86 sour-code of P proves that this trace is correct.
>
> The fact that the line-by-line execution trace of the simulation of P
> exactly matches the x86 sour-code of P proves that this trace is correct.
>
> The fact that the line-by-line execution trace of the simulation of P
> exactly matches the x86 sour-code of P proves that this trace is correct.
>
> The fact that the line-by-line execution trace of the simulation of P
> exactly matches the x86 sour-code of P proves that this trace is correct.
>
> I repeated it to halt your ADD mind will notice that I said it at least
> once. This may take a few hundred more replies before your ADD mind
> notices that I said it at least once.
>
>

Except that is DOESN'T, since the x86 code of P has a call to H that
returns a 0, while the simulation of that code show that H thinks that a
call to H will never return.

HOW IS THAT CORRECT?

Remember, the code of H is PART of the x86 code of P.

Re: Here is what a computer scientist that has been published in CACM said about my work [competence?]

<20220814205543.00006c29@reddwarf.jmc.corp>

  copy mid

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

  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.ams4!peer.am4.highwinds-media.com!news.highwinds-media.com!fx03.ams4.POSTED!not-for-mail
From: flib...@reddwarf.jmc.corp (Mr Flibble)
Newsgroups: comp.theory
Subject: Re: Here is what a computer scientist that has been published in
CACM said about my work [competence?]
Message-ID: <20220814205543.00006c29@reddwarf.jmc.corp>
References: <VUmdneqWu_jdjGT_nZ2dnZfqlJ_NnZ2d@giganews.com>
<20220814201431.00002067@reddwarf.jmc.corp>
<LLednYl9W7ET12T_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=US-ASCII
Content-Transfer-Encoding: 7bit
Lines: 67
X-Complaints-To: abuse@eweka.nl
NNTP-Posting-Date: Sun, 14 Aug 2022 19:55:44 UTC
Date: Sun, 14 Aug 2022 20:55:43 +0100
X-Received-Bytes: 3148
 by: Mr Flibble - Sun, 14 Aug 2022 19:55 UTC

On Sun, 14 Aug 2022 14:18:53 -0500
olcott <NoOne@NoWhere.com> wrote:

> On 8/14/2022 2:14 PM, Mr Flibble wrote:
> > On Sun, 14 Aug 2022 10:14:28 -0500
> > olcott <NoOne@NoWhere.com> wrote:
> >
> >> *This is refers to H(P,P)==0 where H and P are functions in C*
> >>
> >> I believe I have learned something valuable from you:
> >> that by simulation, and by simulations within simulations,
> >> non-halting can sometimes be detected, and in particular,
> >> it can be detected in the program used in the classical
> >> proof of incomputability.
> >>
> >> *Halting problem proofs refuted on the basis of software
> >> engineering* ?
> >>
> >> https://www.researchgate.net/publication/361701808_Halting_problem_proofs_refuted_on_the_basis_of_software_engineering
> >>
> >
> > I am also a computer scientist and I am telling you that your
> > halting decider reporting non-halting when it enters "infinite
> > recursion" is an ERROR. There is no infinite recursion in the HP
> > proofs you are attempting to refute.
> >
> > /Flibble
> >
>
>
> void P(ptr x)
> {
> int Halt_Status = H(x, x);
> if (Halt_Status)
> HERE: goto HERE;
> return;
> }
>
> int main()
> {
> Output("Input_Halts = ", H(P, P));
> }
>
> If it was true that you are a computer scientist then you would
> understand that this execution trace is correct:
>
> (a) H(P,P) simulates P(P) that calls a simulated H(P,P)
> (b) that simulates P(P) that calls a simulated H(P,P)
> (c) that simulates P(P) that calls a simulated H(P,P)
> (d) that simulates P(P) that calls a simulated H(P,P)...
> *Until H aborts its simulation*

I am a computer scientist and all your trace shows is that H (not P) is
at the root of your so called "infinite recursion" and is the primary
reason why you are incorrect to map this recursive behaviour of your H
to a halting decision on P of non-halting.

>
> If you do not understand that the above execution trace is correct
> then this proves that you are not as much as a sufficiently competent
> software engineer.

It seems I understand your trace more than you do which makes it
obvious who is actually lacking in competence here.

/Flibble

Re: Here is what a computer scientist that has been published in CACM said about my work [competence?]

<tdbqq3$1cg2$1@gioia.aioe.org>

  copy mid

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

  copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!aioe.org!ZMtbzDgZJuSNg5Em7lVs0g.user.46.165.242.91.POSTED!not-for-mail
From: polco...@gmail.com (olcott)
Newsgroups: comp.theory
Subject: Re: Here is what a computer scientist that has been published in
CACM said about my work [competence?]
Date: Sun, 14 Aug 2022 16:52:01 -0500 (CDT)
Organization: news.aioe.org
Message-ID: <tdbqq3$1cg2$1@gioia.aioe.org>
References: <VUmdneqWu_jdjGT_nZ2dnZfqlJ_NnZ2d@giganews.com> <20220814201431.00002067@reddwarf.jmc.corp> <LLednYl9W7ET12T_nZ2dnZfqlJzNnZ2d@giganews.com> <20220814205543.00006c29@reddwarf.jmc.corp>
Mime-Version: 1.0
Content-Type: text/plain; charset=ISO-8859-1
Content-Transfer-Encoding: 7bit
Injection-Info: gioia.aioe.org; logging-data="45570"; posting-host="ZMtbzDgZJuSNg5Em7lVs0g.user.gioia.aioe.org"; mail-complaints-to="abuse@aioe.org";
X-Notice: Filtered by postfilter v. 0.9.2
X-Newsreader: PiaoHong.Usenet.Client.Free:2.02
 by: olcott - Sun, 14 Aug 2022 21:52 UTC

Mr Flibble <flibble@reddwarf.jmc.corp> Wrote in message:r
> On Sun, 14 Aug 2022 14:18:53 -0500olcott <NoOne@NoWhere.com> wrote:> On 8/14/2022 2:14 PM, Mr Flibble wrote:> > On Sun, 14 Aug 2022 10:14:28 -0500> > olcott <NoOne@NoWhere.com> wrote:> > > >> *This is refers to H(P,P)==0 where H and P are functions in C*> >>> >> I believe I have learned something valuable from you:> >> that by simulation, and by simulations within simulations,> >> non-halting can sometimes be detected, and in particular,> >> it can be detected in the program used in the classical> >> proof of incomputability.> >>> >> *Halting problem proofs refuted on the basis of software> >> engineering* ?> >>> >> https://www.researchgate.net/publication/361701808_Halting_problem_proofs_refuted_on_the_basis_of_software_engineering> >> > > > > I am also a computer scientist and I am telling you that your> > halting decider reporting non-halting when it enters "infinite> > recursion" is an ERROR. There is no infinite recursion in the HP> > proofs you are attempting to refute.> > > > /Flibble> > > > > void P(ptr x)> {> int Halt_Status = H(x, x);> if (Halt_Status)> HERE: goto HERE;> return;> }> > int main()> {> Output("Input_Hal
ts = ", H(P, P));> }> > If it was true that you are a computer scientist then you would > understand that this execution trace is correct:> > (a) H(P,P) simulates P(P) that calls a simulated H(P,P)> (b) that simulates P(P) that calls a simulated H(P,P)> (c) that simulates P(P) that calls a simulated H(P,P)> (d) that simulates P(P) that calls a simulated H(P,P)...> *Until H aborts its simulation*I am a computer scientist and all your trace shows is that H (not P) isat the root of your so called "infinite recursion" and is the primaryreason why you are incorrect to map this recursive behaviour of your Hto a halting decision on P of non-halting.> > If you do not understand that the above execution trace is correct> then this proves that you are not as much as a sufficiently competent > software engineer.It seems I understand your trace more than you do which makes itobvious who is actually lacking in competence here./Flibble

Because H exactly simulates its input and has no control flow
behavior of it's own while it is simulating this input YOU ARE
BLAMING THE MIRROR FOR WHAT IT REFLECTS.

--
test

----Android NewsGroup Reader----
https://piaohong.s3-us-west-2.amazonaws.com/usenet/index.html

Re: Here is what a computer scientist that has been published in CACM said about my work [competence?]

<cveKK.768959$ssF.612517@fx14.iad>

  copy mid

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

  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!fx14.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.12.0
Subject: Re: Here is what a computer scientist that has been published in CACM
said about my work [competence?]
Content-Language: en-US
Newsgroups: comp.theory
References: <VUmdneqWu_jdjGT_nZ2dnZfqlJ_NnZ2d@giganews.com>
<20220814201431.00002067@reddwarf.jmc.corp>
<LLednYl9W7ET12T_nZ2dnZfqlJzNnZ2d@giganews.com>
<20220814205543.00006c29@reddwarf.jmc.corp> <tdbqq3$1cg2$1@gioia.aioe.org>
From: Rich...@Damon-Family.org (Richard Damon)
In-Reply-To: <tdbqq3$1cg2$1@gioia.aioe.org>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: base64
Lines: 49
Message-ID: <cveKK.768959$ssF.612517@fx14.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, 14 Aug 2022 18:16:40 -0400
X-Received-Bytes: 4630
 by: Richard Damon - Sun, 14 Aug 2022 22:16 UTC

On 8/14/22 5:52 PM, olcott wrote:
> Mr Flibble <flibble@reddwarf.jmc.corp> Wrote in message:r
>> On Sun, 14 Aug 2022 14:18:53 -0500olcott <NoOne@NoWhere.com> wrote:> On 8/14/2022 2:14 PM, Mr Flibble wrote:> > On Sun, 14 Aug 2022 10:14:28 -0500> > olcott <NoOne@NoWhere.com> wrote:> > > >> *This is refers to H(P,P)==0 where H and P are functions in C*> >>> >> I believe I have learned something valuable from you:> >> that by simulation, and by simulations within simulations,> >> non-halting can sometimes be detected, and in particular,> >> it can be detected in the program used in the classical> >> proof of incomputability.> >>> >> *Halting problem proofs refuted on the basis of software> >> engineering* ?> >>> >> https://www.researchgate.net/publication/361701808_Halting_problem_proofs_refuted_on_the_basis_of_software_engineering> >> > > > > I am also a computer scientist and I am telling you that your> > halting decider reporting non-halting when it enters "infinite> > recursion" is an ERROR. There is no infinite recursion in the HP> > proofs you are attempting to refute.> > > > /Flibble> > > > > void P(ptr x)> {> int Halt_Status = H(x, x);> if (Halt_Status)> HERE: goto HERE;> return;> }> > int main()> {> Output("Input_Halts = ", H(P, P));> }> > If it was true that you are a computer scientist then you would > understand that this execution trace is correct:> > (a) H(P,P) simulates P(P) that calls a simulated H(P,P)> (b) that simulates P(P) that calls a simulated H(P,P)> (c) that simulates P(P) that calls a simulated H(P,P)> (d) that simulates P(P) that calls a simulated H(P,P)...> *Until H aborts its simulation*I am a computer scientist and all your trace shows is that H (not P) isat the root of your so called "infinite recursion" and is the primaryreason why you are incorrect to map this recursive behaviour of your Hto a halting decision on P of non-halting.> > If you do not understand that the above execution trace is correct> then this proves that you are not as much as a sufficiently competent > software engineer.It seems I understand your trace more than you do which makes itobvious who is actually lacking in competence here./Flibble
>
> Because H exactly simulates its input and has no control flow
> behavior of it's own while it is simulating this input YOU ARE
> BLAMING THE MIRROR FOR WHAT IT REFLECTS.
>
>
H does have control low on its own, or it can't stop the simulationg to
give an answer.
So either you are a liar, or just badly confused about what you are saying.

Re: Here is what a computer scientist that has been published in CACM said about my work [competence?]

<2h-dnZQ8E7yD42T_nZ2dnZfqlJ9g4p2d@giganews.com>

  copy mid

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

  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!border-1.nntp.ord.giganews.com!nntp.giganews.com!Xl.tags.giganews.com!local-2.nntp.ord.giganews.com!news.giganews.com.POSTED!not-for-mail
NNTP-Posting-Date: Sun, 14 Aug 2022 22:58:38 +0000
Date: Sun, 14 Aug 2022 17:58:58 -0500
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:91.0) Gecko/20100101
Thunderbird/91.12.0
Subject: Re: Here is what a computer scientist that has been published in CACM
said about my work [competence?]
Content-Language: en-US
Newsgroups: comp.theory
References: <VUmdneqWu_jdjGT_nZ2dnZfqlJ_NnZ2d@giganews.com>
<20220814201431.00002067@reddwarf.jmc.corp>
<LLednYl9W7ET12T_nZ2dnZfqlJzNnZ2d@giganews.com>
<20220814205543.00006c29@reddwarf.jmc.corp> <tdbqq3$1cg2$1@gioia.aioe.org>
<cveKK.768959$ssF.612517@fx14.iad>
From: NoO...@NoWhere.com (olcott)
In-Reply-To: <cveKK.768959$ssF.612517@fx14.iad>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Message-ID: <2h-dnZQ8E7yD42T_nZ2dnZfqlJ9g4p2d@giganews.com>
Lines: 76
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-7Hh+0vrl2dUAtbP09liSbOj1V3TDM4S5a+mI8T7hV//IVarKG8Z9pXvV+zvVxg2U7/Ih3zL8HYx42PY!R86UajbO1Aauos3ft5c8xoJx5fO4ujygIUcQt4YOy7iYae/eJUJAIpPbxaBNuuVUhSvSJ+C85Uc=
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, 14 Aug 2022 22:58 UTC

On 8/14/2022 5:16 PM, Richard Damon wrote:
> On 8/14/22 5:52 PM, olcott wrote:
>> Mr Flibble <flibble@reddwarf.jmc.corp> Wrote in message:r
>>> On Sun, 14 Aug 2022 14:18:53 -0500olcott <NoOne@NoWhere.com> wrote:>
>>> On 8/14/2022 2:14 PM, Mr Flibble wrote:> > On Sun, 14 Aug 2022
>>> 10:14:28 -0500> > olcott <NoOne@NoWhere.com> wrote:> >   > >> *This
>>> is refers to H(P,P)==0 where H and P are functions in C*> >>>
>>> >>       I believe I have learned something valuable from you:>
>>> >>       that by simulation, and by simulations within simulations,>
>>> >>       non-halting can sometimes be detected, and in particular,>
>>> >>       it can be detected in the program used in the classical>
>>> >>       proof of incomputability.> >>> >> *Halting problem proofs
>>> refuted on the basis of software> >> engineering* ?> >>> >>
>>> https://www.researchgate.net/publication/361701808_Halting_problem_proofs_refuted_on_the_basis_of_software_engineering>
>>> >>  > > > > I am also a computer scientist and I am telling you that
>>> your> > halting decider reporting non-halting when it enters
>>> "infinite> > recursion" is an ERROR.  There is no infinite recursion
>>> in the HP> > proofs you are attempting to refute.> > > > /Flibble>
>>> >   > > > void P(ptr x)> {>    int Halt_Status = H(x, x);>    if
>>> (Halt_Status)>      HERE: goto HERE;>    return;> }> > int main()>
>>> {>    Output("Input_Halts = ", H(P, P));> }> > If it was true that
>>> you are a computer scientist then you would > understand that this
>>> execution trace is correct:> > (a) H(P,P) simulates P(P) that calls a
>>> simulated H(P,P)> (b) that simulates P(P) that calls a simulated
>>> H(P,P)> (c) that simulates P(P) that calls a simulated H(P,P)> (d)
>>> that simulates P(P) that calls a simulated H(P,P)...> *Until H aborts
>>> its simulation*I am a computer scientist and all your trace shows is
>>> that H (not P) isat the root of your so called "infinite recursion"
>>> and is the primaryreason why you are incorrect to map this recursive
>>> behaviour of your Hto a halting decision on P of non-halting.> > If
>>> you do not understand that the above execution trace is correct> then
>>> this proves that you are not as much as a sufficiently competent >
>>> software engineer.It seems I understand your trace more than you do
>>> which makes itobvious who is actually lacking in competence
>>> here./Flibble
>>
>> Because H exactly simulates its input and has no control flow
>>   behavior of it's own while it is simulating this input YOU ARE
>>   BLAMING THE MIRROR FOR WHAT IT REFLECTS.
>>
>>
>
> H does have control low on its own, or it can't stop the simulationg to
> give an answer.
>

Because H exactly simulates its input and has no control flow
behavior of it's own
while it is simulating this input
while it is simulating this input
while it is simulating this input
while it is simulating this input
while it is simulating this input
while it is simulating this input
while it is simulating this input
while it is simulating this input
while it is simulating this input
while it is simulating this input
while it is simulating this input
while it is simulating this input
while it is simulating this input
while it is simulating this input
YOU ARE BLAMING THE MIRROR FOR WHAT IT REFLECTS.

> So either you are a liar, or just badly confused about what you are saying.

Or you OCD prevents you from paying close enough attention to ALL of my
words.

--
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: Here is what a computer scientist that has been published in CACM said about my work [competence?]

<SzfKK.916573$JVi.396684@fx17.iad>

  copy mid

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

  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!fx17.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.12.0
Subject: Re: Here is what a computer scientist that has been published in CACM
said about my work [competence?]
Content-Language: en-US
Newsgroups: comp.theory
References: <VUmdneqWu_jdjGT_nZ2dnZfqlJ_NnZ2d@giganews.com>
<20220814201431.00002067@reddwarf.jmc.corp>
<LLednYl9W7ET12T_nZ2dnZfqlJzNnZ2d@giganews.com>
<20220814205543.00006c29@reddwarf.jmc.corp> <tdbqq3$1cg2$1@gioia.aioe.org>
<cveKK.768959$ssF.612517@fx14.iad>
<2h-dnZQ8E7yD42T_nZ2dnZfqlJ9g4p2d@giganews.com>
From: Rich...@Damon-Family.org (Richard Damon)
In-Reply-To: <2h-dnZQ8E7yD42T_nZ2dnZfqlJ9g4p2d@giganews.com>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Lines: 93
Message-ID: <SzfKK.916573$JVi.396684@fx17.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, 14 Aug 2022 19:29:54 -0400
X-Received-Bytes: 5576
 by: Richard Damon - Sun, 14 Aug 2022 23:29 UTC

On 8/14/22 6:58 PM, olcott wrote:
> On 8/14/2022 5:16 PM, Richard Damon wrote:
>> On 8/14/22 5:52 PM, olcott wrote:
>>> Mr Flibble <flibble@reddwarf.jmc.corp> Wrote in message:r
>>>> On Sun, 14 Aug 2022 14:18:53 -0500olcott <NoOne@NoWhere.com> wrote:>
>>>> On 8/14/2022 2:14 PM, Mr Flibble wrote:> > On Sun, 14 Aug 2022
>>>> 10:14:28 -0500> > olcott <NoOne@NoWhere.com> wrote:> >   > >> *This
>>>> is refers to H(P,P)==0 where H and P are functions in C*> >>>
>>>> >>       I believe I have learned something valuable from you:>
>>>> >>       that by simulation, and by simulations within simulations,>
>>>> >>       non-halting can sometimes be detected, and in particular,>
>>>> >>       it can be detected in the program used in the classical>
>>>> >>       proof of incomputability.> >>> >> *Halting problem proofs
>>>> refuted on the basis of software> >> engineering* ?> >>> >>
>>>> https://www.researchgate.net/publication/361701808_Halting_problem_proofs_refuted_on_the_basis_of_software_engineering>
>>>> >>  > > > > I am also a computer scientist and I am telling you that
>>>> your> > halting decider reporting non-halting when it enters
>>>> "infinite> > recursion" is an ERROR.  There is no infinite recursion
>>>> in the HP> > proofs you are attempting to refute.> > > > /Flibble>
>>>> >   > > > void P(ptr x)> {>    int Halt_Status = H(x, x);>    if
>>>> (Halt_Status)>      HERE: goto HERE;>    return;> }> > int main()>
>>>> {>    Output("Input_Halts = ", H(P, P));> }> > If it was true that
>>>> you are a computer scientist then you would > understand that this
>>>> execution trace is correct:> > (a) H(P,P) simulates P(P) that calls
>>>> a simulated H(P,P)> (b) that simulates P(P) that calls a simulated
>>>> H(P,P)> (c) that simulates P(P) that calls a simulated H(P,P)> (d)
>>>> that simulates P(P) that calls a simulated H(P,P)...> *Until H
>>>> aborts its simulation*I am a computer scientist and all your trace
>>>> shows is that H (not P) isat the root of your so called "infinite
>>>> recursion" and is the primaryreason why you are incorrect to map
>>>> this recursive behaviour of your Hto a halting decision on P of
>>>> non-halting.> > If you do not understand that the above execution
>>>> trace is correct> then this proves that you are not as much as a
>>>> sufficiently competent > software engineer.It seems I understand
>>>> your trace more than you do which makes itobvious who is actually
>>>> lacking in competence here./Flibble
>>>
>>> Because H exactly simulates its input and has no control flow
>>>   behavior of it's own while it is simulating this input YOU ARE
>>>   BLAMING THE MIRROR FOR WHAT IT REFLECTS.
>>>
>>>
>>
>> H does have control low on its own, or it can't stop the simulationg
>> to give an answer.
>>
>
> Because H exactly simulates its input and has no control flow
> behavior of it's own
> while it is simulating this input
> while it is simulating this input
> while it is simulating this input
> while it is simulating this input
> while it is simulating this input
> while it is simulating this input
> while it is simulating this input
> while it is simulating this input
> while it is simulating this input
> while it is simulating this input
> while it is simulating this input
> while it is simulating this input
> while it is simulating this input
> while it is simulating this input
> YOU ARE BLAMING THE MIRROR FOR WHAT IT REFLECTS.
>
>> So either you are a liar, or just badly confused about what you are
>> saying.
>
> Or you OCD prevents you from paying close enough attention to ALL of my
> words.
>
>

Then how does it decide to stop simulating if it has no control flow
before it stops?

I don't think you understand the meaning of control flow.

After each instruction it simulates, it makes a DECISION about whether
to abort or not.

THAT IS CONTROL FLOW.

Unless you have invented a Tardas, and it goes back in time to change
the path, it made a decision before the simulation was aborted, because
it had to DECIDE to abort its simulation.

You H did execute conditional instructions during its act of simulating,
and a change in that condition is what stopped the simulation.

You are either a very bad liar or a total idiot.

Re: Here is what a computer scientist that has been published in CACM said about my work [competence?]

<MLOcnbPjLuakG2T_nZ2dnZfqlJ9g4p2d@giganews.com>

  copy mid

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

  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, 14 Aug 2022 23:33:13 +0000
Date: Sun, 14 Aug 2022 18:33:33 -0500
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:91.0) Gecko/20100101
Thunderbird/91.12.0
Subject: Re: Here is what a computer scientist that has been published in CACM
said about my work [competence?]
Content-Language: en-US
Newsgroups: comp.theory
References: <VUmdneqWu_jdjGT_nZ2dnZfqlJ_NnZ2d@giganews.com>
<20220814201431.00002067@reddwarf.jmc.corp>
<LLednYl9W7ET12T_nZ2dnZfqlJzNnZ2d@giganews.com>
<20220814205543.00006c29@reddwarf.jmc.corp> <tdbqq3$1cg2$1@gioia.aioe.org>
<cveKK.768959$ssF.612517@fx14.iad>
<2h-dnZQ8E7yD42T_nZ2dnZfqlJ9g4p2d@giganews.com>
<SzfKK.916573$JVi.396684@fx17.iad>
From: NoO...@NoWhere.com (olcott)
In-Reply-To: <SzfKK.916573$JVi.396684@fx17.iad>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Message-ID: <MLOcnbPjLuakG2T_nZ2dnZfqlJ9g4p2d@giganews.com>
Lines: 90
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-90ybzO/odw2vZhLKrHnuvRYCUYiMBwrKqsGzErKfajaUx16m3lHagsJ9ZLUYnGSpsVg7eR+6va/KrdK!8uWCBd0CktuWvz/2VgnOR7kQAyygCLBxlOCjpZR+VJgZrP0SPs6RtDEzAYyyM0XFqcZIKS6OHcU=
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, 14 Aug 2022 23:33 UTC

On 8/14/2022 6:29 PM, Richard Damon wrote:
> On 8/14/22 6:58 PM, olcott wrote:
>> On 8/14/2022 5:16 PM, Richard Damon wrote:
>>> On 8/14/22 5:52 PM, olcott wrote:
>>>> Mr Flibble <flibble@reddwarf.jmc.corp> Wrote in message:r
>>>>> On Sun, 14 Aug 2022 14:18:53 -0500olcott <NoOne@NoWhere.com>
>>>>> wrote:> On 8/14/2022 2:14 PM, Mr Flibble wrote:> > On Sun, 14 Aug
>>>>> 2022 10:14:28 -0500> > olcott <NoOne@NoWhere.com> wrote:> >   > >>
>>>>> *This is refers to H(P,P)==0 where H and P are functions in C*> >>>
>>>>> >>       I believe I have learned something valuable from you:>
>>>>> >>       that by simulation, and by simulations within
>>>>> simulations,> >>       non-halting can sometimes be detected, and
>>>>> in particular,> >>       it can be detected in the program used in
>>>>> the classical> >>       proof of incomputability.> >>> >> *Halting
>>>>> problem proofs refuted on the basis of software> >> engineering* ?>
>>>>> >>> >>
>>>>> https://www.researchgate.net/publication/361701808_Halting_problem_proofs_refuted_on_the_basis_of_software_engineering>
>>>>> >>  > > > > I am also a computer scientist and I am telling you
>>>>> that your> > halting decider reporting non-halting when it enters
>>>>> "infinite> > recursion" is an ERROR.  There is no infinite
>>>>> recursion in the HP> > proofs you are attempting to refute.> > > >
>>>>> /Flibble> >   > > > void P(ptr x)> {>    int Halt_Status = H(x,
>>>>> x);>    if (Halt_Status)>      HERE: goto HERE;>    return;> }> >
>>>>> int main()> {>    Output("Input_Halts = ", H(P, P));> }> > If it
>>>>> was true that you are a computer scientist then you would >
>>>>> understand that this execution trace is correct:> > (a) H(P,P)
>>>>> simulates P(P) that calls a simulated H(P,P)> (b) that simulates
>>>>> P(P) that calls a simulated H(P,P)> (c) that simulates P(P) that
>>>>> calls a simulated H(P,P)> (d) that simulates P(P) that calls a
>>>>> simulated H(P,P)...> *Until H aborts its simulation*I am a computer
>>>>> scientist and all your trace shows is that H (not P) isat the root
>>>>> of your so called "infinite recursion" and is the primaryreason why
>>>>> you are incorrect to map this recursive behaviour of your Hto a
>>>>> halting decision on P of non-halting.> > If you do not understand
>>>>> that the above execution trace is correct> then this proves that
>>>>> you are not as much as a sufficiently competent > software
>>>>> engineer.It seems I understand your trace more than you do which
>>>>> makes itobvious who is actually lacking in competence here./Flibble
>>>>
>>>> Because H exactly simulates its input and has no control flow
>>>>   behavior of it's own while it is simulating this input YOU ARE
>>>>   BLAMING THE MIRROR FOR WHAT IT REFLECTS.
>>>>
>>>>
>>>
>>> H does have control low on its own, or it can't stop the simulationg
>>> to give an answer.
>>>
>>
>> Because H exactly simulates its input and has no control flow
>> behavior of it's own
>> while it is simulating this input
>> while it is simulating this input
>> while it is simulating this input
>> while it is simulating this input
>> while it is simulating this input
>> while it is simulating this input
>> while it is simulating this input
>> while it is simulating this input
>> while it is simulating this input
>> while it is simulating this input
>> while it is simulating this input
>> while it is simulating this input
>> while it is simulating this input
>> while it is simulating this input
>> YOU ARE BLAMING THE MIRROR FOR WHAT IT REFLECTS.
>>
>>> So either you are a liar, or just badly confused about what you are
>>> saying.
>>
>> Or you OCD prevents you from paying close enough attention to ALL of
>> my words.
>>
>>
>
> Then how does it decide to stop simulating if it has no control flow
> before it stops?
>

H does not have any effect on the behavior of its simulated P the whole
time that H is simulating P, thus any recursive behavior that P
demonstrates is behavior of P and not behavior of H.

--
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: Here is what a computer scientist that has been published in CACM said about my work [competence?]

<UqgKK.136200$Me2.116425@fx47.iad>

  copy mid

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

  copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!usenet.blueworldhosting.com!feed1.usenet.blueworldhosting.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.12.0
Subject: Re: Here is what a computer scientist that has been published in CACM
said about my work [competence?]
Content-Language: en-US
Newsgroups: comp.theory
References: <VUmdneqWu_jdjGT_nZ2dnZfqlJ_NnZ2d@giganews.com>
<20220814201431.00002067@reddwarf.jmc.corp>
<LLednYl9W7ET12T_nZ2dnZfqlJzNnZ2d@giganews.com>
<20220814205543.00006c29@reddwarf.jmc.corp> <tdbqq3$1cg2$1@gioia.aioe.org>
<cveKK.768959$ssF.612517@fx14.iad>
<2h-dnZQ8E7yD42T_nZ2dnZfqlJ9g4p2d@giganews.com>
<SzfKK.916573$JVi.396684@fx17.iad>
<MLOcnbPjLuakG2T_nZ2dnZfqlJ9g4p2d@giganews.com>
From: Rich...@Damon-Family.org (Richard Damon)
In-Reply-To: <MLOcnbPjLuakG2T_nZ2dnZfqlJ9g4p2d@giganews.com>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Lines: 120
Message-ID: <UqgKK.136200$Me2.116425@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: Sun, 14 Aug 2022 20:28:36 -0400
X-Received-Bytes: 6933
 by: Richard Damon - Mon, 15 Aug 2022 00:28 UTC

On 8/14/22 7:33 PM, olcott wrote:
> On 8/14/2022 6:29 PM, Richard Damon wrote:
>> On 8/14/22 6:58 PM, olcott wrote:
>>> On 8/14/2022 5:16 PM, Richard Damon wrote:
>>>> On 8/14/22 5:52 PM, olcott wrote:
>>>>> Mr Flibble <flibble@reddwarf.jmc.corp> Wrote in message:r
>>>>>> On Sun, 14 Aug 2022 14:18:53 -0500olcott <NoOne@NoWhere.com>
>>>>>> wrote:> On 8/14/2022 2:14 PM, Mr Flibble wrote:> > On Sun, 14 Aug
>>>>>> 2022 10:14:28 -0500> > olcott <NoOne@NoWhere.com> wrote:> >   > >>
>>>>>> *This is refers to H(P,P)==0 where H and P are functions in C*>
>>>>>> >>> >>       I believe I have learned something valuable from
>>>>>> you:> >>       that by simulation, and by simulations within
>>>>>> simulations,> >>       non-halting can sometimes be detected, and
>>>>>> in particular,> >>       it can be detected in the program used in
>>>>>> the classical> >>       proof of incomputability.> >>> >> *Halting
>>>>>> problem proofs refuted on the basis of software> >> engineering*
>>>>>> ?> >>> >>
>>>>>> https://www.researchgate.net/publication/361701808_Halting_problem_proofs_refuted_on_the_basis_of_software_engineering>
>>>>>> >>  > > > > I am also a computer scientist and I am telling you
>>>>>> that your> > halting decider reporting non-halting when it enters
>>>>>> "infinite> > recursion" is an ERROR.  There is no infinite
>>>>>> recursion in the HP> > proofs you are attempting to refute.> > > >
>>>>>> /Flibble> >   > > > void P(ptr x)> {>    int Halt_Status = H(x,
>>>>>> x);>    if (Halt_Status)>      HERE: goto HERE;>    return;> }> >
>>>>>> int main()> {>    Output("Input_Halts = ", H(P, P));> }> > If it
>>>>>> was true that you are a computer scientist then you would >
>>>>>> understand that this execution trace is correct:> > (a) H(P,P)
>>>>>> simulates P(P) that calls a simulated H(P,P)> (b) that simulates
>>>>>> P(P) that calls a simulated H(P,P)> (c) that simulates P(P) that
>>>>>> calls a simulated H(P,P)> (d) that simulates P(P) that calls a
>>>>>> simulated H(P,P)...> *Until H aborts its simulation*I am a
>>>>>> computer scientist and all your trace shows is that H (not P) isat
>>>>>> the root of your so called "infinite recursion" and is the
>>>>>> primaryreason why you are incorrect to map this recursive
>>>>>> behaviour of your Hto a halting decision on P of non-halting.> >
>>>>>> If you do not understand that the above execution trace is
>>>>>> correct> then this proves that you are not as much as a
>>>>>> sufficiently competent > software engineer.It seems I understand
>>>>>> your trace more than you do which makes itobvious who is actually
>>>>>> lacking in competence here./Flibble
>>>>>
>>>>> Because H exactly simulates its input and has no control flow
>>>>>   behavior of it's own while it is simulating this input YOU ARE
>>>>>   BLAMING THE MIRROR FOR WHAT IT REFLECTS.
>>>>>
>>>>>
>>>>
>>>> H does have control low on its own, or it can't stop the simulationg
>>>> to give an answer.
>>>>
>>>
>>> Because H exactly simulates its input and has no control flow
>>> behavior of it's own
>>> while it is simulating this input
>>> while it is simulating this input
>>> while it is simulating this input
>>> while it is simulating this input
>>> while it is simulating this input
>>> while it is simulating this input
>>> while it is simulating this input
>>> while it is simulating this input
>>> while it is simulating this input
>>> while it is simulating this input
>>> while it is simulating this input
>>> while it is simulating this input
>>> while it is simulating this input
>>> while it is simulating this input
>>> YOU ARE BLAMING THE MIRROR FOR WHAT IT REFLECTS.
>>>
>>>> So either you are a liar, or just badly confused about what you are
>>>> saying.
>>>
>>> Or you OCD prevents you from paying close enough attention to ALL of
>>> my words.
>>>
>>>
>>
>> Then how does it decide to stop simulating if it has no control flow
>> before it stops?
>>
>
> H does not have any effect on the behavior of its simulated P the whole
> time that H is simulating P, thus any recursive behavior that P
> demonstrates is behavior of P and not behavior of H.
>
>

Nope, the problem is in H, not P.

This H by its actions might not affect the behavior of the input it is
simulating, but it doesn't correctly determine the effect that the copy
of H in P will have. Since H is a program, that behavior has been FIXED
and IMMUTABLE, and the behavior of your code is to abort its simulation,
and thus P doesn't get into infinite recusion. H just doesn't figure
that out, because it uses unsound logic.

YOU USE UNSOUND LOGIC.

Note, you answer doesn't answer the question, as the question is about
the affect that H has on the P that calls it, not the P that it is
simulating.

After all, that is what the questions about conditionals in H was about,
how does it affect the P(P) that calls it, and does it break the
otherwise infinite simulation loop. Since the simulated P(P) calls a
H(P,P) that will have conditionals in it, you can't just assume that
this H will just blindly get into the infinite loop that doesn't
actually happen.

You are just proving that you don't understand what you are talking
about and just trying to parrot words you have heard to try to make a point.

You are wrong.

It has been proven.

The fact that H(P,P) returns 0 means that the P(P) that H(P,P) needs to
decide on will be hatling, so H is wrong.

All you are doing is digging a deep grave for your ideas.

Re: Here is what a computer scientist that has been published in CACM said about my work [competence?]

<6UednePy0-E1CmT_nZ2dnZfqlJ_NnZ2d@giganews.com>

  copy mid

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

  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: Mon, 15 Aug 2022 00:47:36 +0000
Date: Sun, 14 Aug 2022 19:47:55 -0500
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:91.0) Gecko/20100101
Thunderbird/91.12.0
Subject: Re: Here is what a computer scientist that has been published in CACM
said about my work [competence?]
Content-Language: en-US
Newsgroups: comp.theory
References: <VUmdneqWu_jdjGT_nZ2dnZfqlJ_NnZ2d@giganews.com>
<20220814201431.00002067@reddwarf.jmc.corp>
<LLednYl9W7ET12T_nZ2dnZfqlJzNnZ2d@giganews.com>
<20220814205543.00006c29@reddwarf.jmc.corp>
From: NoO...@NoWhere.com (olcott)
In-Reply-To: <20220814205543.00006c29@reddwarf.jmc.corp>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 7bit
Message-ID: <6UednePy0-E1CmT_nZ2dnZfqlJ_NnZ2d@giganews.com>
Lines: 84
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-VxtJ3MN10mWfL+o8yJwq84KlzM4Gw7Ov8CK0siWVNRyj+E/ukcrY/fGOtGFqI5UJtfh5uoARqTn7pdc!0oaFSJQvIA+3voOTSRoPxS4ENlWdfYLvSz5i/xYWp3g2/ux982K+oODhsCTWxsijRzhDFWet4RU=
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 - Mon, 15 Aug 2022 00:47 UTC

On 8/14/2022 2:55 PM, Mr Flibble wrote:
> On Sun, 14 Aug 2022 14:18:53 -0500
> olcott <NoOne@NoWhere.com> wrote:
>
>> On 8/14/2022 2:14 PM, Mr Flibble wrote:
>>> On Sun, 14 Aug 2022 10:14:28 -0500
>>> olcott <NoOne@NoWhere.com> wrote:
>>>
>>>> *This is refers to H(P,P)==0 where H and P are functions in C*
>>>>
>>>> I believe I have learned something valuable from you:
>>>> that by simulation, and by simulations within simulations,
>>>> non-halting can sometimes be detected, and in particular,
>>>> it can be detected in the program used in the classical
>>>> proof of incomputability.
>>>>
>>>> *Halting problem proofs refuted on the basis of software
>>>> engineering* ?
>>>>
>>>> https://www.researchgate.net/publication/361701808_Halting_problem_proofs_refuted_on_the_basis_of_software_engineering
>>>>
>>>
>>> I am also a computer scientist and I am telling you that your
>>> halting decider reporting non-halting when it enters "infinite
>>> recursion" is an ERROR. There is no infinite recursion in the HP
>>> proofs you are attempting to refute.
>>>
>>> /Flibble
>>>
>>
>>
>> void P(ptr x)
>> {
>> int Halt_Status = H(x, x);
>> if (Halt_Status)
>> HERE: goto HERE;
>> return;
>> }
>>
>> int main()
>> {
>> Output("Input_Halts = ", H(P, P));
>> }
>>
>> If it was true that you are a computer scientist then you would
>> understand that this execution trace is correct:
>>
>> (a) H(P,P) simulates P(P) that calls a simulated H(P,P)
>> (b) that simulates P(P) that calls a simulated H(P,P)
>> (c) that simulates P(P) that calls a simulated H(P,P)
>> (d) that simulates P(P) that calls a simulated H(P,P)...
>> *Until H aborts its simulation*
>
> I am a computer scientist and all your trace shows is that H (not P) is
> at the root of your so called "infinite recursion"

How can this possibly be when H merely simulates its input and has no
effect what-so-ever on the behavior of this input while it is simulating
this input?

The simulation by H of its input only mirrors the behavior of whatever
this input specifies.

Example 02:
H correctly determines that Infinite_Recursion() never halts

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

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

--
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: Here is what a computer scientist that has been published in CACM said about my work [competence?]

<_KucnbJJWuzxAWT_nZ2dnZfqlJ_NnZ2d@giganews.com>

  copy mid

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

  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: Mon, 15 Aug 2022 01:07:56 +0000
Date: Sun, 14 Aug 2022 20:08:16 -0500
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:91.0) Gecko/20100101
Thunderbird/91.12.0
Subject: Re: Here is what a computer scientist that has been published in CACM
said about my work [competence?]
Content-Language: en-US
Newsgroups: comp.theory
References: <VUmdneqWu_jdjGT_nZ2dnZfqlJ_NnZ2d@giganews.com>
<20220814201431.00002067@reddwarf.jmc.corp>
<LLednYl9W7ET12T_nZ2dnZfqlJzNnZ2d@giganews.com>
<20220814205543.00006c29@reddwarf.jmc.corp> <tdbqq3$1cg2$1@gioia.aioe.org>
<cveKK.768959$ssF.612517@fx14.iad>
<2h-dnZQ8E7yD42T_nZ2dnZfqlJ9g4p2d@giganews.com>
<SzfKK.916573$JVi.396684@fx17.iad>
<MLOcnbPjLuakG2T_nZ2dnZfqlJ9g4p2d@giganews.com>
<UqgKK.136200$Me2.116425@fx47.iad>
From: NoO...@NoWhere.com (olcott)
In-Reply-To: <UqgKK.136200$Me2.116425@fx47.iad>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Message-ID: <_KucnbJJWuzxAWT_nZ2dnZfqlJ_NnZ2d@giganews.com>
Lines: 123
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-XCpSzYjUexMLGI2eE+W2KuXgHQ2hPHM5O6UXztCiHPdJ6dOPuIU2DJI0B2sjP7+KDySQ/ESY2XCjk6D!YEE4jxQzzEZOqNcCpyVE+dQn18iPoROuMcSRGBN984jEPAyk3WlEIYrXF1W7IoYQIP+AJUtvwXk=
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 - Mon, 15 Aug 2022 01:08 UTC

On 8/14/2022 7:28 PM, Richard Damon wrote:
> On 8/14/22 7:33 PM, olcott wrote:
>> On 8/14/2022 6:29 PM, Richard Damon wrote:
>>> On 8/14/22 6:58 PM, olcott wrote:
>>>> On 8/14/2022 5:16 PM, Richard Damon wrote:
>>>>> On 8/14/22 5:52 PM, olcott wrote:
>>>>>> Mr Flibble <flibble@reddwarf.jmc.corp> Wrote in message:r
>>>>>>> On Sun, 14 Aug 2022 14:18:53 -0500olcott <NoOne@NoWhere.com>
>>>>>>> wrote:> On 8/14/2022 2:14 PM, Mr Flibble wrote:> > On Sun, 14 Aug
>>>>>>> 2022 10:14:28 -0500> > olcott <NoOne@NoWhere.com> wrote:> >   >
>>>>>>> >> *This is refers to H(P,P)==0 where H and P are functions in
>>>>>>> C*> >>> >>       I believe I have learned something valuable from
>>>>>>> you:> >>       that by simulation, and by simulations within
>>>>>>> simulations,> >>       non-halting can sometimes be detected, and
>>>>>>> in particular,> >>       it can be detected in the program used
>>>>>>> in the classical> >>       proof of incomputability.> >>> >>
>>>>>>> *Halting problem proofs refuted on the basis of software> >>
>>>>>>> engineering* ?> >>> >>
>>>>>>> https://www.researchgate.net/publication/361701808_Halting_problem_proofs_refuted_on_the_basis_of_software_engineering>
>>>>>>> >>  > > > > I am also a computer scientist and I am telling you
>>>>>>> that your> > halting decider reporting non-halting when it enters
>>>>>>> "infinite> > recursion" is an ERROR.  There is no infinite
>>>>>>> recursion in the HP> > proofs you are attempting to refute.> > >
>>>>>>> > /Flibble> >   > > > void P(ptr x)> {>    int Halt_Status = H(x,
>>>>>>> x);>    if (Halt_Status)>      HERE: goto HERE;>    return;> }> >
>>>>>>> int main()> {>    Output("Input_Halts = ", H(P, P));> }> > If it
>>>>>>> was true that you are a computer scientist then you would >
>>>>>>> understand that this execution trace is correct:> > (a) H(P,P)
>>>>>>> simulates P(P) that calls a simulated H(P,P)> (b) that simulates
>>>>>>> P(P) that calls a simulated H(P,P)> (c) that simulates P(P) that
>>>>>>> calls a simulated H(P,P)> (d) that simulates P(P) that calls a
>>>>>>> simulated H(P,P)...> *Until H aborts its simulation*I am a
>>>>>>> computer scientist and all your trace shows is that H (not P)
>>>>>>> isat the root of your so called "infinite recursion" and is the
>>>>>>> primaryreason why you are incorrect to map this recursive
>>>>>>> behaviour of your Hto a halting decision on P of non-halting.> >
>>>>>>> If you do not understand that the above execution trace is
>>>>>>> correct> then this proves that you are not as much as a
>>>>>>> sufficiently competent > software engineer.It seems I understand
>>>>>>> your trace more than you do which makes itobvious who is actually
>>>>>>> lacking in competence here./Flibble
>>>>>>
>>>>>> Because H exactly simulates its input and has no control flow
>>>>>>   behavior of it's own while it is simulating this input YOU ARE
>>>>>>   BLAMING THE MIRROR FOR WHAT IT REFLECTS.
>>>>>>
>>>>>>
>>>>>
>>>>> H does have control low on its own, or it can't stop the
>>>>> simulationg to give an answer.
>>>>>
>>>>
>>>> Because H exactly simulates its input and has no control flow
>>>> behavior of it's own
>>>> while it is simulating this input
>>>> while it is simulating this input
>>>> while it is simulating this input
>>>> while it is simulating this input
>>>> while it is simulating this input
>>>> while it is simulating this input
>>>> while it is simulating this input
>>>> while it is simulating this input
>>>> while it is simulating this input
>>>> while it is simulating this input
>>>> while it is simulating this input
>>>> while it is simulating this input
>>>> while it is simulating this input
>>>> while it is simulating this input
>>>> YOU ARE BLAMING THE MIRROR FOR WHAT IT REFLECTS.
>>>>
>>>>> So either you are a liar, or just badly confused about what you are
>>>>> saying.
>>>>
>>>> Or you OCD prevents you from paying close enough attention to ALL of
>>>> my words.
>>>>
>>>>
>>>
>>> Then how does it decide to stop simulating if it has no control flow
>>> before it stops?
>>>
>>
>> H does not have any effect on the behavior of its simulated P the
>> whole time that H is simulating P, thus any recursive behavior that P
>> demonstrates is behavior of P and not behavior of H.
>>
>>
>
> Nope, the problem is in H, not P.
>
> This H by its actions might not affect the behavior of the input it is
> simulating, but it doesn't correctly determine the effect that the copy
> of H in P will have.

void P(ptr x)
{ int Halt_Status = H(x, x);
if (Halt_Status)
HERE: goto HERE;
return;
}

int main()
{ Output("Input_Halts = ", H(P, P));
}

So you disagree with this:

(a) H(P,P) simulates P(P) that calls a simulated H(P,P)
(b) that simulates P(P) that calls a simulated H(P,P)
(c) that simulates P(P) that calls a simulated H(P,P)
(d) that simulates P(P) that calls a simulated H(P,P)...
*Until H aborts its simulation*

--
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: Here is what a computer scientist that has been published in CACM said about my work [competence?]

<HkhKK.793605$wIO9.479008@fx12.iad>

  copy mid

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

  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!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.12.0
Subject: Re: Here is what a computer scientist that has been published in CACM
said about my work [competence?]
Content-Language: en-US
Newsgroups: comp.theory
References: <VUmdneqWu_jdjGT_nZ2dnZfqlJ_NnZ2d@giganews.com>
<20220814201431.00002067@reddwarf.jmc.corp>
<LLednYl9W7ET12T_nZ2dnZfqlJzNnZ2d@giganews.com>
<20220814205543.00006c29@reddwarf.jmc.corp> <tdbqq3$1cg2$1@gioia.aioe.org>
<cveKK.768959$ssF.612517@fx14.iad>
<2h-dnZQ8E7yD42T_nZ2dnZfqlJ9g4p2d@giganews.com>
<SzfKK.916573$JVi.396684@fx17.iad>
<MLOcnbPjLuakG2T_nZ2dnZfqlJ9g4p2d@giganews.com>
<UqgKK.136200$Me2.116425@fx47.iad>
<_KucnbJJWuzxAWT_nZ2dnZfqlJ_NnZ2d@giganews.com>
From: Rich...@Damon-Family.org (Richard Damon)
In-Reply-To: <_KucnbJJWuzxAWT_nZ2dnZfqlJ_NnZ2d@giganews.com>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Lines: 144
Message-ID: <HkhKK.793605$wIO9.479008@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: Sun, 14 Aug 2022 21:30:14 -0400
X-Received-Bytes: 7680
 by: Richard Damon - Mon, 15 Aug 2022 01:30 UTC

On 8/14/22 9:08 PM, olcott wrote:
> On 8/14/2022 7:28 PM, Richard Damon wrote:
>> On 8/14/22 7:33 PM, olcott wrote:
>>> On 8/14/2022 6:29 PM, Richard Damon wrote:
>>>> On 8/14/22 6:58 PM, olcott wrote:
>>>>> On 8/14/2022 5:16 PM, Richard Damon wrote:
>>>>>> On 8/14/22 5:52 PM, olcott wrote:
>>>>>>> Mr Flibble <flibble@reddwarf.jmc.corp> Wrote in message:r
>>>>>>>> On Sun, 14 Aug 2022 14:18:53 -0500olcott <NoOne@NoWhere.com>
>>>>>>>> wrote:> On 8/14/2022 2:14 PM, Mr Flibble wrote:> > On Sun, 14
>>>>>>>> Aug 2022 10:14:28 -0500> > olcott <NoOne@NoWhere.com> wrote:>
>>>>>>>> >   > >> *This is refers to H(P,P)==0 where H and P are
>>>>>>>> functions in C*> >>> >>       I believe I have learned something
>>>>>>>> valuable from you:> >>       that by simulation, and by
>>>>>>>> simulations within simulations,> >>       non-halting can
>>>>>>>> sometimes be detected, and in particular,> >>       it can be
>>>>>>>> detected in the program used in the classical> >>       proof of
>>>>>>>> incomputability.> >>> >> *Halting problem proofs refuted on the
>>>>>>>> basis of software> >> engineering* ?> >>> >>
>>>>>>>> https://www.researchgate.net/publication/361701808_Halting_problem_proofs_refuted_on_the_basis_of_software_engineering>
>>>>>>>> >>  > > > > I am also a computer scientist and I am telling you
>>>>>>>> that your> > halting decider reporting non-halting when it
>>>>>>>> enters "infinite> > recursion" is an ERROR.  There is no
>>>>>>>> infinite recursion in the HP> > proofs you are attempting to
>>>>>>>> refute.> > > > /Flibble> >   > > > void P(ptr x)> {>    int
>>>>>>>> Halt_Status = H(x, x);>    if (Halt_Status)>      HERE: goto
>>>>>>>> HERE;>    return;> }> > int main()> {>    Output("Input_Halts =
>>>>>>>> ", H(P, P));> }> > If it was true that you are a computer
>>>>>>>> scientist then you would > understand that this execution trace
>>>>>>>> is correct:> > (a) H(P,P) simulates P(P) that calls a simulated
>>>>>>>> H(P,P)> (b) that simulates P(P) that calls a simulated H(P,P)>
>>>>>>>> (c) that simulates P(P) that calls a simulated H(P,P)> (d) that
>>>>>>>> simulates P(P) that calls a simulated H(P,P)...> *Until H aborts
>>>>>>>> its simulation*I am a computer scientist and all your trace
>>>>>>>> shows is that H (not P) isat the root of your so called
>>>>>>>> "infinite recursion" and is the primaryreason why you are
>>>>>>>> incorrect to map this recursive behaviour of your Hto a halting
>>>>>>>> decision on P of non-halting.> > If you do not understand that
>>>>>>>> the above execution trace is correct> then this proves that you
>>>>>>>> are not as much as a sufficiently competent > software
>>>>>>>> engineer.It seems I understand your trace more than you do which
>>>>>>>> makes itobvious who is actually lacking in competence here./Flibble
>>>>>>>
>>>>>>> Because H exactly simulates its input and has no control flow
>>>>>>>   behavior of it's own while it is simulating this input YOU ARE
>>>>>>>   BLAMING THE MIRROR FOR WHAT IT REFLECTS.
>>>>>>>
>>>>>>>
>>>>>>
>>>>>> H does have control low on its own, or it can't stop the
>>>>>> simulationg to give an answer.
>>>>>>
>>>>>
>>>>> Because H exactly simulates its input and has no control flow
>>>>> behavior of it's own
>>>>> while it is simulating this input
>>>>> while it is simulating this input
>>>>> while it is simulating this input
>>>>> while it is simulating this input
>>>>> while it is simulating this input
>>>>> while it is simulating this input
>>>>> while it is simulating this input
>>>>> while it is simulating this input
>>>>> while it is simulating this input
>>>>> while it is simulating this input
>>>>> while it is simulating this input
>>>>> while it is simulating this input
>>>>> while it is simulating this input
>>>>> while it is simulating this input
>>>>> YOU ARE BLAMING THE MIRROR FOR WHAT IT REFLECTS.
>>>>>
>>>>>> So either you are a liar, or just badly confused about what you
>>>>>> are saying.
>>>>>
>>>>> Or you OCD prevents you from paying close enough attention to ALL
>>>>> of my words.
>>>>>
>>>>>
>>>>
>>>> Then how does it decide to stop simulating if it has no control flow
>>>> before it stops?
>>>>
>>>
>>> H does not have any effect on the behavior of its simulated P the
>>> whole time that H is simulating P, thus any recursive behavior that P
>>> demonstrates is behavior of P and not behavior of H.
>>>
>>>
>>
>> Nope, the problem is in H, not P.
>>
>> This H by its actions might not affect the behavior of the input it is
>> simulating, but it doesn't correctly determine the effect that the
>> copy of H in P will have.
>
> void P(ptr x)
> {
>   int Halt_Status = H(x, x);
>   if (Halt_Status)
>     HERE: goto HERE;
>   return;
> }
>
> int main()
> {
>   Output("Input_Halts = ", H(P, P));
> }
>
> So you disagree with this:
>
> (a) H(P,P) simulates P(P) that calls a simulated H(P,P)
> (b) that simulates P(P) that calls a simulated H(P,P)
> (c) that simulates P(P) that calls a simulated H(P,P)
> (d) that simulates P(P) that calls a simulated H(P,P)...
> *Until H aborts its simulation*
>
>
>

That isn't what your H does, and it answers the wrong question.

Your H just does (a) and the aborts its simulation brcause it THINKS
that a proper simulation of the input would never halt (but it does)

The problem is that BECAUSE H aborts its simulation and returns 0 the
CORRECT and COMPLETE simulation of the input would reach its final state.

You biggest problem is that you are starting from a wrong definition of
the problem.

H(M,x) {or in this case H(P,P)} needs to answer about the behavior that
you say it can't be asked, that of M(x), but that behavior IS the
behavior of the input if H claims to be a Halting decider.

Yes, we can refrase that question to asking about what UTM(M,x) or
UTM(P,P) does, which get around the representation issue you have.

UTM(P,P) Hslts if H(P,P) returns 0, so that isn't a correct response.

Note, the input to UTM(P,P) is EXACTLY the same input as the input to
H(P,P) so your arguement about "non-inputs" don't apply, as the behavior
IS of the input.

Re: Here is what a computer scientist that has been published in CACM said about my work [competence?]

<PuidnRegb5XZOWT_nZ2dnZfqlJxh4p2d@giganews.com>

  copy mid

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

  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: Mon, 15 Aug 2022 01:41:24 +0000
Date: Sun, 14 Aug 2022 20:41:38 -0500
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:91.0) Gecko/20100101
Thunderbird/91.12.0
Subject: Re: Here is what a computer scientist that has been published in CACM
said about my work [competence?]
Content-Language: en-US
Newsgroups: comp.theory
References: <VUmdneqWu_jdjGT_nZ2dnZfqlJ_NnZ2d@giganews.com>
<20220814201431.00002067@reddwarf.jmc.corp>
<LLednYl9W7ET12T_nZ2dnZfqlJzNnZ2d@giganews.com>
<20220814205543.00006c29@reddwarf.jmc.corp> <tdbqq3$1cg2$1@gioia.aioe.org>
<cveKK.768959$ssF.612517@fx14.iad>
<2h-dnZQ8E7yD42T_nZ2dnZfqlJ9g4p2d@giganews.com>
<SzfKK.916573$JVi.396684@fx17.iad>
<MLOcnbPjLuakG2T_nZ2dnZfqlJ9g4p2d@giganews.com>
<UqgKK.136200$Me2.116425@fx47.iad>
<_KucnbJJWuzxAWT_nZ2dnZfqlJ_NnZ2d@giganews.com>
<HkhKK.793605$wIO9.479008@fx12.iad>
From: NoO...@NoWhere.com (olcott)
In-Reply-To: <HkhKK.793605$wIO9.479008@fx12.iad>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Message-ID: <PuidnRegb5XZOWT_nZ2dnZfqlJxh4p2d@giganews.com>
Lines: 140
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-PcYfAwqyRfHud8a+UHV9eTsbvPspUo2u+MlrzG2MXzJ/HupbY/K1w4QQI6y20735hpUk/G5Zrq/KRif!VGCchfYsBpDe6IN0teGUoHIcrWraFepEgBYsuSmYxKJZxWfm/EJGW075jmNt0xLAnLAocR6Qf3I=
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 - Mon, 15 Aug 2022 01:41 UTC

On 8/14/2022 8:30 PM, Richard Damon wrote:
> On 8/14/22 9:08 PM, olcott wrote:
>> On 8/14/2022 7:28 PM, Richard Damon wrote:
>>> On 8/14/22 7:33 PM, olcott wrote:
>>>> On 8/14/2022 6:29 PM, Richard Damon wrote:
>>>>> On 8/14/22 6:58 PM, olcott wrote:
>>>>>> On 8/14/2022 5:16 PM, Richard Damon wrote:
>>>>>>> On 8/14/22 5:52 PM, olcott wrote:
>>>>>>>> Mr Flibble <flibble@reddwarf.jmc.corp> Wrote in message:r
>>>>>>>>> On Sun, 14 Aug 2022 14:18:53 -0500olcott <NoOne@NoWhere.com>
>>>>>>>>> wrote:> On 8/14/2022 2:14 PM, Mr Flibble wrote:> > On Sun, 14
>>>>>>>>> Aug 2022 10:14:28 -0500> > olcott <NoOne@NoWhere.com> wrote:>
>>>>>>>>> >   > >> *This is refers to H(P,P)==0 where H and P are
>>>>>>>>> functions in C*> >>> >>       I believe I have learned
>>>>>>>>> something valuable from you:> >>       that by simulation, and
>>>>>>>>> by simulations within simulations,> >>       non-halting can
>>>>>>>>> sometimes be detected, and in particular,> >>       it can be
>>>>>>>>> detected in the program used in the classical> >>       proof
>>>>>>>>> of incomputability.> >>> >> *Halting problem proofs refuted on
>>>>>>>>> the basis of software> >> engineering* ?> >>> >>
>>>>>>>>> https://www.researchgate.net/publication/361701808_Halting_problem_proofs_refuted_on_the_basis_of_software_engineering>
>>>>>>>>> >>  > > > > I am also a computer scientist and I am telling you
>>>>>>>>> that your> > halting decider reporting non-halting when it
>>>>>>>>> enters "infinite> > recursion" is an ERROR.  There is no
>>>>>>>>> infinite recursion in the HP> > proofs you are attempting to
>>>>>>>>> refute.> > > > /Flibble> >   > > > void P(ptr x)> {>    int
>>>>>>>>> Halt_Status = H(x, x);>    if (Halt_Status)>      HERE: goto
>>>>>>>>> HERE;>    return;> }> > int main()> {>    Output("Input_Halts =
>>>>>>>>> ", H(P, P));> }> > If it was true that you are a computer
>>>>>>>>> scientist then you would > understand that this execution trace
>>>>>>>>> is correct:> > (a) H(P,P) simulates P(P) that calls a simulated
>>>>>>>>> H(P,P)> (b) that simulates P(P) that calls a simulated H(P,P)>
>>>>>>>>> (c) that simulates P(P) that calls a simulated H(P,P)> (d) that
>>>>>>>>> simulates P(P) that calls a simulated H(P,P)...> *Until H
>>>>>>>>> aborts its simulation*I am a computer scientist and all your
>>>>>>>>> trace shows is that H (not P) isat the root of your so called
>>>>>>>>> "infinite recursion" and is the primaryreason why you are
>>>>>>>>> incorrect to map this recursive behaviour of your Hto a halting
>>>>>>>>> decision on P of non-halting.> > If you do not understand that
>>>>>>>>> the above execution trace is correct> then this proves that you
>>>>>>>>> are not as much as a sufficiently competent > software
>>>>>>>>> engineer.It seems I understand your trace more than you do
>>>>>>>>> which makes itobvious who is actually lacking in competence
>>>>>>>>> here./Flibble
>>>>>>>>
>>>>>>>> Because H exactly simulates its input and has no control flow
>>>>>>>>   behavior of it's own while it is simulating this input YOU ARE
>>>>>>>>   BLAMING THE MIRROR FOR WHAT IT REFLECTS.
>>>>>>>>
>>>>>>>>
>>>>>>>
>>>>>>> H does have control low on its own, or it can't stop the
>>>>>>> simulationg to give an answer.
>>>>>>>
>>>>>>
>>>>>> Because H exactly simulates its input and has no control flow
>>>>>> behavior of it's own
>>>>>> while it is simulating this input
>>>>>> while it is simulating this input
>>>>>> while it is simulating this input
>>>>>> while it is simulating this input
>>>>>> while it is simulating this input
>>>>>> while it is simulating this input
>>>>>> while it is simulating this input
>>>>>> while it is simulating this input
>>>>>> while it is simulating this input
>>>>>> while it is simulating this input
>>>>>> while it is simulating this input
>>>>>> while it is simulating this input
>>>>>> while it is simulating this input
>>>>>> while it is simulating this input
>>>>>> YOU ARE BLAMING THE MIRROR FOR WHAT IT REFLECTS.
>>>>>>
>>>>>>> So either you are a liar, or just badly confused about what you
>>>>>>> are saying.
>>>>>>
>>>>>> Or you OCD prevents you from paying close enough attention to ALL
>>>>>> of my words.
>>>>>>
>>>>>>
>>>>>
>>>>> Then how does it decide to stop simulating if it has no control
>>>>> flow before it stops?
>>>>>
>>>>
>>>> H does not have any effect on the behavior of its simulated P the
>>>> whole time that H is simulating P, thus any recursive behavior that
>>>> P demonstrates is behavior of P and not behavior of H.
>>>>
>>>>
>>>
>>> Nope, the problem is in H, not P.
>>>
>>> This H by its actions might not affect the behavior of the input it
>>> is simulating, but it doesn't correctly determine the effect that the
>>> copy of H in P will have.
>>
>> void P(ptr x)
>> {
>>    int Halt_Status = H(x, x);
>>    if (Halt_Status)
>>      HERE: goto HERE;
>>    return;
>> }
>>
>> int main()
>> {
>>    Output("Input_Halts = ", H(P, P));
>> }
>>
>> So you disagree with this:
>>
>> (a) H(P,P) simulates P(P) that calls a simulated H(P,P)
>> (b) that simulates P(P) that calls a simulated H(P,P)
>> (c) that simulates P(P) that calls a simulated H(P,P)
>> (d) that simulates P(P) that calls a simulated H(P,P)...
>> *Until H aborts its simulation*
>>
>>
>>
>
> That isn't what your H does,

Why do you say that isn't what my H does when you know that it is what
my H does and you can verify this with the complete system?

https://www.liarparadox.org/2022_07_22.zip
This is the complete system that compiles under:

Microsoft Visual Studio Community 2017
https://visualstudio.microsoft.com/vs/older-downloads/

--
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: Here is what a computer scientist that has been published in CACM said about my work [competence?]

<OFhKK.730625$5fVf.417433@fx09.iad>

  copy mid

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

  copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!usenet.blueworldhosting.com!feed1.usenet.blueworldhosting.com!peer01.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.12.0
Subject: Re: Here is what a computer scientist that has been published in CACM
said about my work [competence?]
Content-Language: en-US
Newsgroups: comp.theory
References: <VUmdneqWu_jdjGT_nZ2dnZfqlJ_NnZ2d@giganews.com>
<20220814201431.00002067@reddwarf.jmc.corp>
<LLednYl9W7ET12T_nZ2dnZfqlJzNnZ2d@giganews.com>
<20220814205543.00006c29@reddwarf.jmc.corp> <tdbqq3$1cg2$1@gioia.aioe.org>
<cveKK.768959$ssF.612517@fx14.iad>
<2h-dnZQ8E7yD42T_nZ2dnZfqlJ9g4p2d@giganews.com>
<SzfKK.916573$JVi.396684@fx17.iad>
<MLOcnbPjLuakG2T_nZ2dnZfqlJ9g4p2d@giganews.com>
<UqgKK.136200$Me2.116425@fx47.iad>
<_KucnbJJWuzxAWT_nZ2dnZfqlJ_NnZ2d@giganews.com>
<HkhKK.793605$wIO9.479008@fx12.iad>
<PuidnRegb5XZOWT_nZ2dnZfqlJxh4p2d@giganews.com>
From: Rich...@Damon-Family.org (Richard Damon)
In-Reply-To: <PuidnRegb5XZOWT_nZ2dnZfqlJxh4p2d@giganews.com>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Lines: 164
Message-ID: <OFhKK.730625$5fVf.417433@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, 14 Aug 2022 21:52:45 -0400
X-Received-Bytes: 8552
 by: Richard Damon - Mon, 15 Aug 2022 01:52 UTC

On 8/14/22 9:41 PM, olcott wrote:
> On 8/14/2022 8:30 PM, Richard Damon wrote:
>> On 8/14/22 9:08 PM, olcott wrote:
>>> On 8/14/2022 7:28 PM, Richard Damon wrote:
>>>> On 8/14/22 7:33 PM, olcott wrote:
>>>>> On 8/14/2022 6:29 PM, Richard Damon wrote:
>>>>>> On 8/14/22 6:58 PM, olcott wrote:
>>>>>>> On 8/14/2022 5:16 PM, Richard Damon wrote:
>>>>>>>> On 8/14/22 5:52 PM, olcott wrote:
>>>>>>>>> Mr Flibble <flibble@reddwarf.jmc.corp> Wrote in message:r
>>>>>>>>>> On Sun, 14 Aug 2022 14:18:53 -0500olcott <NoOne@NoWhere.com>
>>>>>>>>>> wrote:> On 8/14/2022 2:14 PM, Mr Flibble wrote:> > On Sun, 14
>>>>>>>>>> Aug 2022 10:14:28 -0500> > olcott <NoOne@NoWhere.com> wrote:>
>>>>>>>>>> >   > >> *This is refers to H(P,P)==0 where H and P are
>>>>>>>>>> functions in C*> >>> >>       I believe I have learned
>>>>>>>>>> something valuable from you:> >>       that by simulation, and
>>>>>>>>>> by simulations within simulations,> >>       non-halting can
>>>>>>>>>> sometimes be detected, and in particular,> >>       it can be
>>>>>>>>>> detected in the program used in the classical> >>       proof
>>>>>>>>>> of incomputability.> >>> >> *Halting problem proofs refuted on
>>>>>>>>>> the basis of software> >> engineering* ?> >>> >>
>>>>>>>>>> https://www.researchgate.net/publication/361701808_Halting_problem_proofs_refuted_on_the_basis_of_software_engineering>
>>>>>>>>>> >>  > > > > I am also a computer scientist and I am telling
>>>>>>>>>> you that your> > halting decider reporting non-halting when it
>>>>>>>>>> enters "infinite> > recursion" is an ERROR.  There is no
>>>>>>>>>> infinite recursion in the HP> > proofs you are attempting to
>>>>>>>>>> refute.> > > > /Flibble> >   > > > void P(ptr x)> {>    int
>>>>>>>>>> Halt_Status = H(x, x);>    if (Halt_Status)>      HERE: goto
>>>>>>>>>> HERE;>    return;> }> > int main()> {>    Output("Input_Halts
>>>>>>>>>> = ", H(P, P));> }> > If it was true that you are a computer
>>>>>>>>>> scientist then you would > understand that this execution
>>>>>>>>>> trace is correct:> > (a) H(P,P) simulates P(P) that calls a
>>>>>>>>>> simulated H(P,P)> (b) that simulates P(P) that calls a
>>>>>>>>>> simulated H(P,P)> (c) that simulates P(P) that calls a
>>>>>>>>>> simulated H(P,P)> (d) that simulates P(P) that calls a
>>>>>>>>>> simulated H(P,P)...> *Until H aborts its simulation*I am a
>>>>>>>>>> computer scientist and all your trace shows is that H (not P)
>>>>>>>>>> isat the root of your so called "infinite recursion" and is
>>>>>>>>>> the primaryreason why you are incorrect to map this recursive
>>>>>>>>>> behaviour of your Hto a halting decision on P of non-halting.>
>>>>>>>>>> > If you do not understand that the above execution trace is
>>>>>>>>>> correct> then this proves that you are not as much as a
>>>>>>>>>> sufficiently competent > software engineer.It seems I
>>>>>>>>>> understand your trace more than you do which makes itobvious
>>>>>>>>>> who is actually lacking in competence here./Flibble
>>>>>>>>>
>>>>>>>>> Because H exactly simulates its input and has no control flow
>>>>>>>>>   behavior of it's own while it is simulating this input YOU ARE
>>>>>>>>>   BLAMING THE MIRROR FOR WHAT IT REFLECTS.
>>>>>>>>>
>>>>>>>>>
>>>>>>>>
>>>>>>>> H does have control low on its own, or it can't stop the
>>>>>>>> simulationg to give an answer.
>>>>>>>>
>>>>>>>
>>>>>>> Because H exactly simulates its input and has no control flow
>>>>>>> behavior of it's own
>>>>>>> while it is simulating this input
>>>>>>> while it is simulating this input
>>>>>>> while it is simulating this input
>>>>>>> while it is simulating this input
>>>>>>> while it is simulating this input
>>>>>>> while it is simulating this input
>>>>>>> while it is simulating this input
>>>>>>> while it is simulating this input
>>>>>>> while it is simulating this input
>>>>>>> while it is simulating this input
>>>>>>> while it is simulating this input
>>>>>>> while it is simulating this input
>>>>>>> while it is simulating this input
>>>>>>> while it is simulating this input
>>>>>>> YOU ARE BLAMING THE MIRROR FOR WHAT IT REFLECTS.
>>>>>>>
>>>>>>>> So either you are a liar, or just badly confused about what you
>>>>>>>> are saying.
>>>>>>>
>>>>>>> Or you OCD prevents you from paying close enough attention to ALL
>>>>>>> of my words.
>>>>>>>
>>>>>>>
>>>>>>
>>>>>> Then how does it decide to stop simulating if it has no control
>>>>>> flow before it stops?
>>>>>>
>>>>>
>>>>> H does not have any effect on the behavior of its simulated P the
>>>>> whole time that H is simulating P, thus any recursive behavior that
>>>>> P demonstrates is behavior of P and not behavior of H.
>>>>>
>>>>>
>>>>
>>>> Nope, the problem is in H, not P.
>>>>
>>>> This H by its actions might not affect the behavior of the input it
>>>> is simulating, but it doesn't correctly determine the effect that
>>>> the copy of H in P will have.
>>>
>>> void P(ptr x)
>>> {
>>>    int Halt_Status = H(x, x);
>>>    if (Halt_Status)
>>>      HERE: goto HERE;
>>>    return;
>>> }
>>>
>>> int main()
>>> {
>>>    Output("Input_Halts = ", H(P, P));
>>> }
>>>
>>> So you disagree with this:
>>>
>>> (a) H(P,P) simulates P(P) that calls a simulated H(P,P)
>>> (b) that simulates P(P) that calls a simulated H(P,P)
>>> (c) that simulates P(P) that calls a simulated H(P,P)
>>> (d) that simulates P(P) that calls a simulated H(P,P)...
>>> *Until H aborts its simulation*
>>>
>>>
>>>
>>
>> That isn't what your H does,
>
> Why do you say that isn't what my H does when you know that it is what
> my H does and you can verify this with the complete system?
>
> https://www.liarparadox.org/2022_07_22.zip
> This is the complete system that compiles under:
>
> Microsoft Visual Studio Community 2017
> https://visualstudio.microsoft.com/vs/older-downloads/
>
>
>

Right, you didn't read what I said you H does, did you?

You are just proving how dumb you are.

(b), (c), (d) don't happen BECAUSE H abort its simulation as soon as it
sees P(P) call H(P,P).

BECAUSE H(P,P) aborts at this point, and returns 0, it doesn't actually
do a CORRECT simulation, as it prsumes that the simulated H(P,P) will
not return, but it returns 0, thus H is INCORRECT.

We can see the CORRECT simulation when we do UTM(P,P) which agres with
this Halting Answer.

The question that H needs to answer is NOT does it need to abort it
simulation, since of a given H, there is no choice there, it does what
it is programmed.


Click here to read the complete article
Re: Here is what a computer scientist that has been published in CACM said about my work [competence?]

<Otqdnd4GfKOiNWT_nZ2dnZfqlJxh4p2d@giganews.com>

  copy mid

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

  copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!usenet.blueworldhosting.com!feed1.usenet.blueworldhosting.com!peer01.iad!feed-me.highwinds-media.com!news.highwinds-media.com!border-1.nntp.ord.giganews.com!nntp.giganews.com!Xl.tags.giganews.com!local-2.nntp.ord.giganews.com!news.giganews.com.POSTED!not-for-mail
NNTP-Posting-Date: Mon, 15 Aug 2022 01:58:23 +0000
Date: Sun, 14 Aug 2022 20:58:38 -0500
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:91.0) Gecko/20100101
Thunderbird/91.12.0
Subject: Re: Here is what a computer scientist that has been published in CACM
said about my work [competence?]
Content-Language: en-US
Newsgroups: comp.theory
References: <VUmdneqWu_jdjGT_nZ2dnZfqlJ_NnZ2d@giganews.com>
<20220814201431.00002067@reddwarf.jmc.corp>
<LLednYl9W7ET12T_nZ2dnZfqlJzNnZ2d@giganews.com>
<20220814205543.00006c29@reddwarf.jmc.corp> <tdbqq3$1cg2$1@gioia.aioe.org>
<cveKK.768959$ssF.612517@fx14.iad>
<2h-dnZQ8E7yD42T_nZ2dnZfqlJ9g4p2d@giganews.com>
<SzfKK.916573$JVi.396684@fx17.iad>
<MLOcnbPjLuakG2T_nZ2dnZfqlJ9g4p2d@giganews.com>
<UqgKK.136200$Me2.116425@fx47.iad>
<_KucnbJJWuzxAWT_nZ2dnZfqlJ_NnZ2d@giganews.com>
<HkhKK.793605$wIO9.479008@fx12.iad>
<PuidnRegb5XZOWT_nZ2dnZfqlJxh4p2d@giganews.com>
<OFhKK.730625$5fVf.417433@fx09.iad>
From: NoO...@NoWhere.com (olcott)
In-Reply-To: <OFhKK.730625$5fVf.417433@fx09.iad>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Message-ID: <Otqdnd4GfKOiNWT_nZ2dnZfqlJxh4p2d@giganews.com>
Lines: 150
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-mSSvjI/Fv9wOniJpJQ/AwhwKjhG3fwHh8DPVaccG6cPh5/x7okrbAyfuEjFPQVVO/bPQW18mlNciqAL!6pG5FzJSoRWHzqMyQN80aYbj+RJclXyTVjDI5VVLTwIiDFfhBCfMFkGyQCIfbgF0eyfr86cMczI=
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-Received-Bytes: 8434
 by: olcott - Mon, 15 Aug 2022 01:58 UTC

On 8/14/2022 8:52 PM, Richard Damon wrote:
> On 8/14/22 9:41 PM, olcott wrote:
>> On 8/14/2022 8:30 PM, Richard Damon wrote:
>>> On 8/14/22 9:08 PM, olcott wrote:
>>>> On 8/14/2022 7:28 PM, Richard Damon wrote:
>>>>> On 8/14/22 7:33 PM, olcott wrote:
>>>>>> On 8/14/2022 6:29 PM, Richard Damon wrote:
>>>>>>> On 8/14/22 6:58 PM, olcott wrote:
>>>>>>>> On 8/14/2022 5:16 PM, Richard Damon wrote:
>>>>>>>>> On 8/14/22 5:52 PM, olcott wrote:
>>>>>>>>>> Mr Flibble <flibble@reddwarf.jmc.corp> Wrote in message:r
>>>>>>>>>>> On Sun, 14 Aug 2022 14:18:53 -0500olcott <NoOne@NoWhere.com>
>>>>>>>>>>> wrote:> On 8/14/2022 2:14 PM, Mr Flibble wrote:> > On Sun, 14
>>>>>>>>>>> Aug 2022 10:14:28 -0500> > olcott <NoOne@NoWhere.com> wrote:>
>>>>>>>>>>> >   > >> *This is refers to H(P,P)==0 where H and P are
>>>>>>>>>>> functions in C*> >>> >>       I believe I have learned
>>>>>>>>>>> something valuable from you:> >>       that by simulation,
>>>>>>>>>>> and by simulations within simulations,> >>       non-halting
>>>>>>>>>>> can sometimes be detected, and in particular,> >>       it
>>>>>>>>>>> can be detected in the program used in the classical>
>>>>>>>>>>> >>       proof of incomputability.> >>> >> *Halting problem
>>>>>>>>>>> proofs refuted on the basis of software> >> engineering* ?>
>>>>>>>>>>> >>> >>
>>>>>>>>>>> https://www.researchgate.net/publication/361701808_Halting_problem_proofs_refuted_on_the_basis_of_software_engineering>
>>>>>>>>>>> >>  > > > > I am also a computer scientist and I am telling
>>>>>>>>>>> you that your> > halting decider reporting non-halting when
>>>>>>>>>>> it enters "infinite> > recursion" is an ERROR.  There is no
>>>>>>>>>>> infinite recursion in the HP> > proofs you are attempting to
>>>>>>>>>>> refute.> > > > /Flibble> >   > > > void P(ptr x)> {>    int
>>>>>>>>>>> Halt_Status = H(x, x);>    if (Halt_Status)>      HERE: goto
>>>>>>>>>>> HERE;>    return;> }> > int main()> {>    Output("Input_Halts
>>>>>>>>>>> = ", H(P, P));> }> > If it was true that you are a computer
>>>>>>>>>>> scientist then you would > understand that this execution
>>>>>>>>>>> trace is correct:> > (a) H(P,P) simulates P(P) that calls a
>>>>>>>>>>> simulated H(P,P)> (b) that simulates P(P) that calls a
>>>>>>>>>>> simulated H(P,P)> (c) that simulates P(P) that calls a
>>>>>>>>>>> simulated H(P,P)> (d) that simulates P(P) that calls a
>>>>>>>>>>> simulated H(P,P)...> *Until H aborts its simulation*I am a
>>>>>>>>>>> computer scientist and all your trace shows is that H (not P)
>>>>>>>>>>> isat the root of your so called "infinite recursion" and is
>>>>>>>>>>> the primaryreason why you are incorrect to map this recursive
>>>>>>>>>>> behaviour of your Hto a halting decision on P of
>>>>>>>>>>> non-halting.> > If you do not understand that the above
>>>>>>>>>>> execution trace is correct> then this proves that you are not
>>>>>>>>>>> as much as a sufficiently competent > software engineer.It
>>>>>>>>>>> seems I understand your trace more than you do which makes
>>>>>>>>>>> itobvious who is actually lacking in competence here./Flibble
>>>>>>>>>>
>>>>>>>>>> Because H exactly simulates its input and has no control flow
>>>>>>>>>>   behavior of it's own while it is simulating this input YOU ARE
>>>>>>>>>>   BLAMING THE MIRROR FOR WHAT IT REFLECTS.
>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> H does have control low on its own, or it can't stop the
>>>>>>>>> simulationg to give an answer.
>>>>>>>>>
>>>>>>>>
>>>>>>>> Because H exactly simulates its input and has no control flow
>>>>>>>> behavior of it's own
>>>>>>>> while it is simulating this input
>>>>>>>> while it is simulating this input
>>>>>>>> while it is simulating this input
>>>>>>>> while it is simulating this input
>>>>>>>> while it is simulating this input
>>>>>>>> while it is simulating this input
>>>>>>>> while it is simulating this input
>>>>>>>> while it is simulating this input
>>>>>>>> while it is simulating this input
>>>>>>>> while it is simulating this input
>>>>>>>> while it is simulating this input
>>>>>>>> while it is simulating this input
>>>>>>>> while it is simulating this input
>>>>>>>> while it is simulating this input
>>>>>>>> YOU ARE BLAMING THE MIRROR FOR WHAT IT REFLECTS.
>>>>>>>>
>>>>>>>>> So either you are a liar, or just badly confused about what you
>>>>>>>>> are saying.
>>>>>>>>
>>>>>>>> Or you OCD prevents you from paying close enough attention to
>>>>>>>> ALL of my words.
>>>>>>>>
>>>>>>>>
>>>>>>>
>>>>>>> Then how does it decide to stop simulating if it has no control
>>>>>>> flow before it stops?
>>>>>>>
>>>>>>
>>>>>> H does not have any effect on the behavior of its simulated P the
>>>>>> whole time that H is simulating P, thus any recursive behavior
>>>>>> that P demonstrates is behavior of P and not behavior of H.
>>>>>>
>>>>>>
>>>>>
>>>>> Nope, the problem is in H, not P.
>>>>>
>>>>> This H by its actions might not affect the behavior of the input it
>>>>> is simulating, but it doesn't correctly determine the effect that
>>>>> the copy of H in P will have.
>>>>
>>>> void P(ptr x)
>>>> {
>>>>    int Halt_Status = H(x, x);
>>>>    if (Halt_Status)
>>>>      HERE: goto HERE;
>>>>    return;
>>>> }
>>>>
>>>> int main()
>>>> {
>>>>    Output("Input_Halts = ", H(P, P));
>>>> }
>>>>
>>>> So you disagree with this:
>>>>
>>>> (a) H(P,P) simulates P(P) that calls a simulated H(P,P)
>>>> (b) that simulates P(P) that calls a simulated H(P,P)
>>>> (c) that simulates P(P) that calls a simulated H(P,P)
>>>> (d) that simulates P(P) that calls a simulated H(P,P)...
>>>> *Until H aborts its simulation*
>>>>
>>>>
>>>>
>>>
>>> That isn't what your H does,
>>
>> Why do you say that isn't what my H does when you know that it is what
>> my H does and you can verify this with the complete system?
>>
>> https://www.liarparadox.org/2022_07_22.zip
>> This is the complete system that compiles under:
>>
>> Microsoft Visual Studio Community 2017
>> https://visualstudio.microsoft.com/vs/older-downloads/
>>
>>
>>
>
> Right, you didn't read what I said you H does, did you?
>


Click here to read the complete article
Re: Here is what a computer scientist that has been published in CACM said about my work [competence?]

<KZhKK.772181$zgr9.340328@fx13.iad>

  copy mid

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

  copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!usenet.blueworldhosting.com!feed1.usenet.blueworldhosting.com!peer01.iad!feed-me.highwinds-media.com!news.highwinds-media.com!fx13.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.12.0
Subject: Re: Here is what a computer scientist that has been published in CACM
said about my work [competence?]
Content-Language: en-US
Newsgroups: comp.theory
References: <VUmdneqWu_jdjGT_nZ2dnZfqlJ_NnZ2d@giganews.com>
<20220814201431.00002067@reddwarf.jmc.corp>
<LLednYl9W7ET12T_nZ2dnZfqlJzNnZ2d@giganews.com>
<20220814205543.00006c29@reddwarf.jmc.corp> <tdbqq3$1cg2$1@gioia.aioe.org>
<cveKK.768959$ssF.612517@fx14.iad>
<2h-dnZQ8E7yD42T_nZ2dnZfqlJ9g4p2d@giganews.com>
<SzfKK.916573$JVi.396684@fx17.iad>
<MLOcnbPjLuakG2T_nZ2dnZfqlJ9g4p2d@giganews.com>
<UqgKK.136200$Me2.116425@fx47.iad>
<_KucnbJJWuzxAWT_nZ2dnZfqlJ_NnZ2d@giganews.com>
<HkhKK.793605$wIO9.479008@fx12.iad>
<PuidnRegb5XZOWT_nZ2dnZfqlJxh4p2d@giganews.com>
<OFhKK.730625$5fVf.417433@fx09.iad>
<Otqdnd4GfKOiNWT_nZ2dnZfqlJxh4p2d@giganews.com>
From: Rich...@Damon-Family.org (Richard Damon)
In-Reply-To: <Otqdnd4GfKOiNWT_nZ2dnZfqlJxh4p2d@giganews.com>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Lines: 175
Message-ID: <KZhKK.772181$zgr9.340328@fx13.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, 14 Aug 2022 22:14:01 -0400
X-Received-Bytes: 9150
 by: Richard Damon - Mon, 15 Aug 2022 02:14 UTC

On 8/14/22 9:58 PM, olcott wrote:
> On 8/14/2022 8:52 PM, Richard Damon wrote:
>> On 8/14/22 9:41 PM, olcott wrote:
>>> On 8/14/2022 8:30 PM, Richard Damon wrote:
>>>> On 8/14/22 9:08 PM, olcott wrote:
>>>>> On 8/14/2022 7:28 PM, Richard Damon wrote:
>>>>>> On 8/14/22 7:33 PM, olcott wrote:
>>>>>>> On 8/14/2022 6:29 PM, Richard Damon wrote:
>>>>>>>> On 8/14/22 6:58 PM, olcott wrote:
>>>>>>>>> On 8/14/2022 5:16 PM, Richard Damon wrote:
>>>>>>>>>> On 8/14/22 5:52 PM, olcott wrote:
>>>>>>>>>>> Mr Flibble <flibble@reddwarf.jmc.corp> Wrote in message:r
>>>>>>>>>>>> On Sun, 14 Aug 2022 14:18:53 -0500olcott <NoOne@NoWhere.com>
>>>>>>>>>>>> wrote:> On 8/14/2022 2:14 PM, Mr Flibble wrote:> > On Sun,
>>>>>>>>>>>> 14 Aug 2022 10:14:28 -0500> > olcott <NoOne@NoWhere.com>
>>>>>>>>>>>> wrote:> >   > >> *This is refers to H(P,P)==0 where H and P
>>>>>>>>>>>> are functions in C*> >>> >>       I believe I have learned
>>>>>>>>>>>> something valuable from you:> >>       that by simulation,
>>>>>>>>>>>> and by simulations within simulations,> >>       non-halting
>>>>>>>>>>>> can sometimes be detected, and in particular,> >>       it
>>>>>>>>>>>> can be detected in the program used in the classical>
>>>>>>>>>>>> >>       proof of incomputability.> >>> >> *Halting problem
>>>>>>>>>>>> proofs refuted on the basis of software> >> engineering* ?>
>>>>>>>>>>>> >>> >>
>>>>>>>>>>>> https://www.researchgate.net/publication/361701808_Halting_problem_proofs_refuted_on_the_basis_of_software_engineering>
>>>>>>>>>>>> >>  > > > > I am also a computer scientist and I am telling
>>>>>>>>>>>> you that your> > halting decider reporting non-halting when
>>>>>>>>>>>> it enters "infinite> > recursion" is an ERROR.  There is no
>>>>>>>>>>>> infinite recursion in the HP> > proofs you are attempting to
>>>>>>>>>>>> refute.> > > > /Flibble> >   > > > void P(ptr x)> {>    int
>>>>>>>>>>>> Halt_Status = H(x, x);>    if (Halt_Status)>      HERE: goto
>>>>>>>>>>>> HERE;>    return;> }> > int main()> {>
>>>>>>>>>>>> Output("Input_Halts = ", H(P, P));> }> > If it was true that
>>>>>>>>>>>> you are a computer scientist then you would > understand
>>>>>>>>>>>> that this execution trace is correct:> > (a) H(P,P)
>>>>>>>>>>>> simulates P(P) that calls a simulated H(P,P)> (b) that
>>>>>>>>>>>> simulates P(P) that calls a simulated H(P,P)> (c) that
>>>>>>>>>>>> simulates P(P) that calls a simulated H(P,P)> (d) that
>>>>>>>>>>>> simulates P(P) that calls a simulated H(P,P)...> *Until H
>>>>>>>>>>>> aborts its simulation*I am a computer scientist and all your
>>>>>>>>>>>> trace shows is that H (not P) isat the root of your so
>>>>>>>>>>>> called "infinite recursion" and is the primaryreason why you
>>>>>>>>>>>> are incorrect to map this recursive behaviour of your Hto a
>>>>>>>>>>>> halting decision on P of non-halting.> > If you do not
>>>>>>>>>>>> understand that the above execution trace is correct> then
>>>>>>>>>>>> this proves that you are not as much as a sufficiently
>>>>>>>>>>>> competent > software engineer.It seems I understand your
>>>>>>>>>>>> trace more than you do which makes itobvious who is actually
>>>>>>>>>>>> lacking in competence here./Flibble
>>>>>>>>>>>
>>>>>>>>>>> Because H exactly simulates its input and has no control flow
>>>>>>>>>>>   behavior of it's own while it is simulating this input YOU ARE
>>>>>>>>>>>   BLAMING THE MIRROR FOR WHAT IT REFLECTS.
>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> H does have control low on its own, or it can't stop the
>>>>>>>>>> simulationg to give an answer.
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> Because H exactly simulates its input and has no control flow
>>>>>>>>> behavior of it's own
>>>>>>>>> while it is simulating this input
>>>>>>>>> while it is simulating this input
>>>>>>>>> while it is simulating this input
>>>>>>>>> while it is simulating this input
>>>>>>>>> while it is simulating this input
>>>>>>>>> while it is simulating this input
>>>>>>>>> while it is simulating this input
>>>>>>>>> while it is simulating this input
>>>>>>>>> while it is simulating this input
>>>>>>>>> while it is simulating this input
>>>>>>>>> while it is simulating this input
>>>>>>>>> while it is simulating this input
>>>>>>>>> while it is simulating this input
>>>>>>>>> while it is simulating this input
>>>>>>>>> YOU ARE BLAMING THE MIRROR FOR WHAT IT REFLECTS.
>>>>>>>>>
>>>>>>>>>> So either you are a liar, or just badly confused about what
>>>>>>>>>> you are saying.
>>>>>>>>>
>>>>>>>>> Or you OCD prevents you from paying close enough attention to
>>>>>>>>> ALL of my words.
>>>>>>>>>
>>>>>>>>>
>>>>>>>>
>>>>>>>> Then how does it decide to stop simulating if it has no control
>>>>>>>> flow before it stops?
>>>>>>>>
>>>>>>>
>>>>>>> H does not have any effect on the behavior of its simulated P the
>>>>>>> whole time that H is simulating P, thus any recursive behavior
>>>>>>> that P demonstrates is behavior of P and not behavior of H.
>>>>>>>
>>>>>>>
>>>>>>
>>>>>> Nope, the problem is in H, not P.
>>>>>>
>>>>>> This H by its actions might not affect the behavior of the input
>>>>>> it is simulating, but it doesn't correctly determine the effect
>>>>>> that the copy of H in P will have.
>>>>>
>>>>> void P(ptr x)
>>>>> {
>>>>>    int Halt_Status = H(x, x);
>>>>>    if (Halt_Status)
>>>>>      HERE: goto HERE;
>>>>>    return;
>>>>> }
>>>>>
>>>>> int main()
>>>>> {
>>>>>    Output("Input_Halts = ", H(P, P));
>>>>> }
>>>>>
>>>>> So you disagree with this:
>>>>>
>>>>> (a) H(P,P) simulates P(P) that calls a simulated H(P,P)
>>>>> (b) that simulates P(P) that calls a simulated H(P,P)
>>>>> (c) that simulates P(P) that calls a simulated H(P,P)
>>>>> (d) that simulates P(P) that calls a simulated H(P,P)...
>>>>> *Until H aborts its simulation*
>>>>>
>>>>>
>>>>>
>>>>
>>>> That isn't what your H does,
>>>
>>> Why do you say that isn't what my H does when you know that it is
>>> what my H does and you can verify this with the complete system?
>>>
>>> https://www.liarparadox.org/2022_07_22.zip
>>> This is the complete system that compiles under:
>>>
>>> Microsoft Visual Studio Community 2017
>>> https://visualstudio.microsoft.com/vs/older-downloads/
>>>
>>>
>>>
>>
>> Right, you didn't read what I said you H does, did you?
>>
>
> You said that what I said H does, it does not do, this is incorrect.
> Then you changed the subject.
>


Click here to read the complete article
Re: Here is what a computer scientist that has been published in CACM said about my work [competence?]

<tEmdnfEhQrIvM2T_nZ2dnZfqlJ_NnZ2d@giganews.com>

  copy mid

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

  copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!usenet.blueworldhosting.com!feed1.usenet.blueworldhosting.com!peer01.iad!feed-me.highwinds-media.com!news.highwinds-media.com!border-1.nntp.ord.giganews.com!nntp.giganews.com!Xl.tags.giganews.com!local-2.nntp.ord.giganews.com!news.giganews.com.POSTED!not-for-mail
NNTP-Posting-Date: Mon, 15 Aug 2022 02:25:54 +0000
Date: Sun, 14 Aug 2022 21:26:13 -0500
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:91.0) Gecko/20100101
Thunderbird/91.12.0
Subject: Re: Here is what a computer scientist that has been published in CACM
said about my work [competence?]
Content-Language: en-US
Newsgroups: comp.theory
References: <VUmdneqWu_jdjGT_nZ2dnZfqlJ_NnZ2d@giganews.com>
<20220814201431.00002067@reddwarf.jmc.corp>
<LLednYl9W7ET12T_nZ2dnZfqlJzNnZ2d@giganews.com>
<20220814205543.00006c29@reddwarf.jmc.corp> <tdbqq3$1cg2$1@gioia.aioe.org>
<cveKK.768959$ssF.612517@fx14.iad>
<2h-dnZQ8E7yD42T_nZ2dnZfqlJ9g4p2d@giganews.com>
<SzfKK.916573$JVi.396684@fx17.iad>
<MLOcnbPjLuakG2T_nZ2dnZfqlJ9g4p2d@giganews.com>
<UqgKK.136200$Me2.116425@fx47.iad>
<_KucnbJJWuzxAWT_nZ2dnZfqlJ_NnZ2d@giganews.com>
<HkhKK.793605$wIO9.479008@fx12.iad>
<PuidnRegb5XZOWT_nZ2dnZfqlJxh4p2d@giganews.com>
<OFhKK.730625$5fVf.417433@fx09.iad>
<Otqdnd4GfKOiNWT_nZ2dnZfqlJxh4p2d@giganews.com>
<KZhKK.772181$zgr9.340328@fx13.iad>
From: NoO...@NoWhere.com (olcott)
In-Reply-To: <KZhKK.772181$zgr9.340328@fx13.iad>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Message-ID: <tEmdnfEhQrIvM2T_nZ2dnZfqlJ_NnZ2d@giganews.com>
Lines: 168
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-NSJmL6Njzl8/t501sfAd3hPk7vh9gsrJd63m/xiCuZgIhv0u4BfTclEpyIVu5sGqFgHRjhA1KxwproW!8Cq6AqSzg0JwbQuTaijIEczxkQpHIi0GS4qN0dAXC/jIRZ9LfRAAVupEP46TUXWUlzPKg2j37uI=
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-Received-Bytes: 9278
 by: olcott - Mon, 15 Aug 2022 02:26 UTC

On 8/14/2022 9:14 PM, Richard Damon wrote:
> On 8/14/22 9:58 PM, olcott wrote:
>> On 8/14/2022 8:52 PM, Richard Damon wrote:
>>> On 8/14/22 9:41 PM, olcott wrote:
>>>> On 8/14/2022 8:30 PM, Richard Damon wrote:
>>>>> On 8/14/22 9:08 PM, olcott wrote:
>>>>>> On 8/14/2022 7:28 PM, Richard Damon wrote:
>>>>>>> On 8/14/22 7:33 PM, olcott wrote:
>>>>>>>> On 8/14/2022 6:29 PM, Richard Damon wrote:
>>>>>>>>> On 8/14/22 6:58 PM, olcott wrote:
>>>>>>>>>> On 8/14/2022 5:16 PM, Richard Damon wrote:
>>>>>>>>>>> On 8/14/22 5:52 PM, olcott wrote:
>>>>>>>>>>>> Mr Flibble <flibble@reddwarf.jmc.corp> Wrote in message:r
>>>>>>>>>>>>> On Sun, 14 Aug 2022 14:18:53 -0500olcott
>>>>>>>>>>>>> <NoOne@NoWhere.com> wrote:> On 8/14/2022 2:14 PM, Mr
>>>>>>>>>>>>> Flibble wrote:> > On Sun, 14 Aug 2022 10:14:28 -0500> >
>>>>>>>>>>>>> olcott <NoOne@NoWhere.com> wrote:> >   > >> *This is refers
>>>>>>>>>>>>> to H(P,P)==0 where H and P are functions in C*> >>>
>>>>>>>>>>>>> >>       I believe I have learned something valuable from
>>>>>>>>>>>>> you:> >>       that by simulation, and by simulations
>>>>>>>>>>>>> within simulations,> >>       non-halting can sometimes be
>>>>>>>>>>>>> detected, and in particular,> >>       it can be detected
>>>>>>>>>>>>> in the program used in the classical> >>       proof of
>>>>>>>>>>>>> incomputability.> >>> >> *Halting problem proofs refuted on
>>>>>>>>>>>>> the basis of software> >> engineering* ?> >>> >>
>>>>>>>>>>>>> https://www.researchgate.net/publication/361701808_Halting_problem_proofs_refuted_on_the_basis_of_software_engineering>
>>>>>>>>>>>>> >>  > > > > I am also a computer scientist and I am telling
>>>>>>>>>>>>> you that your> > halting decider reporting non-halting when
>>>>>>>>>>>>> it enters "infinite> > recursion" is an ERROR.  There is no
>>>>>>>>>>>>> infinite recursion in the HP> > proofs you are attempting
>>>>>>>>>>>>> to refute.> > > > /Flibble> >   > > > void P(ptr x)> {>
>>>>>>>>>>>>> int Halt_Status = H(x, x);>    if (Halt_Status)>      HERE:
>>>>>>>>>>>>> goto HERE;>    return;> }> > int main()> {>
>>>>>>>>>>>>> Output("Input_Halts = ", H(P, P));> }> > If it was true
>>>>>>>>>>>>> that you are a computer scientist then you would >
>>>>>>>>>>>>> understand that this execution trace is correct:> > (a)
>>>>>>>>>>>>> H(P,P) simulates P(P) that calls a simulated H(P,P)> (b)
>>>>>>>>>>>>> that simulates P(P) that calls a simulated H(P,P)> (c) that
>>>>>>>>>>>>> simulates P(P) that calls a simulated H(P,P)> (d) that
>>>>>>>>>>>>> simulates P(P) that calls a simulated H(P,P)...> *Until H
>>>>>>>>>>>>> aborts its simulation*I am a computer scientist and all
>>>>>>>>>>>>> your trace shows is that H (not P) isat the root of your so
>>>>>>>>>>>>> called "infinite recursion" and is the primaryreason why
>>>>>>>>>>>>> you are incorrect to map this recursive behaviour of your
>>>>>>>>>>>>> Hto a halting decision on P of non-halting.> > If you do
>>>>>>>>>>>>> not understand that the above execution trace is correct>
>>>>>>>>>>>>> then this proves that you are not as much as a sufficiently
>>>>>>>>>>>>> competent > software engineer.It seems I understand your
>>>>>>>>>>>>> trace more than you do which makes itobvious who is
>>>>>>>>>>>>> actually lacking in competence here./Flibble
>>>>>>>>>>>>
>>>>>>>>>>>> Because H exactly simulates its input and has no control flow
>>>>>>>>>>>>   behavior of it's own while it is simulating this input YOU
>>>>>>>>>>>> ARE
>>>>>>>>>>>>   BLAMING THE MIRROR FOR WHAT IT REFLECTS.
>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> H does have control low on its own, or it can't stop the
>>>>>>>>>>> simulationg to give an answer.
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> Because H exactly simulates its input and has no control flow
>>>>>>>>>> behavior of it's own
>>>>>>>>>> while it is simulating this input
>>>>>>>>>> while it is simulating this input
>>>>>>>>>> while it is simulating this input
>>>>>>>>>> while it is simulating this input
>>>>>>>>>> while it is simulating this input
>>>>>>>>>> while it is simulating this input
>>>>>>>>>> while it is simulating this input
>>>>>>>>>> while it is simulating this input
>>>>>>>>>> while it is simulating this input
>>>>>>>>>> while it is simulating this input
>>>>>>>>>> while it is simulating this input
>>>>>>>>>> while it is simulating this input
>>>>>>>>>> while it is simulating this input
>>>>>>>>>> while it is simulating this input
>>>>>>>>>> YOU ARE BLAMING THE MIRROR FOR WHAT IT REFLECTS.
>>>>>>>>>>
>>>>>>>>>>> So either you are a liar, or just badly confused about what
>>>>>>>>>>> you are saying.
>>>>>>>>>>
>>>>>>>>>> Or you OCD prevents you from paying close enough attention to
>>>>>>>>>> ALL of my words.
>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> Then how does it decide to stop simulating if it has no control
>>>>>>>>> flow before it stops?
>>>>>>>>>
>>>>>>>>
>>>>>>>> H does not have any effect on the behavior of its simulated P
>>>>>>>> the whole time that H is simulating P, thus any recursive
>>>>>>>> behavior that P demonstrates is behavior of P and not behavior
>>>>>>>> of H.
>>>>>>>>
>>>>>>>>
>>>>>>>
>>>>>>> Nope, the problem is in H, not P.
>>>>>>>
>>>>>>> This H by its actions might not affect the behavior of the input
>>>>>>> it is simulating, but it doesn't correctly determine the effect
>>>>>>> that the copy of H in P will have.
>>>>>>
>>>>>> void P(ptr x)
>>>>>> {
>>>>>>    int Halt_Status = H(x, x);
>>>>>>    if (Halt_Status)
>>>>>>      HERE: goto HERE;
>>>>>>    return;
>>>>>> }
>>>>>>
>>>>>> int main()
>>>>>> {
>>>>>>    Output("Input_Halts = ", H(P, P));
>>>>>> }
>>>>>>
>>>>>> So you disagree with this:
>>>>>>
>>>>>> (a) H(P,P) simulates P(P) that calls a simulated H(P,P)
>>>>>> (b) that simulates P(P) that calls a simulated H(P,P)
>>>>>> (c) that simulates P(P) that calls a simulated H(P,P)
>>>>>> (d) that simulates P(P) that calls a simulated H(P,P)...
>>>>>> *Until H aborts its simulation*
>>>>>>
>>>>>>
>>>>>>
>>>>>
>>>>> That isn't what your H does,
>>>>
>>>> Why do you say that isn't what my H does when you know that it is
>>>> what my H does and you can verify this with the complete system?
>>>>
>>>> https://www.liarparadox.org/2022_07_22.zip
>>>> This is the complete system that compiles under:
>>>>
>>>> Microsoft Visual Studio Community 2017
>>>> https://visualstudio.microsoft.com/vs/older-downloads/
>>>>
>>>>
>>>>
>>>
>>> Right, you didn't read what I said you H does, did you?
>>>
>>
>> You said that what I said H does, it does not do, this is incorrect.
>> Then you changed the subject.
>>
>
> You H does NOT get to the step (b) that you have posted, so doesn't
> match you pattern.
>


Click here to read the complete article
Re: Here is what a computer scientist that has been published in CACM said about my work [competence?]

<sqqKK.137501$Me2.29783@fx47.iad>

  copy mid

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

  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!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.12.0
Subject: Re: Here is what a computer scientist that has been published in CACM
said about my work [competence?]
Content-Language: en-US
Newsgroups: comp.theory
References: <VUmdneqWu_jdjGT_nZ2dnZfqlJ_NnZ2d@giganews.com>
<20220814201431.00002067@reddwarf.jmc.corp>
<LLednYl9W7ET12T_nZ2dnZfqlJzNnZ2d@giganews.com>
<20220814205543.00006c29@reddwarf.jmc.corp> <tdbqq3$1cg2$1@gioia.aioe.org>
<cveKK.768959$ssF.612517@fx14.iad>
<2h-dnZQ8E7yD42T_nZ2dnZfqlJ9g4p2d@giganews.com>
<SzfKK.916573$JVi.396684@fx17.iad>
<MLOcnbPjLuakG2T_nZ2dnZfqlJ9g4p2d@giganews.com>
<UqgKK.136200$Me2.116425@fx47.iad>
<_KucnbJJWuzxAWT_nZ2dnZfqlJ_NnZ2d@giganews.com>
<HkhKK.793605$wIO9.479008@fx12.iad>
<PuidnRegb5XZOWT_nZ2dnZfqlJxh4p2d@giganews.com>
<OFhKK.730625$5fVf.417433@fx09.iad>
<Otqdnd4GfKOiNWT_nZ2dnZfqlJxh4p2d@giganews.com>
<KZhKK.772181$zgr9.340328@fx13.iad>
<tEmdnfEhQrIvM2T_nZ2dnZfqlJ_NnZ2d@giganews.com>
From: Rich...@Damon-Family.org (Richard Damon)
In-Reply-To: <tEmdnfEhQrIvM2T_nZ2dnZfqlJ_NnZ2d@giganews.com>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Lines: 181
Message-ID: <sqqKK.137501$Me2.29783@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: Mon, 15 Aug 2022 07:50:48 -0400
X-Received-Bytes: 9504
 by: Richard Damon - Mon, 15 Aug 2022 11:50 UTC

On 8/14/22 10:26 PM, olcott wrote:
> On 8/14/2022 9:14 PM, Richard Damon wrote:
>> On 8/14/22 9:58 PM, olcott wrote:
>>> On 8/14/2022 8:52 PM, Richard Damon wrote:
>>>> On 8/14/22 9:41 PM, olcott wrote:
>>>>> On 8/14/2022 8:30 PM, Richard Damon wrote:
>>>>>> On 8/14/22 9:08 PM, olcott wrote:
>>>>>>> On 8/14/2022 7:28 PM, Richard Damon wrote:
>>>>>>>> On 8/14/22 7:33 PM, olcott wrote:
>>>>>>>>> On 8/14/2022 6:29 PM, Richard Damon wrote:
>>>>>>>>>> On 8/14/22 6:58 PM, olcott wrote:
>>>>>>>>>>> On 8/14/2022 5:16 PM, Richard Damon wrote:
>>>>>>>>>>>> On 8/14/22 5:52 PM, olcott wrote:
>>>>>>>>>>>>> Mr Flibble <flibble@reddwarf.jmc.corp> Wrote in message:r
>>>>>>>>>>>>>> On Sun, 14 Aug 2022 14:18:53 -0500olcott
>>>>>>>>>>>>>> <NoOne@NoWhere.com> wrote:> On 8/14/2022 2:14 PM, Mr
>>>>>>>>>>>>>> Flibble wrote:> > On Sun, 14 Aug 2022 10:14:28 -0500> >
>>>>>>>>>>>>>> olcott <NoOne@NoWhere.com> wrote:> >   > >> *This is
>>>>>>>>>>>>>> refers to H(P,P)==0 where H and P are functions in C*> >>>
>>>>>>>>>>>>>> >>       I believe I have learned something valuable from
>>>>>>>>>>>>>> you:> >>       that by simulation, and by simulations
>>>>>>>>>>>>>> within simulations,> >>       non-halting can sometimes be
>>>>>>>>>>>>>> detected, and in particular,> >>       it can be detected
>>>>>>>>>>>>>> in the program used in the classical> >>       proof of
>>>>>>>>>>>>>> incomputability.> >>> >> *Halting problem proofs refuted
>>>>>>>>>>>>>> on the basis of software> >> engineering* ?> >>> >>
>>>>>>>>>>>>>> https://www.researchgate.net/publication/361701808_Halting_problem_proofs_refuted_on_the_basis_of_software_engineering>
>>>>>>>>>>>>>> >>  > > > > I am also a computer scientist and I am
>>>>>>>>>>>>>> telling you that your> > halting decider reporting
>>>>>>>>>>>>>> non-halting when it enters "infinite> > recursion" is an
>>>>>>>>>>>>>> ERROR.  There is no infinite recursion in the HP> > proofs
>>>>>>>>>>>>>> you are attempting to refute.> > > > /Flibble> >   > > >
>>>>>>>>>>>>>> void P(ptr x)> {> int Halt_Status = H(x, x);>    if
>>>>>>>>>>>>>> (Halt_Status)>      HERE: goto HERE;>    return;> }> > int
>>>>>>>>>>>>>> main()> {> Output("Input_Halts = ", H(P, P));> }> > If it
>>>>>>>>>>>>>> was true that you are a computer scientist then you would
>>>>>>>>>>>>>> > understand that this execution trace is correct:> > (a)
>>>>>>>>>>>>>> H(P,P) simulates P(P) that calls a simulated H(P,P)> (b)
>>>>>>>>>>>>>> that simulates P(P) that calls a simulated H(P,P)> (c)
>>>>>>>>>>>>>> that simulates P(P) that calls a simulated H(P,P)> (d)
>>>>>>>>>>>>>> that simulates P(P) that calls a simulated H(P,P)...>
>>>>>>>>>>>>>> *Until H aborts its simulation*I am a computer scientist
>>>>>>>>>>>>>> and all your trace shows is that H (not P) isat the root
>>>>>>>>>>>>>> of your so called "infinite recursion" and is the
>>>>>>>>>>>>>> primaryreason why you are incorrect to map this recursive
>>>>>>>>>>>>>> behaviour of your Hto a halting decision on P of
>>>>>>>>>>>>>> non-halting.> > If you do not understand that the above
>>>>>>>>>>>>>> execution trace is correct> then this proves that you are
>>>>>>>>>>>>>> not as much as a sufficiently competent > software
>>>>>>>>>>>>>> engineer.It seems I understand your trace more than you do
>>>>>>>>>>>>>> which makes itobvious who is actually lacking in
>>>>>>>>>>>>>> competence here./Flibble
>>>>>>>>>>>>>
>>>>>>>>>>>>> Because H exactly simulates its input and has no control flow
>>>>>>>>>>>>>   behavior of it's own while it is simulating this input
>>>>>>>>>>>>> YOU ARE
>>>>>>>>>>>>>   BLAMING THE MIRROR FOR WHAT IT REFLECTS.
>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> H does have control low on its own, or it can't stop the
>>>>>>>>>>>> simulationg to give an answer.
>>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> Because H exactly simulates its input and has no control flow
>>>>>>>>>>> behavior of it's own
>>>>>>>>>>> while it is simulating this input
>>>>>>>>>>> while it is simulating this input
>>>>>>>>>>> while it is simulating this input
>>>>>>>>>>> while it is simulating this input
>>>>>>>>>>> while it is simulating this input
>>>>>>>>>>> while it is simulating this input
>>>>>>>>>>> while it is simulating this input
>>>>>>>>>>> while it is simulating this input
>>>>>>>>>>> while it is simulating this input
>>>>>>>>>>> while it is simulating this input
>>>>>>>>>>> while it is simulating this input
>>>>>>>>>>> while it is simulating this input
>>>>>>>>>>> while it is simulating this input
>>>>>>>>>>> while it is simulating this input
>>>>>>>>>>> YOU ARE BLAMING THE MIRROR FOR WHAT IT REFLECTS.
>>>>>>>>>>>
>>>>>>>>>>>> So either you are a liar, or just badly confused about what
>>>>>>>>>>>> you are saying.
>>>>>>>>>>>
>>>>>>>>>>> Or you OCD prevents you from paying close enough attention to
>>>>>>>>>>> ALL of my words.
>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> Then how does it decide to stop simulating if it has no
>>>>>>>>>> control flow before it stops?
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> H does not have any effect on the behavior of its simulated P
>>>>>>>>> the whole time that H is simulating P, thus any recursive
>>>>>>>>> behavior that P demonstrates is behavior of P and not behavior
>>>>>>>>> of H.
>>>>>>>>>
>>>>>>>>>
>>>>>>>>
>>>>>>>> Nope, the problem is in H, not P.
>>>>>>>>
>>>>>>>> This H by its actions might not affect the behavior of the input
>>>>>>>> it is simulating, but it doesn't correctly determine the effect
>>>>>>>> that the copy of H in P will have.
>>>>>>>
>>>>>>> void P(ptr x)
>>>>>>> {
>>>>>>>    int Halt_Status = H(x, x);
>>>>>>>    if (Halt_Status)
>>>>>>>      HERE: goto HERE;
>>>>>>>    return;
>>>>>>> }
>>>>>>>
>>>>>>> int main()
>>>>>>> {
>>>>>>>    Output("Input_Halts = ", H(P, P));
>>>>>>> }
>>>>>>>
>>>>>>> So you disagree with this:
>>>>>>>
>>>>>>> (a) H(P,P) simulates P(P) that calls a simulated H(P,P)
>>>>>>> (b) that simulates P(P) that calls a simulated H(P,P)
>>>>>>> (c) that simulates P(P) that calls a simulated H(P,P)
>>>>>>> (d) that simulates P(P) that calls a simulated H(P,P)...
>>>>>>> *Until H aborts its simulation*
>>>>>>>
>>>>>>>
>>>>>>>
>>>>>>
>>>>>> That isn't what your H does,
>>>>>
>>>>> Why do you say that isn't what my H does when you know that it is
>>>>> what my H does and you can verify this with the complete system?
>>>>>
>>>>> https://www.liarparadox.org/2022_07_22.zip
>>>>> This is the complete system that compiles under:
>>>>>
>>>>> Microsoft Visual Studio Community 2017
>>>>> https://visualstudio.microsoft.com/vs/older-downloads/
>>>>>
>>>>>
>>>>>
>>>>
>>>> Right, you didn't read what I said you H does, did you?
>>>>
>>>
>>> You said that what I said H does, it does not do, this is incorrect.
>>> Then you changed the subject.
>>>
>>
>> You H does NOT get to the step (b) that you have posted, so doesn't
>> match you pattern.
>>
>
> One H does not get past step (b)
> The other H does not get past step (c) and can be adapted to proceed any
> finite number of steps.
>
> The point is that no correct simulation of the input to H(P,P) by H ever
> stops running until H aborts it.
>


Click here to read the complete article
Re: Here is what a computer scientist that has been published in CACM said about my work [competence?]

<T9GdncITtZzow2f_nZ2dnZfqlJ9g4p2d@giganews.com>

  copy mid

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

  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!border-1.nntp.ord.giganews.com!nntp.giganews.com!Xl.tags.giganews.com!local-2.nntp.ord.giganews.com!news.giganews.com.POSTED!not-for-mail
NNTP-Posting-Date: Mon, 15 Aug 2022 14:55:49 +0000
Date: Mon, 15 Aug 2022 09:56:10 -0500
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:91.0) Gecko/20100101
Thunderbird/91.12.0
Subject: Re: Here is what a computer scientist that has been published in CACM
said about my work [competence?]
Content-Language: en-US
Newsgroups: comp.theory
References: <VUmdneqWu_jdjGT_nZ2dnZfqlJ_NnZ2d@giganews.com>
<20220814201431.00002067@reddwarf.jmc.corp>
<LLednYl9W7ET12T_nZ2dnZfqlJzNnZ2d@giganews.com>
<20220814205543.00006c29@reddwarf.jmc.corp> <tdbqq3$1cg2$1@gioia.aioe.org>
<cveKK.768959$ssF.612517@fx14.iad>
<2h-dnZQ8E7yD42T_nZ2dnZfqlJ9g4p2d@giganews.com>
<SzfKK.916573$JVi.396684@fx17.iad>
<MLOcnbPjLuakG2T_nZ2dnZfqlJ9g4p2d@giganews.com>
<UqgKK.136200$Me2.116425@fx47.iad>
<_KucnbJJWuzxAWT_nZ2dnZfqlJ_NnZ2d@giganews.com>
<HkhKK.793605$wIO9.479008@fx12.iad>
<PuidnRegb5XZOWT_nZ2dnZfqlJxh4p2d@giganews.com>
<OFhKK.730625$5fVf.417433@fx09.iad>
<Otqdnd4GfKOiNWT_nZ2dnZfqlJxh4p2d@giganews.com>
<KZhKK.772181$zgr9.340328@fx13.iad>
<tEmdnfEhQrIvM2T_nZ2dnZfqlJ_NnZ2d@giganews.com>
<sqqKK.137501$Me2.29783@fx47.iad>
From: NoO...@NoWhere.com (olcott)
In-Reply-To: <sqqKK.137501$Me2.29783@fx47.iad>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Message-ID: <T9GdncITtZzow2f_nZ2dnZfqlJ9g4p2d@giganews.com>
Lines: 175
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-w6g4/JZPsM66GTR7thsPAtuMzfVVjZkhY1rtTnkrRZeokjnQ56h+tGCGNzif+Qpzxb0yaO+iOiGF/IV!K61k/bzPj4qziAvqkwqbGcAg6j+GVZ1wjm3UyhVsXvlBwekqe5X2fREVIc/dQ9Gw8zqx7eEgLr4=
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 - Mon, 15 Aug 2022 14:56 UTC

On 8/15/2022 6:50 AM, Richard Damon wrote:
> On 8/14/22 10:26 PM, olcott wrote:
>> On 8/14/2022 9:14 PM, Richard Damon wrote:
>>> On 8/14/22 9:58 PM, olcott wrote:
>>>> On 8/14/2022 8:52 PM, Richard Damon wrote:
>>>>> On 8/14/22 9:41 PM, olcott wrote:
>>>>>> On 8/14/2022 8:30 PM, Richard Damon wrote:
>>>>>>> On 8/14/22 9:08 PM, olcott wrote:
>>>>>>>> On 8/14/2022 7:28 PM, Richard Damon wrote:
>>>>>>>>> On 8/14/22 7:33 PM, olcott wrote:
>>>>>>>>>> On 8/14/2022 6:29 PM, Richard Damon wrote:
>>>>>>>>>>> On 8/14/22 6:58 PM, olcott wrote:
>>>>>>>>>>>> On 8/14/2022 5:16 PM, Richard Damon wrote:
>>>>>>>>>>>>> On 8/14/22 5:52 PM, olcott wrote:
>>>>>>>>>>>>>> Mr Flibble <flibble@reddwarf.jmc.corp> Wrote in message:r
>>>>>>>>>>>>>>> On Sun, 14 Aug 2022 14:18:53 -0500olcott
>>>>>>>>>>>>>>> <NoOne@NoWhere.com> wrote:> On 8/14/2022 2:14 PM, Mr
>>>>>>>>>>>>>>> Flibble wrote:> > On Sun, 14 Aug 2022 10:14:28 -0500> >
>>>>>>>>>>>>>>> olcott <NoOne@NoWhere.com> wrote:> >   > >> *This is
>>>>>>>>>>>>>>> refers to H(P,P)==0 where H and P are functions in C*>
>>>>>>>>>>>>>>> >>> >>       I believe I have learned something valuable
>>>>>>>>>>>>>>> from you:> >>       that by simulation, and by
>>>>>>>>>>>>>>> simulations within simulations,> >>       non-halting can
>>>>>>>>>>>>>>> sometimes be detected, and in particular,> >>       it
>>>>>>>>>>>>>>> can be detected in the program used in the classical>
>>>>>>>>>>>>>>> >>       proof of incomputability.> >>> >> *Halting
>>>>>>>>>>>>>>> problem proofs refuted on the basis of software> >>
>>>>>>>>>>>>>>> engineering* ?> >>> >>
>>>>>>>>>>>>>>> https://www.researchgate.net/publication/361701808_Halting_problem_proofs_refuted_on_the_basis_of_software_engineering>
>>>>>>>>>>>>>>> >>  > > > > I am also a computer scientist and I am
>>>>>>>>>>>>>>> telling you that your> > halting decider reporting
>>>>>>>>>>>>>>> non-halting when it enters "infinite> > recursion" is an
>>>>>>>>>>>>>>> ERROR.  There is no infinite recursion in the HP> >
>>>>>>>>>>>>>>> proofs you are attempting to refute.> > > > /Flibble> >
>>>>>>>>>>>>>>> > > > void P(ptr x)> {> int Halt_Status = H(x, x);>    if
>>>>>>>>>>>>>>> (Halt_Status)>      HERE: goto HERE;>    return;> }> >
>>>>>>>>>>>>>>> int main()> {> Output("Input_Halts = ", H(P, P));> }> >
>>>>>>>>>>>>>>> If it was true that you are a computer scientist then you
>>>>>>>>>>>>>>> would > understand that this execution trace is correct:>
>>>>>>>>>>>>>>> > (a) H(P,P) simulates P(P) that calls a simulated
>>>>>>>>>>>>>>> H(P,P)> (b) that simulates P(P) that calls a simulated
>>>>>>>>>>>>>>> H(P,P)> (c) that simulates P(P) that calls a simulated
>>>>>>>>>>>>>>> H(P,P)> (d) that simulates P(P) that calls a simulated
>>>>>>>>>>>>>>> H(P,P)...> *Until H aborts its simulation*I am a computer
>>>>>>>>>>>>>>> scientist and all your trace shows is that H (not P) isat
>>>>>>>>>>>>>>> the root of your so called "infinite recursion" and is
>>>>>>>>>>>>>>> the primaryreason why you are incorrect to map this
>>>>>>>>>>>>>>> recursive behaviour of your Hto a halting decision on P
>>>>>>>>>>>>>>> of non-halting.> > If you do not understand that the
>>>>>>>>>>>>>>> above execution trace is correct> then this proves that
>>>>>>>>>>>>>>> you are not as much as a sufficiently competent >
>>>>>>>>>>>>>>> software engineer.It seems I understand your trace more
>>>>>>>>>>>>>>> than you do which makes itobvious who is actually lacking
>>>>>>>>>>>>>>> in competence here./Flibble
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> Because H exactly simulates its input and has no control flow
>>>>>>>>>>>>>>   behavior of it's own while it is simulating this input
>>>>>>>>>>>>>> YOU ARE
>>>>>>>>>>>>>>   BLAMING THE MIRROR FOR WHAT IT REFLECTS.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>> H does have control low on its own, or it can't stop the
>>>>>>>>>>>>> simulationg to give an answer.
>>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> Because H exactly simulates its input and has no control flow
>>>>>>>>>>>> behavior of it's own
>>>>>>>>>>>> while it is simulating this input
>>>>>>>>>>>> while it is simulating this input
>>>>>>>>>>>> while it is simulating this input
>>>>>>>>>>>> while it is simulating this input
>>>>>>>>>>>> while it is simulating this input
>>>>>>>>>>>> while it is simulating this input
>>>>>>>>>>>> while it is simulating this input
>>>>>>>>>>>> while it is simulating this input
>>>>>>>>>>>> while it is simulating this input
>>>>>>>>>>>> while it is simulating this input
>>>>>>>>>>>> while it is simulating this input
>>>>>>>>>>>> while it is simulating this input
>>>>>>>>>>>> while it is simulating this input
>>>>>>>>>>>> while it is simulating this input
>>>>>>>>>>>> YOU ARE BLAMING THE MIRROR FOR WHAT IT REFLECTS.
>>>>>>>>>>>>
>>>>>>>>>>>>> So either you are a liar, or just badly confused about what
>>>>>>>>>>>>> you are saying.
>>>>>>>>>>>>
>>>>>>>>>>>> Or you OCD prevents you from paying close enough attention
>>>>>>>>>>>> to ALL of my words.
>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> Then how does it decide to stop simulating if it has no
>>>>>>>>>>> control flow before it stops?
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> H does not have any effect on the behavior of its simulated P
>>>>>>>>>> the whole time that H is simulating P, thus any recursive
>>>>>>>>>> behavior that P demonstrates is behavior of P and not behavior
>>>>>>>>>> of H.
>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> Nope, the problem is in H, not P.
>>>>>>>>>
>>>>>>>>> This H by its actions might not affect the behavior of the
>>>>>>>>> input it is simulating, but it doesn't correctly determine the
>>>>>>>>> effect that the copy of H in P will have.
>>>>>>>>
>>>>>>>> void P(ptr x)
>>>>>>>> {
>>>>>>>>    int Halt_Status = H(x, x);
>>>>>>>>    if (Halt_Status)
>>>>>>>>      HERE: goto HERE;
>>>>>>>>    return;
>>>>>>>> }
>>>>>>>>
>>>>>>>> int main()
>>>>>>>> {
>>>>>>>>    Output("Input_Halts = ", H(P, P));
>>>>>>>> }
>>>>>>>>
>>>>>>>> So you disagree with this:
>>>>>>>>
>>>>>>>> (a) H(P,P) simulates P(P) that calls a simulated H(P,P)
>>>>>>>> (b) that simulates P(P) that calls a simulated H(P,P)
>>>>>>>> (c) that simulates P(P) that calls a simulated H(P,P)
>>>>>>>> (d) that simulates P(P) that calls a simulated H(P,P)...
>>>>>>>> *Until H aborts its simulation*
>>>>>>>>
>>>>>>>>
>>>>>>>>
>>>>>>>
>>>>>>> That isn't what your H does,
>>>>>>
>>>>>> Why do you say that isn't what my H does when you know that it is
>>>>>> what my H does and you can verify this with the complete system?
>>>>>>
>>>>>> https://www.liarparadox.org/2022_07_22.zip
>>>>>> This is the complete system that compiles under:
>>>>>>
>>>>>> Microsoft Visual Studio Community 2017
>>>>>> https://visualstudio.microsoft.com/vs/older-downloads/
>>>>>>
>>>>>>
>>>>>>
>>>>>
>>>>> Right, you didn't read what I said you H does, did you?
>>>>>
>>>>
>>>> You said that what I said H does, it does not do, this is incorrect.
>>>> Then you changed the subject.
>>>>
>>>
>>> You H does NOT get to the step (b) that you have posted, so doesn't
>>> match you pattern.
>>>
>>
>> One H does not get past step (b)
>> The other H does not get past step (c) and can be adapted to proceed
>> any finite number of steps.
>>
>> The point is that no correct simulation of the input to H(P,P) by H
>> ever stops running until H aborts it.
>>
>
> Nope, look at the code you provided.
Liar


Click here to read the complete article
Re: Here is what a computer scientist that has been published in CACM said about my work [competence?]

<d2AKK.1016233$X_i.4836@fx18.iad>

  copy mid

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

  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!fx18.iad.POSTED!not-for-mail
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:91.0)
Gecko/20100101 Thunderbird/91.12.0
Subject: Re: Here is what a computer scientist that has been published in CACM
said about my work [competence?]
Content-Language: en-US
Newsgroups: comp.theory
References: <VUmdneqWu_jdjGT_nZ2dnZfqlJ_NnZ2d@giganews.com>
<20220814201431.00002067@reddwarf.jmc.corp>
<LLednYl9W7ET12T_nZ2dnZfqlJzNnZ2d@giganews.com>
<20220814205543.00006c29@reddwarf.jmc.corp> <tdbqq3$1cg2$1@gioia.aioe.org>
<cveKK.768959$ssF.612517@fx14.iad>
<2h-dnZQ8E7yD42T_nZ2dnZfqlJ9g4p2d@giganews.com>
<SzfKK.916573$JVi.396684@fx17.iad>
<MLOcnbPjLuakG2T_nZ2dnZfqlJ9g4p2d@giganews.com>
<UqgKK.136200$Me2.116425@fx47.iad>
<_KucnbJJWuzxAWT_nZ2dnZfqlJ_NnZ2d@giganews.com>
<HkhKK.793605$wIO9.479008@fx12.iad>
<PuidnRegb5XZOWT_nZ2dnZfqlJxh4p2d@giganews.com>
<OFhKK.730625$5fVf.417433@fx09.iad>
<Otqdnd4GfKOiNWT_nZ2dnZfqlJxh4p2d@giganews.com>
<KZhKK.772181$zgr9.340328@fx13.iad>
<tEmdnfEhQrIvM2T_nZ2dnZfqlJ_NnZ2d@giganews.com>
<sqqKK.137501$Me2.29783@fx47.iad>
<T9GdncITtZzow2f_nZ2dnZfqlJ9g4p2d@giganews.com>
From: Rich...@Damon-Family.org (Richard Damon)
In-Reply-To: <T9GdncITtZzow2f_nZ2dnZfqlJ9g4p2d@giganews.com>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Lines: 177
Message-ID: <d2AKK.1016233$X_i.4836@fx18.iad>
X-Complaints-To: abuse@easynews.com
Organization: Forte - www.forteinc.com
X-Complaints-Info: Please be sure to forward a copy of ALL headers otherwise we will be unable to process your complaint properly.
Date: Mon, 15 Aug 2022 18:47:36 -0400
X-Received-Bytes: 9685
 by: Richard Damon - Mon, 15 Aug 2022 22:47 UTC

On 8/15/22 10:56 AM, olcott wrote:
> On 8/15/2022 6:50 AM, Richard Damon wrote:
>> On 8/14/22 10:26 PM, olcott wrote:
>>> On 8/14/2022 9:14 PM, Richard Damon wrote:
>>>> On 8/14/22 9:58 PM, olcott wrote:
>>>>> On 8/14/2022 8:52 PM, Richard Damon wrote:
>>>>>> On 8/14/22 9:41 PM, olcott wrote:
>>>>>>> On 8/14/2022 8:30 PM, Richard Damon wrote:
>>>>>>>> On 8/14/22 9:08 PM, olcott wrote:
>>>>>>>>> On 8/14/2022 7:28 PM, Richard Damon wrote:
>>>>>>>>>> On 8/14/22 7:33 PM, olcott wrote:
>>>>>>>>>>> On 8/14/2022 6:29 PM, Richard Damon wrote:
>>>>>>>>>>>> On 8/14/22 6:58 PM, olcott wrote:
>>>>>>>>>>>>> On 8/14/2022 5:16 PM, Richard Damon wrote:
>>>>>>>>>>>>>> On 8/14/22 5:52 PM, olcott wrote:
>>>>>>>>>>>>>>> Mr Flibble <flibble@reddwarf.jmc.corp> Wrote in message:r
>>>>>>>>>>>>>>>> On Sun, 14 Aug 2022 14:18:53 -0500olcott
>>>>>>>>>>>>>>>> <NoOne@NoWhere.com> wrote:> On 8/14/2022 2:14 PM, Mr
>>>>>>>>>>>>>>>> Flibble wrote:> > On Sun, 14 Aug 2022 10:14:28 -0500> >
>>>>>>>>>>>>>>>> olcott <NoOne@NoWhere.com> wrote:> >   > >> *This is
>>>>>>>>>>>>>>>> refers to H(P,P)==0 where H and P are functions in C*>
>>>>>>>>>>>>>>>> >>> >>       I believe I have learned something valuable
>>>>>>>>>>>>>>>> from you:> >>       that by simulation, and by
>>>>>>>>>>>>>>>> simulations within simulations,> >>       non-halting
>>>>>>>>>>>>>>>> can sometimes be detected, and in particular,> >>
>>>>>>>>>>>>>>>> it can be detected in the program used in the classical>
>>>>>>>>>>>>>>>> >>       proof of incomputability.> >>> >> *Halting
>>>>>>>>>>>>>>>> problem proofs refuted on the basis of software> >>
>>>>>>>>>>>>>>>> engineering* ?> >>> >>
>>>>>>>>>>>>>>>> https://www.researchgate.net/publication/361701808_Halting_problem_proofs_refuted_on_the_basis_of_software_engineering>
>>>>>>>>>>>>>>>> >>  > > > > I am also a computer scientist and I am
>>>>>>>>>>>>>>>> telling you that your> > halting decider reporting
>>>>>>>>>>>>>>>> non-halting when it enters "infinite> > recursion" is an
>>>>>>>>>>>>>>>> ERROR.  There is no infinite recursion in the HP> >
>>>>>>>>>>>>>>>> proofs you are attempting to refute.> > > > /Flibble> >
>>>>>>>>>>>>>>>> > > > void P(ptr x)> {> int Halt_Status = H(x, x);>
>>>>>>>>>>>>>>>> if (Halt_Status)>      HERE: goto HERE;>    return;> }>
>>>>>>>>>>>>>>>> > int main()> {> Output("Input_Halts = ", H(P, P));> }>
>>>>>>>>>>>>>>>> > If it was true that you are a computer scientist then
>>>>>>>>>>>>>>>> you would > understand that this execution trace is
>>>>>>>>>>>>>>>> correct:> > (a) H(P,P) simulates P(P) that calls a
>>>>>>>>>>>>>>>> simulated H(P,P)> (b) that simulates P(P) that calls a
>>>>>>>>>>>>>>>> simulated H(P,P)> (c) that simulates P(P) that calls a
>>>>>>>>>>>>>>>> simulated H(P,P)> (d) that simulates P(P) that calls a
>>>>>>>>>>>>>>>> simulated H(P,P)...> *Until H aborts its simulation*I am
>>>>>>>>>>>>>>>> a computer scientist and all your trace shows is that H
>>>>>>>>>>>>>>>> (not P) isat the root of your so called "infinite
>>>>>>>>>>>>>>>> recursion" and is the primaryreason why you are
>>>>>>>>>>>>>>>> incorrect to map this recursive behaviour of your Hto a
>>>>>>>>>>>>>>>> halting decision on P of non-halting.> > If you do not
>>>>>>>>>>>>>>>> understand that the above execution trace is correct>
>>>>>>>>>>>>>>>> then this proves that you are not as much as a
>>>>>>>>>>>>>>>> sufficiently competent > software engineer.It seems I
>>>>>>>>>>>>>>>> understand your trace more than you do which makes
>>>>>>>>>>>>>>>> itobvious who is actually lacking in competence
>>>>>>>>>>>>>>>> here./Flibble
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> Because H exactly simulates its input and has no control
>>>>>>>>>>>>>>> flow
>>>>>>>>>>>>>>>   behavior of it's own while it is simulating this input
>>>>>>>>>>>>>>> YOU ARE
>>>>>>>>>>>>>>>   BLAMING THE MIRROR FOR WHAT IT REFLECTS.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> H does have control low on its own, or it can't stop the
>>>>>>>>>>>>>> simulationg to give an answer.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>> Because H exactly simulates its input and has no control flow
>>>>>>>>>>>>> behavior of it's own
>>>>>>>>>>>>> while it is simulating this input
>>>>>>>>>>>>> while it is simulating this input
>>>>>>>>>>>>> while it is simulating this input
>>>>>>>>>>>>> while it is simulating this input
>>>>>>>>>>>>> while it is simulating this input
>>>>>>>>>>>>> while it is simulating this input
>>>>>>>>>>>>> while it is simulating this input
>>>>>>>>>>>>> while it is simulating this input
>>>>>>>>>>>>> while it is simulating this input
>>>>>>>>>>>>> while it is simulating this input
>>>>>>>>>>>>> while it is simulating this input
>>>>>>>>>>>>> while it is simulating this input
>>>>>>>>>>>>> while it is simulating this input
>>>>>>>>>>>>> while it is simulating this input
>>>>>>>>>>>>> YOU ARE BLAMING THE MIRROR FOR WHAT IT REFLECTS.
>>>>>>>>>>>>>
>>>>>>>>>>>>>> So either you are a liar, or just badly confused about
>>>>>>>>>>>>>> what you are saying.
>>>>>>>>>>>>>
>>>>>>>>>>>>> Or you OCD prevents you from paying close enough attention
>>>>>>>>>>>>> to ALL of my words.
>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> Then how does it decide to stop simulating if it has no
>>>>>>>>>>>> control flow before it stops?
>>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> H does not have any effect on the behavior of its simulated P
>>>>>>>>>>> the whole time that H is simulating P, thus any recursive
>>>>>>>>>>> behavior that P demonstrates is behavior of P and not
>>>>>>>>>>> behavior of H.
>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> Nope, the problem is in H, not P.
>>>>>>>>>>
>>>>>>>>>> This H by its actions might not affect the behavior of the
>>>>>>>>>> input it is simulating, but it doesn't correctly determine the
>>>>>>>>>> effect that the copy of H in P will have.
>>>>>>>>>
>>>>>>>>> void P(ptr x)
>>>>>>>>> {
>>>>>>>>>    int Halt_Status = H(x, x);
>>>>>>>>>    if (Halt_Status)
>>>>>>>>>      HERE: goto HERE;
>>>>>>>>>    return;
>>>>>>>>> }
>>>>>>>>>
>>>>>>>>> int main()
>>>>>>>>> {
>>>>>>>>>    Output("Input_Halts = ", H(P, P));
>>>>>>>>> }
>>>>>>>>>
>>>>>>>>> So you disagree with this:
>>>>>>>>>
>>>>>>>>> (a) H(P,P) simulates P(P) that calls a simulated H(P,P)
>>>>>>>>> (b) that simulates P(P) that calls a simulated H(P,P)
>>>>>>>>> (c) that simulates P(P) that calls a simulated H(P,P)
>>>>>>>>> (d) that simulates P(P) that calls a simulated H(P,P)...
>>>>>>>>> *Until H aborts its simulation*
>>>>>>>>>
>>>>>>>>>
>>>>>>>>>
>>>>>>>>
>>>>>>>> That isn't what your H does,
>>>>>>>
>>>>>>> Why do you say that isn't what my H does when you know that it is
>>>>>>> what my H does and you can verify this with the complete system?
>>>>>>>
>>>>>>> https://www.liarparadox.org/2022_07_22.zip
>>>>>>> This is the complete system that compiles under:
>>>>>>>
>>>>>>> Microsoft Visual Studio Community 2017
>>>>>>> https://visualstudio.microsoft.com/vs/older-downloads/
>>>>>>>
>>>>>>>
>>>>>>>
>>>>>>
>>>>>> Right, you didn't read what I said you H does, did you?
>>>>>>
>>>>>
>>>>> You said that what I said H does, it does not do, this is incorrect.
>>>>> Then you changed the subject.
>>>>>
>>>>
>>>> You H does NOT get to the step (b) that you have posted, so doesn't
>>>> match you pattern.
>>>>
>>>
>>> One H does not get past step (b)
>>> The other H does not get past step (c) and can be adapted to proceed
>>> any finite number of steps.
>>>
>>> The point is that no correct simulation of the input to H(P,P) by H
>>> ever stops running until H aborts it.
>>>
>>
>> Nope, look at the code you provided.
> Liar
>


Click here to read the complete article
Re: Here is what a computer scientist that has been published in CACM said about my work [competence?]

<t5idnUq6Z-PBRWf_nZ2dnZfqlJzNnZ2d@giganews.com>

  copy mid

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

  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: Mon, 15 Aug 2022 23:35:56 +0000
Date: Mon, 15 Aug 2022 18:36:11 -0500
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:91.0) Gecko/20100101
Thunderbird/91.12.0
Subject: Re: Here is what a computer scientist that has been published in CACM
said about my work [competence?]
Content-Language: en-US
Newsgroups: comp.theory
References: <VUmdneqWu_jdjGT_nZ2dnZfqlJ_NnZ2d@giganews.com>
<20220814201431.00002067@reddwarf.jmc.corp>
<LLednYl9W7ET12T_nZ2dnZfqlJzNnZ2d@giganews.com>
<20220814205543.00006c29@reddwarf.jmc.corp> <tdbqq3$1cg2$1@gioia.aioe.org>
<cveKK.768959$ssF.612517@fx14.iad>
<2h-dnZQ8E7yD42T_nZ2dnZfqlJ9g4p2d@giganews.com>
<SzfKK.916573$JVi.396684@fx17.iad>
<MLOcnbPjLuakG2T_nZ2dnZfqlJ9g4p2d@giganews.com>
<UqgKK.136200$Me2.116425@fx47.iad>
<_KucnbJJWuzxAWT_nZ2dnZfqlJ_NnZ2d@giganews.com>
<HkhKK.793605$wIO9.479008@fx12.iad>
<PuidnRegb5XZOWT_nZ2dnZfqlJxh4p2d@giganews.com>
<OFhKK.730625$5fVf.417433@fx09.iad>
<Otqdnd4GfKOiNWT_nZ2dnZfqlJxh4p2d@giganews.com>
<KZhKK.772181$zgr9.340328@fx13.iad>
<tEmdnfEhQrIvM2T_nZ2dnZfqlJ_NnZ2d@giganews.com>
<sqqKK.137501$Me2.29783@fx47.iad>
<T9GdncITtZzow2f_nZ2dnZfqlJ9g4p2d@giganews.com>
<d2AKK.1016233$X_i.4836@fx18.iad>
From: NoO...@NoWhere.com (olcott)
In-Reply-To: <d2AKK.1016233$X_i.4836@fx18.iad>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Message-ID: <t5idnUq6Z-PBRWf_nZ2dnZfqlJzNnZ2d@giganews.com>
Lines: 194
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-pAToglbfSlgpYOdLRHM+FQxt7qC6Nfyyr6NzSbmUB9dlff7NioJxhtj3cRqr4bVqgodqglo6Me+Sq8N!e+AYWMYuM4a9qTvUaaTshfvxoUhVXVSteOjZCIvzXf6VH9qkhPmAoy7psdZ+tMNjubHQ1WgYyb0=
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 - Mon, 15 Aug 2022 23:36 UTC

On 8/15/2022 5:47 PM, Richard Damon wrote:
> On 8/15/22 10:56 AM, olcott wrote:
>> On 8/15/2022 6:50 AM, Richard Damon wrote:
>>> On 8/14/22 10:26 PM, olcott wrote:
>>>> On 8/14/2022 9:14 PM, Richard Damon wrote:
>>>>> On 8/14/22 9:58 PM, olcott wrote:
>>>>>> On 8/14/2022 8:52 PM, Richard Damon wrote:
>>>>>>> On 8/14/22 9:41 PM, olcott wrote:
>>>>>>>> On 8/14/2022 8:30 PM, Richard Damon wrote:
>>>>>>>>> On 8/14/22 9:08 PM, olcott wrote:
>>>>>>>>>> On 8/14/2022 7:28 PM, Richard Damon wrote:
>>>>>>>>>>> On 8/14/22 7:33 PM, olcott wrote:
>>>>>>>>>>>> On 8/14/2022 6:29 PM, Richard Damon wrote:
>>>>>>>>>>>>> On 8/14/22 6:58 PM, olcott wrote:
>>>>>>>>>>>>>> On 8/14/2022 5:16 PM, Richard Damon wrote:
>>>>>>>>>>>>>>> On 8/14/22 5:52 PM, olcott wrote:
>>>>>>>>>>>>>>>> Mr Flibble <flibble@reddwarf.jmc.corp> Wrote in message:r
>>>>>>>>>>>>>>>>> On Sun, 14 Aug 2022 14:18:53 -0500olcott
>>>>>>>>>>>>>>>>> <NoOne@NoWhere.com> wrote:> On 8/14/2022 2:14 PM, Mr
>>>>>>>>>>>>>>>>> Flibble wrote:> > On Sun, 14 Aug 2022 10:14:28 -0500> >
>>>>>>>>>>>>>>>>> olcott <NoOne@NoWhere.com> wrote:> >   > >> *This is
>>>>>>>>>>>>>>>>> refers to H(P,P)==0 where H and P are functions in C*>
>>>>>>>>>>>>>>>>> >>> >>       I believe I have learned something
>>>>>>>>>>>>>>>>> valuable from you:> >>       that by simulation, and by
>>>>>>>>>>>>>>>>> simulations within simulations,> >>       non-halting
>>>>>>>>>>>>>>>>> can sometimes be detected, and in particular,> >> it
>>>>>>>>>>>>>>>>> can be detected in the program used in the classical>
>>>>>>>>>>>>>>>>> >>       proof of incomputability.> >>> >> *Halting
>>>>>>>>>>>>>>>>> problem proofs refuted on the basis of software> >>
>>>>>>>>>>>>>>>>> engineering* ?> >>> >>
>>>>>>>>>>>>>>>>> https://www.researchgate.net/publication/361701808_Halting_problem_proofs_refuted_on_the_basis_of_software_engineering>
>>>>>>>>>>>>>>>>> >>  > > > > I am also a computer scientist and I am
>>>>>>>>>>>>>>>>> telling you that your> > halting decider reporting
>>>>>>>>>>>>>>>>> non-halting when it enters "infinite> > recursion" is
>>>>>>>>>>>>>>>>> an ERROR.  There is no infinite recursion in the HP> >
>>>>>>>>>>>>>>>>> proofs you are attempting to refute.> > > > /Flibble> >
>>>>>>>>>>>>>>>>> > > > void P(ptr x)> {> int Halt_Status = H(x, x);> if
>>>>>>>>>>>>>>>>> (Halt_Status)>      HERE: goto HERE;>    return;> }> >
>>>>>>>>>>>>>>>>> int main()> {> Output("Input_Halts = ", H(P, P));> }> >
>>>>>>>>>>>>>>>>> If it was true that you are a computer scientist then
>>>>>>>>>>>>>>>>> you would > understand that this execution trace is
>>>>>>>>>>>>>>>>> correct:> > (a) H(P,P) simulates P(P) that calls a
>>>>>>>>>>>>>>>>> simulated H(P,P)> (b) that simulates P(P) that calls a
>>>>>>>>>>>>>>>>> simulated H(P,P)> (c) that simulates P(P) that calls a
>>>>>>>>>>>>>>>>> simulated H(P,P)> (d) that simulates P(P) that calls a
>>>>>>>>>>>>>>>>> simulated H(P,P)...> *Until H aborts its simulation*I
>>>>>>>>>>>>>>>>> am a computer scientist and all your trace shows is
>>>>>>>>>>>>>>>>> that H (not P) isat the root of your so called
>>>>>>>>>>>>>>>>> "infinite recursion" and is the primaryreason why you
>>>>>>>>>>>>>>>>> are incorrect to map this recursive behaviour of your
>>>>>>>>>>>>>>>>> Hto a halting decision on P of non-halting.> > If you
>>>>>>>>>>>>>>>>> do not understand that the above execution trace is
>>>>>>>>>>>>>>>>> correct> then this proves that you are not as much as a
>>>>>>>>>>>>>>>>> sufficiently competent > software engineer.It seems I
>>>>>>>>>>>>>>>>> understand your trace more than you do which makes
>>>>>>>>>>>>>>>>> itobvious who is actually lacking in competence
>>>>>>>>>>>>>>>>> here./Flibble
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> Because H exactly simulates its input and has no control
>>>>>>>>>>>>>>>> flow
>>>>>>>>>>>>>>>>   behavior of it's own while it is simulating this input
>>>>>>>>>>>>>>>> YOU ARE
>>>>>>>>>>>>>>>>   BLAMING THE MIRROR FOR WHAT IT REFLECTS.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> H does have control low on its own, or it can't stop the
>>>>>>>>>>>>>>> simulationg to give an answer.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> Because H exactly simulates its input and has no control flow
>>>>>>>>>>>>>> behavior of it's own
>>>>>>>>>>>>>> while it is simulating this input
>>>>>>>>>>>>>> while it is simulating this input
>>>>>>>>>>>>>> while it is simulating this input
>>>>>>>>>>>>>> while it is simulating this input
>>>>>>>>>>>>>> while it is simulating this input
>>>>>>>>>>>>>> while it is simulating this input
>>>>>>>>>>>>>> while it is simulating this input
>>>>>>>>>>>>>> while it is simulating this input
>>>>>>>>>>>>>> while it is simulating this input
>>>>>>>>>>>>>> while it is simulating this input
>>>>>>>>>>>>>> while it is simulating this input
>>>>>>>>>>>>>> while it is simulating this input
>>>>>>>>>>>>>> while it is simulating this input
>>>>>>>>>>>>>> while it is simulating this input
>>>>>>>>>>>>>> YOU ARE BLAMING THE MIRROR FOR WHAT IT REFLECTS.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> So either you are a liar, or just badly confused about
>>>>>>>>>>>>>>> what you are saying.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> Or you OCD prevents you from paying close enough attention
>>>>>>>>>>>>>> to ALL of my words.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>> Then how does it decide to stop simulating if it has no
>>>>>>>>>>>>> control flow before it stops?
>>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> H does not have any effect on the behavior of its simulated
>>>>>>>>>>>> P the whole time that H is simulating P, thus any recursive
>>>>>>>>>>>> behavior that P demonstrates is behavior of P and not
>>>>>>>>>>>> behavior of H.
>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> Nope, the problem is in H, not P.
>>>>>>>>>>>
>>>>>>>>>>> This H by its actions might not affect the behavior of the
>>>>>>>>>>> input it is simulating, but it doesn't correctly determine
>>>>>>>>>>> the effect that the copy of H in P will have.
>>>>>>>>>>
>>>>>>>>>> void P(ptr x)
>>>>>>>>>> {
>>>>>>>>>>    int Halt_Status = H(x, x);
>>>>>>>>>>    if (Halt_Status)
>>>>>>>>>>      HERE: goto HERE;
>>>>>>>>>>    return;
>>>>>>>>>> }
>>>>>>>>>>
>>>>>>>>>> int main()
>>>>>>>>>> {
>>>>>>>>>>    Output("Input_Halts = ", H(P, P));
>>>>>>>>>> }
>>>>>>>>>>
>>>>>>>>>> So you disagree with this:
>>>>>>>>>>
>>>>>>>>>> (a) H(P,P) simulates P(P) that calls a simulated H(P,P)
>>>>>>>>>> (b) that simulates P(P) that calls a simulated H(P,P)
>>>>>>>>>> (c) that simulates P(P) that calls a simulated H(P,P)
>>>>>>>>>> (d) that simulates P(P) that calls a simulated H(P,P)...
>>>>>>>>>> *Until H aborts its simulation*
>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> That isn't what your H does,
>>>>>>>>
>>>>>>>> Why do you say that isn't what my H does when you know that it
>>>>>>>> is what my H does and you can verify this with the complete system?
>>>>>>>>
>>>>>>>> https://www.liarparadox.org/2022_07_22.zip
>>>>>>>> This is the complete system that compiles under:
>>>>>>>>
>>>>>>>> Microsoft Visual Studio Community 2017
>>>>>>>> https://visualstudio.microsoft.com/vs/older-downloads/
>>>>>>>>
>>>>>>>>
>>>>>>>>
>>>>>>>
>>>>>>> Right, you didn't read what I said you H does, did you?
>>>>>>>
>>>>>>
>>>>>> You said that what I said H does, it does not do, this is incorrect.
>>>>>> Then you changed the subject.
>>>>>>
>>>>>
>>>>> You H does NOT get to the step (b) that you have posted, so doesn't
>>>>> match you pattern.
>>>>>
>>>>
>>>> One H does not get past step (b)
>>>> The other H does not get past step (c) and can be adapted to proceed
>>>> any finite number of steps.
>>>>
>>>> The point is that no correct simulation of the input to H(P,P) by H
>>>> ever stops running until H aborts it.
>>>>
>>>
>>> Nope, look at the code you provided.
>> Liar
>>
>
> Are you saying the code you provided DOESN'T abort the simulation done
> by H(P,P) at the point where P(P) calls H(P,P)?
>
>


Click here to read the complete article
Re: Here is what a computer scientist that has been published in CACM said about my work [competence?]

<3BBKK.730686$5fVf.367715@fx09.iad>

  copy mid

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

  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!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.12.0
Subject: Re: Here is what a computer scientist that has been published in CACM
said about my work [competence?]
Content-Language: en-US
Newsgroups: comp.theory
References: <VUmdneqWu_jdjGT_nZ2dnZfqlJ_NnZ2d@giganews.com>
<20220814201431.00002067@reddwarf.jmc.corp>
<LLednYl9W7ET12T_nZ2dnZfqlJzNnZ2d@giganews.com>
<20220814205543.00006c29@reddwarf.jmc.corp> <tdbqq3$1cg2$1@gioia.aioe.org>
<cveKK.768959$ssF.612517@fx14.iad>
<2h-dnZQ8E7yD42T_nZ2dnZfqlJ9g4p2d@giganews.com>
<SzfKK.916573$JVi.396684@fx17.iad>
<MLOcnbPjLuakG2T_nZ2dnZfqlJ9g4p2d@giganews.com>
<UqgKK.136200$Me2.116425@fx47.iad>
<_KucnbJJWuzxAWT_nZ2dnZfqlJ_NnZ2d@giganews.com>
<HkhKK.793605$wIO9.479008@fx12.iad>
<PuidnRegb5XZOWT_nZ2dnZfqlJxh4p2d@giganews.com>
<OFhKK.730625$5fVf.417433@fx09.iad>
<Otqdnd4GfKOiNWT_nZ2dnZfqlJxh4p2d@giganews.com>
<KZhKK.772181$zgr9.340328@fx13.iad>
<tEmdnfEhQrIvM2T_nZ2dnZfqlJ_NnZ2d@giganews.com>
<sqqKK.137501$Me2.29783@fx47.iad>
<T9GdncITtZzow2f_nZ2dnZfqlJ9g4p2d@giganews.com>
<d2AKK.1016233$X_i.4836@fx18.iad>
<t5idnUq6Z-PBRWf_nZ2dnZfqlJzNnZ2d@giganews.com>
From: Rich...@Damon-Family.org (Richard Damon)
In-Reply-To: <t5idnUq6Z-PBRWf_nZ2dnZfqlJzNnZ2d@giganews.com>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Lines: 208
Message-ID: <3BBKK.730686$5fVf.367715@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: Mon, 15 Aug 2022 20:33:03 -0400
X-Received-Bytes: 11319
 by: Richard Damon - Tue, 16 Aug 2022 00:33 UTC

On 8/15/22 7:36 PM, olcott wrote:
> On 8/15/2022 5:47 PM, Richard Damon wrote:
>> On 8/15/22 10:56 AM, olcott wrote:
>>> On 8/15/2022 6:50 AM, Richard Damon wrote:
>>>> On 8/14/22 10:26 PM, olcott wrote:
>>>>> On 8/14/2022 9:14 PM, Richard Damon wrote:
>>>>>> On 8/14/22 9:58 PM, olcott wrote:
>>>>>>> On 8/14/2022 8:52 PM, Richard Damon wrote:
>>>>>>>> On 8/14/22 9:41 PM, olcott wrote:
>>>>>>>>> On 8/14/2022 8:30 PM, Richard Damon wrote:
>>>>>>>>>> On 8/14/22 9:08 PM, olcott wrote:
>>>>>>>>>>> On 8/14/2022 7:28 PM, Richard Damon wrote:
>>>>>>>>>>>> On 8/14/22 7:33 PM, olcott wrote:
>>>>>>>>>>>>> On 8/14/2022 6:29 PM, Richard Damon wrote:
>>>>>>>>>>>>>> On 8/14/22 6:58 PM, olcott wrote:
>>>>>>>>>>>>>>> On 8/14/2022 5:16 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>> On 8/14/22 5:52 PM, olcott wrote:
>>>>>>>>>>>>>>>>> Mr Flibble <flibble@reddwarf.jmc.corp> Wrote in message:r
>>>>>>>>>>>>>>>>>> On Sun, 14 Aug 2022 14:18:53 -0500olcott
>>>>>>>>>>>>>>>>>> <NoOne@NoWhere.com> wrote:> On 8/14/2022 2:14 PM, Mr
>>>>>>>>>>>>>>>>>> Flibble wrote:> > On Sun, 14 Aug 2022 10:14:28 -0500>
>>>>>>>>>>>>>>>>>> > olcott <NoOne@NoWhere.com> wrote:> >   > >> *This is
>>>>>>>>>>>>>>>>>> refers to H(P,P)==0 where H and P are functions in C*>
>>>>>>>>>>>>>>>>>> >>> >>       I believe I have learned something
>>>>>>>>>>>>>>>>>> valuable from you:> >>       that by simulation, and
>>>>>>>>>>>>>>>>>> by simulations within simulations,> >>
>>>>>>>>>>>>>>>>>> non-halting can sometimes be detected, and in
>>>>>>>>>>>>>>>>>> particular,> >> it can be detected in the program used
>>>>>>>>>>>>>>>>>> in the classical> >>       proof of incomputability.>
>>>>>>>>>>>>>>>>>> >>> >> *Halting problem proofs refuted on the basis of
>>>>>>>>>>>>>>>>>> software> >> engineering* ?> >>> >>
>>>>>>>>>>>>>>>>>> https://www.researchgate.net/publication/361701808_Halting_problem_proofs_refuted_on_the_basis_of_software_engineering>
>>>>>>>>>>>>>>>>>> >>  > > > > I am also a computer scientist and I am
>>>>>>>>>>>>>>>>>> telling you that your> > halting decider reporting
>>>>>>>>>>>>>>>>>> non-halting when it enters "infinite> > recursion" is
>>>>>>>>>>>>>>>>>> an ERROR.  There is no infinite recursion in the HP> >
>>>>>>>>>>>>>>>>>> proofs you are attempting to refute.> > > > /Flibble>
>>>>>>>>>>>>>>>>>> > > > > void P(ptr x)> {> int Halt_Status = H(x, x);>
>>>>>>>>>>>>>>>>>> if (Halt_Status)>      HERE: goto HERE;>    return;>
>>>>>>>>>>>>>>>>>> }> > int main()> {> Output("Input_Halts = ", H(P,
>>>>>>>>>>>>>>>>>> P));> }> > If it was true that you are a computer
>>>>>>>>>>>>>>>>>> scientist then you would > understand that this
>>>>>>>>>>>>>>>>>> execution trace is correct:> > (a) H(P,P) simulates
>>>>>>>>>>>>>>>>>> P(P) that calls a simulated H(P,P)> (b) that simulates
>>>>>>>>>>>>>>>>>> P(P) that calls a simulated H(P,P)> (c) that simulates
>>>>>>>>>>>>>>>>>> P(P) that calls a simulated H(P,P)> (d) that simulates
>>>>>>>>>>>>>>>>>> P(P) that calls a simulated H(P,P)...> *Until H aborts
>>>>>>>>>>>>>>>>>> its simulation*I am a computer scientist and all your
>>>>>>>>>>>>>>>>>> trace shows is that H (not P) isat the root of your so
>>>>>>>>>>>>>>>>>> called "infinite recursion" and is the primaryreason
>>>>>>>>>>>>>>>>>> why you are incorrect to map this recursive behaviour
>>>>>>>>>>>>>>>>>> of your Hto a halting decision on P of non-halting.> >
>>>>>>>>>>>>>>>>>> If you do not understand that the above execution
>>>>>>>>>>>>>>>>>> trace is correct> then this proves that you are not as
>>>>>>>>>>>>>>>>>> much as a sufficiently competent > software
>>>>>>>>>>>>>>>>>> engineer.It seems I understand your trace more than
>>>>>>>>>>>>>>>>>> you do which makes itobvious who is actually lacking
>>>>>>>>>>>>>>>>>> in competence here./Flibble
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> Because H exactly simulates its input and has no
>>>>>>>>>>>>>>>>> control flow
>>>>>>>>>>>>>>>>>   behavior of it's own while it is simulating this
>>>>>>>>>>>>>>>>> input YOU ARE
>>>>>>>>>>>>>>>>>   BLAMING THE MIRROR FOR WHAT IT REFLECTS.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> H does have control low on its own, or it can't stop the
>>>>>>>>>>>>>>>> simulationg to give an answer.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> Because H exactly simulates its input and has no control
>>>>>>>>>>>>>>> flow
>>>>>>>>>>>>>>> behavior of it's own
>>>>>>>>>>>>>>> while it is simulating this input
>>>>>>>>>>>>>>> while it is simulating this input
>>>>>>>>>>>>>>> while it is simulating this input
>>>>>>>>>>>>>>> while it is simulating this input
>>>>>>>>>>>>>>> while it is simulating this input
>>>>>>>>>>>>>>> while it is simulating this input
>>>>>>>>>>>>>>> while it is simulating this input
>>>>>>>>>>>>>>> while it is simulating this input
>>>>>>>>>>>>>>> while it is simulating this input
>>>>>>>>>>>>>>> while it is simulating this input
>>>>>>>>>>>>>>> while it is simulating this input
>>>>>>>>>>>>>>> while it is simulating this input
>>>>>>>>>>>>>>> while it is simulating this input
>>>>>>>>>>>>>>> while it is simulating this input
>>>>>>>>>>>>>>> YOU ARE BLAMING THE MIRROR FOR WHAT IT REFLECTS.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> So either you are a liar, or just badly confused about
>>>>>>>>>>>>>>>> what you are saying.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> Or you OCD prevents you from paying close enough
>>>>>>>>>>>>>>> attention to ALL of my words.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> Then how does it decide to stop simulating if it has no
>>>>>>>>>>>>>> control flow before it stops?
>>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>> H does not have any effect on the behavior of its simulated
>>>>>>>>>>>>> P the whole time that H is simulating P, thus any recursive
>>>>>>>>>>>>> behavior that P demonstrates is behavior of P and not
>>>>>>>>>>>>> behavior of H.
>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> Nope, the problem is in H, not P.
>>>>>>>>>>>>
>>>>>>>>>>>> This H by its actions might not affect the behavior of the
>>>>>>>>>>>> input it is simulating, but it doesn't correctly determine
>>>>>>>>>>>> the effect that the copy of H in P will have.
>>>>>>>>>>>
>>>>>>>>>>> void P(ptr x)
>>>>>>>>>>> {
>>>>>>>>>>>    int Halt_Status = H(x, x);
>>>>>>>>>>>    if (Halt_Status)
>>>>>>>>>>>      HERE: goto HERE;
>>>>>>>>>>>    return;
>>>>>>>>>>> }
>>>>>>>>>>>
>>>>>>>>>>> int main()
>>>>>>>>>>> {
>>>>>>>>>>>    Output("Input_Halts = ", H(P, P));
>>>>>>>>>>> }
>>>>>>>>>>>
>>>>>>>>>>> So you disagree with this:
>>>>>>>>>>>
>>>>>>>>>>> (a) H(P,P) simulates P(P) that calls a simulated H(P,P)
>>>>>>>>>>> (b) that simulates P(P) that calls a simulated H(P,P)
>>>>>>>>>>> (c) that simulates P(P) that calls a simulated H(P,P)
>>>>>>>>>>> (d) that simulates P(P) that calls a simulated H(P,P)...
>>>>>>>>>>> *Until H aborts its simulation*
>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> That isn't what your H does,
>>>>>>>>>
>>>>>>>>> Why do you say that isn't what my H does when you know that it
>>>>>>>>> is what my H does and you can verify this with the complete
>>>>>>>>> system?
>>>>>>>>>
>>>>>>>>> https://www.liarparadox.org/2022_07_22.zip
>>>>>>>>> This is the complete system that compiles under:
>>>>>>>>>
>>>>>>>>> Microsoft Visual Studio Community 2017
>>>>>>>>> https://visualstudio.microsoft.com/vs/older-downloads/
>>>>>>>>>
>>>>>>>>>
>>>>>>>>>
>>>>>>>>
>>>>>>>> Right, you didn't read what I said you H does, did you?
>>>>>>>>
>>>>>>>
>>>>>>> You said that what I said H does, it does not do, this is incorrect.
>>>>>>> Then you changed the subject.
>>>>>>>
>>>>>>
>>>>>> You H does NOT get to the step (b) that you have posted, so
>>>>>> doesn't match you pattern.
>>>>>>
>>>>>
>>>>> One H does not get past step (b)
>>>>> The other H does not get past step (c) and can be adapted to
>>>>> proceed any finite number of steps.
>>>>>
>>>>> The point is that no correct simulation of the input to H(P,P) by H
>>>>> ever stops running until H aborts it.
>>>>>
>>>>
>>>> Nope, look at the code you provided.
>>> Liar
>>>
>>
>> Are you saying the code you provided DOESN'T abort the simulation done
>> by H(P,P) at the point where P(P) calls H(P,P)?
>>
>>
>
> The algorithm implemented by H:
> The correct simulation by H(P,P), never stops running until H aborts it.


Click here to read the complete article
Re: Here is what a computer scientist that has been published in CACM said about my work [competence?]

<Vp6dnZdlCtCndWf_nZ2dnZfqlJzNnZ2d@giganews.com>

  copy mid

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

  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!border-1.nntp.ord.giganews.com!nntp.giganews.com!Xl.tags.giganews.com!local-2.nntp.ord.giganews.com!news.giganews.com.POSTED!not-for-mail
NNTP-Posting-Date: Tue, 16 Aug 2022 00:43:38 +0000
Date: Mon, 15 Aug 2022 19:43:53 -0500
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:91.0) Gecko/20100101
Thunderbird/91.12.0
Subject: Re: Here is what a computer scientist that has been published in CACM
said about my work [competence?]
Content-Language: en-US
Newsgroups: comp.theory
References: <VUmdneqWu_jdjGT_nZ2dnZfqlJ_NnZ2d@giganews.com>
<20220814201431.00002067@reddwarf.jmc.corp>
<LLednYl9W7ET12T_nZ2dnZfqlJzNnZ2d@giganews.com>
<20220814205543.00006c29@reddwarf.jmc.corp> <tdbqq3$1cg2$1@gioia.aioe.org>
<cveKK.768959$ssF.612517@fx14.iad>
<2h-dnZQ8E7yD42T_nZ2dnZfqlJ9g4p2d@giganews.com>
<SzfKK.916573$JVi.396684@fx17.iad>
<MLOcnbPjLuakG2T_nZ2dnZfqlJ9g4p2d@giganews.com>
<UqgKK.136200$Me2.116425@fx47.iad>
<_KucnbJJWuzxAWT_nZ2dnZfqlJ_NnZ2d@giganews.com>
<HkhKK.793605$wIO9.479008@fx12.iad>
<PuidnRegb5XZOWT_nZ2dnZfqlJxh4p2d@giganews.com>
<OFhKK.730625$5fVf.417433@fx09.iad>
<Otqdnd4GfKOiNWT_nZ2dnZfqlJxh4p2d@giganews.com>
<KZhKK.772181$zgr9.340328@fx13.iad>
<tEmdnfEhQrIvM2T_nZ2dnZfqlJ_NnZ2d@giganews.com>
<sqqKK.137501$Me2.29783@fx47.iad>
<T9GdncITtZzow2f_nZ2dnZfqlJ9g4p2d@giganews.com>
<d2AKK.1016233$X_i.4836@fx18.iad>
<t5idnUq6Z-PBRWf_nZ2dnZfqlJzNnZ2d@giganews.com>
<3BBKK.730686$5fVf.367715@fx09.iad>
From: NoO...@NoWhere.com (olcott)
In-Reply-To: <3BBKK.730686$5fVf.367715@fx09.iad>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Message-ID: <Vp6dnZdlCtCndWf_nZ2dnZfqlJzNnZ2d@giganews.com>
Lines: 207
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-RTvIFg5w+tG5R7f5G6whA08yzCW/wCG96NguygDjnnpNkiA4LsybTCkeBIlmOWzXZkgEZci0Cvj7Ce3!kaPMXeC/oNJB6xKTnp4Fu9rIZQvLZbn7SoSJZ9m9QVtkEJ08aUKzQjGRO1ucSAP1WDKnVHKQ5co=
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 - Tue, 16 Aug 2022 00:43 UTC

On 8/15/2022 7:33 PM, Richard Damon wrote:
> On 8/15/22 7:36 PM, olcott wrote:
>> On 8/15/2022 5:47 PM, Richard Damon wrote:
>>> On 8/15/22 10:56 AM, olcott wrote:
>>>> On 8/15/2022 6:50 AM, Richard Damon wrote:
>>>>> On 8/14/22 10:26 PM, olcott wrote:
>>>>>> On 8/14/2022 9:14 PM, Richard Damon wrote:
>>>>>>> On 8/14/22 9:58 PM, olcott wrote:
>>>>>>>> On 8/14/2022 8:52 PM, Richard Damon wrote:
>>>>>>>>> On 8/14/22 9:41 PM, olcott wrote:
>>>>>>>>>> On 8/14/2022 8:30 PM, Richard Damon wrote:
>>>>>>>>>>> On 8/14/22 9:08 PM, olcott wrote:
>>>>>>>>>>>> On 8/14/2022 7:28 PM, Richard Damon wrote:
>>>>>>>>>>>>> On 8/14/22 7:33 PM, olcott wrote:
>>>>>>>>>>>>>> On 8/14/2022 6:29 PM, Richard Damon wrote:
>>>>>>>>>>>>>>> On 8/14/22 6:58 PM, olcott wrote:
>>>>>>>>>>>>>>>> On 8/14/2022 5:16 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>> On 8/14/22 5:52 PM, olcott wrote:
>>>>>>>>>>>>>>>>>> Mr Flibble <flibble@reddwarf.jmc.corp> Wrote in message:r
>>>>>>>>>>>>>>>>>>> On Sun, 14 Aug 2022 14:18:53 -0500olcott
>>>>>>>>>>>>>>>>>>> <NoOne@NoWhere.com> wrote:> On 8/14/2022 2:14 PM, Mr
>>>>>>>>>>>>>>>>>>> Flibble wrote:> > On Sun, 14 Aug 2022 10:14:28 -0500>
>>>>>>>>>>>>>>>>>>> > olcott <NoOne@NoWhere.com> wrote:> >   > >> *This
>>>>>>>>>>>>>>>>>>> is refers to H(P,P)==0 where H and P are functions in
>>>>>>>>>>>>>>>>>>> C*> >>> >>       I believe I have learned something
>>>>>>>>>>>>>>>>>>> valuable from you:> >>       that by simulation, and
>>>>>>>>>>>>>>>>>>> by simulations within simulations,> >> non-halting
>>>>>>>>>>>>>>>>>>> can sometimes be detected, and in particular,> >> it
>>>>>>>>>>>>>>>>>>> can be detected in the program used in the classical>
>>>>>>>>>>>>>>>>>>> >>       proof of incomputability.> >>> >> *Halting
>>>>>>>>>>>>>>>>>>> problem proofs refuted on the basis of software> >>
>>>>>>>>>>>>>>>>>>> engineering* ?> >>> >>
>>>>>>>>>>>>>>>>>>> https://www.researchgate.net/publication/361701808_Halting_problem_proofs_refuted_on_the_basis_of_software_engineering>
>>>>>>>>>>>>>>>>>>> >>  > > > > I am also a computer scientist and I am
>>>>>>>>>>>>>>>>>>> telling you that your> > halting decider reporting
>>>>>>>>>>>>>>>>>>> non-halting when it enters "infinite> > recursion" is
>>>>>>>>>>>>>>>>>>> an ERROR.  There is no infinite recursion in the HP>
>>>>>>>>>>>>>>>>>>> > proofs you are attempting to refute.> > > >
>>>>>>>>>>>>>>>>>>> /Flibble> > > > > void P(ptr x)> {> int Halt_Status =
>>>>>>>>>>>>>>>>>>> H(x, x);> if (Halt_Status)>      HERE: goto HERE;>
>>>>>>>>>>>>>>>>>>> return;> }> > int main()> {> Output("Input_Halts = ",
>>>>>>>>>>>>>>>>>>> H(P, P));> }> > If it was true that you are a
>>>>>>>>>>>>>>>>>>> computer scientist then you would > understand that
>>>>>>>>>>>>>>>>>>> this execution trace is correct:> > (a) H(P,P)
>>>>>>>>>>>>>>>>>>> simulates P(P) that calls a simulated H(P,P)> (b)
>>>>>>>>>>>>>>>>>>> that simulates P(P) that calls a simulated H(P,P)>
>>>>>>>>>>>>>>>>>>> (c) that simulates P(P) that calls a simulated
>>>>>>>>>>>>>>>>>>> H(P,P)> (d) that simulates P(P) that calls a
>>>>>>>>>>>>>>>>>>> simulated H(P,P)...> *Until H aborts its simulation*I
>>>>>>>>>>>>>>>>>>> am a computer scientist and all your trace shows is
>>>>>>>>>>>>>>>>>>> that H (not P) isat the root of your so called
>>>>>>>>>>>>>>>>>>> "infinite recursion" and is the primaryreason why you
>>>>>>>>>>>>>>>>>>> are incorrect to map this recursive behaviour of your
>>>>>>>>>>>>>>>>>>> Hto a halting decision on P of non-halting.> > If you
>>>>>>>>>>>>>>>>>>> do not understand that the above execution trace is
>>>>>>>>>>>>>>>>>>> correct> then this proves that you are not as much as
>>>>>>>>>>>>>>>>>>> a sufficiently competent > software engineer.It seems
>>>>>>>>>>>>>>>>>>> I understand your trace more than you do which makes
>>>>>>>>>>>>>>>>>>> itobvious who is actually lacking in competence
>>>>>>>>>>>>>>>>>>> here./Flibble
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> Because H exactly simulates its input and has no
>>>>>>>>>>>>>>>>>> control flow
>>>>>>>>>>>>>>>>>>   behavior of it's own while it is simulating this
>>>>>>>>>>>>>>>>>> input YOU ARE
>>>>>>>>>>>>>>>>>>   BLAMING THE MIRROR FOR WHAT IT REFLECTS.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> H does have control low on its own, or it can't stop
>>>>>>>>>>>>>>>>> the simulationg to give an answer.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> Because H exactly simulates its input and has no control
>>>>>>>>>>>>>>>> flow
>>>>>>>>>>>>>>>> behavior of it's own
>>>>>>>>>>>>>>>> while it is simulating this input
>>>>>>>>>>>>>>>> while it is simulating this input
>>>>>>>>>>>>>>>> while it is simulating this input
>>>>>>>>>>>>>>>> while it is simulating this input
>>>>>>>>>>>>>>>> while it is simulating this input
>>>>>>>>>>>>>>>> while it is simulating this input
>>>>>>>>>>>>>>>> while it is simulating this input
>>>>>>>>>>>>>>>> while it is simulating this input
>>>>>>>>>>>>>>>> while it is simulating this input
>>>>>>>>>>>>>>>> while it is simulating this input
>>>>>>>>>>>>>>>> while it is simulating this input
>>>>>>>>>>>>>>>> while it is simulating this input
>>>>>>>>>>>>>>>> while it is simulating this input
>>>>>>>>>>>>>>>> while it is simulating this input
>>>>>>>>>>>>>>>> YOU ARE BLAMING THE MIRROR FOR WHAT IT REFLECTS.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> So either you are a liar, or just badly confused about
>>>>>>>>>>>>>>>>> what you are saying.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> Or you OCD prevents you from paying close enough
>>>>>>>>>>>>>>>> attention to ALL of my words.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> Then how does it decide to stop simulating if it has no
>>>>>>>>>>>>>>> control flow before it stops?
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> H does not have any effect on the behavior of its
>>>>>>>>>>>>>> simulated P the whole time that H is simulating P, thus
>>>>>>>>>>>>>> any recursive behavior that P demonstrates is behavior of
>>>>>>>>>>>>>> P and not behavior of H.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>> Nope, the problem is in H, not P.
>>>>>>>>>>>>>
>>>>>>>>>>>>> This H by its actions might not affect the behavior of the
>>>>>>>>>>>>> input it is simulating, but it doesn't correctly determine
>>>>>>>>>>>>> the effect that the copy of H in P will have.
>>>>>>>>>>>>
>>>>>>>>>>>> void P(ptr x)
>>>>>>>>>>>> {
>>>>>>>>>>>>    int Halt_Status = H(x, x);
>>>>>>>>>>>>    if (Halt_Status)
>>>>>>>>>>>>      HERE: goto HERE;
>>>>>>>>>>>>    return;
>>>>>>>>>>>> }
>>>>>>>>>>>>
>>>>>>>>>>>> int main()
>>>>>>>>>>>> {
>>>>>>>>>>>>    Output("Input_Halts = ", H(P, P));
>>>>>>>>>>>> }
>>>>>>>>>>>>
>>>>>>>>>>>> So you disagree with this:
>>>>>>>>>>>>
>>>>>>>>>>>> (a) H(P,P) simulates P(P) that calls a simulated H(P,P)
>>>>>>>>>>>> (b) that simulates P(P) that calls a simulated H(P,P)
>>>>>>>>>>>> (c) that simulates P(P) that calls a simulated H(P,P)
>>>>>>>>>>>> (d) that simulates P(P) that calls a simulated H(P,P)...
>>>>>>>>>>>> *Until H aborts its simulation*
>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> That isn't what your H does,
>>>>>>>>>>
>>>>>>>>>> Why do you say that isn't what my H does when you know that it
>>>>>>>>>> is what my H does and you can verify this with the complete
>>>>>>>>>> system?
>>>>>>>>>>
>>>>>>>>>> https://www.liarparadox.org/2022_07_22.zip
>>>>>>>>>> This is the complete system that compiles under:
>>>>>>>>>>
>>>>>>>>>> Microsoft Visual Studio Community 2017
>>>>>>>>>> https://visualstudio.microsoft.com/vs/older-downloads/
>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> Right, you didn't read what I said you H does, did you?
>>>>>>>>>
>>>>>>>>
>>>>>>>> You said that what I said H does, it does not do, this is
>>>>>>>> incorrect.
>>>>>>>> Then you changed the subject.
>>>>>>>>
>>>>>>>
>>>>>>> You H does NOT get to the step (b) that you have posted, so
>>>>>>> doesn't match you pattern.
>>>>>>>
>>>>>>
>>>>>> One H does not get past step (b)
>>>>>> The other H does not get past step (c) and can be adapted to
>>>>>> proceed any finite number of steps.
>>>>>>
>>>>>> The point is that no correct simulation of the input to H(P,P) by
>>>>>> H ever stops running until H aborts it.
>>>>>>
>>>>>
>>>>> Nope, look at the code you provided.
>>>> Liar
>>>>
>>>
>>> Are you saying the code you provided DOESN'T abort the simulation
>>> done by H(P,P) at the point where P(P) calls H(P,P)?
>>>
>>>
>>
>> The algorithm implemented by H:
>> The correct simulation by H(P,P), never stops running until H aborts it.
>
> No, the algorithm implemented by your H is to abort the simulation of
> P(P) as soon as it calls H(P,P).
So you don't know the difference between an algorithm and its
implementation?


Click here to read the complete article
Re: Here is what a computer scientist that has been published in CACM said about my work [competence?]

<82CKK.917261$JVi.344055@fx17.iad>

  copy mid

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

  copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!usenet.blueworldhosting.com!feed1.usenet.blueworldhosting.com!peer01.iad!feed-me.highwinds-media.com!news.highwinds-media.com!fx17.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.12.0
Subject: Re: Here is what a computer scientist that has been published in CACM
said about my work [competence?]
Content-Language: en-US
Newsgroups: comp.theory
References: <VUmdneqWu_jdjGT_nZ2dnZfqlJ_NnZ2d@giganews.com>
<20220814201431.00002067@reddwarf.jmc.corp>
<LLednYl9W7ET12T_nZ2dnZfqlJzNnZ2d@giganews.com>
<20220814205543.00006c29@reddwarf.jmc.corp> <tdbqq3$1cg2$1@gioia.aioe.org>
<cveKK.768959$ssF.612517@fx14.iad>
<2h-dnZQ8E7yD42T_nZ2dnZfqlJ9g4p2d@giganews.com>
<SzfKK.916573$JVi.396684@fx17.iad>
<MLOcnbPjLuakG2T_nZ2dnZfqlJ9g4p2d@giganews.com>
<UqgKK.136200$Me2.116425@fx47.iad>
<_KucnbJJWuzxAWT_nZ2dnZfqlJ_NnZ2d@giganews.com>
<HkhKK.793605$wIO9.479008@fx12.iad>
<PuidnRegb5XZOWT_nZ2dnZfqlJxh4p2d@giganews.com>
<OFhKK.730625$5fVf.417433@fx09.iad>
<Otqdnd4GfKOiNWT_nZ2dnZfqlJxh4p2d@giganews.com>
<KZhKK.772181$zgr9.340328@fx13.iad>
<tEmdnfEhQrIvM2T_nZ2dnZfqlJ_NnZ2d@giganews.com>
<sqqKK.137501$Me2.29783@fx47.iad>
<T9GdncITtZzow2f_nZ2dnZfqlJ9g4p2d@giganews.com>
<d2AKK.1016233$X_i.4836@fx18.iad>
<t5idnUq6Z-PBRWf_nZ2dnZfqlJzNnZ2d@giganews.com>
<3BBKK.730686$5fVf.367715@fx09.iad>
<Vp6dnZdlCtCndWf_nZ2dnZfqlJzNnZ2d@giganews.com>
From: Rich...@Damon-Family.org (Richard Damon)
In-Reply-To: <Vp6dnZdlCtCndWf_nZ2dnZfqlJzNnZ2d@giganews.com>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Lines: 231
Message-ID: <82CKK.917261$JVi.344055@fx17.iad>
X-Complaints-To: abuse@easynews.com
Organization: Forte - www.forteinc.com
X-Complaints-Info: Please be sure to forward a copy of ALL headers otherwise we will be unable to process your complaint properly.
Date: Mon, 15 Aug 2022 21:04:04 -0400
X-Received-Bytes: 12533
 by: Richard Damon - Tue, 16 Aug 2022 01:04 UTC

On 8/15/22 8:43 PM, olcott wrote:
> On 8/15/2022 7:33 PM, Richard Damon wrote:
>> On 8/15/22 7:36 PM, olcott wrote:
>>> On 8/15/2022 5:47 PM, Richard Damon wrote:
>>>> On 8/15/22 10:56 AM, olcott wrote:
>>>>> On 8/15/2022 6:50 AM, Richard Damon wrote:
>>>>>> On 8/14/22 10:26 PM, olcott wrote:
>>>>>>> On 8/14/2022 9:14 PM, Richard Damon wrote:
>>>>>>>> On 8/14/22 9:58 PM, olcott wrote:
>>>>>>>>> On 8/14/2022 8:52 PM, Richard Damon wrote:
>>>>>>>>>> On 8/14/22 9:41 PM, olcott wrote:
>>>>>>>>>>> On 8/14/2022 8:30 PM, Richard Damon wrote:
>>>>>>>>>>>> On 8/14/22 9:08 PM, olcott wrote:
>>>>>>>>>>>>> On 8/14/2022 7:28 PM, Richard Damon wrote:
>>>>>>>>>>>>>> On 8/14/22 7:33 PM, olcott wrote:
>>>>>>>>>>>>>>> On 8/14/2022 6:29 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>> On 8/14/22 6:58 PM, olcott wrote:
>>>>>>>>>>>>>>>>> On 8/14/2022 5:16 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>> On 8/14/22 5:52 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>> Mr Flibble <flibble@reddwarf.jmc.corp> Wrote in
>>>>>>>>>>>>>>>>>>> message:r
>>>>>>>>>>>>>>>>>>>> On Sun, 14 Aug 2022 14:18:53 -0500olcott
>>>>>>>>>>>>>>>>>>>> <NoOne@NoWhere.com> wrote:> On 8/14/2022 2:14 PM, Mr
>>>>>>>>>>>>>>>>>>>> Flibble wrote:> > On Sun, 14 Aug 2022 10:14:28
>>>>>>>>>>>>>>>>>>>> -0500> > olcott <NoOne@NoWhere.com> wrote:> >   > >>
>>>>>>>>>>>>>>>>>>>> *This is refers to H(P,P)==0 where H and P are
>>>>>>>>>>>>>>>>>>>> functions in C*> >>> >>       I believe I have
>>>>>>>>>>>>>>>>>>>> learned something valuable from you:> >>       that
>>>>>>>>>>>>>>>>>>>> by simulation, and by simulations within
>>>>>>>>>>>>>>>>>>>> simulations,> >> non-halting can sometimes be
>>>>>>>>>>>>>>>>>>>> detected, and in particular,> >> it can be detected
>>>>>>>>>>>>>>>>>>>> in the program used in the classical> >>       proof
>>>>>>>>>>>>>>>>>>>> of incomputability.> >>> >> *Halting problem proofs
>>>>>>>>>>>>>>>>>>>> refuted on the basis of software> >> engineering* ?>
>>>>>>>>>>>>>>>>>>>> >>> >>
>>>>>>>>>>>>>>>>>>>> https://www.researchgate.net/publication/361701808_Halting_problem_proofs_refuted_on_the_basis_of_software_engineering>
>>>>>>>>>>>>>>>>>>>> >>  > > > > I am also a computer scientist and I am
>>>>>>>>>>>>>>>>>>>> telling you that your> > halting decider reporting
>>>>>>>>>>>>>>>>>>>> non-halting when it enters "infinite> > recursion"
>>>>>>>>>>>>>>>>>>>> is an ERROR.  There is no infinite recursion in the
>>>>>>>>>>>>>>>>>>>> HP> > proofs you are attempting to refute.> > > >
>>>>>>>>>>>>>>>>>>>> /Flibble> > > > > void P(ptr x)> {> int Halt_Status
>>>>>>>>>>>>>>>>>>>> = H(x, x);> if (Halt_Status)>      HERE: goto HERE;>
>>>>>>>>>>>>>>>>>>>> return;> }> > int main()> {> Output("Input_Halts =
>>>>>>>>>>>>>>>>>>>> ", H(P, P));> }> > If it was true that you are a
>>>>>>>>>>>>>>>>>>>> computer scientist then you would > understand that
>>>>>>>>>>>>>>>>>>>> this execution trace is correct:> > (a) H(P,P)
>>>>>>>>>>>>>>>>>>>> simulates P(P) that calls a simulated H(P,P)> (b)
>>>>>>>>>>>>>>>>>>>> that simulates P(P) that calls a simulated H(P,P)>
>>>>>>>>>>>>>>>>>>>> (c) that simulates P(P) that calls a simulated
>>>>>>>>>>>>>>>>>>>> H(P,P)> (d) that simulates P(P) that calls a
>>>>>>>>>>>>>>>>>>>> simulated H(P,P)...> *Until H aborts its
>>>>>>>>>>>>>>>>>>>> simulation*I am a computer scientist and all your
>>>>>>>>>>>>>>>>>>>> trace shows is that H (not P) isat the root of your
>>>>>>>>>>>>>>>>>>>> so called "infinite recursion" and is the
>>>>>>>>>>>>>>>>>>>> primaryreason why you are incorrect to map this
>>>>>>>>>>>>>>>>>>>> recursive behaviour of your Hto a halting decision
>>>>>>>>>>>>>>>>>>>> on P of non-halting.> > If you do not understand
>>>>>>>>>>>>>>>>>>>> that the above execution trace is correct> then this
>>>>>>>>>>>>>>>>>>>> proves that you are not as much as a sufficiently
>>>>>>>>>>>>>>>>>>>> competent > software engineer.It seems I understand
>>>>>>>>>>>>>>>>>>>> your trace more than you do which makes itobvious
>>>>>>>>>>>>>>>>>>>> who is actually lacking in competence here./Flibble
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> Because H exactly simulates its input and has no
>>>>>>>>>>>>>>>>>>> control flow
>>>>>>>>>>>>>>>>>>>   behavior of it's own while it is simulating this
>>>>>>>>>>>>>>>>>>> input YOU ARE
>>>>>>>>>>>>>>>>>>>   BLAMING THE MIRROR FOR WHAT IT REFLECTS.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> H does have control low on its own, or it can't stop
>>>>>>>>>>>>>>>>>> the simulationg to give an answer.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> Because H exactly simulates its input and has no
>>>>>>>>>>>>>>>>> control flow
>>>>>>>>>>>>>>>>> behavior of it's own
>>>>>>>>>>>>>>>>> while it is simulating this input
>>>>>>>>>>>>>>>>> while it is simulating this input
>>>>>>>>>>>>>>>>> while it is simulating this input
>>>>>>>>>>>>>>>>> while it is simulating this input
>>>>>>>>>>>>>>>>> while it is simulating this input
>>>>>>>>>>>>>>>>> while it is simulating this input
>>>>>>>>>>>>>>>>> while it is simulating this input
>>>>>>>>>>>>>>>>> while it is simulating this input
>>>>>>>>>>>>>>>>> while it is simulating this input
>>>>>>>>>>>>>>>>> while it is simulating this input
>>>>>>>>>>>>>>>>> while it is simulating this input
>>>>>>>>>>>>>>>>> while it is simulating this input
>>>>>>>>>>>>>>>>> while it is simulating this input
>>>>>>>>>>>>>>>>> while it is simulating this input
>>>>>>>>>>>>>>>>> YOU ARE BLAMING THE MIRROR FOR WHAT IT REFLECTS.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> So either you are a liar, or just badly confused about
>>>>>>>>>>>>>>>>>> what you are saying.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> Or you OCD prevents you from paying close enough
>>>>>>>>>>>>>>>>> attention to ALL of my words.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> Then how does it decide to stop simulating if it has no
>>>>>>>>>>>>>>>> control flow before it stops?
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> H does not have any effect on the behavior of its
>>>>>>>>>>>>>>> simulated P the whole time that H is simulating P, thus
>>>>>>>>>>>>>>> any recursive behavior that P demonstrates is behavior of
>>>>>>>>>>>>>>> P and not behavior of H.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> Nope, the problem is in H, not P.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> This H by its actions might not affect the behavior of the
>>>>>>>>>>>>>> input it is simulating, but it doesn't correctly determine
>>>>>>>>>>>>>> the effect that the copy of H in P will have.
>>>>>>>>>>>>>
>>>>>>>>>>>>> void P(ptr x)
>>>>>>>>>>>>> {
>>>>>>>>>>>>>    int Halt_Status = H(x, x);
>>>>>>>>>>>>>    if (Halt_Status)
>>>>>>>>>>>>>      HERE: goto HERE;
>>>>>>>>>>>>>    return;
>>>>>>>>>>>>> }
>>>>>>>>>>>>>
>>>>>>>>>>>>> int main()
>>>>>>>>>>>>> {
>>>>>>>>>>>>>    Output("Input_Halts = ", H(P, P));
>>>>>>>>>>>>> }
>>>>>>>>>>>>>
>>>>>>>>>>>>> So you disagree with this:
>>>>>>>>>>>>>
>>>>>>>>>>>>> (a) H(P,P) simulates P(P) that calls a simulated H(P,P)
>>>>>>>>>>>>> (b) that simulates P(P) that calls a simulated H(P,P)
>>>>>>>>>>>>> (c) that simulates P(P) that calls a simulated H(P,P)
>>>>>>>>>>>>> (d) that simulates P(P) that calls a simulated H(P,P)...
>>>>>>>>>>>>> *Until H aborts its simulation*
>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> That isn't what your H does,
>>>>>>>>>>>
>>>>>>>>>>> Why do you say that isn't what my H does when you know that
>>>>>>>>>>> it is what my H does and you can verify this with the
>>>>>>>>>>> complete system?
>>>>>>>>>>>
>>>>>>>>>>> https://www.liarparadox.org/2022_07_22.zip
>>>>>>>>>>> This is the complete system that compiles under:
>>>>>>>>>>>
>>>>>>>>>>> Microsoft Visual Studio Community 2017
>>>>>>>>>>> https://visualstudio.microsoft.com/vs/older-downloads/
>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> Right, you didn't read what I said you H does, did you?
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> You said that what I said H does, it does not do, this is
>>>>>>>>> incorrect.
>>>>>>>>> Then you changed the subject.
>>>>>>>>>
>>>>>>>>
>>>>>>>> You H does NOT get to the step (b) that you have posted, so
>>>>>>>> doesn't match you pattern.
>>>>>>>>
>>>>>>>
>>>>>>> One H does not get past step (b)
>>>>>>> The other H does not get past step (c) and can be adapted to
>>>>>>> proceed any finite number of steps.
>>>>>>>
>>>>>>> The point is that no correct simulation of the input to H(P,P) by
>>>>>>> H ever stops running until H aborts it.
>>>>>>>
>>>>>>
>>>>>> Nope, look at the code you provided.
>>>>> Liar
>>>>>
>>>>
>>>> Are you saying the code you provided DOESN'T abort the simulation
>>>> done by H(P,P) at the point where P(P) calls H(P,P)?
>>>>
>>>>
>>>
>>> The algorithm implemented by H:
>>> The correct simulation by H(P,P), never stops running until H aborts it.
>>
>> No, the algorithm implemented by your H is to abort the simulation of
>> P(P) as soon as it calls H(P,P).
> So you don't know the difference between an algorithm and its
> implementation?
>
> https://www.geeksforgeeks.org/introduction-to-algorithms/
>
> The algorithm: A simulating halt decider (SHD) continues to simulate its
> input until it correctly matches a non-halting behavior pattern or the
> input halts on its own. If a non-halting behavior pattern is matched
> then the SHD aborts the simulation of its input and reports non-halting.
> If the input halts on its own the SHD report halting.
>


Click here to read the complete article
Pages:12345678910
server_pubkey.txt

rocksolid light 0.9.8
clearnet tor