Rocksolid Light

Welcome to novaBBS (click a section below)

mail  files  register  newsreader  groups  login

Message-ID:  

I must have slipped a disk -- my pack hurts!


devel / comp.theory / Re: Definition of the term [simulating halt decider][ criteria ]

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: Definition of the term [simulating halt decider]

<zdCLK.805685$ssF.310139@fx14.iad>

 copy mid

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

 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!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: Definition of the term [simulating halt decider]
Content-Language: en-US
Newsgroups: comp.theory
References: <VUmdneqWu_jdjGT_nZ2dnZfqlJ_NnZ2d@giganews.com>
<nLOdnZYR-unTHmH_nZ2dnZfqlJ_NnZ2d@giganews.com>
<TC4LK.734216$5fVf.250358@fx09.iad>
<ENOdndtEMevGmWD_nZ2dnZfqlJzNnZ2d@giganews.com>
<y0gLK.793819$J0r9.671384@fx11.iad>
<AN-dnZxwirJvDGD_nZ2dnZfqlJxh4p2d@giganews.com>
<EIgLK.927006$JVi.159216@fx17.iad>
<HfCdnUCy77LtPWD_nZ2dnZfqlJzNnZ2d@giganews.com>
<nxhLK.927011$JVi.780897@fx17.iad>
<EmadnWSi2664NWD_nZ2dnZfqlJ_NnZ2d@giganews.com>
<oYhLK.780561$ssF.60988@fx14.iad>
<VeucndlM27uDMmD_nZ2dnZfqlJ9g4p2d@giganews.com>
<3ce2b023-e24a-410b-be6d-88358baf9d6cn@googlegroups.com>
<mOmdneWkX-TaKGD_nZ2dnZfqlJzNnZ2d@giganews.com>
<1vpLK.679507$vAW9.331179@fx10.iad>
<G4udnW9QVcpV1WP_nZ2dnZfqlJxh4p2d@giganews.com>
<NEzLK.680580$vAW9.195507@fx10.iad>
<TL2cnagZj8PtVGP_nZ2dnZfqlJ_NnZ2d@giganews.com>
<j9ALK.797754$J0r9.465455@fx11.iad>
<mducnbROPbTJTWP_nZ2dnZfqlJ_NnZ2d@giganews.com>
<LCALK.225277$eQ5.128204@fx08.iad>
<mtOdnb4XsYRtRWP_nZ2dnZfqlJxh4p2d@giganews.com>
From: Rich...@Damon-Family.org (Richard Damon)
In-Reply-To: <mtOdnb4XsYRtRWP_nZ2dnZfqlJxh4p2d@giganews.com>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 7bit
Lines: 90
Message-ID: <zdCLK.805685$ssF.310139@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: Thu, 18 Aug 2022 22:05:19 -0400
X-Received-Bytes: 5076
 by: Richard Damon - Fri, 19 Aug 2022 02:05 UTC

On 8/18/22 8:27 PM, olcott wrote:
> On 8/18/2022 7:15 PM, Richard Damon wrote:
>> On 8/18/22 7:51 PM, olcott wrote:
>>> On 8/18/2022 6:44 PM, Richard Damon wrote:
>>>>
>>>> On 8/18/22 7:21 PM, olcott wrote:
>>>>> On 8/18/2022 6:09 PM, Richard Damon wrote:
>>>>>> On 8/18/22 10:12 AM, olcott wrote:
>>>>>>> On 8/18/2022 6:36 AM, Richard Damon wrote:
>>>>>>>> On 8/17/22 11:43 PM, olcott wrote:
>>>>>>>>> *THIS IS SIMPLY OVER YOUR HEAD*
>>>>>>>>> It is an axiom that when-so-ever any simulating halt decider
>>>>>>>>> (SHD) performs a correct simulation of its input and this
>>>>>>>>> simulation would never stop running unless this simulation is
>>>>>>>>> aborted that this SHD is correct to reject this input as
>>>>>>>>> non-halting.
>>>>>>>>>
>>>>>>>>
>>>>>>>>
>>>>>>>> LIE.
>>>>>>>
>>>>>>> Try and prove otherwise without using double-talk.
>>>>>>>
>>>>>>>
>>>>>>
>>>>>> Claiming a not established fact as an axiom IS a LIE.
>>>>>>
>>>>>>
>>>>>
>>>>> noun: axiom; plural noun: axioms
>>>>> a statement or proposition which is regarded as being established,
>>>>> accepted, or self-evidently true.
>>>>
>>>> Right, "regarded", that means by the COMMUNITY, not just an individual.
>>>>
>>>> Note, in a FORMAL system, the only Axioms avaiable are those that
>>>> are the formation of the system. After that you need to actually
>>>> PROVE your statements from the Axioms and other proven statements.
>>>>
>>>>>
>>>>> *The definition of the term [simulating halt decider] is an axiom*
>>>>> A simulating halt decider
>>>>> (a) examines the dynamic behavior of a program and
>>>>> (b) correctly predicts that this program would never reach its
>>>>> final state if this simulation was never aborted.
>>>>>
>>>>> The SHD makes this prediction on the basis of correctly matching a
>>>>> correct infinite behavior pattern.
>>>>>
>>>>>
>>>>
>>>> So, your SHD is NOT a Halt Decider because it doesn't answer the
>>>> actual question that a Halt Decider needs to answer, so you have
>>>> just spent 18 your developing your POOP.
>>>>
>>>>
>>>> DEFINITION.
>>>>
>>>> You are just showing that you don't understand how logic works.
>>>
>>> My system is correct from a software engineering point of view.
>>> H does correctly determine that the actual behavior of its actual
>>> input specifies a sequence of instructions that never reach their
>>> final state.
>>>
>>> Once this is accepted as true THENN (then and only then) we can begin
>>> examining why computer science disgrees with software engineering.
>>>
>>
>> No, it doesn't. The problem is you don't use the right definitions, so
>> you don't get the right answer.
>>
>
> When-so-ever the correct partial simulation of a machine description
> correctly matches a correct infinite behavior pattern then it is certain
> that this machine description specifies infinite behavior.
>
>

And you do not have a correct infinite behavior pattern.

FAIL.

The problem is your "pattern" ignores/imputes incorrectly the behavior
of the H that P calls.

It presumes that H actually meets the specifications, when it does not.

Proving something is correct by first assuming it is correct is not a
valid method of proof.

Re: Definition of the term [simulating halt decider]

<kL2cnU_OMaAjZmP_nZ2dnZfqlJ_NnZ2d@giganews.com>

 copy mid

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

 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: Fri, 19 Aug 2022 02:55:58 +0000
Date: Thu, 18 Aug 2022 21:56:21 -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: Definition of the term [simulating halt decider]
Content-Language: en-US
Newsgroups: comp.theory
References: <VUmdneqWu_jdjGT_nZ2dnZfqlJ_NnZ2d@giganews.com>
<y0gLK.793819$J0r9.671384@fx11.iad>
<AN-dnZxwirJvDGD_nZ2dnZfqlJxh4p2d@giganews.com>
<EIgLK.927006$JVi.159216@fx17.iad>
<HfCdnUCy77LtPWD_nZ2dnZfqlJzNnZ2d@giganews.com>
<nxhLK.927011$JVi.780897@fx17.iad>
<EmadnWSi2664NWD_nZ2dnZfqlJ_NnZ2d@giganews.com>
<oYhLK.780561$ssF.60988@fx14.iad>
<VeucndlM27uDMmD_nZ2dnZfqlJ9g4p2d@giganews.com>
<3ce2b023-e24a-410b-be6d-88358baf9d6cn@googlegroups.com>
<mOmdneWkX-TaKGD_nZ2dnZfqlJzNnZ2d@giganews.com>
<1vpLK.679507$vAW9.331179@fx10.iad>
<G4udnW9QVcpV1WP_nZ2dnZfqlJxh4p2d@giganews.com>
<NEzLK.680580$vAW9.195507@fx10.iad>
<TL2cnagZj8PtVGP_nZ2dnZfqlJ_NnZ2d@giganews.com>
<j9ALK.797754$J0r9.465455@fx11.iad>
<mducnbROPbTJTWP_nZ2dnZfqlJ_NnZ2d@giganews.com>
<83ee368a-0a10-49a7-9711-7fbaed66eac8n@googlegroups.com>
<7qSdndIv-fvVSGP_nZ2dnZfqlJxh4p2d@giganews.com>
<d4c09662-9db6-47de-b3ee-a986c5c67ecan@googlegroups.com>
<6t2dnblhubPGeGP_nZ2dnZfqlJ_NnZ2d@giganews.com>
<5bCLK.805583$ssF.125283@fx14.iad>
From: NoO...@NoWhere.com (olcott)
In-Reply-To: <5bCLK.805583$ssF.125283@fx14.iad>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 7bit
Message-ID: <kL2cnU_OMaAjZmP_nZ2dnZfqlJ_NnZ2d@giganews.com>
Lines: 84
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-dCKNPVcp8JA/oZuknRhlHDyyqLyKvb/0kuUGilkcVoeYiLe9+yfsvWArWucf+z7hcMWX7Sx4Hj1Hkyx!OuRGna+cKaQQBrn/hns9xbVGnQ8QVz0OznMEXumisIy+uYI5yZlmDu8uzGiS5jkeBVKDBSuQJAE=
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 - Fri, 19 Aug 2022 02:56 UTC

On 8/18/2022 9:02 PM, Richard Damon wrote:
>
> On 8/18/22 9:20 PM, olcott wrote:
>> On 8/18/2022 8:04 PM, Skep Dick wrote:
>>> On Friday, 19 August 2022 at 02:12:26 UTC+2, olcott wrote:
>>>> On 8/18/2022 7:05 PM, Skep Dick wrote:
>>>>> On Friday, 19 August 2022 at 01:51:13 UTC+2, olcott wrote:
>>>>>> My system is correct from a software engineering point of view.
>>>>>> H does correctly determine that the actual behavior of its actual
>>>>>> input
>>>>>> specifies a sequence of instructions that never reach their final
>>>>>> state.
>>>>> Your program doesn't determine that the input NEVER (key word!!!)
>>>>> reach their final state.
>>>>>
>>>>> Your program determines that input doesn't reach its final state
>>>>> within N number of CPU cycles.
>>>>>
>>>> When-so-ever the partial simulation of a machine description correctly
>>>> matches a correct infinite behavior pattern then it is certain that
>>>> this
>>>> machine description specifies infinite behavior.
>>>
>>> You can correctly put as correct many correct uses of the correct
>>> word correct but correct is not correct to be correct correct correct
>>> correct.
>>>
>>> You are incorrect.
>>
>> *Since there are no mistakes no one can point out any mistakes*
>> *Since there are no mistakes no one can point out any mistakes*
>> *Since there are no mistakes no one can point out any mistakes*
>
> People HAVE pointed out the mistakes, but you are apparently too dumb to
> understand the problem.
>
>>
>> (a) The correct partial simulation of a machine description
>> (b) Correctly matches
>> (c) A correct infinite behavior pattern
>
> But the pattern you suggest is NOT corrct.
>

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

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

*TRY AND FIND ANY EXAMPLE OF FALSE POSITIVE*
(1) Infinite_Recursion() is called twice in sequence from the same
machine address of Infinite_Recursion() .
(2) With the same arguments to Infinite_Recursion()
(3) With no control flow instructions between the invocation of
Infinite_Recursion() and the call to Infinite_Recursion() from
Infinite_Recursion()

The fact that no false positives exist proves that there are no false
positives. Every time that the above pattern is matched is a case of
infinite recursion.

>> (d) Then this machine description specifies infinite behavior.
>>
>> (a)(b)(c) premises that are verified to be true
>
> But they are NOT
>
>> (d) logically follows from (a)(b)(c)
>>
>
> So (d) does not follow.

--
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: Definition of the term [simulating halt decider]

<ecDLK.682433$vAW9.55970@fx10.iad>

 copy mid

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

 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!fx10.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: Definition of the term [simulating halt decider]
Content-Language: en-US
Newsgroups: comp.theory
References: <VUmdneqWu_jdjGT_nZ2dnZfqlJ_NnZ2d@giganews.com>
<EIgLK.927006$JVi.159216@fx17.iad>
<HfCdnUCy77LtPWD_nZ2dnZfqlJzNnZ2d@giganews.com>
<nxhLK.927011$JVi.780897@fx17.iad>
<EmadnWSi2664NWD_nZ2dnZfqlJ_NnZ2d@giganews.com>
<oYhLK.780561$ssF.60988@fx14.iad>
<VeucndlM27uDMmD_nZ2dnZfqlJ9g4p2d@giganews.com>
<3ce2b023-e24a-410b-be6d-88358baf9d6cn@googlegroups.com>
<mOmdneWkX-TaKGD_nZ2dnZfqlJzNnZ2d@giganews.com>
<1vpLK.679507$vAW9.331179@fx10.iad>
<G4udnW9QVcpV1WP_nZ2dnZfqlJxh4p2d@giganews.com>
<NEzLK.680580$vAW9.195507@fx10.iad>
<TL2cnagZj8PtVGP_nZ2dnZfqlJ_NnZ2d@giganews.com>
<j9ALK.797754$J0r9.465455@fx11.iad>
<mducnbROPbTJTWP_nZ2dnZfqlJ_NnZ2d@giganews.com>
<83ee368a-0a10-49a7-9711-7fbaed66eac8n@googlegroups.com>
<7qSdndIv-fvVSGP_nZ2dnZfqlJxh4p2d@giganews.com>
<d4c09662-9db6-47de-b3ee-a986c5c67ecan@googlegroups.com>
<6t2dnblhubPGeGP_nZ2dnZfqlJ_NnZ2d@giganews.com>
<5bCLK.805583$ssF.125283@fx14.iad>
<kL2cnU_OMaAjZmP_nZ2dnZfqlJ_NnZ2d@giganews.com>
From: Rich...@Damon-Family.org (Richard Damon)
In-Reply-To: <kL2cnU_OMaAjZmP_nZ2dnZfqlJ_NnZ2d@giganews.com>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Lines: 98
Message-ID: <ecDLK.682433$vAW9.55970@fx10.iad>
X-Complaints-To: abuse@easynews.com
Organization: Forte - www.forteinc.com
X-Complaints-Info: Please be sure to forward a copy of ALL headers otherwise we will be unable to process your complaint properly.
Date: Thu, 18 Aug 2022 23:12:09 -0400
X-Received-Bytes: 5207
 by: Richard Damon - Fri, 19 Aug 2022 03:12 UTC

On 8/18/22 10:56 PM, olcott wrote:
> On 8/18/2022 9:02 PM, Richard Damon wrote:
>>
>> On 8/18/22 9:20 PM, olcott wrote:
>>> On 8/18/2022 8:04 PM, Skep Dick wrote:
>>>> On Friday, 19 August 2022 at 02:12:26 UTC+2, olcott wrote:
>>>>> On 8/18/2022 7:05 PM, Skep Dick wrote:
>>>>>> On Friday, 19 August 2022 at 01:51:13 UTC+2, olcott wrote:
>>>>>>> My system is correct from a software engineering point of view.
>>>>>>> H does correctly determine that the actual behavior of its actual
>>>>>>> input
>>>>>>> specifies a sequence of instructions that never reach their final
>>>>>>> state.
>>>>>> Your program doesn't determine that the input NEVER (key word!!!)
>>>>>> reach their final state.
>>>>>>
>>>>>> Your program determines that input doesn't reach its final state
>>>>>> within N number of CPU cycles.
>>>>>>
>>>>> When-so-ever the partial simulation of a machine description correctly
>>>>> matches a correct infinite behavior pattern then it is certain that
>>>>> this
>>>>> machine description specifies infinite behavior.
>>>>
>>>> You can correctly put as correct many correct uses of the correct
>>>> word correct but correct is not correct to be correct correct
>>>> correct correct.
>>>>
>>>> You are incorrect.
>>>
>>> *Since there are no mistakes no one can point out any mistakes*
>>> *Since there are no mistakes no one can point out any mistakes*
>>> *Since there are no mistakes no one can point out any mistakes*
>>
>> People HAVE pointed out the mistakes, but you are apparently too dumb
>> to understand the problem.
>>
>>>
>>> (a) The correct partial simulation of a machine description
>>> (b) Correctly matches
>>> (c) A correct infinite behavior pattern
>>
>> But the pattern you suggest is NOT corrct.
>>
>
> void Infinite_Recursion(int N)
> {
>   Infinite_Recursion(N);
> }
>
> int main()
> {
>   Output("Input_Halts = ", H((u32)Infinite_Recursion, 0x777));
> }
>
> *TRY AND FIND ANY EXAMPLE OF FALSE POSITIVE*
> (1) Infinite_Recursion() is called twice in sequence from the same
> machine address of Infinite_Recursion() .
> (2) With the same arguments to Infinite_Recursion()
> (3) With no control flow instructions between the invocation of
> Infinite_Recursion()  and the call to Infinite_Recursion() from
> Infinite_Recursion()
>
> The fact that no false positives exist proves that there are no false
> positives. Every time that the above pattern is matched is a case of
> infinite recursion.

Fallacy of the Strawman.

I am not saying it doesn't work for Recursion, it doesn't work for the
infinite simulation pattern.

You just proved you have lost, because you need to put up strawmen for
you to take down.

You are just proving you are too stupid to be doing this sort of work
and have been wasting the last decades of your life, which if you
haven't been lying will likely soon be over, and you will have left a
legacy proving your stupidity.

There is still a chance to repent and improve your reputation. Maybe not
do something to make you famous, but at least erase a lot of the
infamous from your name.

>
>>> (d) Then this machine description specifies infinite behavior.
>>>
>>> (a)(b)(c) premises that are verified to be true
>>
>> But they are NOT
>>
>>> (d) logically follows from (a)(b)(c)
>>>
>>
>> So (d) does not follow.
>
>

Re: Definition of the term [simulating halt decider]

<eLWdnUNJWsycnWL_nZ2dnZfqlJxh4p2d@giganews.com>

 copy mid

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

 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: Fri, 19 Aug 2022 03:14:09 +0000
Date: Thu, 18 Aug 2022 22:14:26 -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: Definition of the term [simulating halt decider]
Content-Language: en-US
Newsgroups: comp.theory
References: <VUmdneqWu_jdjGT_nZ2dnZfqlJ_NnZ2d@giganews.com>
<EIgLK.927006$JVi.159216@fx17.iad>
<HfCdnUCy77LtPWD_nZ2dnZfqlJzNnZ2d@giganews.com>
<nxhLK.927011$JVi.780897@fx17.iad>
<EmadnWSi2664NWD_nZ2dnZfqlJ_NnZ2d@giganews.com>
<oYhLK.780561$ssF.60988@fx14.iad>
<VeucndlM27uDMmD_nZ2dnZfqlJ9g4p2d@giganews.com>
<3ce2b023-e24a-410b-be6d-88358baf9d6cn@googlegroups.com>
<mOmdneWkX-TaKGD_nZ2dnZfqlJzNnZ2d@giganews.com>
<1vpLK.679507$vAW9.331179@fx10.iad>
<G4udnW9QVcpV1WP_nZ2dnZfqlJxh4p2d@giganews.com>
<NEzLK.680580$vAW9.195507@fx10.iad>
<TL2cnagZj8PtVGP_nZ2dnZfqlJ_NnZ2d@giganews.com>
<j9ALK.797754$J0r9.465455@fx11.iad>
<mducnbROPbTJTWP_nZ2dnZfqlJ_NnZ2d@giganews.com>
<83ee368a-0a10-49a7-9711-7fbaed66eac8n@googlegroups.com>
<7qSdndIv-fvVSGP_nZ2dnZfqlJxh4p2d@giganews.com>
<d4c09662-9db6-47de-b3ee-a986c5c67ecan@googlegroups.com>
<6t2dnblhubPGeGP_nZ2dnZfqlJ_NnZ2d@giganews.com>
<5bCLK.805583$ssF.125283@fx14.iad>
<kL2cnU_OMaAjZmP_nZ2dnZfqlJ_NnZ2d@giganews.com>
<ecDLK.682433$vAW9.55970@fx10.iad>
From: NoO...@NoWhere.com (olcott)
In-Reply-To: <ecDLK.682433$vAW9.55970@fx10.iad>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Message-ID: <eLWdnUNJWsycnWL_nZ2dnZfqlJxh4p2d@giganews.com>
Lines: 91
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-B1pA+BIqLHK3QY7nC0Rgg31+tayfcWsBLWiErOBsCoIZIgKFiIkURLTQxobc6BwyKl4ZtZwcUjFQCdw!nO2tGfy21XZDXZ07vgW4NucBbSpEI49ucSJQkNb+zWKSqlrHazic6RkV3BOTC8UlB5bj6sZQluQ=
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 - Fri, 19 Aug 2022 03:14 UTC

On 8/18/2022 10:12 PM, Richard Damon wrote:
> On 8/18/22 10:56 PM, olcott wrote:
>> On 8/18/2022 9:02 PM, Richard Damon wrote:
>>>
>>> On 8/18/22 9:20 PM, olcott wrote:
>>>> On 8/18/2022 8:04 PM, Skep Dick wrote:
>>>>> On Friday, 19 August 2022 at 02:12:26 UTC+2, olcott wrote:
>>>>>> On 8/18/2022 7:05 PM, Skep Dick wrote:
>>>>>>> On Friday, 19 August 2022 at 01:51:13 UTC+2, olcott wrote:
>>>>>>>> My system is correct from a software engineering point of view.
>>>>>>>> H does correctly determine that the actual behavior of its
>>>>>>>> actual input
>>>>>>>> specifies a sequence of instructions that never reach their
>>>>>>>> final state.
>>>>>>> Your program doesn't determine that the input NEVER (key word!!!)
>>>>>>> reach their final state.
>>>>>>>
>>>>>>> Your program determines that input doesn't reach its final state
>>>>>>> within N number of CPU cycles.
>>>>>>>
>>>>>> When-so-ever the partial simulation of a machine description
>>>>>> correctly
>>>>>> matches a correct infinite behavior pattern then it is certain
>>>>>> that this
>>>>>> machine description specifies infinite behavior.
>>>>>
>>>>> You can correctly put as correct many correct uses of the correct
>>>>> word correct but correct is not correct to be correct correct
>>>>> correct correct.
>>>>>
>>>>> You are incorrect.
>>>>
>>>> *Since there are no mistakes no one can point out any mistakes*
>>>> *Since there are no mistakes no one can point out any mistakes*
>>>> *Since there are no mistakes no one can point out any mistakes*
>>>
>>> People HAVE pointed out the mistakes, but you are apparently too dumb
>>> to understand the problem.
>>>
>>>>
>>>> (a) The correct partial simulation of a machine description
>>>> (b) Correctly matches
>>>> (c) A correct infinite behavior pattern
>>>
>>> But the pattern you suggest is NOT corrct.
>>>
>>
>> void Infinite_Recursion(int N)
>> {
>>    Infinite_Recursion(N);
>> }
>>
>> int main()
>> {
>>    Output("Input_Halts = ", H((u32)Infinite_Recursion, 0x777));
>> }
>>
>> *TRY AND FIND ANY EXAMPLE OF FALSE POSITIVE*
>> (1) Infinite_Recursion() is called twice in sequence from the same
>> machine address of Infinite_Recursion() .
>> (2) With the same arguments to Infinite_Recursion()
>> (3) With no control flow instructions between the invocation of
>> Infinite_Recursion()  and the call to Infinite_Recursion() from
>> Infinite_Recursion()
>>
>> The fact that no false positives exist proves that there are no false
>> positives. Every time that the above pattern is matched is a case of
>> infinite recursion.
>
> Fallacy of the Strawman.
>
> I am not saying it doesn't work for Recursion, it doesn't work for the
> infinite simulation pattern.
>

So then you agree that this reasoning is correct as long as the behavior
pattern is correct?

(a) The correct partial simulation of a machine description
(b) Correctly matches
(c) A correct infinite behavior pattern
(d) Then this machine description specifies infinite behavior.

--
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: Definition of the term [simulating halt decider]

<anDLK.782712$zgr9.182386@fx13.iad>

 copy mid

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

 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: Definition of the term [simulating halt decider]
Content-Language: en-US
Newsgroups: comp.theory
References: <VUmdneqWu_jdjGT_nZ2dnZfqlJ_NnZ2d@giganews.com>
<nxhLK.927011$JVi.780897@fx17.iad>
<EmadnWSi2664NWD_nZ2dnZfqlJ_NnZ2d@giganews.com>
<oYhLK.780561$ssF.60988@fx14.iad>
<VeucndlM27uDMmD_nZ2dnZfqlJ9g4p2d@giganews.com>
<3ce2b023-e24a-410b-be6d-88358baf9d6cn@googlegroups.com>
<mOmdneWkX-TaKGD_nZ2dnZfqlJzNnZ2d@giganews.com>
<1vpLK.679507$vAW9.331179@fx10.iad>
<G4udnW9QVcpV1WP_nZ2dnZfqlJxh4p2d@giganews.com>
<NEzLK.680580$vAW9.195507@fx10.iad>
<TL2cnagZj8PtVGP_nZ2dnZfqlJ_NnZ2d@giganews.com>
<j9ALK.797754$J0r9.465455@fx11.iad>
<mducnbROPbTJTWP_nZ2dnZfqlJ_NnZ2d@giganews.com>
<83ee368a-0a10-49a7-9711-7fbaed66eac8n@googlegroups.com>
<7qSdndIv-fvVSGP_nZ2dnZfqlJxh4p2d@giganews.com>
<d4c09662-9db6-47de-b3ee-a986c5c67ecan@googlegroups.com>
<6t2dnblhubPGeGP_nZ2dnZfqlJ_NnZ2d@giganews.com>
<5bCLK.805583$ssF.125283@fx14.iad>
<kL2cnU_OMaAjZmP_nZ2dnZfqlJ_NnZ2d@giganews.com>
<ecDLK.682433$vAW9.55970@fx10.iad>
<eLWdnUNJWsycnWL_nZ2dnZfqlJxh4p2d@giganews.com>
From: Rich...@Damon-Family.org (Richard Damon)
In-Reply-To: <eLWdnUNJWsycnWL_nZ2dnZfqlJxh4p2d@giganews.com>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Lines: 107
Message-ID: <anDLK.782712$zgr9.182386@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: Thu, 18 Aug 2022 23:23:49 -0400
X-Received-Bytes: 5963
 by: Richard Damon - Fri, 19 Aug 2022 03:23 UTC

On 8/18/22 11:14 PM, olcott wrote:
> On 8/18/2022 10:12 PM, Richard Damon wrote:
>> On 8/18/22 10:56 PM, olcott wrote:
>>> On 8/18/2022 9:02 PM, Richard Damon wrote:
>>>>
>>>> On 8/18/22 9:20 PM, olcott wrote:
>>>>> On 8/18/2022 8:04 PM, Skep Dick wrote:
>>>>>> On Friday, 19 August 2022 at 02:12:26 UTC+2, olcott wrote:
>>>>>>> On 8/18/2022 7:05 PM, Skep Dick wrote:
>>>>>>>> On Friday, 19 August 2022 at 01:51:13 UTC+2, olcott wrote:
>>>>>>>>> My system is correct from a software engineering point of view.
>>>>>>>>> H does correctly determine that the actual behavior of its
>>>>>>>>> actual input
>>>>>>>>> specifies a sequence of instructions that never reach their
>>>>>>>>> final state.
>>>>>>>> Your program doesn't determine that the input NEVER (key
>>>>>>>> word!!!) reach their final state.
>>>>>>>>
>>>>>>>> Your program determines that input doesn't reach its final state
>>>>>>>> within N number of CPU cycles.
>>>>>>>>
>>>>>>> When-so-ever the partial simulation of a machine description
>>>>>>> correctly
>>>>>>> matches a correct infinite behavior pattern then it is certain
>>>>>>> that this
>>>>>>> machine description specifies infinite behavior.
>>>>>>
>>>>>> You can correctly put as correct many correct uses of the correct
>>>>>> word correct but correct is not correct to be correct correct
>>>>>> correct correct.
>>>>>>
>>>>>> You are incorrect.
>>>>>
>>>>> *Since there are no mistakes no one can point out any mistakes*
>>>>> *Since there are no mistakes no one can point out any mistakes*
>>>>> *Since there are no mistakes no one can point out any mistakes*
>>>>
>>>> People HAVE pointed out the mistakes, but you are apparently too
>>>> dumb to understand the problem.
>>>>
>>>>>
>>>>> (a) The correct partial simulation of a machine description
>>>>> (b) Correctly matches
>>>>> (c) A correct infinite behavior pattern
>>>>
>>>> But the pattern you suggest is NOT corrct.
>>>>
>>>
>>> void Infinite_Recursion(int N)
>>> {
>>>    Infinite_Recursion(N);
>>> }
>>>
>>> int main()
>>> {
>>>    Output("Input_Halts = ", H((u32)Infinite_Recursion, 0x777));
>>> }
>>>
>>> *TRY AND FIND ANY EXAMPLE OF FALSE POSITIVE*
>>> (1) Infinite_Recursion() is called twice in sequence from the same
>>> machine address of Infinite_Recursion() .
>>> (2) With the same arguments to Infinite_Recursion()
>>> (3) With no control flow instructions between the invocation of
>>> Infinite_Recursion()  and the call to Infinite_Recursion() from
>>> Infinite_Recursion()
>>>
>>> The fact that no false positives exist proves that there are no false
>>> positives. Every time that the above pattern is matched is a case of
>>> infinite recursion.
>>
>> Fallacy of the Strawman.
>>
>> I am not saying it doesn't work for Recursion, it doesn't work for the
>> infinite simulation pattern.
>>
>
> So then you agree that this reasoning is correct as long as the behavior
> pattern is correct?
>
> (a) The correct partial simulation of a machine description
> (b) Correctly matches
> (c) A correct infinite behavior pattern
> (d) Then this machine description specifies infinite behavior.
>
>
>

If you HAD a correct infinite simulation pattern, then yes, if you
detect it, (BY DEFINITION) the behavior would be infinite, as that is
the definition of correct.

The problem is that there is NO actual correct infinite simulation
pattern in the trace of P(P) that H can detect, as any pattern that H
sees, if it treats it as an infinite simulation pattern, but H then
acting on it, makes P(P) not get caught in an infinite simulation loop,
BECAUSE the H that P calls will also act on it and abort its simulation
and return 0 and cause P(P) to Halt.

All that will occur in the CORRECT AND COMPLETE simulation of the input
(not done by H since it aborted) after H aborted is PARTIAL simulation
of the input, but that does prove that the pattern was incorrect, and
thus H was wrong to use it.

You can not assume existance of a finite pattern.

And you can not use an infinite pattern as you need ot answer in finite
time.

Re: Definition of the term [simulating halt decider]

<fcmdnfgGV8aSmGL_nZ2dnZfqlJzNnZ2d@giganews.com>

 copy mid

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

 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: Fri, 19 Aug 2022 03:35:43 +0000
Date: Thu, 18 Aug 2022 22:35:59 -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: Definition of the term [simulating halt decider]
Content-Language: en-US
Newsgroups: comp.theory
References: <VUmdneqWu_jdjGT_nZ2dnZfqlJ_NnZ2d@giganews.com>
<nxhLK.927011$JVi.780897@fx17.iad>
<EmadnWSi2664NWD_nZ2dnZfqlJ_NnZ2d@giganews.com>
<oYhLK.780561$ssF.60988@fx14.iad>
<VeucndlM27uDMmD_nZ2dnZfqlJ9g4p2d@giganews.com>
<3ce2b023-e24a-410b-be6d-88358baf9d6cn@googlegroups.com>
<mOmdneWkX-TaKGD_nZ2dnZfqlJzNnZ2d@giganews.com>
<1vpLK.679507$vAW9.331179@fx10.iad>
<G4udnW9QVcpV1WP_nZ2dnZfqlJxh4p2d@giganews.com>
<NEzLK.680580$vAW9.195507@fx10.iad>
<TL2cnagZj8PtVGP_nZ2dnZfqlJ_NnZ2d@giganews.com>
<j9ALK.797754$J0r9.465455@fx11.iad>
<mducnbROPbTJTWP_nZ2dnZfqlJ_NnZ2d@giganews.com>
<83ee368a-0a10-49a7-9711-7fbaed66eac8n@googlegroups.com>
<7qSdndIv-fvVSGP_nZ2dnZfqlJxh4p2d@giganews.com>
<d4c09662-9db6-47de-b3ee-a986c5c67ecan@googlegroups.com>
<6t2dnblhubPGeGP_nZ2dnZfqlJ_NnZ2d@giganews.com>
<5bCLK.805583$ssF.125283@fx14.iad>
<kL2cnU_OMaAjZmP_nZ2dnZfqlJ_NnZ2d@giganews.com>
<ecDLK.682433$vAW9.55970@fx10.iad>
<eLWdnUNJWsycnWL_nZ2dnZfqlJxh4p2d@giganews.com>
<anDLK.782712$zgr9.182386@fx13.iad>
From: NoO...@NoWhere.com (olcott)
In-Reply-To: <anDLK.782712$zgr9.182386@fx13.iad>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Message-ID: <fcmdnfgGV8aSmGL_nZ2dnZfqlJzNnZ2d@giganews.com>
Lines: 169
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-ysRoagSWuCuY3Lx/toR1aQIENPy+bozinmqXo6RJolFkDqR9Gz65XeXJvzs28L7v9lePgVRkDvYWEIr!AElYRN0Qm/LCH3jC/4JEjShDUEgQDkhlRoWCFQxfKAWzGlv867RCXBI/KKf696LvDMwFgkstbG8=
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 - Fri, 19 Aug 2022 03:35 UTC

On 8/18/2022 10:23 PM, Richard Damon wrote:
> On 8/18/22 11:14 PM, olcott wrote:
>> On 8/18/2022 10:12 PM, Richard Damon wrote:
>>> On 8/18/22 10:56 PM, olcott wrote:
>>>> On 8/18/2022 9:02 PM, Richard Damon wrote:
>>>>>
>>>>> On 8/18/22 9:20 PM, olcott wrote:
>>>>>> On 8/18/2022 8:04 PM, Skep Dick wrote:
>>>>>>> On Friday, 19 August 2022 at 02:12:26 UTC+2, olcott wrote:
>>>>>>>> On 8/18/2022 7:05 PM, Skep Dick wrote:
>>>>>>>>> On Friday, 19 August 2022 at 01:51:13 UTC+2, olcott wrote:
>>>>>>>>>> My system is correct from a software engineering point of view.
>>>>>>>>>> H does correctly determine that the actual behavior of its
>>>>>>>>>> actual input
>>>>>>>>>> specifies a sequence of instructions that never reach their
>>>>>>>>>> final state.
>>>>>>>>> Your program doesn't determine that the input NEVER (key
>>>>>>>>> word!!!) reach their final state.
>>>>>>>>>
>>>>>>>>> Your program determines that input doesn't reach its final
>>>>>>>>> state within N number of CPU cycles.
>>>>>>>>>
>>>>>>>> When-so-ever the partial simulation of a machine description
>>>>>>>> correctly
>>>>>>>> matches a correct infinite behavior pattern then it is certain
>>>>>>>> that this
>>>>>>>> machine description specifies infinite behavior.
>>>>>>>
>>>>>>> You can correctly put as correct many correct uses of the correct
>>>>>>> word correct but correct is not correct to be correct correct
>>>>>>> correct correct.
>>>>>>>
>>>>>>> You are incorrect.
>>>>>>
>>>>>> *Since there are no mistakes no one can point out any mistakes*
>>>>>> *Since there are no mistakes no one can point out any mistakes*
>>>>>> *Since there are no mistakes no one can point out any mistakes*
>>>>>
>>>>> People HAVE pointed out the mistakes, but you are apparently too
>>>>> dumb to understand the problem.
>>>>>
>>>>>>
>>>>>> (a) The correct partial simulation of a machine description
>>>>>> (b) Correctly matches
>>>>>> (c) A correct infinite behavior pattern
>>>>>
>>>>> But the pattern you suggest is NOT corrct.
>>>>>
>>>>
>>>> void Infinite_Recursion(int N)
>>>> {
>>>>    Infinite_Recursion(N);
>>>> }
>>>>
>>>> int main()
>>>> {
>>>>    Output("Input_Halts = ", H((u32)Infinite_Recursion, 0x777));
>>>> }
>>>>
>>>> *TRY AND FIND ANY EXAMPLE OF FALSE POSITIVE*
>>>> (1) Infinite_Recursion() is called twice in sequence from the same
>>>> machine address of Infinite_Recursion() .
>>>> (2) With the same arguments to Infinite_Recursion()
>>>> (3) With no control flow instructions between the invocation of
>>>> Infinite_Recursion()  and the call to Infinite_Recursion() from
>>>> Infinite_Recursion()
>>>>
>>>> The fact that no false positives exist proves that there are no
>>>> false positives. Every time that the above pattern is matched is a
>>>> case of infinite recursion.
>>>
>>> Fallacy of the Strawman.
>>>
>>> I am not saying it doesn't work for Recursion, it doesn't work for
>>> the infinite simulation pattern.
>>>
>>
>> So then you agree that this reasoning is correct as long as the
>> behavior pattern is correct?
>>
>> (a) The correct partial simulation of a machine description
>> (b) Correctly matches
>> (c) A correct infinite behavior pattern
>> (d) Then this machine description specifies infinite behavior.
>>
>>
>>
>
> If you HAD a correct infinite simulation pattern, then yes, if you
> detect it, (BY DEFINITION) the behavior would be infinite, as that is
> the definition of correct.
>

I am surprised that you say that, most people here seem to be happy to
disagree with verified facts and logical necessity as long as they can
do this as part of their rebuttal to make sure that they always disagree
with everything that I say.

Do you agree that this infinite recursion behavior pattern will never
have any false positive matches?

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

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

_Infinite_Recursion()
[000010f2](01) 55 push ebp
[000010f3](02) 8bec mov ebp,esp
[000010f5](03) 8b4508 mov eax,[ebp+08]
[000010f8](01) 50 push eax
[000010f9](05) e8f4ffffff call 000010f2
[000010fe](03) 83c404 add esp,+04
[00001101](01) 5d pop ebp
[00001102](01) c3 ret
Size in bytes:(0017) [00001102]

H: Begin Simulation Execution Trace Stored at:111fe5
[000010f2][00111fd1][00111fd5] 55 push ebp
[000010f3][00111fd1][00111fd5] 8bec mov ebp,esp
[000010f5][00111fd1][00111fd5] 8b4508 mov eax,[ebp+08]
[000010f8][00111fcd][00000777] 50 push eax // push 0x777
[000010f9][00111fc9][000010fe] e8f4ffffff call 000010f2 // call
Infinite_Recursion
[000010f2][00111fc5][00111fd1] 55 push ebp
[000010f3][00111fc5][00111fd1] 8bec mov ebp,esp
[000010f5][00111fc5][00111fd1] 8b4508 mov eax,[ebp+08]
[000010f8][00111fc1][00000777] 50 push eax // push 0x777
[000010f9][00111fbd][000010fe] e8f4ffffff call 000010f2 // call
Infinite_Recursion
H: Infinite Recursion Detected Simulation Stopped

(1) Infinite_Recursion() is called twice in sequence from the same
machine address of Infinite_Recursion() .
(2) With the same arguments to Infinite_Recursion()
(3) With no control flow instructions between the invocation of
Infinite_Recursion() and the call to Infinite_Recursion() from
Infinite_Recursion()

> The problem is that there is NO actual correct infinite simulation
> pattern in the trace of P(P) that H can detect, as any pattern that H
> sees, if it treats it as an infinite simulation pattern, but H then
> acting on it, makes P(P) not get caught in an infinite simulation loop,
> BECAUSE the H that P calls will also act on it and abort its simulation
> and return 0 and cause P(P) to Halt.
>
> All that will occur in the CORRECT AND COMPLETE simulation of the input
> (not done by H since it aborted) after H aborted is PARTIAL simulation
> of the input, but that does prove that the pattern was incorrect, and
> thus H was wrong to use it.
>
> You can not assume existance of a finite pattern.
>
> And you can not use an infinite pattern as you need ot answer in finite
> time.

--
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: Definition of the term [simulating halt decider]

<4795105e-2370-478a-a7c7-f929478c5b40n@googlegroups.com>

 copy mid

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

 copy link   Newsgroups: comp.theory
X-Received: by 2002:a05:622a:1452:b0:344:51de:cc10 with SMTP id v18-20020a05622a145200b0034451decc10mr5436652qtx.432.1660893178319;
Fri, 19 Aug 2022 00:12:58 -0700 (PDT)
X-Received: by 2002:a25:add1:0:b0:691:3523:13c8 with SMTP id
d17-20020a25add1000000b00691352313c8mr6670153ybe.52.1660893178056; Fri, 19
Aug 2022 00:12:58 -0700 (PDT)
Path: i2pn2.org!i2pn.org!usenet.blueworldhosting.com!feed1.usenet.blueworldhosting.com!peer03.iad!feed-me.highwinds-media.com!news.highwinds-media.com!news-out.google.com!nntp.google.com!postnews.google.com!google-groups.googlegroups.com!not-for-mail
Newsgroups: comp.theory
Date: Fri, 19 Aug 2022 00:12:57 -0700 (PDT)
In-Reply-To: <JMmdndHvOed3dGP_nZ2dnZfqlJzNnZ2d@giganews.com>
Injection-Info: google-groups.googlegroups.com; posting-host=2001:470:1f23:2:34b4:5d02:9b6a:8e80;
posting-account=ZZETkAoAAACd4T-hRBh8m6HZV7_HBvWo
NNTP-Posting-Host: 2001:470:1f23:2:34b4:5d02:9b6a:8e80
References: <VUmdneqWu_jdjGT_nZ2dnZfqlJ_NnZ2d@giganews.com>
<AN-dnZxwirJvDGD_nZ2dnZfqlJxh4p2d@giganews.com> <EIgLK.927006$JVi.159216@fx17.iad>
<HfCdnUCy77LtPWD_nZ2dnZfqlJzNnZ2d@giganews.com> <nxhLK.927011$JVi.780897@fx17.iad>
<EmadnWSi2664NWD_nZ2dnZfqlJ_NnZ2d@giganews.com> <oYhLK.780561$ssF.60988@fx14.iad>
<VeucndlM27uDMmD_nZ2dnZfqlJ9g4p2d@giganews.com> <3ce2b023-e24a-410b-be6d-88358baf9d6cn@googlegroups.com>
<mOmdneWkX-TaKGD_nZ2dnZfqlJzNnZ2d@giganews.com> <1vpLK.679507$vAW9.331179@fx10.iad>
<G4udnW9QVcpV1WP_nZ2dnZfqlJxh4p2d@giganews.com> <NEzLK.680580$vAW9.195507@fx10.iad>
<TL2cnagZj8PtVGP_nZ2dnZfqlJ_NnZ2d@giganews.com> <j9ALK.797754$J0r9.465455@fx11.iad>
<mducnbROPbTJTWP_nZ2dnZfqlJ_NnZ2d@giganews.com> <83ee368a-0a10-49a7-9711-7fbaed66eac8n@googlegroups.com>
<7qSdndIv-fvVSGP_nZ2dnZfqlJxh4p2d@giganews.com> <d4c09662-9db6-47de-b3ee-a986c5c67ecan@googlegroups.com>
<6t2dnblhubPGeGP_nZ2dnZfqlJ_NnZ2d@giganews.com> <2cd5e2de-0718-411b-89fc-4d59c8b2ae3fn@googlegroups.com>
<JMmdndHvOed3dGP_nZ2dnZfqlJzNnZ2d@giganews.com>
User-Agent: G2/1.0
MIME-Version: 1.0
Message-ID: <4795105e-2370-478a-a7c7-f929478c5b40n@googlegroups.com>
Subject: Re: Definition of the term [simulating halt decider]
From: skepdic...@gmail.com (Skep Dick)
Injection-Date: Fri, 19 Aug 2022 07:12:58 +0000
Content-Type: text/plain; charset="UTF-8"
X-Received-Bytes: 4478
 by: Skep Dick - Fri, 19 Aug 2022 07:12 UTC

On Friday, 19 August 2022 at 03:40:28 UTC+2, olcott wrote:
> On 8/18/2022 8:28 PM, Skep Dick wrote:
> > On Friday, 19 August 2022 at 03:20:56 UTC+2, olcott wrote:
> >> On 8/18/2022 8:04 PM, Skep Dick wrote:
> >>> On Friday, 19 August 2022 at 02:12:26 UTC+2, olcott wrote:
> >>>> On 8/18/2022 7:05 PM, Skep Dick wrote:
> >>>>> On Friday, 19 August 2022 at 01:51:13 UTC+2, olcott wrote:
> >>>>>> My system is correct from a software engineering point of view.
> >>>>>> H does correctly determine that the actual behavior of its actual input
> >>>>>> specifies a sequence of instructions that never reach their final state.
> >>>>> Your program doesn't determine that the input NEVER (key word!!!) reach their final state.
> >>>>>
> >>>>> Your program determines that input doesn't reach its final state within N number of CPU cycles.
> >>>>>
> >>>> When-so-ever the partial simulation of a machine description correctly
> >>>> matches a correct infinite behavior pattern then it is certain that this
> >>>> machine description specifies infinite behavior.
> >>>
> >>> You can correctly put as correct many correct uses of the correct word correct but correct is not correct to be correct correct correct correct.
> >>>
> >>> You are incorrect.
> >> *Since there are no mistakes no one can point out any mistakes*
> >> *Since there are no mistakes no one can point out any mistakes*
> >> *Since there are no mistakes no one can point out any mistakes*
> >
> > The mistake is obvious. You terminated the program prematurely thus denying it an opportunity to halt (in due time and on its own terms).
> >
> *THAT WAS A DISHONEST DODGE AND YOU KNOW IT*
> *YOU CAN'T FREAKING CHANGE THE SUBJECT AND COUNT THAT AS A REBUTTAL*

Why are you trying to change the subject then, you dishonest twat?

I have pointed out an OBVIOUS MISTAKE. And now you are back-peddling and muddying the water with your faux outrage.

> *YOU MUST PROVE THAT*
> (1) At least one of the premises is false
No I don't. It's sufficient to demonstrate that the premise is not true. Or false.

By your own admission the simulation is partial. It's neither true nor false. Therefore it's neither correct nor incorrect.

> (2) The conclusion does not logically follow from the premises.
Q.E.D

Re: Definition of the term [simulating halt decider]

<T1KLK.687395$vAW9.210771@fx10.iad>

 copy mid

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

 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!fx10.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: Definition of the term [simulating halt decider]
Content-Language: en-US
Newsgroups: comp.theory
References: <VUmdneqWu_jdjGT_nZ2dnZfqlJ_NnZ2d@giganews.com>
<oYhLK.780561$ssF.60988@fx14.iad>
<VeucndlM27uDMmD_nZ2dnZfqlJ9g4p2d@giganews.com>
<3ce2b023-e24a-410b-be6d-88358baf9d6cn@googlegroups.com>
<mOmdneWkX-TaKGD_nZ2dnZfqlJzNnZ2d@giganews.com>
<1vpLK.679507$vAW9.331179@fx10.iad>
<G4udnW9QVcpV1WP_nZ2dnZfqlJxh4p2d@giganews.com>
<NEzLK.680580$vAW9.195507@fx10.iad>
<TL2cnagZj8PtVGP_nZ2dnZfqlJ_NnZ2d@giganews.com>
<j9ALK.797754$J0r9.465455@fx11.iad>
<mducnbROPbTJTWP_nZ2dnZfqlJ_NnZ2d@giganews.com>
<83ee368a-0a10-49a7-9711-7fbaed66eac8n@googlegroups.com>
<7qSdndIv-fvVSGP_nZ2dnZfqlJxh4p2d@giganews.com>
<d4c09662-9db6-47de-b3ee-a986c5c67ecan@googlegroups.com>
<6t2dnblhubPGeGP_nZ2dnZfqlJ_NnZ2d@giganews.com>
<5bCLK.805583$ssF.125283@fx14.iad>
<kL2cnU_OMaAjZmP_nZ2dnZfqlJ_NnZ2d@giganews.com>
<ecDLK.682433$vAW9.55970@fx10.iad>
<eLWdnUNJWsycnWL_nZ2dnZfqlJxh4p2d@giganews.com>
<anDLK.782712$zgr9.182386@fx13.iad>
<fcmdnfgGV8aSmGL_nZ2dnZfqlJzNnZ2d@giganews.com>
From: Rich...@Damon-Family.org (Richard Damon)
In-Reply-To: <fcmdnfgGV8aSmGL_nZ2dnZfqlJzNnZ2d@giganews.com>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Lines: 181
Message-ID: <T1KLK.687395$vAW9.210771@fx10.iad>
X-Complaints-To: abuse@easynews.com
Organization: Forte - www.forteinc.com
X-Complaints-Info: Please be sure to forward a copy of ALL headers otherwise we will be unable to process your complaint properly.
Date: Fri, 19 Aug 2022 06:58:59 -0400
X-Received-Bytes: 9129
 by: Richard Damon - Fri, 19 Aug 2022 10:58 UTC

On 8/18/22 11:35 PM, olcott wrote:
> On 8/18/2022 10:23 PM, Richard Damon wrote:
>> On 8/18/22 11:14 PM, olcott wrote:
>>> On 8/18/2022 10:12 PM, Richard Damon wrote:
>>>> On 8/18/22 10:56 PM, olcott wrote:
>>>>> On 8/18/2022 9:02 PM, Richard Damon wrote:
>>>>>>
>>>>>> On 8/18/22 9:20 PM, olcott wrote:
>>>>>>> On 8/18/2022 8:04 PM, Skep Dick wrote:
>>>>>>>> On Friday, 19 August 2022 at 02:12:26 UTC+2, olcott wrote:
>>>>>>>>> On 8/18/2022 7:05 PM, Skep Dick wrote:
>>>>>>>>>> On Friday, 19 August 2022 at 01:51:13 UTC+2, olcott wrote:
>>>>>>>>>>> My system is correct from a software engineering point of view.
>>>>>>>>>>> H does correctly determine that the actual behavior of its
>>>>>>>>>>> actual input
>>>>>>>>>>> specifies a sequence of instructions that never reach their
>>>>>>>>>>> final state.
>>>>>>>>>> Your program doesn't determine that the input NEVER (key
>>>>>>>>>> word!!!) reach their final state.
>>>>>>>>>>
>>>>>>>>>> Your program determines that input doesn't reach its final
>>>>>>>>>> state within N number of CPU cycles.
>>>>>>>>>>
>>>>>>>>> When-so-ever the partial simulation of a machine description
>>>>>>>>> correctly
>>>>>>>>> matches a correct infinite behavior pattern then it is certain
>>>>>>>>> that this
>>>>>>>>> machine description specifies infinite behavior.
>>>>>>>>
>>>>>>>> You can correctly put as correct many correct uses of the
>>>>>>>> correct word correct but correct is not correct to be correct
>>>>>>>> correct correct correct.
>>>>>>>>
>>>>>>>> You are incorrect.
>>>>>>>
>>>>>>> *Since there are no mistakes no one can point out any mistakes*
>>>>>>> *Since there are no mistakes no one can point out any mistakes*
>>>>>>> *Since there are no mistakes no one can point out any mistakes*
>>>>>>
>>>>>> People HAVE pointed out the mistakes, but you are apparently too
>>>>>> dumb to understand the problem.
>>>>>>
>>>>>>>
>>>>>>> (a) The correct partial simulation of a machine description
>>>>>>> (b) Correctly matches
>>>>>>> (c) A correct infinite behavior pattern
>>>>>>
>>>>>> But the pattern you suggest is NOT corrct.
>>>>>>
>>>>>
>>>>> void Infinite_Recursion(int N)
>>>>> {
>>>>>    Infinite_Recursion(N);
>>>>> }
>>>>>
>>>>> int main()
>>>>> {
>>>>>    Output("Input_Halts = ", H((u32)Infinite_Recursion, 0x777));
>>>>> }
>>>>>
>>>>> *TRY AND FIND ANY EXAMPLE OF FALSE POSITIVE*
>>>>> (1) Infinite_Recursion() is called twice in sequence from the same
>>>>> machine address of Infinite_Recursion() .
>>>>> (2) With the same arguments to Infinite_Recursion()
>>>>> (3) With no control flow instructions between the invocation of
>>>>> Infinite_Recursion()  and the call to Infinite_Recursion() from
>>>>> Infinite_Recursion()
>>>>>
>>>>> The fact that no false positives exist proves that there are no
>>>>> false positives. Every time that the above pattern is matched is a
>>>>> case of infinite recursion.
>>>>
>>>> Fallacy of the Strawman.
>>>>
>>>> I am not saying it doesn't work for Recursion, it doesn't work for
>>>> the infinite simulation pattern.
>>>>
>>>
>>> So then you agree that this reasoning is correct as long as the
>>> behavior pattern is correct?
>>>
>>> (a) The correct partial simulation of a machine description
>>> (b) Correctly matches
>>> (c) A correct infinite behavior pattern
>>> (d) Then this machine description specifies infinite behavior.
>>>
>>>
>>>
>>
>> If you HAD a correct infinite simulation pattern, then yes, if you
>> detect it, (BY DEFINITION) the behavior would be infinite, as that is
>> the definition of correct.
>>
>
> I am surprised that you say that, most people here seem to be happy to
> disagree with verified facts and logical necessity as long as they can
> do this as part of their rebuttal to make sure that they always disagree
> with everything that I say.
>
> Do you agree that this infinite recursion behavior pattern will never
> have any false positive matches?
>
> void Infinite_Recursion(int N)
> {
>   Infinite_Recursion(N);
> }
>
> int main()
> {
>   Output("Input_Halts = ", H((u32)Infinite_Recursion, 0x777));
> }
>
> _Infinite_Recursion()
> [000010f2](01)  55         push ebp
> [000010f3](02)  8bec       mov ebp,esp
> [000010f5](03)  8b4508     mov eax,[ebp+08]
> [000010f8](01)  50         push eax
> [000010f9](05)  e8f4ffffff call 000010f2
> [000010fe](03)  83c404     add esp,+04
> [00001101](01)  5d         pop ebp
> [00001102](01)  c3         ret
> Size in bytes:(0017) [00001102]
>
> H: Begin Simulation   Execution Trace Stored at:111fe5
> [000010f2][00111fd1][00111fd5] 55         push ebp
> [000010f3][00111fd1][00111fd5] 8bec       mov ebp,esp
> [000010f5][00111fd1][00111fd5] 8b4508     mov eax,[ebp+08]
> [000010f8][00111fcd][00000777] 50         push eax      // push 0x777
> [000010f9][00111fc9][000010fe] e8f4ffffff call 000010f2 // call
> Infinite_Recursion
> [000010f2][00111fc5][00111fd1] 55         push ebp
> [000010f3][00111fc5][00111fd1] 8bec       mov ebp,esp
> [000010f5][00111fc5][00111fd1] 8b4508     mov eax,[ebp+08]
> [000010f8][00111fc1][00000777] 50         push eax      // push 0x777
> [000010f9][00111fbd][000010fe] e8f4ffffff call 000010f2 // call
> Infinite_Recursion
> H: Infinite Recursion Detected Simulation Stopped
>
> (1) Infinite_Recursion() is called twice in sequence from the same
> machine address of Infinite_Recursion() .
> (2) With the same arguments to Infinite_Recursion()
> (3) With no control flow instructions between the invocation of
> Infinite_Recursion()  and the call to Infinite_Recursion() from
> Infinite_Recursion()

For RECURSION, yes. Note that (3) the two mentions of
"Infinite_Recursion()" specify the SAME function.

Note, when you change this to the simulation version, you don't have the
same pattern, as it becomes P(P) and H(P,P) and there is conditionality
in the other half of the "loop", between the call to H(P,P) and the
simulation of P(P), that comes from the PREVIOUS call to H(P,P) that is
simulating this code.

You confuse UNCONDITIONAL simulation with CONDITIONAL simulation for
Halt Detection, and thus get an incorrect answer.

THus, the infinite simulation pattern that you derive from the recursive
call pattern is incorrect.

>
>
>> The problem is that there is NO actual correct infinite simulation
>> pattern in the trace of P(P) that H can detect, as any pattern that H
>> sees, if it treats it as an infinite simulation pattern, but H then
>> acting on it, makes P(P) not get caught in an infinite simulation
>> loop, BECAUSE the H that P calls will also act on it and abort its
>> simulation and return 0 and cause P(P) to Halt.
>>
>> All that will occur in the CORRECT AND COMPLETE simulation of the
>> input (not done by H since it aborted) after H aborted is PARTIAL
>> simulation of the input, but that does prove that the pattern was
>> incorrect, and thus H was wrong to use it.
>>
>> You can not assume existance of a finite pattern.
>>
>> And you can not use an infinite pattern as you need ot answer in
>> finite time.
>
>

Re: Definition of the term [simulating halt decider][ criteria ]

<1fydnSqsYraFMGL_nZ2dnZfqlJzNnZ2d@giganews.com>

 copy mid

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

 copy link   Newsgroups: comp.theory comp.lang.c comp.lang.c++
Followup: 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: Fri, 19 Aug 2022 15:32:40 +0000
Date: Fri, 19 Aug 2022 10:32:56 -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: Definition of the term [simulating halt decider][ criteria ]
Content-Language: en-US
Newsgroups: comp.theory,comp.lang.c,comp.lang.c++
References: <VUmdneqWu_jdjGT_nZ2dnZfqlJ_NnZ2d@giganews.com>
<oYhLK.780561$ssF.60988@fx14.iad>
<VeucndlM27uDMmD_nZ2dnZfqlJ9g4p2d@giganews.com>
<3ce2b023-e24a-410b-be6d-88358baf9d6cn@googlegroups.com>
<mOmdneWkX-TaKGD_nZ2dnZfqlJzNnZ2d@giganews.com>
<1vpLK.679507$vAW9.331179@fx10.iad>
<G4udnW9QVcpV1WP_nZ2dnZfqlJxh4p2d@giganews.com>
<NEzLK.680580$vAW9.195507@fx10.iad>
<TL2cnagZj8PtVGP_nZ2dnZfqlJ_NnZ2d@giganews.com>
<j9ALK.797754$J0r9.465455@fx11.iad>
<mducnbROPbTJTWP_nZ2dnZfqlJ_NnZ2d@giganews.com>
<83ee368a-0a10-49a7-9711-7fbaed66eac8n@googlegroups.com>
<7qSdndIv-fvVSGP_nZ2dnZfqlJxh4p2d@giganews.com>
<d4c09662-9db6-47de-b3ee-a986c5c67ecan@googlegroups.com>
<6t2dnblhubPGeGP_nZ2dnZfqlJ_NnZ2d@giganews.com>
<5bCLK.805583$ssF.125283@fx14.iad>
<kL2cnU_OMaAjZmP_nZ2dnZfqlJ_NnZ2d@giganews.com>
<ecDLK.682433$vAW9.55970@fx10.iad>
<eLWdnUNJWsycnWL_nZ2dnZfqlJxh4p2d@giganews.com>
<anDLK.782712$zgr9.182386@fx13.iad>
<fcmdnfgGV8aSmGL_nZ2dnZfqlJzNnZ2d@giganews.com>
<T1KLK.687395$vAW9.210771@fx10.iad>
From: NoO...@NoWhere.com (olcott)
Followup-To: comp.theory
In-Reply-To: <T1KLK.687395$vAW9.210771@fx10.iad>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Message-ID: <1fydnSqsYraFMGL_nZ2dnZfqlJzNnZ2d@giganews.com>
Lines: 269
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-86JFsl2lb/8MbEancmY90CNYIqq1pcHyvRAnpvIzjcDFQdfVNfM7KKCTj6EsJIiUjK0DQ6g9tOgeU2u!0JiMeMpkO0FOcEa5RSf8l/UfP1tq6f0d2LsmgBwcM2MwyqsVYu1XQglfXPw6tWVG9iXRJNNYzJ0=
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 - Fri, 19 Aug 2022 15:32 UTC

On 8/19/2022 5:58 AM, Richard Damon wrote:
> On 8/18/22 11:35 PM, olcott wrote:
>> On 8/18/2022 10:23 PM, Richard Damon wrote:
>>> On 8/18/22 11:14 PM, olcott wrote:
>>>> On 8/18/2022 10:12 PM, Richard Damon wrote:
>>>>> On 8/18/22 10:56 PM, olcott wrote:
>>>>>> On 8/18/2022 9:02 PM, Richard Damon wrote:
>>>>>>>
>>>>>>> On 8/18/22 9:20 PM, olcott wrote:
>>>>>>>> On 8/18/2022 8:04 PM, Skep Dick wrote:
>>>>>>>>> On Friday, 19 August 2022 at 02:12:26 UTC+2, olcott wrote:
>>>>>>>>>> On 8/18/2022 7:05 PM, Skep Dick wrote:
>>>>>>>>>>> On Friday, 19 August 2022 at 01:51:13 UTC+2, olcott wrote:
>>>>>>>>>>>> My system is correct from a software engineering point of view.
>>>>>>>>>>>> H does correctly determine that the actual behavior of its
>>>>>>>>>>>> actual input
>>>>>>>>>>>> specifies a sequence of instructions that never reach their
>>>>>>>>>>>> final state.
>>>>>>>>>>> Your program doesn't determine that the input NEVER (key
>>>>>>>>>>> word!!!) reach their final state.
>>>>>>>>>>>
>>>>>>>>>>> Your program determines that input doesn't reach its final
>>>>>>>>>>> state within N number of CPU cycles.
>>>>>>>>>>>
>>>>>>>>>> When-so-ever the partial simulation of a machine description
>>>>>>>>>> correctly
>>>>>>>>>> matches a correct infinite behavior pattern then it is certain
>>>>>>>>>> that this
>>>>>>>>>> machine description specifies infinite behavior.
>>>>>>>>>
>>>>>>>>> You can correctly put as correct many correct uses of the
>>>>>>>>> correct word correct but correct is not correct to be correct
>>>>>>>>> correct correct correct.
>>>>>>>>>
>>>>>>>>> You are incorrect.
>>>>>>>>
>>>>>>>> *Since there are no mistakes no one can point out any mistakes*
>>>>>>>> *Since there are no mistakes no one can point out any mistakes*
>>>>>>>> *Since there are no mistakes no one can point out any mistakes*
>>>>>>>
>>>>>>> People HAVE pointed out the mistakes, but you are apparently too
>>>>>>> dumb to understand the problem.
>>>>>>>
>>>>>>>>
>>>>>>>> (a) The correct partial simulation of a machine description
>>>>>>>> (b) Correctly matches
>>>>>>>> (c) A correct infinite behavior pattern
>>>>>>>
>>>>>>> But the pattern you suggest is NOT corrct.
>>>>>>>
>>>>>>
>>>>>> void Infinite_Recursion(int N)
>>>>>> {
>>>>>>    Infinite_Recursion(N);
>>>>>> }
>>>>>>
>>>>>> int main()
>>>>>> {
>>>>>>    Output("Input_Halts = ", H((u32)Infinite_Recursion, 0x777));
>>>>>> }
>>>>>>
>>>>>> *TRY AND FIND ANY EXAMPLE OF FALSE POSITIVE*
>>>>>> (1) Infinite_Recursion() is called twice in sequence from the same
>>>>>> machine address of Infinite_Recursion() .
>>>>>> (2) With the same arguments to Infinite_Recursion()
>>>>>> (3) With no control flow instructions between the invocation of
>>>>>> Infinite_Recursion()  and the call to Infinite_Recursion() from
>>>>>> Infinite_Recursion()
>>>>>>
>>>>>> The fact that no false positives exist proves that there are no
>>>>>> false positives. Every time that the above pattern is matched is a
>>>>>> case of infinite recursion.
>>>>>
>>>>> Fallacy of the Strawman.
>>>>>
>>>>> I am not saying it doesn't work for Recursion, it doesn't work for
>>>>> the infinite simulation pattern.
>>>>>
>>>>
>>>> So then you agree that this reasoning is correct as long as the
>>>> behavior pattern is correct?
>>>>
>>>> (a) The correct partial simulation of a machine description
>>>> (b) Correctly matches
>>>> (c) A correct infinite behavior pattern
>>>> (d) Then this machine description specifies infinite behavior.
>>>>
>>>>
>>>>
>>>
>>> If you HAD a correct infinite simulation pattern, then yes, if you
>>> detect it, (BY DEFINITION) the behavior would be infinite, as that is
>>> the definition of correct.
>>>
>>
>> I am surprised that you say that, most people here seem to be happy to
>> disagree with verified facts and logical necessity as long as they can
>> do this as part of their rebuttal to make sure that they always
>> disagree with everything that I say.
>>
>> Do you agree that this infinite recursion behavior pattern will never
>> have any false positive matches?
>>
>> void Infinite_Recursion(int N)
>> {
>>    Infinite_Recursion(N);
>> }
>>
>> int main()
>> {
>>    Output("Input_Halts = ", H((u32)Infinite_Recursion, 0x777));
>> }
>>
>> _Infinite_Recursion()
>> [000010f2](01)  55         push ebp
>> [000010f3](02)  8bec       mov ebp,esp
>> [000010f5](03)  8b4508     mov eax,[ebp+08]
>> [000010f8](01)  50         push eax
>> [000010f9](05)  e8f4ffffff call 000010f2
>> [000010fe](03)  83c404     add esp,+04
>> [00001101](01)  5d         pop ebp
>> [00001102](01)  c3         ret
>> Size in bytes:(0017) [00001102]
>>
>> H: Begin Simulation   Execution Trace Stored at:111fe5
>> [000010f2][00111fd1][00111fd5] 55         push ebp
>> [000010f3][00111fd1][00111fd5] 8bec       mov ebp,esp
>> [000010f5][00111fd1][00111fd5] 8b4508     mov eax,[ebp+08]
>> [000010f8][00111fcd][00000777] 50         push eax      // push 0x777
>> [000010f9][00111fc9][000010fe] e8f4ffffff call 000010f2 // call
>> Infinite_Recursion
>> [000010f2][00111fc5][00111fd1] 55         push ebp
>> [000010f3][00111fc5][00111fd1] 8bec       mov ebp,esp
>> [000010f5][00111fc5][00111fd1] 8b4508     mov eax,[ebp+08]
>> [000010f8][00111fc1][00000777] 50         push eax      // push 0x777
>> [000010f9][00111fbd][000010fe] e8f4ffffff call 000010f2 // call
>> Infinite_Recursion
>> H: Infinite Recursion Detected Simulation Stopped
>>
>> (1) Infinite_Recursion() is called twice in sequence from the same
>> machine address of Infinite_Recursion() .
>> (2) With the same arguments to Infinite_Recursion()
>> (3) With no control flow instructions between the invocation of
>> Infinite_Recursion()  and the call to Infinite_Recursion() from
>> Infinite_Recursion()
>
> For RECURSION, yes. Note that (3) the two mentions of
> "Infinite_Recursion()" specify the SAME function.
>

*Here it is adapted to a more complex case of infinite recursion*
(1) HR is called twice in sequence from the same machine address of PR.
(2) With the same arguments to HR.
(3) With no control flow instructions between the invocation of PR and
the call to HR from PR

*False Positive*
Reporting infinite recursion when there is no infinite recursion.

Do you agree that the above criteria would have no false positives?
(see all the details below).

*H detects that PR is calling HR in infinite recursion*

PR(u32 x)
{ HR(x);
}

HR(u32 y)
{ PR(y);
}

int main()
{ Output((char*)"Input_Halts = ", H(PR, (ptr)0x777));
}

_HR()
[00001042](01) 55 push ebp
[00001043](02) 8bec mov ebp,esp
[00001045](03) 8b4508 mov eax,[ebp+08]
[00001048](01) 50 push eax
[00001049](05) e814000000 call 00001062
[0000104e](03) 83c404 add esp,+04
[00001051](01) 5d pop ebp
[00001052](01) c3 ret
Size in bytes:(0017) [00001052]


Click here to read the complete article
Re: Definition of the term [simulating halt decider][ criteria ]

<QgOLK.842717$wIO9.486197@fx12.iad>

 copy mid

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

 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!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: Definition of the term [simulating halt decider][ criteria ]
Content-Language: en-US
Newsgroups: comp.theory
References: <VUmdneqWu_jdjGT_nZ2dnZfqlJ_NnZ2d@giganews.com>
<3ce2b023-e24a-410b-be6d-88358baf9d6cn@googlegroups.com>
<mOmdneWkX-TaKGD_nZ2dnZfqlJzNnZ2d@giganews.com>
<1vpLK.679507$vAW9.331179@fx10.iad>
<G4udnW9QVcpV1WP_nZ2dnZfqlJxh4p2d@giganews.com>
<NEzLK.680580$vAW9.195507@fx10.iad>
<TL2cnagZj8PtVGP_nZ2dnZfqlJ_NnZ2d@giganews.com>
<j9ALK.797754$J0r9.465455@fx11.iad>
<mducnbROPbTJTWP_nZ2dnZfqlJ_NnZ2d@giganews.com>
<83ee368a-0a10-49a7-9711-7fbaed66eac8n@googlegroups.com>
<7qSdndIv-fvVSGP_nZ2dnZfqlJxh4p2d@giganews.com>
<d4c09662-9db6-47de-b3ee-a986c5c67ecan@googlegroups.com>
<6t2dnblhubPGeGP_nZ2dnZfqlJ_NnZ2d@giganews.com>
<5bCLK.805583$ssF.125283@fx14.iad>
<kL2cnU_OMaAjZmP_nZ2dnZfqlJ_NnZ2d@giganews.com>
<ecDLK.682433$vAW9.55970@fx10.iad>
<eLWdnUNJWsycnWL_nZ2dnZfqlJxh4p2d@giganews.com>
<anDLK.782712$zgr9.182386@fx13.iad>
<fcmdnfgGV8aSmGL_nZ2dnZfqlJzNnZ2d@giganews.com>
<T1KLK.687395$vAW9.210771@fx10.iad>
<1fydnSqsYraFMGL_nZ2dnZfqlJzNnZ2d@giganews.com>
From: Rich...@Damon-Family.org (Richard Damon)
In-Reply-To: <1fydnSqsYraFMGL_nZ2dnZfqlJzNnZ2d@giganews.com>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Lines: 273
Message-ID: <QgOLK.842717$wIO9.486197@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: Fri, 19 Aug 2022 11:47:59 -0400
X-Received-Bytes: 13553
 by: Richard Damon - Fri, 19 Aug 2022 15:47 UTC

On 8/19/22 11:32 AM, olcott wrote:
> On 8/19/2022 5:58 AM, Richard Damon wrote:
>> On 8/18/22 11:35 PM, olcott wrote:
>>> On 8/18/2022 10:23 PM, Richard Damon wrote:
>>>> On 8/18/22 11:14 PM, olcott wrote:
>>>>> On 8/18/2022 10:12 PM, Richard Damon wrote:
>>>>>> On 8/18/22 10:56 PM, olcott wrote:
>>>>>>> On 8/18/2022 9:02 PM, Richard Damon wrote:
>>>>>>>>
>>>>>>>> On 8/18/22 9:20 PM, olcott wrote:
>>>>>>>>> On 8/18/2022 8:04 PM, Skep Dick wrote:
>>>>>>>>>> On Friday, 19 August 2022 at 02:12:26 UTC+2, olcott wrote:
>>>>>>>>>>> On 8/18/2022 7:05 PM, Skep Dick wrote:
>>>>>>>>>>>> On Friday, 19 August 2022 at 01:51:13 UTC+2, olcott wrote:
>>>>>>>>>>>>> My system is correct from a software engineering point of
>>>>>>>>>>>>> view.
>>>>>>>>>>>>> H does correctly determine that the actual behavior of its
>>>>>>>>>>>>> actual input
>>>>>>>>>>>>> specifies a sequence of instructions that never reach their
>>>>>>>>>>>>> final state.
>>>>>>>>>>>> Your program doesn't determine that the input NEVER (key
>>>>>>>>>>>> word!!!) reach their final state.
>>>>>>>>>>>>
>>>>>>>>>>>> Your program determines that input doesn't reach its final
>>>>>>>>>>>> state within N number of CPU cycles.
>>>>>>>>>>>>
>>>>>>>>>>> When-so-ever the partial simulation of a machine description
>>>>>>>>>>> correctly
>>>>>>>>>>> matches a correct infinite behavior pattern then it is
>>>>>>>>>>> certain that this
>>>>>>>>>>> machine description specifies infinite behavior.
>>>>>>>>>>
>>>>>>>>>> You can correctly put as correct many correct uses of the
>>>>>>>>>> correct word correct but correct is not correct to be correct
>>>>>>>>>> correct correct correct.
>>>>>>>>>>
>>>>>>>>>> You are incorrect.
>>>>>>>>>
>>>>>>>>> *Since there are no mistakes no one can point out any mistakes*
>>>>>>>>> *Since there are no mistakes no one can point out any mistakes*
>>>>>>>>> *Since there are no mistakes no one can point out any mistakes*
>>>>>>>>
>>>>>>>> People HAVE pointed out the mistakes, but you are apparently too
>>>>>>>> dumb to understand the problem.
>>>>>>>>
>>>>>>>>>
>>>>>>>>> (a) The correct partial simulation of a machine description
>>>>>>>>> (b) Correctly matches
>>>>>>>>> (c) A correct infinite behavior pattern
>>>>>>>>
>>>>>>>> But the pattern you suggest is NOT corrct.
>>>>>>>>
>>>>>>>
>>>>>>> void Infinite_Recursion(int N)
>>>>>>> {
>>>>>>>    Infinite_Recursion(N);
>>>>>>> }
>>>>>>>
>>>>>>> int main()
>>>>>>> {
>>>>>>>    Output("Input_Halts = ", H((u32)Infinite_Recursion, 0x777));
>>>>>>> }
>>>>>>>
>>>>>>> *TRY AND FIND ANY EXAMPLE OF FALSE POSITIVE*
>>>>>>> (1) Infinite_Recursion() is called twice in sequence from the
>>>>>>> same machine address of Infinite_Recursion() .
>>>>>>> (2) With the same arguments to Infinite_Recursion()
>>>>>>> (3) With no control flow instructions between the invocation of
>>>>>>> Infinite_Recursion()  and the call to Infinite_Recursion() from
>>>>>>> Infinite_Recursion()
>>>>>>>
>>>>>>> The fact that no false positives exist proves that there are no
>>>>>>> false positives. Every time that the above pattern is matched is
>>>>>>> a case of infinite recursion.
>>>>>>
>>>>>> Fallacy of the Strawman.
>>>>>>
>>>>>> I am not saying it doesn't work for Recursion, it doesn't work for
>>>>>> the infinite simulation pattern.
>>>>>>
>>>>>
>>>>> So then you agree that this reasoning is correct as long as the
>>>>> behavior pattern is correct?
>>>>>
>>>>> (a) The correct partial simulation of a machine description
>>>>> (b) Correctly matches
>>>>> (c) A correct infinite behavior pattern
>>>>> (d) Then this machine description specifies infinite behavior.
>>>>>
>>>>>
>>>>>
>>>>
>>>> If you HAD a correct infinite simulation pattern, then yes, if you
>>>> detect it, (BY DEFINITION) the behavior would be infinite, as that
>>>> is the definition of correct.
>>>>
>>>
>>> I am surprised that you say that, most people here seem to be happy
>>> to disagree with verified facts and logical necessity as long as they
>>> can do this as part of their rebuttal to make sure that they always
>>> disagree with everything that I say.
>>>
>>> Do you agree that this infinite recursion behavior pattern will never
>>> have any false positive matches?
>>>
>>> void Infinite_Recursion(int N)
>>> {
>>>    Infinite_Recursion(N);
>>> }
>>>
>>> int main()
>>> {
>>>    Output("Input_Halts = ", H((u32)Infinite_Recursion, 0x777));
>>> }
>>>
>>> _Infinite_Recursion()
>>> [000010f2](01)  55         push ebp
>>> [000010f3](02)  8bec       mov ebp,esp
>>> [000010f5](03)  8b4508     mov eax,[ebp+08]
>>> [000010f8](01)  50         push eax
>>> [000010f9](05)  e8f4ffffff call 000010f2
>>> [000010fe](03)  83c404     add esp,+04
>>> [00001101](01)  5d         pop ebp
>>> [00001102](01)  c3         ret
>>> Size in bytes:(0017) [00001102]
>>>
>>> H: Begin Simulation   Execution Trace Stored at:111fe5
>>> [000010f2][00111fd1][00111fd5] 55         push ebp
>>> [000010f3][00111fd1][00111fd5] 8bec       mov ebp,esp
>>> [000010f5][00111fd1][00111fd5] 8b4508     mov eax,[ebp+08]
>>> [000010f8][00111fcd][00000777] 50         push eax      // push 0x777
>>> [000010f9][00111fc9][000010fe] e8f4ffffff call 000010f2 // call
>>> Infinite_Recursion
>>> [000010f2][00111fc5][00111fd1] 55         push ebp
>>> [000010f3][00111fc5][00111fd1] 8bec       mov ebp,esp
>>> [000010f5][00111fc5][00111fd1] 8b4508     mov eax,[ebp+08]
>>> [000010f8][00111fc1][00000777] 50         push eax      // push 0x777
>>> [000010f9][00111fbd][000010fe] e8f4ffffff call 000010f2 // call
>>> Infinite_Recursion
>>> H: Infinite Recursion Detected Simulation Stopped
>>>
>>> (1) Infinite_Recursion() is called twice in sequence from the same
>>> machine address of Infinite_Recursion() .
>>> (2) With the same arguments to Infinite_Recursion()
>>> (3) With no control flow instructions between the invocation of
>>> Infinite_Recursion()  and the call to Infinite_Recursion() from
>>> Infinite_Recursion()
>>
>> For RECURSION, yes. Note that (3) the two mentions of
>> "Infinite_Recursion()" specify the SAME function.
>>
>
> *Here it is adapted to a more complex case of infinite recursion*
> (1) HR is called twice in sequence from the same machine address of PR.
> (2) With the same arguments to HR.
> (3) With no control flow instructions between the invocation of PR and
> the call to HR from PR
>
> *False Positive*
> Reporting infinite recursion when there is no infinite recursion.
>
> Do you agree that the above criteria would have no false positives?
> (see all the details below).
>
> *H detects that PR is calling HR in infinite recursion*


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

rocksolid light 0.9.7
clearnet tor