Path: ...!weretis.net!feeder9.news.weretis.net!i2pn.org!i2pn2.org!.POSTED!not-for-mail
From: Richard Damon <richard@damon-family.org>
Newsgroups: comp.theory
Subject: Re: Who knows that DDD correctly simulated by HHH cannot possibly
 reach its own return instruction final state?
Date: Wed, 7 Aug 2024 21:01:06 -0400
Organization: i2pn2 (i2pn.org)
Message-ID: <a378fffac74e647a8c0484933e79c954a0842fa6@i2pn2.org>
References: <v8jh7m$30k55$1@dont-email.me> <v8lr4u$3iali$1@dont-email.me>
 <c949dfc8c7354f19a3a3d31325ee9847be91f333@i2pn2.org>
 <v8lt59$3iali$2@dont-email.me>
 <74c4fe66234c5332f4ec6032bc55cc6c5f038aee@i2pn2.org>
 <v8lv3a$3j30t$1@dont-email.me>
 <9fb36dd006e570bf987f882a8310bc13e8fc04a7@i2pn2.org>
 <v8m331$3ju7r$1@dont-email.me>
 <3ecbe8eddd0f3644c7045e937ccaf6ddc1cdb3a9@i2pn2.org>
 <v8m5a5$3kbok$1@dont-email.me>
 <de8528a486cdc94aec9fc7dc3d0195fdce3b4fbe@i2pn2.org>
 <v8m93b$3l8jv$1@dont-email.me>
 <c50f1d87c5e386a7c388c982a4f7da8c5889e493@i2pn2.org>
 <v8ma68$3lgfl$1@dont-email.me>
 <03571f185bf16590c5e535908467086b1efaffef@i2pn2.org>
 <v8meta$3ma4t$1@dont-email.me>
 <b1e8c0c9b69cc026f777b37bbd49af5d2afddd21@i2pn2.org>
 <v8mqt0$3s736$1@dont-email.me>
 <1c483f9a972618a0db5c00e03b894c3fe6adc1fa@i2pn2.org>
 <v8nsho$1n09$4@dont-email.me> <v8pv8a$if6p$1@dont-email.me>
 <4-qdnbVw1JztSi37nZ2dnZfqlJydnZ2d@giganews.com>
 <v8v730$29l8n$1@dont-email.me> <v8vsql$32fso$11@dont-email.me>
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Injection-Date: Thu, 8 Aug 2024 01:01:06 -0000 (UTC)
Injection-Info: i2pn2.org;
	logging-data="1814287"; mail-complaints-to="usenet@i2pn2.org";
	posting-account="diqKR1lalukngNWEqoq9/uFtbkm5U+w3w6FQ0yesrXg";
User-Agent: Mozilla Thunderbird
Content-Language: en-US
X-Spam-Checker-Version: SpamAssassin 4.0.0
In-Reply-To: <v8vsql$32fso$11@dont-email.me>
Bytes: 6664
Lines: 139

On 8/7/24 9:28 AM, olcott wrote:
> On 8/7/2024 2:17 AM, Mikko wrote:
>> On 2024-08-05 13:45:19 +0000, olcott said:
>>
>>> On 8/5/2024 2:33 AM, Mikko wrote:
>>>> On 2024-08-04 12:35:04 +0000, olcott said:
>>>>
>>>>> On 8/4/2024 6:12 AM, Richard Damon wrote:
>>>>>> On 8/3/24 11:00 PM, olcott wrote:
>>>>>>> On 8/3/2024 9:56 PM, Richard Damon wrote:
>>>>>>>> On 8/3/24 7:36 PM, olcott wrote:
>>>>>>>>> On 8/3/2024 5:51 PM, Richard Damon wrote:
>>>>>>>>>> On 8/3/24 6:15 PM, olcott wrote:
>>>>>>>>>>> On 8/3/2024 5:07 PM, Richard Damon wrote:
>>>>>>>>>>>>
>>>>>>>>>>>> The problem is that every one of those emulation is of a 
>>>>>>>>>>>> *DIFFERENT* input, so they don't prove anything together 
>>>>>>>>>>>> except that each one didn't go far enough.
>>>>>>>>>>>
>>>>>>>>>>> void DDD()
>>>>>>>>>>> {
>>>>>>>>>>>    HHH(DDD);
>>>>>>>>>>>    return;
>>>>>>>>>>> }
>>>>>>>>>>>
>>>>>>>>>>> When each HHH correctly emulates 0 to infinity steps of
>>>>>>>>>>> its corresponding DDD and none of them reach the "return"
>>>>>>>>>>> halt state of DDD then even the one that emulated infinite
>>>>>>>>>>> steps of DDD did not emulate enough steps?
>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> Just says lying YOU.
>>>>>>>>>>
>>>>>>>>>> You got any source for that other than yourself?
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> It is self-evident and you know it. I do have four
>>>>>>>>> people (two with masters in CS) that attest to that.
>>>>>>>>> *It is as simple as I can possibly make it*
>>>>>>>>
>>>>>>>> Maybe to your mind filled with false facts, but it isn't true.
>>>>>>>>
>>>>>>>>>
>>>>>>>>> I wonder how you think that you are not swearing your
>>>>>>>>> allegiance to that father of lies?
>>>>>>>>
>>>>>>>> Because, I know I speak the truth.
>>>>>>>>
>>>>>>>> Why do you not think you are lying?
>>>>>>>>
>>>>>>>>>
>>>>>>>>> Anyone that truly understands infinite recursion knows
>>>>>>>>> that DDD correctly simulated by HHH cannot possibly reach
>>>>>>>>> its own "return" final state.
>>>>>>>>
>>>>>>>> Right, but for every other HHH, which the ones that answer are, 
>>>>>>>> it isn't a fact.
>>>>>>>>
>>>>>>>>
>>>>>>>>>
>>>>>>>>> Surpisingly (to me) Jeff Barnett set the record straight
>>>>>>>>> on exactly what halting means.
>>>>>>>>>
>>>>>>>>
>>>>>>>> No, there is one, and only one definition, it is a machine that 
>>>>>>>> reaches its final state.
>>>>>>>>
>>>>>>>> Note, *a machine*, not a (partial) emulation of the machine
>>>>>>>>
>>>>>>>
>>>>>>> You already know that a complete emulation of a non-ending
>>>>>>> sequence is impossible and you already acknowledged that
>>>>>>> DDD emulated by HHH that never aborts is non-ending.
>>>>>>>
>>>>>>>
>>>>>>>
>>>>>>
>>>>>> WHy do you say it is impossible, it just takes forever,
>>>>>
>>>>> A complete emulation is after all of the instructions have been
>>>>> emulated. That never happens with any infinite execution.
>>>>
>>>> No, that is not what the words mean. A complete emulation is one 
>>>> that is
>>>> continued as long as it can be continued. THe emulation is completed 
>>>> when
>>>> all of its instructions are executed. A complete emulaton  that can be
>>>> continues forever is complete but never completed.
>>>
>>> That is incorrect. A completed task is a task where
>>> there are no more steps to be accomplished.
>>
>> That you agree does not mean that I was wrong (though it certainly
>> means that I should check one more time, and I did, and found some
>> typos but no substantial error).
>>
> 
> On 8/2/2024 11:32 PM, Jeff Barnett wrote:
>  > ...In some formulations, there are specific states
>  >    defined as "halting states" and the machine only
>  >    halts if either the start state is a halt state...
> 
>  > ...these and many other definitions all have
>  >    equivalent computing prowess...
> 
> A completed task is one that reaches its halt state.
> 
> void Infinite_Recursion()
> {
>    Infinite_Recursion();
>    return;
> }
> 
> void DDD()
> {
>    HHH(DDD);
>    return;
> }
> 
> int main()
> {
>    HHH(Infinite_Recursion);
>    HHH(DDD);
> }
> 
> Neither Infinite_Recursion nor DDD simulated by HHH
> according to the semantics of the x86 language can
> possibly reach their own halt state of "return" thus
> can never be completed tasks.
> 

Nope,

The full behavior of the DDD that HHH partially emulates continues past 
the point that HHH aborts its emulation, as defined by the x86 language, 
and then reaches its final state.

The partial emulation of HHH doesn't reach there, but that isn't a 
correct emulation by the rules you say you are following.