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: Two dozen people were simply wrong --- Try to prove otherwise ---
 pinned down
Date: Fri, 31 May 2024 17:36:33 -0400
Organization: i2pn2 (i2pn.org)
Message-ID: <v3dft1$2lfup$1@i2pn2.org>
References: <v3501h$lpnh$1@dont-email.me> <v362eu$2d367$3@i2pn2.org>
 <v363js$vg63$2@dont-email.me> <v36803$2d368$3@i2pn2.org>
 <v368je$100kd$3@dont-email.me> <v373mr$2d367$5@i2pn2.org>
 <v37bpa$15n0b$1@dont-email.me> <v37i9p$lls$1@news.muc.de>
 <87y17smqnq.fsf@bsb.me.uk> <v37sap$18mfo$1@dont-email.me>
 <v38eq4$2foi0$1@i2pn2.org> <v38fe0$1bndb$1@dont-email.me>
 <v38g31$2foi0$11@i2pn2.org> <v38gi5$1bndb$3@dont-email.me>
 <v38ici$2fohv$2@i2pn2.org> <v38j17$1c8ir$2@dont-email.me>
 <v38jgo$2foi0$14@i2pn2.org> <v38jv9$1c8ir$4@dont-email.me>
 <v39agi$1jiql$1@dont-email.me> <v39v3h$1mtd9$5@dont-email.me>
 <v3b9kj$2im02$1@i2pn2.org> <v3bale$222n5$1@dont-email.me>
 <v3bbs2$2im01$1@i2pn2.org> <v3bcre$22a8n$1@dont-email.me>
 <v3bduk$2im01$2@i2pn2.org> <v3bedb$22f8h$1@dont-email.me>
 <v3bfbm$2im01$3@i2pn2.org> <v3bg39$22o6m$1@dont-email.me>
 <v3cbhu$2k3ld$1@i2pn2.org> <v3clo2$28p7n$1@dont-email.me>
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Injection-Date: Fri, 31 May 2024 21:36:33 -0000 (UTC)
Injection-Info: i2pn2.org;
	logging-data="2801625"; mail-complaints-to="usenet@i2pn2.org";
	posting-account="diqKR1lalukngNWEqoq9/uFtbkm5U+w3w6FQ0yesrXg";
User-Agent: Mozilla Thunderbird
X-Spam-Checker-Version: SpamAssassin 4.0.0
In-Reply-To: <v3clo2$28p7n$1@dont-email.me>
Content-Language: en-US
Bytes: 6235
Lines: 125

On 5/31/24 10:10 AM, olcott wrote:
> On 5/31/2024 6:16 AM, Richard Damon wrote:
>> On 5/30/24 11:27 PM, olcott wrote:
>>> Try and show how HH using an x86 emulator can correctly emulate
>>> the following x86 machine code such that DD reaches its own
>>> machine address 00001c47.
>>
>> Why should I, since that isn't what I was saying.
>>
> 
> *To me that looks like you know that*
> *you have been busted in a lie and are backing down*

no, YOU are LYING RIGHT HERE AND NOW.

Prove that I said that the simulation by HH made it there, or admit to 
being a DAMNED LIAR.

What I have been saying is the the DIRECT EXDCUTION of DD, and the 
CORRECT (and complete) simulation of the input to HH by an actual UTM 
will get there.

FAILURE TO PROVE YOUR STATMENT WILL BE CONSIDERED AN ADMISSION OF TOTAL 
GUILT.

> 
> "...the Turing machine will halt whenever it enters a final state."
> Linz(1990:234)
> 
> *You have been denying this*

Nope. You are just LYING. Maybe because you don't understand the meaning 
of the words.

The Turing Machine is NOT the simulation of it by H, it is the running 
of the independent program on its own, either H^ (H^) or DD(DD) as 
directly called by main.

> DD correctly simulated by pure function HH cannot possibly reach
> its own final state at line 06 in any finite number of steps of
> correct simulation.

Which means nothing, since HHs simulation is NOT "Correct" per the 
definition of computation theory which is needed to correlate the 
simulaiton to the behavior of the machine.

> 
> *Which in x86 is this*  

Maybe that is what you are trying to use as the definition, but that 
means that you have FORFETTED the abilith to correlate your simulation 
to acutal behavior of the actual program, and any such correlation is 
just a LIE.

You might beleive it, but that just shows you don't understand what 
truth actually means.

> DD correctly emulated by HH with an x86 emulator cannot possibly
> reach its own final state at machine address 00001c47 in any finite
> number of steps of correct emulation.

So?

This DD which calls this HH CAN BE correct simluated by a REAL correct 
simulator that doesn't stop until it reaches a final state,

One of your errors is thinking that "templates" have a halting behavior, 
or that the template can be simulated by your definition.

Since the template just calls "whatever" HH, it is impossible to 
actually simulate THE TEMPLATE past that call HH.

All you can do is simulate an INSTANCE of the template, and each 
instance is a DIFFERENT entity being simulated, so you can't use the 
results ofone to talk about another. At least no with valid logic.

> 
> typedef int (*ptr)();  // ptr is pointer to int function in C
> 00       int HH(ptr p, ptr i);
> 01       int DD(ptr p)
> 02       {
> 03         int Halt_Status = HH(p, p);
> 04         if (Halt_Status)
> 05           HERE: goto HERE;
> 06         return Halt_Status;
> 07       }
> 08
> 09       int main()
> 10       {
> 11         HH(DD,DD);
> 12         return 0;
> 13       }
> 
> _DD()
> [00001c22] 55         push ebp
> [00001c23] 8bec       mov ebp,esp
> [00001c25] 51         push ecx
> [00001c26] 8b4508     mov eax,[ebp+08]
> [00001c29] 50         push eax        ; push DD 1c22
> [00001c2a] 8b4d08     mov ecx,[ebp+08]
> [00001c2d] 51         push ecx        ; push DD 1c22
> [00001c2e] e80ff7ffff call 00001342   ; call HH
> [00001c33] 83c408     add esp,+08
> [00001c36] 8945fc     mov [ebp-04],eax
> [00001c39] 837dfc00   cmp dword [ebp-04],+00
> [00001c3d] 7402       jz 00001c41
> [00001c3f] ebfe       jmp 00001c3f
> [00001c41] 8b45fc     mov eax,[ebp-04]
> [00001c44] 8be5       mov esp,ebp
> [00001c46] 5d         pop ebp
> [00001c47] c3         ret
> Size in bytes:(0038) [00001c47]
> 
> Linz, Peter 1990. An Introduction to Formal Languages and Automata.
> Lexington/Toronto: D. C. Heath and Company. (317-320)
> 
> 

And what is the correct simultion of the call HH above?

You claim your HH has done so, so what is it?

(if it goes into HH, WHICH HH since that is an infinite set) if DD is 
just a template.

LIAR!