Re: Two dozen people were simply wrong --- Try to prove otherwise --- pinned down

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!