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,sci.logic
Subject: =?UTF-8?Q?Re=3A_A_simulating_halt_decider_applied_to_the_The_Peter_?=
 =?UTF-8?Q?Linz_Turing_Machine_description_=E2=9F=A8=C4=A4=E2=9F=A9?=
Date: Mon, 27 May 2024 11:58:20 -0400
Organization: i2pn2 (i2pn.org)
Message-ID: <v32ait$28n58$4@i2pn2.org>
References: <v2nsvh$1rd65$2@dont-email.me> <v2trch$23vgp$1@i2pn2.org>
 <v2trts$331vq$1@dont-email.me> <v2tsub$23vgp$2@i2pn2.org>
 <v2u0o5$33mgp$1@dont-email.me> <v2u2uf$23vgp$4@i2pn2.org>
 <v2u5a0$349br$2@dont-email.me> <v2u6if$23vgo$3@i2pn2.org>
 <v2u7fj$38fjo$1@dont-email.me> <v2v79q$25ell$2@i2pn2.org>
 <v2vg1g$3e8pb$4@dont-email.me> <v2vo5h$26570$3@i2pn2.org>
 <v2vpt6$3g0m3$3@dont-email.me> <v2vqou$26570$5@i2pn2.org>
 <v2vrcl$3gakv$1@dont-email.me> <v2vslp$26570$6@i2pn2.org>
 <v301m6$3hcgb$1@dont-email.me> <v305j9$26571$1@i2pn2.org>
 <v30e5l$3lerc$1@dont-email.me> <v30fbr$26570$9@i2pn2.org>
 <v30hiq$3lv80$1@dont-email.me> <v30jb5$26571$2@i2pn2.org>
 <v30pr8$3r67p$1@dont-email.me> <v30rvv$3riij$1@dont-email.me>
 <v30t8u$26571$6@i2pn2.org> <v30u04$3rour$1@dont-email.me>
 <v30upc$26571$7@i2pn2.org> <v30vp3$3s4od$1@dont-email.me>
 <v321o0$28n58$1@i2pn2.org> <v3255k$2pkb$2@dont-email.me>
 <v326fd$28n59$2@i2pn2.org> <v327h8$3a17$1@dont-email.me>
 <v328l1$28n58$2@i2pn2.org> <v329t8$3mh0$2@dont-email.me>
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Injection-Date: Mon, 27 May 2024 15:58:21 -0000 (UTC)
Injection-Info: i2pn2.org;
	logging-data="2383016"; 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: <v329t8$3mh0$2@dont-email.me>
Bytes: 6728
Lines: 106

On 5/27/24 11:46 AM, olcott wrote:
> On 5/27/2024 10:25 AM, Richard Damon wrote:
>> On 5/27/24 11:06 AM, 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 either pure simulator H or 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 many reviewers had a different notion of
>     correct simulation that diverges from this notion.
> 
>     A simulator is an x86 emulator that correctly emulates 1 to N of the
>     x86 instructions of D in the order specified by the x86 instructions
>     of D. This may include M recursive emulations of H emulating itself
>     emulating D.

And how do you apply that to a TEMPLATE that doesn't define what a call 
H means (as it could be any of the infinite set of Hs that you can 
instantiate the template on)?

Do you mean the specific instance that this particular H generates? In 
which case each H simulates a DIFFERENT input, and thus the simulations 
can not be used for any other input.

> 
> When we see that D correctly simulated by pure simulator H would remain
> stuck in infinite recursive simulation then we also know that less than
> an infinite number of steps is not enough steps for D correctly
> simulated by pure function H to reach its own simulated final state at
> line 06 and halt.

And by the previous comment, either you simulation isn't defined, or the 
simulation by the pure simulator doesn't provide behavior for the 
simulation by the finite simulation done by other Hs.

It is IMPOSSIBLE for any of your Hs to actually simulate the TEMPLATE D 
beyond the call H instruction, as there is no defined code for H in the 
template, only in instances of it.

When we accept that your simulation MUST be of the instance given, and 
NOT the "template", then all you have proved is that all the finite 
simulators just didn't simulate far enough to reach a possible final 
state, as simulations of different imputs do not logically correlate to 
each other allowing inferences across them.

> 
>> But the D that was non-halting was a DIFFERENT D then the one 
>> simulated by the finite stepping simulator, so the answers don't apply.
>>
> 
> https://en.wikipedia.org/wiki/Shell_game
> *I updated my words to address your persistent shell-game ploy*
> 
> The above template refers to an infinite set of H/D pairs where D is
> correctly simulated by either pure simulator H or 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.
> 
> I must continue to improve the clarity of words to the point
> that *INTENTIONAL MISINTERPRETATION* looks utterly ridiculous.
> 
> *The dishonest dodge strawman deception CHANGE-THE-SUBJECT*
> *fake rebuttal already looks utterly ridiculous*
> 


And thus you need to either fix your definition of "simulation" to 
define what happens when you "simulate" an infinte set of different 
code, or fix your logic where you try to use logic about the simulation 
of DIFFERENT specific inputs to derive behaviors of an input that is 
objectively different then the simulation you are doing here.

In other words, your attempt to define your H and D as Infinite sets has 
is incompatible with your definition of "Correct Simulation" and you 
need to resolve this.

It seems your problem is that you are having a hard time to find the 
words to express what you mean, because what you are thinking about is 
just a logical contradiction, which gets revealed by trying to be 
precise in the words, so you need to keep the words fuzzy.

You can't simulate the instructions of a template that don't exist 
because they are variable based on the machine the template will be 
instantiated on. You need to either change your definition of what 
"Correct Simulation" means on the template, or define that you are 
processing specific instances, and accept that this means that each 
instance is a totally seperate problem, and you can't just argue across 
the problems.