Path: ...!news.misty.com!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: HHH maps its input to the behavior specified by it --- Which if
 HHH returns, will be halting.
Date: Sat, 10 Aug 2024 13:51:50 -0400
Organization: i2pn2 (i2pn.org)
Message-ID: <614b136972063ab2c9d5e3d91e4289858ef24f55@i2pn2.org>
References: <v8jh7m$30k55$1@dont-email.me>
 <950d4eed7965040e841a970d48d5b6f417ff43dc@i2pn2.org>
 <v8oj1n$6kik$3@dont-email.me> <v8pvke$ih0a$1@dont-email.me>
 <4-qdnbdw1JzlRS37nZ2dnZfqlJydnZ2d@giganews.com>
 <v8v7p3$29r2r$1@dont-email.me> <v8vub1$32fso$14@dont-email.me>
 <1e1fa9bc4bbc00aa65c1a7974bd1bda87687c92b@i2pn2.org>
 <v90di8$38oni$1@dont-email.me>
 <47a76378d634bf0db4017f879d0160793b57125e@i2pn2.org>
 <v9161o$3gaju$1@dont-email.me>
 <b84374e766c199e1ba38ef1dc3bc8f6ab2c39dfc@i2pn2.org>
 <v91i97$3n4m0$1@dont-email.me> <v91unh$3rbor$1@dont-email.me>
 <v92gja$p1$3@dont-email.me> <v94m0l$ljf4$1@dont-email.me>
 <v95ae9$p5rb$1@dont-email.me> <v978dv$h1ib$1@dont-email.me>
 <v97j0q$ilah$2@dont-email.me>
 <ccc5dafb53acf66239baac0183a6291687794963@i2pn2.org>
 <v97l3j$kof0$2@dont-email.me> <v97pgq$l4f4$2@dont-email.me>
 <v97qf0$lise$2@dont-email.me> <v97rq3$l4f4$4@dont-email.me>
 <v97t7g$m8l6$1@dont-email.me>
 <332fdac834dd53dbe6a8650e170f08fac33ca2cf@i2pn2.org>
 <v988fu$r9k6$1@dont-email.me>
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Injection-Date: Sat, 10 Aug 2024 17:51:51 -0000 (UTC)
Injection-Info: i2pn2.org;
	logging-data="2111483"; mail-complaints-to="usenet@i2pn2.org";
	posting-account="diqKR1lalukngNWEqoq9/uFtbkm5U+w3w6FQ0yesrXg";
User-Agent: Mozilla Thunderbird
Content-Language: en-US
In-Reply-To: <v988fu$r9k6$1@dont-email.me>
X-Spam-Checker-Version: SpamAssassin 4.0.0
Bytes: 7814
Lines: 154

On 8/10/24 1:37 PM, olcott wrote:
> On 8/10/2024 12:23 PM, Richard Damon wrote:
>> On 8/10/24 10:24 AM, olcott wrote:
>>> On 8/10/2024 9:00 AM, Fred. Zwarts wrote:
>>>> Op 10.aug.2024 om 15:37 schreef olcott:
>>>>> On 8/10/2024 8:21 AM, Fred. Zwarts wrote:
>>>>>> Op 10.aug.2024 om 14:06 schreef olcott:
>>>>>>> On 8/10/2024 6:57 AM, Richard Damon wrote:
>>>>>>>> On 8/10/24 7:30 AM, olcott wrote:
>>>>>>>>> On 8/10/2024 3:29 AM, Mikko wrote:
>>>>>>>>>> On 2024-08-09 14:51:51 +0000, olcott said:
>>>>>>>>>>
>>>>>>>>>>> On 8/9/2024 4:03 AM, Mikko wrote:
>>>>>>>>>>>> On 2024-08-08 13:18:34 +0000, olcott said:
>>>>>>>>>>>>
>>>>>>>>>>>>> void DDD()
>>>>>>>>>>>>> {
>>>>>>>>>>>>>    HHH(DDD);
>>>>>>>>>>>>>    return;
>>>>>>>>>>>>> }
>>>>>>>>>>>>>
>>>>>>>>>>>>> Each HHH of every HHH that can possibly exist definitely
>>>>>>>>>>>>> *emulates zero to infinity instructions correctly* In
>>>>>>>>>>>>> none of these cases does the emulated DDD ever reach
>>>>>>>>>>>>> its "return" instruction halt state.
>>>>>>>>>>>>
>>>>>>>>>>>> The ranges of "each HHH" and "every HHH" are not defined above
>>>>>>>>>>>> so that does not really mean anything.
>>>>>>>>>>>
>>>>>>>>>>> Here is something that literally does not mean anything:
>>>>>>>>>>> "0i34ine ir m0945r (*&ubYU  I*(ubn)I*054 gfdpodf["
>>>>>>>>>>
>>>>>>>>>> Looks like encrypted text that might mean something.
>>>>>>>>>>
>>>>>>>>>>> "Colorless green ideas sleep furiously"
>>>>>>>>>>
>>>>>>>>>> This could be encrypted text, too, or perhaps refers to some
>>>>>>>>>> inside knowledge or convention.
>>>>>>>>>>
>>>>>>>>>>> I defined an infinite set of HHH x86 emulators.
>>>>>>>>>>
>>>>>>>>>> Maybe somewnete but not in the message I commented.
>>>>>>>>>>
>>>>>>>>>>> I stipulated that each member of this set emulates
>>>>>>>>>>> zero to infinity instructions of DDD.
>>>>>>>>>>
>>>>>>>>>> That doesn't restrict much.
>>>>>>>>>>
>>>>>>>>>>> *I can't say it this way without losing 90% of my audience*
>>>>>>>>>>> Each element of this set is mapped to one element of the
>>>>>>>>>>> set of non-negative integers indicating the number of
>>>>>>>>>>> x86 instructions of DDD that it emulates.
>>>>>>>>>>
>>>>>>>>>> It is easier to talk about mapping if is given a name.
>>>>>>>>>>
>>>>>>>>>>> *This one seems to be good*
>>>>>>>>>>> Each element of this set corresponds to one element of
>>>>>>>>>>> the set of positive integers indicating the number of
>>>>>>>>>>> x86 instructions of DDD that it emulates.
>>>>>>>>>>
>>>>>>>>>> That would mean that only a finite number (possibly zero) of
>>>>>>>>>> instructions is emulated. But the restriction to DDD does not
>>>>>>>>>> seem reasonable.
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> *The set of HHH x86 emulators are defined such that*
>>>>>>>>
>>>>>>>> I thopught HHH was a deider?
>>>>>>>>
>>>>>>>>>
>>>>>>>>> Each element of this set corresponds to one element of
>>>>>>>>> the set of positive integers indicating the number of
>>>>>>>>> x86 instructions of DDD that it correctly emulates.
>>>>>>>>
>>>>>>>> And only those element of the set that either reach the final 
>>>>>>>> state, or simulate forever are "correct" emulators of the whole 
>>>>>>>> program, suitable to show halting.
>>>>>>>>
>>>>>>>
>>>>>>> void DDD()
>>>>>>> {
>>>>>>>    HHH(DDD);
>>>>>>>    return;
>>>>>>> }
>>>>>>>
>>>>>>> In other words even though it is dead obvious to
>>>>>>> us that a complete simulation of DDD simulated by HHH
>>>>>>
>>>>>> is impossible, because HHH is programmed to abort and, therefore, 
>>>>>> it is unable to do a complete simulation.
>>>>>
>>>>> A complete simulation of DDD by a pure x86 emulator
>>>>> named HHH cannot possibly reach its own "return"
>>>>> instruction halt state.
>>>>
>>>> Indeed, HHH fails to reach its own halt state. HHH cannot possibly 
>>>> simulate itself up to its halt state.
>>>> Which proves that the simulation is incomplete and, therefore, 
>>>> incorrect.
>>>>
>>>
>>> That an emulation of an input is necessary correct no matter
>>> what-the-Hell it does as long as it conforms to the semantics
>>> of the x86 language is either over your head or you persistently
>>> lie about it.
>>>
>>
>> Which isn't "what the hell it does". but a correct x86 emulation by 
>> the semantic of the x86 language will ALWAYS and ONLY behave EXACTLY 
>> like that input when run as a program, 
> 
> <MIT Professor Sipser agreed to ONLY these verbatim words 10/13/2022>
>      If simulating halt decider H correctly simulates its input D
>      until H correctly determines that its simulated D would never
>      stop running unless aborted then
> 
>      H can abort its simulation of D and correctly report that D
>      specifies a non-halting sequence of configurations.
> </MIT Professor Sipser agreed to ONLY these verbatim words 10/13/2022>
> 
> That is true in every case except when an input calls its
> own simulating halt decider.


Nope. No exeptions. That is just another of your "I made it up but can't 
prove it but it must be true" lies.


> 
> void DDD()
> {
>    HHH(DDD);
>    return;
> }
> 
> *The set of HHH x86 emulators are defined such that*
> Each element of this set corresponds to one element of the set
> of positive integers indicating the number of  x86 instructions
> of DDD that it emulates.

But every one that emulates for a finite number of steps, and then 
returns create a halting DDD, so you claim is just disproven.


> 
> In the above set no DDD ever reaches its own “return”
> instruction halt state thus every HHH can correctly report this.
> 
> 

Of course they do, what don't reach there is the partial emulation by 
the partial emulator.


This is why partial emulations are not "correct" but only partial.