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: Philosophy of Computation: Three seem to agree how emulating
 termination analyzers are supposed to work
Date: Sun, 10 Nov 2024 18:08:27 -0500
Organization: i2pn2 (i2pn.org)
Message-ID: <3055c658c3ef2cad29ffe44f65c4dbd349388f46@i2pn2.org>
References: <vgr1gs$hc36$1@dont-email.me>
 <114d7d0cb5266295ec2c9e9097158d78e5f51dea@i2pn2.org>
 <vgr9i1$ikr6$1@dont-email.me>
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Injection-Date: Sun, 10 Nov 2024 23:08:28 -0000 (UTC)
Injection-Info: i2pn2.org;
	logging-data="1884690"; 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: <vgr9i1$ikr6$1@dont-email.me>
Bytes: 7934
Lines: 174

On 11/10/24 4:45 PM, olcott wrote:
> On 11/10/2024 3:02 PM, Richard Damon wrote:
>> On 11/10/24 2:28 PM, olcott wrote:
>>> *The best selling author of theory of computation textbooks*
>>> <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
>>
>> Right, if the correct (and thus complete) emulation of this precise 
>> input would not halt.
>>
> 
> That is what I have been saying for years.
> (even though there cannot be such a thing
> as the complete emulation of a non-terminating input).

So, you just agreed that the correct answer for HHH, is based on the 
behavior of the COMPLETE emulation of the EXACT input that HHH got.

Since that is DDD that calls the HHH that aborts and returns 0, and that 
is exactly the emulation that HHH1 does, and reaches its end, shows that 
the correct answer for HHH is to say HALTING, and thus it is wrong.

> 
>>>
>>> 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>
>>
>> Which your H doesn't do.
>>
> 
> It is a matter of objective fact H does abort its
> emulation and it does reject its input D as non-halting.
> I just ran the code and it does do this.
> https://github.com/plolcott/x86utm/blob/master/Halt7.c

Yes, H rejects its input CLAIMING it to be non-halting, but didn't do a 
complete emulation of that input, so by itself it doesn't actually 
establish it to be correct.

H1, when given that exact same input, the D that calls H, DOES doe a 
complete emulation of that exact input, and it reaches the end, thus 
PROVING that D is a HALTING computation, and H was just wrong.

> 
>>>
>>> Correct simulation is defined as D is emulated by H according to
>>> the semantics of the x86 language thus includes H emulating itself
>>> emulating D.
>>
>> And also means that it can not be aborted, as "stopping" in the middle 
>> is not to the semantics of the x86 language.
>>
> 
> Every H, HH, HHH, H1, HH1, and HHH1
> (a) Predicts that its input would not stop running unless aborted.
> (b) Lets its input continue to run until completion.

No, H1, HH1, and HHH1, see that the input to H, HH, and HHH 
respectfully, (which is the D that calls H, the DD that calls HH, and 
the DDD that calls HHH, in each case the one that aborted and returns 0) 
can be emuiated by itself to the end, thus showing the input is Halting, 
and thus PROVING that H, HH, and HHH were incorrect to say the input is 
non-halting.

> 
>> An thus, your H fails to determine that the CORRECT emulation by H 
>> will not terminate, since it doesn't do one.
>>
>>>
>>> I made D simpler so that the key essence of recursive simulation
>>> could be analyzed separately. ChatGPT totally understood this.
>>
>> Nope, your broke the rules of the field, and thus invalidates your proof.
>>
>> Either by passing the address of DDD to HHH implies passing the FULL 
>> MEMORY that DDD is in (or at least every part accessed in the 
>> emulation of DDD) and thus changed in your
>>
>>>
>>> void DDD()
>>> {
>>> HHH(DDD);
>>> return;
>>> }
>>>
>>> ChatGPT
>>> Simplified Analogy:
>>> Think of HHH as a "watchdog" that steps in during real execution
>>> to stop DDD() from running forever. But when HHH simulates DDD(),
>>> it's analyzing an "idealized" version of DDD() where nothing stops the
>>> recursion. In the simulation, DDD() is seen as endlessly recursive, so
>>> HHH concludes that it would not halt without external intervention.
>>
>> But DDD doesn't call an "ideaized" verision of HHH, 
> 
>      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
> 
>      *simulated D would never stop running unless aborted*
>      has ALWAYS been this idealized input.

Nope, there is no such thing in Comptation Theory, a machine is only and 
exactly the machine that it is.

Sorry, you just admitted that you don't know what you are talking about.

> 
>> it calls the exact function defined as HHH, s0 your arguemet is based 
>> on false premises, and thus is just a :OE/
>>
>>>
>>> https://chatgpt.com/share/67158ec6-3398-8011-98d1-41198baa29f2
>>> This link is live so you can try to convince ChatGPT that its wrong.
>>>
>>> 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.
>>>  >
>>>
>>> *Breaking that down into its key element*
>>>  > [This bounded HHH] must CORRECTLY determine what
>>>  > an unbounded emulation of that input would do...
>>>
>>> When that input is unbounded that means it is never
>>> aborted at any level, otherwise it is bounded at some
>>> level thus not unbounded.
>>>
>>
>> No, because there aren't "levels" of emulation under consideration here. 
> 
> There sure the Hell are.
>      *simulated D would never stop running unless aborted*
>      *simulated D would never stop running unless aborted*
>      *simulated D would never stop running unless aborted*
> Has always involved levels of simulation when
> H emulates itself emulating D

But the outer emulator doesn't care about the other levels of emulation, 
and since D calls an H that will abort its emulation, that emulation 
doesn't go on forever.

> 
>> Only does the emulation that the top level HHH is doing, since 
>> everything else is just fixed by the problem.
>>
> 
>      *simulated D would never stop running unless aborted*
>      *simulated D would never stop running unless aborted*
>      *simulated D would never stop running unless aborted*
> has always meant reject D
> 

But THAT D, that calls an H that aborts its input, can be simulated 
without needing to be aborted.

Since that *IS* the D that H was given (if it is a H that aborts its 
input, and if not it fails by not answering) so we see that the 
emulation of the outer H will halt even if not aborted, but that H can't 
do that emulation since it is programmed to abort, and a machine like it 
that doesn't abort isn't it.

Your logic is just based on the LIE that programs can be changes.

Sorry, you are just proving how STUPID and IGNORANT you are of what you 
are talking about.