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: DDD correctly emulated by HHH is INCorrectly rejected as
 non-halting V2
Date: Sun, 14 Jul 2024 14:22:35 -0400
Organization: i2pn2 (i2pn.org)
Message-ID: <14b210030f4c004027350d37e5810957e406faf9@i2pn2.org>
References: <v6rg65$32o1o$3@dont-email.me>
 <97e0632d0d889d141bdc6005ce6e513c53867798@i2pn2.org>
 <v6sdlu$382g0$1@dont-email.me> <v6td3a$3ge79$1@dont-email.me>
 <v6tp1j$3imib$2@dont-email.me> <v6trdu$3irhh$1@dont-email.me>
 <v6tu01$3imib$11@dont-email.me>
 <a177dd76613794d6bb877c65ffe6c587a8f31bc1@i2pn2.org>
 <v6tvpv$3imib$14@dont-email.me>
 <091e8b7baeea467ee894b1c79c8943cb9773adb7@i2pn2.org>
 <v6u346$3khl8$1@dont-email.me>
 <16ac79611a441e7e01119631051f69119eee958a@i2pn2.org>
 <v6v06i$3pivt$1@dont-email.me>
 <23cb2d2401b87bf4f6a604aa1a78b93ffc9a29bc@i2pn2.org>
 <v6v2t1$3pmjn$3@dont-email.me>
 <3fc6548531f91ed14a27420caf9679a634573ed0@i2pn2.org>
 <v70lmo$61d8$1@dont-email.me>
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Injection-Date: Sun, 14 Jul 2024 18:22:35 -0000 (UTC)
Injection-Info: i2pn2.org;
	logging-data="3273011"; mail-complaints-to="usenet@i2pn2.org";
	posting-account="diqKR1lalukngNWEqoq9/uFtbkm5U+w3w6FQ0yesrXg";
User-Agent: Mozilla Thunderbird
In-Reply-To: <v70lmo$61d8$1@dont-email.me>
Content-Language: en-US
X-Spam-Checker-Version: SpamAssassin 4.0.0
Bytes: 7209
Lines: 140

On 7/14/24 10:00 AM, olcott wrote:
> On 7/14/2024 3:29 AM, joes wrote:
>> Am Sat, 13 Jul 2024 18:33:53 -0500 schrieb olcott:
>>> On 7/13/2024 6:26 PM, joes wrote:
>>>> Can you elaborate? All runtime instances share the same static code.
>>>> I am talking about the inner HHH which is called by the simulated DDD.
>>>> That one is, according to you, aborted. Which is wrong, because by
>>>> virtue of running the same code, the inner HHH aborts ITS simulation of
>>>> DDD calling another HHH.
> 
>>> If you have a 100% complete understanding infinite recursion then I can
>>> explain it in terms of much more details, otherwise you can't possibly
>>> understand.
> 
>> What are the twins and what is their difference?
>> Please do explain.
>> Do you disagree with my tracing?
>>
> 
> void DDD()
> {
>    HHH(DDD);
> }
> 
> int main()
> {
>    DDD();
> }
> 
> The directly executed DDD is like the first call of infinite
> recursion. The emulated DDD is just like the second call of
> infinite recursion. When the second call of infinite recursion
> is aborted then the first call halts.
> 
> void Infinite_Recursion()
> {
>    Infinite_Recursion();
> }
> 
> _Infinite_Recursion()
> [00002122] 55         push ebp
> [00002123] 8bec       mov ebp,esp
> [00002125] e8f8ffffff call 00002122
> [0000212a] 5d         pop ebp
> [0000212b] c3         ret
> Size in bytes:(0010) [0000212b]
> 
> The above *is* infinite recursion.
> A program could emulate the above code and simply
> skip line 3 causing Infinite_Recursion() to halt.
> 
> When DDD calls HHH(DDD) HHH returns.
> When DDD correctly emulated by HHH the call never returns as is
> proven below. The executed DDD() has HHH(DDD) skip this call.
> HHH(DDD) must skip this call itself by terminating the whole
> DDD process.

And thus the "Behavior" of DDD is established to be Haltin.

> 
> Because this HHH does not know its own machine address HHH only
> sees that DDD calls a function that causes its first four steps
> to be repeated. HHH does not know that this is recursive simulation.
> To HHH it looks just like infinite recursion.

But it is wrong about that. And HHH is using logic about stuff you claim 
it doesn't know.


When DDD calls HHH, what HHH sees it the instructions of HHH being 
executed. Thre is NOTHING in that simulation that says that it is seeing 
another simulation of DDD happening.

For that to occur, HHH must KNOW that the address giveen is actualy a 
x86 COINDITIONAL emulator (if it is designed to assume it is an 
unconditional x8 6 emulator, it was programmed with a false fact).

> 
> New slave_stack at:1038c4 -- create new process context for 1st DDD
> Begin Local Halt Decider Simulation   Execution Trace Stored at:1138cc
> [00002172][001138bc][001138c0] 55         push ebp      ; housekeeping
> [00002173][001138bc][001138c0] 8bec       mov ebp,esp   ; housekeeping
> [00002175][001138b8][00002172] 6872210000 push 00002172 ; push DDD
> [0000217a][001138b4][0000217f] e853f4ffff call 000015d2 ; call HHH(DDD)
> New slave_stack at:14e2ec -- create new process context for 2nd DDD

And this never occurs as part of the x86 emulation of the first DDD

> [00002172][0015e2e4][0015e2e8] 55         push ebp      ; housekeeping
> [00002173][0015e2e4][0015e2e8] 8bec       mov ebp,esp   ; housekeeping
> [00002175][0015e2e0][00002172] 6872210000 push 00002172 ; push DDD
> [0000217a][0015e2dc][0000217f] e853f4ffff call 000015d2 ; call HHH(DDD)
> Local Halt Decider: Infinite Recursion Detected Simulation Stopped



> 
> Computable functions are the formalized analogue of the
> intuitive notion of algorithms, in the sense that a
> function is computable if there exists an algorithm that
> can do the job of the function, i.e. given an input of the
> function domain it can return the corresponding output. 
> https://en.wikipedia.org/wiki/Computable_function

But who says that Halting is a computable function.

If HHH claims to be a "Halt Decider" then it must answer with the actual 
results defined for a Halt Decider

> 
> According to the theory of computation the DDD that calls
> HHH(DDD) is not in the domain of HHH. HHH is not allowed
> to report on the behavior of the process that it is contained
> within. *That breaks the rules of computation theory* HHH
> cannot even see the steps that were executed before it
> was first invoked.
> 

Of course it is. It is a program. Programs have representations, and 
that representation can be given to HHH to decide on.

HHH is given a representation of a program, that representation doesn't 
say which copy of the program it is looking at, as it doesn't need to as 
they all behave the same. That is a fundamental property of 
Computations, all copies of them behave the same.

If HHH is going to work by using some simulation, the HHH creates within 
itself a virtual context to simulate that input in.

Yes, we can not ask HHH to decide abou "who ever called you", but we can 
ask it to decide about a DDD that happens to call copy of that HHH..

the interaction may make it harder (or even impossible) for HHH to get 
the right answer, but that is still the requirement.

You problem seems to be that you have no actual foundation in 
computation theory but are just guessing at basic principles based on 
some casual reading.

You did that to yourself, and it seems to have made you waste that last 
two decades of your life