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,sci.logic
Subject: Re: Can you see that D correctly simulated by H remains stuck in
 recursive simulation?
Date: Thu, 23 May 2024 23:47:34 -0400
Organization: i2pn2 (i2pn.org)
Message-ID: <v2p2km$1tsmo$6@i2pn2.org>
References: <v2nsvh$1rd65$2@dont-email.me> <v2oreb$1tsmo$4@i2pn2.org>
 <v2otlq$24vfk$1@dont-email.me> <v2oupf$1tsmn$1@i2pn2.org>
 <v2p07v$25aq3$1@dont-email.me>
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Injection-Date: Fri, 24 May 2024 03:47:34 -0000 (UTC)
Injection-Info: i2pn2.org;
	logging-data="2028248"; mail-complaints-to="usenet@i2pn2.org";
	posting-account="diqKR1lalukngNWEqoq9/uFtbkm5U+w3w6FQ0yesrXg";
User-Agent: Mozilla Thunderbird
In-Reply-To: <v2p07v$25aq3$1@dont-email.me>
X-Spam-Checker-Version: SpamAssassin 4.0.0
Content-Language: en-US
Bytes: 14241
Lines: 355

On 5/23/24 11:06 PM, olcott wrote:
> On 5/23/2024 9:41 PM, Richard Damon wrote:
>> On 5/23/24 10:22 PM, olcott wrote:
>>> On 5/23/2024 8:44 PM, Richard Damon wrote:
>>>> On 5/23/24 1:04 PM, olcott wrote:
>>>>> typedef int (*ptr)();  // ptr is pointer to int function in C
>>>>> 00       int H(ptr p, ptr i);
>>>>> 01       int D(ptr p)
>>>>> 02       {
>>>>> 03         int Halt_Status = H(p, p);
>>>>> 04         if (Halt_Status)
>>>>> 05           HERE: goto HERE;
>>>>> 06         return Halt_Status;
>>>>> 07       }
>>>>> 08
>>>>> 09       int main()
>>>>> 10       {
>>>>> 11         H(D,D);
>>>>> 12         return 0;
>>>>> 13       }
>>>>>
>>>>> The above template refers to an infinite set of H/D pairs where D is
>>>>> correctly simulated by pure function H. This was done because many
>>>>> reviewers used the shell game ploy to endlessly switch which H/D pair
>>>>> was being referred to.
>>>>>
>>>>> *Correct Simulation Defined*
>>>>>     This is provided because every reviewer had a different notion of
>>>>>     correct simulation that diverges from this notion.
>>>>>
>>>>>     A simulator is an x86 emulator that correctly emulates at least 
>>>>> one
>>>>>     of the x86 instructions of D in the order specified by the x86
>>>>>     instructions of D.
>>>>>
>>>>>     This may include correctly emulating the x86 instructions of H in
>>>>>     the order specified by the x86 instructions of H thus calling 
>>>>> H(D,D)
>>>>>     in recursive simulation.
>>>>>
>>>>> *Execution Trace*
>>>>>     Line 11: main() invokes H(D,D); H(D,D) simulates lines 01, 02, 
>>>>> and 03
>>>>>     of D. This invokes H(D,D) again to repeat the process in endless
>>>>>     recursive simulation.
>>>>>
>>>>
>>>> Questions:
>>>>
>>>> By your definiton of "Correct Simulation", you do realize that you 
>>>> have broken connection between the simulaiton not completing and the 
>>>> program described by the input not halting?
>>>>
>>>
>>> In other words you are requiring that the x86 instructions of D
>>> (and possibly H) be simulated incorrectly and/or in the wrong order.
>>
>> No, they must be simulated COMPLETELY.
>>
> 
> (a) *Clearly you are terrible at reading a spec*
> (b) *non terminating computations cannot be simulated completely*

Not by your definition,

D(D) proves you wrong, since it HALTS when run, it terminates.

You may be able to prove that no decider can simulate the "not a machine 
but a template" that your D is. Since the problem space SHOULD be 
"programs", you fail at even that point

> 
>> That is the only simulation that Computation Theory recognises as 
>> showing halting status.
>>
> 
> *Infinite loops need not be simulated completely to show a halt status*

Right, becasue we can prove that the 
Computaton-Theory-Correct-Simulation will never reach an end,

> 
>> You should know that, so you are just showing you are deflecting.
>>
> 
> DUMB MISTAKE ON YOUR PART
> *Infinite loops need not be simulated completely to show a halt status*

Right, because we can prove that the 
Computaiton-Theory-Correct-Simulation will never reach an end.

That doesn't happen for your H/D compinations, the 
Computation-Theory-correct-simulation of the input to any of the H/D 
pairs where H returns an answer, will reacn the final state, so the H 
was wrong about halting.

And so is your logic.

> 
>>>
>>>> Also, you do realize that by your requirement on H just being a 
>>>> "pure function" that does NOT say that you H qualified to be the 
>>>> computational equivalent for a Turing Machine?
>>>>
>>>
>>> That I require it to be a pure function
>>> (a) Disallows you use of static local data.
>>> (b) Does mean that H is Turing computable even if you don't 
>>> understand this.
>>>
>>
>> Nope.
>>
>> It is neither suffient or required.
>>
> 
> *So you don't even know what a spec is*

Sure I do, you are the one that fails at it.

> 
>> Your H1 being claimed to be a "copy" but giving a different value is a 
>> proof of the insufficiency.
>>
> 
> THAT IS OFF-TOPIC FOR THE SUBJECT OF THIS THREAD.

Nope, proves the point that "Pure Function" by your definition is 
insufficient for a program to be a Turing machine equivalent.

I guess you are just conceeding that one.

> 
>>>> That due to your "strange" definition of what D is, you are putting 
>>>> yourself outside of the grounds of "Computation Theory", as that 
>>>> deals with the behavior of specific PROGRAMS, and not the "Program 
>>>> Templates" like your D, our the "Infinite set of H/D pairs"?
>>>>
>>>
>>> How you can fail to understand that this <is> such a template?
>>> When Ĥ is applied to ⟨Ĥ⟩
>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>
>> Nope, not a "template" as H (from which you built your embedded H) is 
>> a SPEICIF (but arbitary) machine that meets that specification, and 
>> thus, so is H^.
>>
> 
> Arbitrary MEANS template.

Nope.

If I say choose an arbitrary student in a class, and then do something, 
I mean to choose any one student from the class and do it with them.

> 
>> You don't seem to understand the maning of the terms.
>>
> 
> You are the one the directly contradicted yourself
> It cannot be {A SPECIFIC MACHINE} and {AN ARBITRARY MACHINE}

Sure it can. Being Arbirary means I am not limiting which one you can 
choose.

I guess you don't understand the meaning of the words.

> 
>>>
>>>> Also, your "templagte D" is NOT built per either the Linz or Sipser 
>>>> rules, as both of those had D built with a COPY of H, which is one 
>>>> of your problems with a "Pure Function" as the equivelent. You have 
>>>> shown that your H fails to meet the requirements of a Turing Machine 
>>>
========== REMAINDER OF ARTICLE TRUNCATED ==========