Path: ...!weretis.net!feeder9.news.weretis.net!news.nk.ca!rocksolid2!i2pn2.org!.POSTED!not-for-mail
From: Richard Damon <richard@damon-family.org>
Newsgroups: comp.theory
Subject: Re: The philosophy of computation reformulates existing ideas on a
 new basis ---x86 code is a liar?
Date: Thu, 7 Nov 2024 22:10:52 -0500
Organization: i2pn2 (i2pn.org)
Message-ID: <c7372fcf786ecb5e394cf44079e5ff126899e252@i2pn2.org>
References: <vfli1h$fj8s$1@dont-email.me> <vg9h2j$pi2n$1@dont-email.me>
 <1ee05647789dbaab013f1194411ff373e45a463e@i2pn2.org>
 <vgafqv$umps$1@dont-email.me>
 <0cdb23355b23731751b9614543e8a1c257214b5a@i2pn2.org>
 <vgbskb$172co$1@dont-email.me>
 <157b13f5b452420f1bb20db458bfa7b952449ecf@i2pn2.org>
 <vgc2ju$1bqmm$1@dont-email.me>
 <585823321cf0a5e579b855438cfbf93229b233ee@i2pn2.org>
 <vgdjdq$1jr80$1@dont-email.me>
 <b24e957b9f2af15c0ba7f18a3f7bfe2c6ff6419d@i2pn2.org>
 <vgegce$1phg2$1@dont-email.me>
 <e36afcb3758e0fb26d58019c08a24c6df0b562a7@i2pn2.org>
 <vgenp1$1uh1b$2@dont-email.me>
 <acecb0ba68d86b00c95fae1ecf690ec514aee26b@i2pn2.org>
 <vgfq86$24mon$1@dont-email.me>
 <e7a092c593ad1431a1bf6589d0102312545612ef@i2pn2.org>
 <vghb16$2ge1v$1@dont-email.me>
 <e51f21daadd358ef13801c918106c2fdc65a9f6b@i2pn2.org>
 <vghe3p$2gr3p$1@dont-email.me>
 <4cb98b3918d6745f53bb19582b59e786d4af5022@i2pn2.org>
 <vghgar$2h30o$1@dont-email.me>
 <e40629600e317dba47dd3d066d83899fa7b8a7ab@i2pn2.org>
 <vgiq1d$2nkqv$1@dont-email.me>
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Injection-Date: Fri, 8 Nov 2024 03:10:52 -0000 (UTC)
Injection-Info: i2pn2.org;
	logging-data="1460222"; 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: <vgiq1d$2nkqv$1@dont-email.me>
Bytes: 23339
Lines: 504

On 11/7/24 11:31 AM, olcott wrote:
> On 11/7/2024 5:56 AM, Richard Damon wrote:
>> On 11/6/24 11:39 PM, olcott wrote:
>>> On 11/6/2024 10:10 PM, Richard Damon wrote:
>>>> On 11/6/24 11:02 PM, olcott wrote:
>>>>> On 11/6/2024 9:42 PM, Richard Damon wrote:
>>>>>> On 11/6/24 10:09 PM, olcott wrote:
>>>>>>> On 11/6/2024 6:45 PM, Richard Damon wrote:
>>>>>>>> On 11/6/24 8:16 AM, olcott wrote:
>>>>>>>>> On 11/6/2024 5:37 AM, Richard Damon wrote:
>>>>>>>>>> On 11/5/24 10:28 PM, olcott wrote:
>>>>>>>>>>> On 11/5/2024 7:50 PM, Richard Damon wrote:
>>>>>>>>>>>> On 11/5/24 8:22 PM, olcott wrote:
>>>>>>>>>>>>> On 11/5/2024 6:04 PM, Richard Damon wrote:
>>>>>>>>>>>>>> On 11/5/24 12:08 PM, olcott wrote:
>>>>>>>>>>>>>>> On 11/5/2024 6:03 AM, Richard Damon wrote:
>>>>>>>>>>>>>>>> On 11/4/24 10:15 PM, olcott wrote:
>>>>>>>>>>>>>>>>> On 11/4/2024 8:42 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>> On 11/4/24 8:32 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>> On 11/4/2024 6:21 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>> On 11/4/24 7:48 AM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>> On 11/4/2024 6:07 AM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>> On 11/3/24 11:03 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>> On 11/3/2024 9:57 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>> On 11/3/24 10:19 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>> On 11/3/2024 7:46 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>> On 11/3/24 8:38 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>> On 11/3/2024 7:26 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 11/3/24 8:21 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> What would an unbounded emulation do?
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>> Keep on emulating for an unbounded number of 
>>>>>>>>>>>>>>>>>>>>>>>>>>>> steps.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>> Something you don't seem to understand as 
>>>>>>>>>>>>>>>>>>>>>>>>>>>> part of the requirements.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>> Non-Halting isn't just did reach a final 
>>>>>>>>>>>>>>>>>>>>>>>>>>>> state in some finite number of steps, but 
>>>>>>>>>>>>>>>>>>>>>>>>>>>> that it will NEVER reach a final state even 
>>>>>>>>>>>>>>>>>>>>>>>>>>>> if you process an unbounded number of steps.
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>> Would an unbounded emulation of DDD by HHH halt?
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>> Not a valid question, as your HHH does not do 
>>>>>>>>>>>>>>>>>>>>>>>>>> an unbounded emulation, but aborts after a 
>>>>>>>>>>>>>>>>>>>>>>>>>> defined time.
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> *Now you are contradicting yourself*
>>>>>>>>>>>>>>>>>>>>>>>>> YOU JUST SAID THAT HHH NEED NOT DO AN UNBOUNDED
>>>>>>>>>>>>>>>>>>>>>>>>> EMULATION TO PREDICT WHAT AN UNBOUNDED 
>>>>>>>>>>>>>>>>>>>>>>>>> EMULATION WOULD DO.
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> Right. it doesn't NEED to do the operation, just 
>>>>>>>>>>>>>>>>>>>>>>>> report what an unbounded emulation would do.
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> You asked about an "unbounded emulation of DDD 
>>>>>>>>>>>>>>>>>>>>>>>> by HHH" but that isn't possible, as HHH doesn't 
>>>>>>>>>>>>>>>>>>>>>>>> do that.
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> On 11/3/2024 12:20 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>  > On 11/3/24 9:39 AM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>  >>
>>>>>>>>>>>>>>>>>>>>>>>  >> The finite string input to HHH specifies that 
>>>>>>>>>>>>>>>>>>>>>>> HHH
>>>>>>>>>>>>>>>>>>>>>>>  >> MUST EMULATE ITSELF emulating DDD.
>>>>>>>>>>>>>>>>>>>>>>>  >
>>>>>>>>>>>>>>>>>>>>>>>  > Right, and it must CORRECTLY determine what an 
>>>>>>>>>>>>>>>>>>>>>>> unbounded
>>>>>>>>>>>>>>>>>>>>>>>  > emulation of that input would do, even if its 
>>>>>>>>>>>>>>>>>>>>>>> own programming
>>>>>>>>>>>>>>>>>>>>>>>  > only lets it emulate a part of that.
>>>>>>>>>>>>>>>>>>>>>>>  >
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> *You JUST said that HHH does not need to do an 
>>>>>>>>>>>>>>>>>>>>>>> unbounded emulation*
>>>>>>>>>>>>>>>>>>>>>>> *You JUST said that HHH does not need to do an 
>>>>>>>>>>>>>>>>>>>>>>> unbounded emulation*
>>>>>>>>>>>>>>>>>>>>>>> *You JUST said that HHH does not need to do an 
>>>>>>>>>>>>>>>>>>>>>>> unbounded emulation*
>>>>>>>>>>>>>>>>>>>>>>> *You JUST said that HHH does not need to do an 
>>>>>>>>>>>>>>>>>>>>>>> unbounded emulation*
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> Right, it doesn't need to DO the unbounded 
>>>>>>>>>>>>>>>>>>>>>> emulatiohn just figure out what it would do.
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> Just like we can compute:
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> 1 + 1/2 + 1/4 + 1/8 + ... + 1/2^n + ...
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> Ether by adding the infinite number of terms, or 
>>>>>>>>>>>>>>>>>>>>>> we can notice something about it to say it will 
>>>>>>>>>>>>>>>>>>>>>> sum, in the infinite limit, to 2.
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> In the same way, if HHH can see something in its 
>>>>>>>>>>>>>>>>>>>>>> simulation that tells it THIS this program can 
>>>>>>>>>>>>>>>>>>>>>> NEVER halt, it can report it.
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> Anyone with sufficient technical competence can see 
>>>>>>>>>>>>>>>>>>>>> that
>>>>>>>>>>>>>>>>>>>>> the unbounded emulation of DDD emulated by HHH can 
>>>>>>>>>>>>>>>>>>>>> never halt.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> No, because the HHH that is given doesn't do that, 
>>>>>>>>>>>>>>>>>>>> and that is the only one that matters.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> On 11/3/2024 12:20 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>  > On 11/3/24 9:39 AM, olcott wrote:
>>>>>>>>>>>>>>>>>>>  >>
>>>>>>>>>>>>>>>>>>>  >> The finite string input to HHH specifies that HHH
>>>>>>>>>>>>>>>>>>>  >> MUST EMULATE ITSELF emulating DDD.
>>>>>>>>>>>>>>>>>>>  >
>>>>>>>>>>>>>>>>>>>  > Right, and it must CORRECTLY determine what an 
>>>>>>>>>>>>>>>>>>> unbounded
>>>>>>>>>>>>>>>>>>>  > emulation of that input would do, even if its own 
>>>>>>>>>>>>>>>>>>> programming
>>>>>>>>>>>>>>>>>>>  > only lets it emulate a part of that.
>>>>>>>>>>>>>>>>>>>  >
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> If you are going to keep contradicting yourself
>>>>>>>>>>>>>>>>>>> I am going to stop looking at anything you say.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> And where is the contradiction?
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> HHH doesn't need to do the unlimited emulation, just 
>>>>>>>>>>>>>>>>>> say what the unlimited emulation by the unlimited 
>>>>>>>>>>>>>>>>>> emulator (which WILL be a different program) will do.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> That is what I have been saying all along.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> So, you agree that HHH1's emulation to the completion 
>>>>>>>>>>>>>>>> shows that the complete emulation of the input to HHH 
>>>>>>>>>>>>>>>> does halt, and thus the correct answer for HHH to give 
>>>>>>>>>>>>>>>> for *THIS* input, which has implicitly included *THIS* 
>>>>>>>>>>>>>>>> HHH as part of it, is that it halts.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> Nothing like this.
>>>>>>>>>>>>>>> You continue to fail to understand that halting
>>>>>>>>>>>>>>> requires reaching the "return" instruction final
>>>>>>>>>>>>>>> halt state. DDD emulated by HHH never does this.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> But the emulation by HHH isn't the correct measure of DDD 
>>>>>>>>>>>>>> reaching its return statement.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>
========== REMAINDER OF ARTICLE TRUNCATED ==========