Path: ...!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(DDD) does not see the exact same behavior pattern as
 HHH(Infinite_Recursion)
Date: Sun, 28 Jul 2024 12:58:37 -0400
Organization: i2pn2 (i2pn.org)
Message-ID: <1227368ad4d54aa9ddab0722b08ed7432f1a3b2b@i2pn2.org>
References: <v85kp7$3v9fb$3@dont-email.me>
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Injection-Date: Sun, 28 Jul 2024 16:58:37 -0000 (UTC)
Injection-Info: i2pn2.org;
	logging-data="667010"; mail-complaints-to="usenet@i2pn2.org";
	posting-account="diqKR1lalukngNWEqoq9/uFtbkm5U+w3w6FQ0yesrXg";
User-Agent: Mozilla Thunderbird
Content-Language: en-US
In-Reply-To: <v85kp7$3v9fb$3@dont-email.me>
X-Spam-Checker-Version: SpamAssassin 4.0.0
Bytes: 7100
Lines: 139

On 7/28/24 10:32 AM, olcott wrote:
> It is ridiculously stupid to expect the correct emulation
> of a non-halting input to end.

Right. SO why does your supposed "correct emulation" of a input you 
claim to b on-halting end. Only because you are showing that HHH's 
emulation is *NOT* a "correct emulation", but only a PARTIAL emulaiton, 
which doesn't show the behavior of the input after it aborts.

> 
> HHH(DDD) is the exact same pattern with Infinite_Recursion()
> where there are no conditional branch instructions that would
> prevent the first three instructions of Infinite_Recursion()
> from endlessly repeating.

Nope, becasue a call to Infinite_Recursion is not the same thing as a 
call to HHH(DDD).

The call to Infinite_Recursion will never end no matter how long you 
look at the behavior of the program.

THe call to HHH(DDD) will, by your admission, emulate DDD for a while 
and then abort its emulation and then Return. This is because there ARE 
conditional branch instructions in the execution path, which goes into HHH.

So, unless you want to try to claim that running forever is exactly the 
same as talting behaovir of HHH(DDD)< you are stuck with being shown to 
be a liar.

Now, if HHH was an UNCONDITIONAL emulator, and not a decider, there are 
arguements that the pattern, while not EXACTLY the same, is close enough 
that a similar proof could be built. But that requires HHH to be a 
UNCONDITIONAL emulator, the fact that its emulation is conditioned on 
its halting deciding adds that conditional branch that breaks the 
infinite loop.

You are just so stupid you don't see that clear and obvous fact, because 
you don't even seem to know what a PROGRAM is that can be decided on.

Your problem is that you just made yourself into a self-made ignorant 
idiot which doesn't actually care about what it true, which has made you 
into the pathetic pathological liar you have proved yourself to be.

> 
> void Infinite_Recursion()
> {
>    Infinite_Recursion();
> }
> 
> _Infinite_Recursion()
> [0000215a] 55         push ebp      ; 1st line
> [0000215b] 8bec       mov ebp,esp   ; 2nd line
> [0000215d] e8f8ffffff call 0000215a ; 3rd line
> [00002162] 5d         pop ebp
> [00002163] c3         ret
> Size in bytes:(0010) [00002163]
> 
> Begin Local Halt Decider Simulation   Execution Trace Stored at:113934
> [0000215a][00113924][00113928] 55         push ebp      ; 1st line
> [0000215b][00113924][00113928] 8bec       mov ebp,esp   ; 2nd line
> [0000215d][00113920][00002162] e8f8ffffff call 0000215a ; 3rd line
> [0000215a][0011391c][00113924] 55         push ebp      ; 1st line
> [0000215b][0011391c][00113924] 8bec       mov ebp,esp   ; 2nd line
> [0000215d][00113918][00002162] e8f8ffffff call 0000215a ; 3rd line
> Local Halt Decider: Infinite Recursion Detected Simulation Stopped
> 
> If you cannot see that the above x86 machine code proves that
> it will never halt then you can't possibly understand what I
> have been saying.
> 
> The first three lines of _Infinite_Recursion() repeat and there
> are no conditional branch in that sequence that can possibly keep
> it from repeating forever.
> 
> HHH(DDD) is the exact same pattern is shown below. The first
> four lines of DDD repeat and there are are no conditional branch
> in that sequence that can possibly keep it from repeating forever.
> 
> =====
> 
> void DDD()
> {
>    HHH(DDD);
> }
> 
> _DDD()
> [00002177] 55               push ebp      ; 1st line
> [00002178] 8bec             mov ebp,esp   ; 2nd line
> [0000217a] 6877210000       push 00002177 ; push DDD
> [0000217f] e853f4ffff       call 000015d7 ; call HHH
> [00002184] 83c404           add esp,+04
> [00002187] 5d               pop ebp
> [00002188] c3               ret
> Size in bytes:(0018) [00002188]

Which CAN NOT be the input for the progream "DDD" as it calls outside of 
the input, and thus you are proving that you are just a pathetic 
ignorant pathological liar.

> 
> // executed HHH emulates 1st instance of DDD
> New slave_stack at:10388d
> Begin Local Halt Decider Simulation   Execution Trace Stored at:113895
> [00002177][00113885][00113889] 55         push ebp      ; 1st line
> [00002178][00113885][00113889] 8bec       mov ebp,esp   ; 2nd line
> [0000217a][00113881][00002177] 6877210000 push 00002177 ; push DDD
> [0000217f][0011387d][00002184] e853f4ffff call 000015d7 ; call HHH
> 
> // emulated HHH emulates 2nd instance of DDD

But that isn't a correct emulation of the call HHH by ANY criteria.

By the x86 criteria, it must be the instrcuctions of HHH, which need to 
be part of the input, thus proving your stupdiity.

If by functional equivalence, since HHH is a CONDITIONAL emulation, 
every step along the way needs to be marked by the fact that the HHH 
that was called had the option of stopping the emulation before 
continuing, which shows that the trace is FUNDANMENTALLY DIFFERENT


> New slave_stack at:14e2b5
> [00002177][0015e2ad][0015e2b1] 55         push ebp      ; 1st line
> [00002178][0015e2ad][0015e2b1] 8bec       mov ebp,esp   ; 2nd line
> [0000217a][0015e2a9][00002177] 6877210000 push 00002177 ; push DDD
> [0000217f][0015e2a5][00002184] e853f4ffff call 000015d7 ; call HHH
> Local Halt Decider: Infinite Recursion Detected Simulation Stopped
> 

Not, if the trace IS correct, and there was no conditionality of the 
emulation, then that final abort statement is just a LIE, or the proof 
that you lied before.

Sorry, you are just proving you don't care about what is actually true, 
but are running your halting-problem scam by the playbook of the 
election deniers and the climate-change deniers, thus telling them that 
you agree with their methods, as you use them too.

Sorrty, that just makes you a damned hypocritical liar that is likely 
destined for an eternity in Gehenna.