On 5/31/2024 3:08 AM, Mikko wrote:
On 2024-05-30 09:08:05 +0000, joes said:
Am Wed, 29 May 2024 21:32:49 -0500 schrieb olcott:
On 5/29/2024 9:27 PM, Richard Damon wrote:
On 5/29/24 9:48 PM, olcott wrote:
On 5/29/2024 8:24 PM, Richard Damon wrote:
On 5/29/24 9:15 PM, olcott wrote:
On 5/29/2024 8:07 PM, Richard Damon wrote:
On 5/29/24 8:59 PM, olcott wrote:
On 5/29/2024 7:48 PM, Richard Damon wrote:
On 5/29/24 8:17 PM, olcott wrote:
On 5/29/2024 7:09 PM, Richard Damon wrote:
On 5/29/24 7:57 PM, olcott wrote:
On 5/29/2024 6:47 PM, Richard Damon wrote:
On 5/29/24 2:31 PM, olcott wrote:
On 5/29/2024 1:14 PM, Ben Bacarisse wrote:
Alan Mackenzie <acm@muc.de> writes:
How about a bit of respect? Mike specifically asked you
not to cite his
name as a back up for your points. Why do you keep doing it?
>
It turns out that two dozen people are easily proven wrong when
they claimed that the correct simulation of the input to H(D,D)
is the behavior of int main() { D(D); }
>
How is that?
>
Which isn't a "Correct Simulation" by the definition that
allow the relating of a "Simulation" to the behavior of an
input.
Right the execution trace of D simulated by pure function H using
an x86 emulator must show that D cannot possibly reach its own
simulated final state and halt or the simulation of the machine
language of D is incorrect or in the wrong order.
Or aborts prematurely.
>
So, you aren't going to resolve the question but just keep up
with your contradiction that H is simulating a template (that
doesn't HAVE any instrucitons of H in it) but also DOES
simulate those non-existance instructions by LYING about what
it does and simulating a SPECIFIC instance that it LIES behaves
just like DIFFERENT specific instatces.
>
But the question ISN'T about the SIMULATED D, but about the
behavior of the actual PROGRAM/MACHINE D
Which should be the same.
This seems to be your blind spot.
>
∃H ∈ Turing_Machines
∀x ∈ Turing_Machines_Descriptions
∀y ∈ Finite_Strings
such that H(x,y) = Halts(x,y)
>
Not really the above formalization does not can cannot
specify Turing Machines as the input to any decider H.
>
Then what is x representing?
>
x <is> a finite string Turing machine description that SPECIFIES
behavior. The term: "representing" is inaccurate.
What’s the difference?
>
No, it specifies the machine, and thus, though that, the behavior.
>
If we assume that a decider takes an actual Turing machine as its
input that is correct otherwise that is one level of indirection
away from what we are really looking at.
>
The people have perpetuated this mistake for many decades never
actually made it not a mistake.
>
>
You need to define what you mean by "Indirection", because you aren't
using it in the normal manner.
>
I have conclusively proven that the behavior of the correct
simulation of the x86 code of D by pure function H has
different behavior than the direct execution of D(D).
Then H is not a correct simulator.
Either that or the correct simulation of the x86 of D by pure function
H does not exists. If you ensure that H is not a pure functin or
that H never performs a correct simulation of D you can say whatever
you want about the impossible simulation, for example that it
is yellow.
*I proved that Mike Terry is wrong and he simply ignored the proof*
*I proved that Mike Terry is wrong and he simply ignored the proof*
*I proved that Mike Terry is wrong and he simply ignored the proof*
http://al.howardknight.net/?STYPE=msgid&MSGI=%3CS8CcnRadHexfe8X7nZ2dnZfqnPqdnZ2d%40brightview.co.uk%3E+"...the Turing machine will halt whenever it enters a final state."
Linz(1990:234)
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.
_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]
*The Provably Correct Execution Trace that Mike Terry Ignored*
*The Provably Correct Execution Trace that Mike Terry Ignored*
*The Provably Correct Execution Trace that Mike Terry Ignored*
Begin Local Halt Decider Simulation Execution Trace Stored at:113075
[00001c22][00113061][00113065] 55 push ebp
[00001c23][00113061][00113065] 8bec mov ebp,esp
[00001c25][0011305d][00103031] 51 push ecx
[00001c26][0011305d][00103031] 8b4508 mov eax,[ebp+08]
[00001c29][00113059][00001c22] 50 push eax ; push DD
[00001c2a][00113059][00001c22] 8b4d08 mov ecx,[ebp+08]
[00001c2d][00113055][00001c22] 51 push ecx ; push DD
[00001c2e][00113051][00001c33] e80ff7ffff call 00001342 ; call HH
New slave_stack at:14da95
[00001c22][0015da89][0015da8d] 55 push ebp
[00001c23][0015da89][0015da8d] 8bec mov ebp,esp
[00001c25][0015da85][0014da59] 51 push ecx
[00001c26][0015da85][0014da59] 8b4508 mov eax,[ebp+08]
[00001c29][0015da81][00001c22] 50 push eax ; push DD
[00001c2a][0015da81][00001c22] 8b4d08 mov ecx,[ebp+08]
[00001c2d][0015da7d][00001c22] 51 push ecx ; push DD
[00001c2e][0015da79][00001c33] e80ff7ffff call 00001342 ; call HH
Local Halt Decider: Recursive Simulation Detected Simulation Stopped
*The Execution Trace is proven to be correct on the basis of*
*the fact that the above x86 machine language instructions of DD*
*are correctly emulated by HH in their correct order*
"...the Turing machine will halt whenever it enters a final state."
Linz(1990:234)
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.
*Here is the C version*
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 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.
-- Copyright 2024 Olcott "Talent hits a target no one else can hit; Geniushits a target no one else can see." Arthur Schopenhauer
D correctly simulated by H cannot possibly halt --- templates and infinite sets
Re: D correctly simulated by H cannot possibly halt --- templates and infinite sets