Path: ...!eternal-september.org!feeder3.eternal-september.org!news.eternal-september.org!eternal-september.org!.POSTED!not-for-mail
From: Keith Thompson <Keith.S.Thompson+u@gmail.com>
Newsgroups: comp.theory
Subject: Re: Incorrect requirements --- Computing the mapping from the input to HHH(DD)
Date: Fri, 09 May 2025 20:12:39 -0700
Organization: None to speak of
Lines: 83
Message-ID: <87msblcg60.fsf@nosuchdomain.example.com>
References: <vv97ft$3fg66$1@dont-email.me> <vvgt36$1auqp$2@dont-email.me>
	<vvgtbe$1b0li$1@dont-email.me> <vvguot$1auqp$3@dont-email.me>
	<vvh0t2$1b939$1@dont-email.me> <vvhap5$1hp80$1@dont-email.me>
	<vvhf20$1ihs9$1@dont-email.me> <vvhfnd$1hvei$3@dont-email.me>
	<vvil99$1ugd5$1@dont-email.me> <vvinvp$1vglb$1@dont-email.me>
	<vviv75$222r6$1@dont-email.me> <vvj1fp$22a62$1@dont-email.me>
	<vvj2j6$23gk7$1@dont-email.me> <as9TP.251456$lZjd.93653@fx05.ams4>
	<87msbmeo3b.fsf@nosuchdomain.example.com>
	<vvjc9b$27753$1@dont-email.me>
	<87ecwyekg2.fsf@nosuchdomain.example.com>
	<vvjg6a$28g5i$3@dont-email.me>
	<d577d485d0f5dfab26315f54f91eb84f25eecc40@i2pn2.org>
	<87bjs2cyj6.fsf@nosuchdomain.example.com>
	<vvm69v$34ivd$1@dont-email.me>
MIME-Version: 1.0
Content-Type: text/plain; charset=utf-8
Content-Transfer-Encoding: 8bit
Injection-Date: Sat, 10 May 2025 05:12:40 +0200 (CEST)
Injection-Info: dont-email.me; posting-host="8bc3288f4b42a8d6fbbe53fa021cb69a";
	logging-data="3468361"; mail-complaints-to="abuse@eternal-september.org";	posting-account="U2FsdGVkX18hJATbRjamgOVDcpfXfUqU"
User-Agent: Gnus/5.13 (Gnus v5.13)
Cancel-Lock: sha1:JuJmJYfzw0Wx60RU5j6ccUTRTEc=
	sha1:tKBhLcoh6emw0NBAiU2/wdeJtug=
Bytes: 5346

Mike Terry <news.dead.person.stones@darjeeling.plus.com> writes:
> On 09/05/2025 03:23, Keith Thompson wrote:
>> Richard Damon <richard@damon-family.org> writes:
>>> On 5/8/25 7:53 PM, olcott wrote:
>> [...]
>>>> void DDD()
>>>> {
>>>>     HHH(DDD);
>>>>     return;
>>>> }
>>>> We don't need to look at any of my code for me
>>>> to totally prove my point. For example when
>>>> the above DDD is correctly simulated by HHH
>>>> this simulated DDD cannot possibly reach its own
>>>> "return" instruction.
>>>
>>> And thus not correctly simulatd.
>>>
>>> Sorry, there is no "OS Exemption" to correct simulaiton;.
>> Perhaps I've missed something.  I don't see anything in the above
>> that
>> implies that HHH does not correctly simulate DDD.  Richard, you've read
>> far more of olcott's posts than I have, so perhaps you can clarify.
>> If we assume that HHH correctly simulates DDD, then the above code
>> is
>> equivalent to:
>>      void DDD()
>>      {
>>        DDD();
>>        return;
>>      }
>> which is a trivial case of infinite recursion.  As far as I can
>> tell,
>> assuming that DDD() is actually called at some point, neither the
>> outer execution of DDD nor the nested (simulated) execution of DDD
>> can reach the return statement.  Infinite recursion might either
>> cause a stack overflow and a probable program crash, or an unending
>> loop if the compiler implements tail call optimization.
>> I see no contradiction, just an uninteresting case of infinite
>> recursion, something that's well understood by anyone with a
>> reasonable level of programming experience.  (And it has nothing to
>> do with the halting problem as far as I can tell, though of course
>> olcott has discussed the halting problem elsewhere.)
>> Richard, what am I missing?
>
> Depends on what you've picked up on.
>
> Do you get that HHH's simulation is a /partial/ simulation?  HHH is
> free to simulate a few x86 instructions of DDD, and then simply
> abandon the simulation and return.  Since such a simulation is
> obviously NOT equivalent to a direct call to DDD, and above you argue
> that it is, I'd say you've missed that.

I have not read the vast majority of olcott's post here.  For most
of the recent discussion I had with him, there was no mention of
partial simulation.  olcott finally said something about simulating
just a few instructions, but at the same time he finally indicated
that understanding his arguments would require an understanding of
x86 machine and/or assembly language.  That's when I bailed out.

A "correct simulation", as I understand the term, would require fully
simulate the execution of DDD.  If DDD never halts, its simulation never
halts.  olcott seems to think that he's found a way around this that's
relevant to the Halting Problem, but I withdrew before getting to that
point.

[...]

> Other posters have suggested that what you're missing is some
> variation of "once you answer PO's current question (about whether the
> simulation by HHH progresses as far as DDD's return) PO will go on to
> do something else wrong".  Well, of course he will, but that's hardly
> something you're missing if he's not done it yet!  :)  I'd also say
> it's no reason not to answer PO's question honestly, acknowledging
> that he is talking about /partial/ simulations...  The time to
> challenge future mistakes he will go on to make, is when he makes
> them.

That sounds about right.

-- 
Keith Thompson (The_Other_Keith) Keith.S.Thompson+u@gmail.com
void Void(void) { Void(); } /* The recursive call of the void */