Path: ...!eternal-september.org!feeder2.eternal-september.org!news.quux.org!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: Wed, 6 Nov 2024 06:37:21 -0500
Organization: i2pn2 (i2pn.org)
Message-ID: <f7586329a0ad4bac5e71131a6ecf8abba1de2611@i2pn2.org>
References: <vfli1h$fj8s$1@dont-email.me> <vg8fm9$fg4n$2@dont-email.me>
 <418c3ffcdca6ac4b1adc7f2a5f81f297000a5bdd@i2pn2.org>
 <vg8u0b$i9jj$5@dont-email.me>
 <2f2988b4d581398be9780ea082754d2a67bee1f6@i2pn2.org>
 <vg97j5$kb67$2@dont-email.me>
 <a89303e978559d2b152a014ad587e6f3defa323c@i2pn2.org>
 <vg98im$khai$1@dont-email.me>
 <b9a05a3897bb42f444e98f907bc9285a641415ab@i2pn2.org>
 <vg9efe$p463$1@dont-email.me>
 <fdcd7140ef71f12f42a99a9d5b720e1574b98920@i2pn2.org>
 <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>
 <vgen36$1uh1b$1@dont-email.me>
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Injection-Date: Wed, 6 Nov 2024 11:37:21 -0000 (UTC)
Injection-Info: i2pn2.org;
	logging-data="1203430"; 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: <vgen36$1uh1b$1@dont-email.me>
Bytes: 12037
Lines: 250

On 11/5/24 10:16 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.
>>>>
>>>
>>> Well we did get somewhere on this so that is more progress.
>>> Only reaching the final state is halting.
>>
>> And only something that continues to the end shows that, an emulation 
>> that aborts doesn't show that the input is non-halting unless it can 
>> prove that the unaborted emulation of that EXACT PROGRAM would never 
>> halt.
>>
> 
> That statement is self-contradictory. The exact same
> program that aborts is different than when it would
> never abort.

How is my statement self-contradictory. THere can't be an "exact same 
program" that aborts and never abort.

That is YOUR contradiction, you try to claim that the HHH that does one 
is the "same" as the one that does the other, and that both are looking 
at the "same" DDD that is built on it.

DDD (the orignial, calling HHH that aborts) does reach its return when 
========== REMAINDER OF ARTICLE TRUNCATED ==========