XPost: sci.logic

Op 04.jun.2024 om 18:13 schreef olcott:

Proof that executed HH(DD,DD) and simulated HH(DD,DD) simulate DD
correctly. This proof requires expert knowledge of the C programming
language and the x86 programming language.

With this expertise it is easy to confirm that both the directly
executed HH(DD,DD) and the simulated executed HH(DD,DD) simulate the
steps of DD exactly the way that the x86 machine language specifies.

If one also has expertise on the mapping from the C source code to the
x86 assembly language then one also confirms that the x86 version of
DD is exactly what the C source-code specifies.

01   int DD(int (*x)())
02   {
03     int Halt_Status = HH(x, x);
04     if (Halt_Status)
05         HERE: goto HERE;
06     return Halt_Status;
07   }
08
09   int main()
10   {
11     Output("Input_Halts = ", HH(DD,DD));
12   }

_DD()
[00001db2] 55         push ebp
[00001db3] 8bec       mov ebp,esp
[00001db5] 51         push ecx
[00001db6] 8b4508     mov eax,[ebp+08]
[00001db9] 50         push eax        ; push DD
[00001dba] 8b4d08     mov ecx,[ebp+08]
[00001dbd] 51         push ecx        ; push DD
[00001dbe] e8bff5ffff call 00001382   ; call HH
[00001dc3] 83c408     add esp,+08
[00001dc6] 8945fc     mov [ebp-04],eax
[00001dc9] 837dfc00   cmp dword [ebp-04],+00
[00001dcd] 7402       jz 00001dd1
[00001dcf] ebfe       jmp 00001dcf
[00001dd1] 8b45fc     mov eax,[ebp-04]
[00001dd4] 8be5       mov esp,ebp
[00001dd6] 5d         pop ebp
[00001dd7] c3         ret
Size in bytes:(0038) [00001dd7]

 machine   stack     stack     machine    assembly
 address   address   data      code       language
 ========  ========  ========  =========  ============= [00001de2][00103292][00000000] 55         push ebp [00001de3][00103292][00000000] 8bec       mov ebp,esp [00001de5][0010328e][00001db2] 68b21d0000 push 00001db2 ; push DD [00001dea][0010328a][00001db2] 68b21d0000 push 00001db2 ; push DD [00001def][00103286][00001df4] e88ef5ffff call 00001382 ; call HH
New slave_stack at:103336

Begin Local Halt Decider Simulation   Execution Trace Stored at:11333e [00001db2][0011332a][0011332e] 55         push ebp         ; DD line 01
[00001db3][0011332a][0011332e] 8bec       mov ebp,esp      ; DD line 02
[00001db5][00113326][001032fa] 51         push ecx         ; DD line 03
[00001db6][00113326][001032fa] 8b4508     mov eax,[ebp+08] ; DD line 04 [00001db9][00113322][00001db2] 50         push eax         ; push DD
[00001dba][00113322][00001db2] 8b4d08     mov ecx,[ebp+08] ; DD line 06 [00001dbd][0011331e][00001db2] 51         push ecx         ; push DD
[00001dbe][0011331a][00001dc3] e8bff5ffff call 00001382    ; call HH
New slave_stack at:14dd5e
[00001db2][0015dd52][0015dd56] 55         push ebp         ; DD line 01
[00001db3][0015dd52][0015dd56] 8bec       mov ebp,esp      ; DD line 02
[00001db5][0015dd4e][0014dd22] 51         push ecx         ; DD line 03
[00001db6][0015dd4e][0014dd22] 8b4508     mov eax,[ebp+08] ; DD line 04 [00001db9][0015dd4a][00001db2] 50         push eax         ; push DD
[00001dba][0015dd4a][00001db2] 8b4d08     mov ecx,[ebp+08] ; DD line 06 [00001dbd][0015dd46][00001db2] 51         push ecx         ; push DD
[00001dbe][0015dd42][00001dc3] e8bff5ffff call 00001382    ; call HH
Local Halt Decider: Infinite Recursion Detected Simulation Stopped

[00001df4][00103292][00000000] 83c408     add esp,+08 [00001df7][0010328e][00000000] 50         push eax [00001df8][0010328a][00000743] 6843070000 push 00000743 [00001dfd][0010328a][00000743] e8a0e9ffff call 000007a2
Input_Halts = 0
[00001e02][00103292][00000000] 83c408     add esp,+08 [00001e05][00103292][00000000] eb79       jmp 00001e80 [00001e80][00103292][00000000] 33c0       xor eax,eax [00001e82][00103296][00000018] 5d         pop ebp [00001e83][0010329a][00000000] c3         ret
Number of Instructions Executed(16829) == 251 Pages

It is clearly a false negative.

Olcott defends a simulating halt decider H. The problem with it is, that
it introduces another halting problem: The H itself does not halt when simulated by itself. This cause false negatives: many functions are now diagnosed by H to be non-halting only by the mere fact that they call H,
even if their direct execution does halt.

H even diagnoses itself to be non-halting, which is illustrated in the following example (where the D that contradicts H is eliminated):

typedef int (*ptr)(); // ptr is pointer to int function in C

int H(ptr p, ptr i);

int main()
{
H(main, 0);
}

The program main does nothing but calling H. H is required to halt, so
main itself should also halt. Nevertheless H reports that main does not
halt.

Of the infinite set of H that simulate at least one step, none of them,
when simulated by H, reaches its final state. So, it follows that H
determines non-halting behaviour of H.

This illustrates that a simulating halt-decider is a bad idea, because
the decider itself does not halt when simulated by itself and therefore
its results are often false negatives.

--- SoupGate-Win32 v1.05
* Origin: fsxNet Usenet Gateway (21:1/5)

XPost: sci.logic

Op 04.jun.2024 om 18:28 schreef olcott:

Heh Mike Terry, please study this to see your mistaken
conclusion of this post:

On 5/30/2024 3:51 PM, Mike Terry wrote:

On 30/05/2024 17:55, olcott wrote:

http://al.howardknight.net/?STYPE=msgid&MSGI=%3CS8CcnRadHexfe8X7nZ2dnZfqnPqdnZ2d%40brightview.co.uk%3E+
Message-ID: <S8CcnRadHexfe8X7nZ2dnZfqnPqdnZ2d@brightview.co.uk>

*Here is your mistaken conclusion*
On 5/30/2024 3:51 PM, Mike Terry wrote:

On 30/05/2024 17:55, olcott wrote:

That HH is not a pure function does not show that
the simulation is incorrect because:

It shows that the simulation is "rubbish" and any
trace produced by it can just be ignored.

Err, that's it.

Mike.

Proof that executed HH(DD,DD) and simulated HH(DD,DD) simulate DD
correctly. This proof requires expert knowledge of the C programming
language and the x86 programming language.

With this expertise it is easy to confirm that both the directly
executed HH(DD,DD) and the simulated executed HH(DD,DD) simulate the
steps of DD exactly the way that the x86 machine language specifies.

*New Paragraph inserted*
We can see that the pair of execution traces derived by the executed HH(DD,DD) and the simulated HH(DD,DD) (shown below) exactly match
the x86 machine code of DD, (also shown below) thus are proven to be
correct.

If one also has expertise on the mapping from the C source code to the
x86 assembly language then one also confirms that the x86 version of
DD is exactly what the C source-code specifies.

01   int DD(int (*x)())
02   {
03     int Halt_Status = HH(x, x);
04     if (Halt_Status)
05         HERE: goto HERE;
06     return Halt_Status;
07   }
08
09   int main()
10   {
11     Output("Input_Halts = ", HH(DD,DD));
12   }

_DD()
[00001db2] 55         push ebp
[00001db3] 8bec       mov ebp,esp
[00001db5] 51         push ecx
[00001db6] 8b4508     mov eax,[ebp+08]
[00001db9] 50         push eax        ; push DD
[00001dba] 8b4d08     mov ecx,[ebp+08]
[00001dbd] 51         push ecx        ; push DD
[00001dbe] e8bff5ffff call 00001382   ; call HH
[00001dc3] 83c408     add esp,+08
[00001dc6] 8945fc     mov [ebp-04],eax
[00001dc9] 837dfc00   cmp dword [ebp-04],+00
[00001dcd] 7402       jz 00001dd1
[00001dcf] ebfe       jmp 00001dcf
[00001dd1] 8b45fc     mov eax,[ebp-04]
[00001dd4] 8be5       mov esp,ebp
[00001dd6] 5d         pop ebp
[00001dd7] c3         ret
Size in bytes:(0038) [00001dd7]

 machine   stack     stack     machine    assembly
 address   address   data      code       language
 ========  ========  ========  =========  ============= [00001de2][00103292][00000000] 55         push ebp [00001de3][00103292][00000000] 8bec       mov ebp,esp [00001de5][0010328e][00001db2] 68b21d0000 push 00001db2 ; push DD [00001dea][0010328a][00001db2] 68b21d0000 push 00001db2 ; push DD [00001def][00103286][00001df4] e88ef5ffff call 00001382 ; call HH
New slave_stack at:103336

Begin Local Halt Decider Simulation   Execution Trace Stored at:11333e [00001db2][0011332a][0011332e] 55         push ebp         ; DD line 01
[00001db3][0011332a][0011332e] 8bec       mov ebp,esp      ; DD line 02
[00001db5][00113326][001032fa] 51         push ecx         ; DD line 03
[00001db6][00113326][001032fa] 8b4508     mov eax,[ebp+08] ; DD line 04 [00001db9][00113322][00001db2] 50         push eax         ; push DD
[00001dba][00113322][00001db2] 8b4d08     mov ecx,[ebp+08] ; DD line 06 [00001dbd][0011331e][00001db2] 51         push ecx         ; push DD
[00001dbe][0011331a][00001dc3] e8bff5ffff call 00001382    ; call HH
New slave_stack at:14dd5e
[00001db2][0015dd52][0015dd56] 55         push ebp         ; DD line 01
[00001db3][0015dd52][0015dd56] 8bec       mov ebp,esp      ; DD line 02
[00001db5][0015dd4e][0014dd22] 51         push ecx         ; DD line 03
[00001db6][0015dd4e][0014dd22] 8b4508     mov eax,[ebp+08] ; DD line 04 [00001db9][0015dd4a][00001db2] 50         push eax         ; push DD
[00001dba][0015dd4a][00001db2] 8b4d08     mov ecx,[ebp+08] ; DD line 06 [00001dbd][0015dd46][00001db2] 51         push ecx         ; push DD
[00001dbe][0015dd42][00001dc3] e8bff5ffff call 00001382    ; call HH
Local Halt Decider: Infinite Recursion Detected Simulation Stopped

[00001df4][00103292][00000000] 83c408     add esp,+08 [00001df7][0010328e][00000000] 50         push eax [00001df8][0010328a][00000743] 6843070000 push 00000743 [00001dfd][0010328a][00000743] e8a0e9ffff call 000007a2
Input_Halts = 0
[00001e02][00103292][00000000] 83c408     add esp,+08 [00001e05][00103292][00000000] eb79       jmp 00001e80 [00001e80][00103292][00000000] 33c0       xor eax,eax [00001e82][00103296][00000018] 5d         pop ebp [00001e83][0010329a][00000000] c3         ret
Number of Instructions Executed(16829) == 251 Pages

This is a perfect example of a false negative. It is explained by the following:

Olcott defends a simulating halt decider H. The problem with it is, that
it introduces another halting problem: The H itself does not halt when simulated by itself. This causes false negatives: many functions are now diagnosed by H to be non-halting only by the mere fact that they call H,
even if their direct execution does halt.

We see in olcott's example above that the simulation of H invokes a
recursive simulation of H.

H even diagnoses itself to be non-halting, which is illustrated in the following example (where the D that contradicts H is eliminated):

typedef int (*ptr)(); // ptr is pointer to int function in C

int H(ptr p, ptr i);

int main()
{
H(main, 0);
}

The program main does nothing but calling H. H is required to halt, so
main itself should also halt. Nevertheless H reports that main does not
halt.

Of the infinite set of H that simulate at least one step, none of them,
when simulated by H, reaches its final state. So, it follows that H
determines non-halting behaviour of H.

This illustrates that a simulating halt-decider is a bad idea, because
the decider itself does not halt when simulated by itself and therefore
its results are often false negatives.

--- SoupGate-Win32 v1.05
* Origin: fsxNet Usenet Gateway (21:1/5)

XPost: sci.logic

On 6/4/24 12:13 PM, olcott wrote:

Proof that executed HH(DD,DD) and simulated HH(DD,DD) simulate DD
correctly. This proof requires expert knowledge of the C programming
language and the x86 programming language.

With this expertise it is easy to confirm that both the directly
executed HH(DD,DD) and the simulated executed HH(DD,DD) simulate the
steps of DD exactly the way that the x86 machine language specifies.

The problem is you have two different classes of HH, that generate two different classes of DD (HH needs to simulate just an INSTANCE of your
DD template, and can't simulate the template itself by your rules, and
thus different HH get different DD that can have different answers).

The HH that never stop there simulation do show that their class of DD
actually is non-halting, but fail to give an answer, so are not deciders.

The HH that are programmed to stop their simulation at some point may
have correctly simulated PART of the behavior of DD, but not enough to
actually show that it would be non-halting, and as can be proven, it
WILL halt, as a correct FULL simulation of this class of DD will reach
an end, as will the direct execution.

Your deception of trying to combine these two classes into one with all behaving the same is just a LIE. and proves how little you care about
the actual truth of things.

If one also has expertise on the mapping from the C source code to the
x86 assembly language then one also confirms that the x86 version of
DD is exactly what the C source-code specifies.

So?

The problem is the input is incomplete, as to hactually HAVE behvaior,
we need the code (C or x86) of HH.

As the simple template, we can only simulate the first 8 instructions,
and then we get stuck.

The fact that you don't understand this means you must not understand
very much about the behavior of C code.

01   int DD(int (*x)())
02   {
03     int Halt_Status = HH(x, x);
04     if (Halt_Status)
05         HERE: goto HERE;
06     return Halt_Status;
07   }
08
09   int main()
10   {
11     Output("Input_Halts = ", HH(DD,DD));
12   }

_DD()
[00001db2] 55         push ebp
[00001db3] 8bec       mov ebp,esp
[00001db5] 51         push ecx
[00001db6] 8b4508     mov eax,[ebp+08]
[00001db9] 50         push eax        ; push DD
[00001dba] 8b4d08     mov ecx,[ebp+08]
[00001dbd] 51         push ecx        ; push DD
[00001dbe] e8bff5ffff call 00001382   ; call HH
[00001dc3] 83c408     add esp,+08
[00001dc6] 8945fc     mov [ebp-04],eax
[00001dc9] 837dfc00   cmp dword [ebp-04],+00
[00001dcd] 7402       jz 00001dd1
[00001dcf] ebfe       jmp 00001dcf
[00001dd1] 8b45fc     mov eax,[ebp-04]
[00001dd4] 8be5       mov esp,ebp
[00001dd6] 5d         pop ebp
[00001dd7] c3         ret
Size in bytes:(0038) [00001dd7]

 machine   stack     stack     machine    assembly
 address   address   data      code       language
 ========  ========  ========  =========  ============= [00001de2][00103292][00000000] 55         push ebp [00001de3][00103292][00000000] 8bec       mov ebp,esp [00001de5][0010328e][00001db2] 68b21d0000 push 00001db2 ; push DD [00001dea][0010328a][00001db2] 68b21d0000 push 00001db2 ; push DD [00001def][00103286][00001df4] e88ef5ffff call 00001382 ; call HH
New slave_stack at:103336

Begin Local Halt Decider Simulation   Execution Trace Stored at:11333e [00001db2][0011332a][0011332e] 55         push ebp         ; DD line 01
[00001db3][0011332a][0011332e] 8bec       mov ebp,esp      ; DD line 02
[00001db5][00113326][001032fa] 51         push ecx         ; DD line 03
[00001db6][00113326][001032fa] 8b4508     mov eax,[ebp+08] ; DD line 04 [00001db9][00113322][00001db2] 50         push eax         ; push DD
[00001dba][00113322][00001db2] 8b4d08     mov ecx,[ebp+08] ; DD line 06 [00001dbd][0011331e][00001db2] 51         push ecx         ; push DD
[00001dbe][0011331a][00001dc3] e8bff5ffff call 00001382    ; call HH
New slave_stack at:14dd5e
[00001db2][0015dd52][0015dd56] 55         push ebp         ; DD line 01
[00001db3][0015dd52][0015dd56] 8bec       mov ebp,esp      ; DD line 02
[00001db5][0015dd4e][0014dd22] 51         push ecx         ; DD line 03
[00001db6][0015dd4e][0014dd22] 8b4508     mov eax,[ebp+08] ; DD line 04 [00001db9][0015dd4a][00001db2] 50         push eax         ; push DD
[00001dba][0015dd4a][00001db2] 8b4d08     mov ecx,[ebp+08] ; DD line 06 [00001dbd][0015dd46][00001db2] 51         push ecx         ; push DD
[00001dbe][0015dd42][00001dc3] e8bff5ffff call 00001382    ; call HH
Local Halt Decider: Infinite Recursion Detected Simulation Stopped

[00001df4][00103292][00000000] 83c408     add esp,+08 [00001df7][0010328e][00000000] 50         push eax [00001df8][0010328a][00000743] 6843070000 push 00000743 [00001dfd][0010328a][00000743] e8a0e9ffff call 000007a2
Input_Halts = 0
[00001e02][00103292][00000000] 83c408     add esp,+08 [00001e05][00103292][00000000] eb79       jmp 00001e80 [00001e80][00103292][00000000] 33c0       xor eax,eax [00001e82][00103296][00000018] 5d         pop ebp [00001e83][0010329a][00000000] c3         ret
Number of Instructions Executed(16829) == 251 Pages

--- SoupGate-Win32 v1.05
* Origin: fsxNet Usenet Gateway (21:1/5)

XPost: sci.logic

Op 04.jun.2024 om 18:49 schreef olcott:

On 6/4/2024 11:23 AM, Fred. Zwarts wrote:

Op 04.jun.2024 om 18:13 schreef olcott:

Proof that executed HH(DD,DD) and simulated HH(DD,DD) simulate DD
correctly. This proof requires expert knowledge of the C programming
language and the x86 programming language.

With this expertise it is easy to confirm that both the directly
executed HH(DD,DD) and the simulated executed HH(DD,DD) simulate the
steps of DD exactly the way that the x86 machine language specifies.

If one also has expertise on the mapping from the C source code to the
x86 assembly language then one also confirms that the x86 version of
DD is exactly what the C source-code specifies.

01   int DD(int (*x)())
02   {
03     int Halt_Status = HH(x, x);
04     if (Halt_Status)
05         HERE: goto HERE;
06     return Halt_Status;
07   }
08
09   int main()
10   {
11     Output("Input_Halts = ", HH(DD,DD));
12   }

_DD()
[00001db2] 55         push ebp
[00001db3] 8bec       mov ebp,esp
[00001db5] 51         push ecx
[00001db6] 8b4508     mov eax,[ebp+08]
[00001db9] 50         push eax        ; push DD
[00001dba] 8b4d08     mov ecx,[ebp+08]
[00001dbd] 51         push ecx        ; push DD
[00001dbe] e8bff5ffff call 00001382   ; call HH
[00001dc3] 83c408     add esp,+08
[00001dc6] 8945fc     mov [ebp-04],eax
[00001dc9] 837dfc00   cmp dword [ebp-04],+00
[00001dcd] 7402       jz 00001dd1
[00001dcf] ebfe       jmp 00001dcf
[00001dd1] 8b45fc     mov eax,[ebp-04]
[00001dd4] 8be5       mov esp,ebp
[00001dd6] 5d         pop ebp
[00001dd7] c3         ret
Size in bytes:(0038) [00001dd7]

  machine   stack     stack     machine    assembly
  address   address   data      code       language
  ========  ========  ========  =========  =============
[00001de2][00103292][00000000] 55         push ebp
[00001de3][00103292][00000000] 8bec       mov ebp,esp
[00001de5][0010328e][00001db2] 68b21d0000 push 00001db2 ; push DD
[00001dea][0010328a][00001db2] 68b21d0000 push 00001db2 ; push DD
[00001def][00103286][00001df4] e88ef5ffff call 00001382 ; call HH
New slave_stack at:103336

Begin Local Halt Decider Simulation   Execution Trace Stored at:11333e >>> [00001db2][0011332a][0011332e] 55         push ebp         ; DD line 01
[00001db3][0011332a][0011332e] 8bec       mov ebp,esp      ; DD line 02
[00001db5][00113326][001032fa] 51         push ecx         ; DD line 03
[00001db6][00113326][001032fa] 8b4508     mov eax,[ebp+08] ; DD line 04 >>> [00001db9][00113322][00001db2] 50         push eax         ; push DD
[00001dba][00113322][00001db2] 8b4d08     mov ecx,[ebp+08] ; DD line 06 >>> [00001dbd][0011331e][00001db2] 51         push ecx         ; push DD
[00001dbe][0011331a][00001dc3] e8bff5ffff call 00001382    ; call HH
New slave_stack at:14dd5e
[00001db2][0015dd52][0015dd56] 55         push ebp         ; DD line 01
[00001db3][0015dd52][0015dd56] 8bec       mov ebp,esp      ; DD line 02
[00001db5][0015dd4e][0014dd22] 51         push ecx         ; DD line 03
[00001db6][0015dd4e][0014dd22] 8b4508     mov eax,[ebp+08] ; DD line 04 >>> [00001db9][0015dd4a][00001db2] 50         push eax         ; push DD
[00001dba][0015dd4a][00001db2] 8b4d08     mov ecx,[ebp+08] ; DD line 06 >>> [00001dbd][0015dd46][00001db2] 51         push ecx         ; push DD
[00001dbe][0015dd42][00001dc3] e8bff5ffff call 00001382    ; call HH
Local Halt Decider: Infinite Recursion Detected Simulation Stopped

[00001df4][00103292][00000000] 83c408     add esp,+08
[00001df7][0010328e][00000000] 50         push eax
[00001df8][0010328a][00000743] 6843070000 push 00000743
[00001dfd][0010328a][00000743] e8a0e9ffff call 000007a2
Input_Halts = 0
[00001e02][00103292][00000000] 83c408     add esp,+08
[00001e05][00103292][00000000] eb79       jmp 00001e80
[00001e80][00103292][00000000] 33c0       xor eax,eax
[00001e82][00103296][00000018] 5d         pop ebp
[00001e83][0010329a][00000000] c3         ret
Number of Instructions Executed(16829) == 251 Pages

It is clearly a false negative.

Olcott defends a simulating halt decider H. The problem with it is,
that it introduces another halting problem: The H itself does not halt
when simulated by itself. This cause false negatives: many functions
are now diagnosed by H to be non-halting only by the mere fact that
they call H, even if their direct execution does halt.

Clearly you did not pay close enough attention to Mike Terry's
reply to you and/or you lack the required prerequisite skill
in the C programming language and/or the x86 language.

It never has mattered at all that HH(DD,DD) indirectly aborts
a simulation of itself by aborting its simulation of DD.

The directly executed HH sees that neither DD nor its simulation
of itself can possibly halt and that <is> its correct basis for
rejecting DD as non-halting.

It seems you are unable to read. I told you already that Mike's reply
has as a consequence that both HH and DD go in recursive recursion, so,
neither of them reaches its final state.

I understand that you removed the remainder of my text from the quote,
because it proves that your simulation introduces another non-halting behaviour, such that H even diagnoses itself as non-halting:

typedef int (*ptr)(); // ptr is pointer to int function in C

int H(ptr p, ptr i);

int main()
{
H(main, 0);
}

The program main does nothing but calling H. H is required to halt, so
main itself should also halt. Nevertheless H reports that main does not
halt.

Of the infinite set of H that simulate at least one step, none of them,
when simulated by H, reaches its final state. So, it follows that H
determines non-halting behaviour of H.

This illustrates that a simulating halt-decider is a bad idea, because
the decider itself does not halt when simulated by itself and therefore
its results are often false negatives.

--- SoupGate-Win32 v1.05
* Origin: fsxNet Usenet Gateway (21:1/5)

On 2024-06-04 16:46:21 +0000, Fred. Zwarts said:

Op 04.jun.2024 om 18:28 schreef olcott:

Heh Mike Terry, please study this to see your mistaken
conclusion of this post:

On 5/30/2024 3:51 PM, Mike Terry wrote:

On 30/05/2024 17:55, olcott wrote:

http://al.howardknight.net/?STYPE=msgid&MSGI=%3CS8CcnRadHexfe8X7nZ2dnZfqnPqdnZ2d%40brightview.co.uk%3E+

Message-ID: <S8CcnRadHexfe8X7nZ2dnZfqnPqdnZ2d@brightview.co.uk>

*Here is your mistaken conclusion*
On 5/30/2024 3:51 PM, Mike Terry wrote:

On 30/05/2024 17:55, olcott wrote:

That HH is not a pure function does not show that
the simulation is incorrect because:

It shows that the simulation is "rubbish" and any
trace produced by it can just be ignored.

Err, that's it.

Mike.

Proof that executed HH(DD,DD) and simulated HH(DD,DD) simulate DD
correctly. This proof requires expert knowledge of the C programming
language and the x86 programming language.

With this expertise it is easy to confirm that both the directly
executed HH(DD,DD) and the simulated executed HH(DD,DD) simulate the
steps of DD exactly the way that the x86 machine language specifies.

*New Paragraph inserted*
We can see that the pair of execution traces derived by the executed
HH(DD,DD) and the simulated HH(DD,DD) (shown below) exactly match
the x86 machine code of DD, (also shown below) thus are proven to be
correct.

If one also has expertise on the mapping from the C source code to the
x86 assembly language then one also confirms that the x86 version of
DD is exactly what the C source-code specifies.

01   int DD(int (*x)())
02   {
03     int Halt_Status = HH(x, x);
04     if (Halt_Status)
05         HERE: goto HERE;
06     return Halt_Status;
07   }
08
09   int main()
10   {
11     Output("Input_Halts = ", HH(DD,DD));
12   }

_DD()
[00001db2] 55         push ebp
[00001db3] 8bec       mov ebp,esp
[00001db5] 51         push ecx
[00001db6] 8b4508     mov eax,[ebp+08]
[00001db9] 50         push eax        ; push DD
[00001dba] 8b4d08     mov ecx,[ebp+08]
[00001dbd] 51         push ecx        ; push DD
[00001dbe] e8bff5ffff call 00001382   ; call HH
[00001dc3] 83c408     add esp,+08
[00001dc6] 8945fc     mov [ebp-04],eax
[00001dc9] 837dfc00   cmp dword [ebp-04],+00
[00001dcd] 7402       jz 00001dd1
[00001dcf] ebfe       jmp 00001dcf
[00001dd1] 8b45fc     mov eax,[ebp-04]
[00001dd4] 8be5       mov esp,ebp
[00001dd6] 5d         pop ebp
[00001dd7] c3         ret
Size in bytes:(0038) [00001dd7]

 machine   stack     stack     machine    assembly
 address   address   data      code       language
 ========  ========  ========  =========  =============
[00001de2][00103292][00000000] 55         push ebp
[00001de3][00103292][00000000] 8bec       mov ebp,esp
[00001de5][0010328e][00001db2] 68b21d0000 push 00001db2 ; push DD
[00001dea][0010328a][00001db2] 68b21d0000 push 00001db2 ; push DD
[00001def][00103286][00001df4] e88ef5ffff call 00001382 ; call HH
New slave_stack at:103336

Begin Local Halt Decider Simulation   Execution Trace Stored at:11333e
[00001db2][0011332a][0011332e] 55         push ebp         ; DD line 01
[00001db3][0011332a][0011332e] 8bec       mov ebp,esp      ; DD line 02
[00001db5][00113326][001032fa] 51         push ecx         ; DD line 03
[00001db6][00113326][001032fa] 8b4508     mov eax,[ebp+08] ; DD line 04 >> [00001db9][00113322][00001db2] 50         push eax         ; push DD
[00001dba][00113322][00001db2] 8b4d08     mov ecx,[ebp+08] ; DD line 06 >> [00001dbd][0011331e][00001db2] 51         push ecx         ; push DD
[00001dbe][0011331a][00001dc3] e8bff5ffff call 00001382    ; call HH
New slave_stack at:14dd5e
[00001db2][0015dd52][0015dd56] 55         push ebp         ; DD line 01
[00001db3][0015dd52][0015dd56] 8bec       mov ebp,esp      ; DD line 02
[00001db5][0015dd4e][0014dd22] 51         push ecx         ; DD line 03
[00001db6][0015dd4e][0014dd22] 8b4508     mov eax,[ebp+08] ; DD line 04 >> [00001db9][0015dd4a][00001db2] 50         push eax         ; push DD
[00001dba][0015dd4a][00001db2] 8b4d08     mov ecx,[ebp+08] ; DD line 06 >> [00001dbd][0015dd46][00001db2] 51         push ecx         ; push DD
[00001dbe][0015dd42][00001dc3] e8bff5ffff call 00001382    ; call HH
Local Halt Decider: Infinite Recursion Detected Simulation Stopped

[00001df4][00103292][00000000] 83c408     add esp,+08
[00001df7][0010328e][00000000] 50         push eax
[00001df8][0010328a][00000743] 6843070000 push 00000743
[00001dfd][0010328a][00000743] e8a0e9ffff call 000007a2
Input_Halts = 0
[00001e02][00103292][00000000] 83c408     add esp,+08
[00001e05][00103292][00000000] eb79       jmp 00001e80
[00001e80][00103292][00000000] 33c0       xor eax,eax
[00001e82][00103296][00000018] 5d         pop ebp
[00001e83][0010329a][00000000] c3         ret
Number of Instructions Executed(16829) == 251 Pages

This is a perfect example of a false negative. It is explained by the following:

Olcott defends a simulating halt decider H. The problem with it is,
that it introduces another halting problem: The H itself does not halt
when simulated by itself. This causes false negatives: many functions
are now diagnosed by H to be non-halting only by the mere fact that
they call H, even if their direct execution does halt.

We see in olcott's example above that the simulation of H invokes a
recursive simulation of H.

H even diagnoses itself to be non-halting, which is illustrated in the following example (where the D that contradicts H is eliminated):

typedef int (*ptr)(); // ptr is pointer to int function in C

int H(ptr p, ptr i);

int main()
{
H(main, 0);
}

That program does not tell what H says. You should instead say

int main()
{
return H(main, 0);
}

so that the result is returned to the operating systems. Many operating
systems tell the value returned by main or they can be asked about it.

--
Mikko

--- SoupGate-Win32 v1.05
* Origin: fsxNet Usenet Gateway (21:1/5)

XPost: sci.logic

Op 05.jun.2024 om 15:31 schreef olcott:

On 6/5/2024 2:55 AM, Fred. Zwarts wrote:

Op 04.jun.2024 om 18:49 schreef olcott:

On 6/4/2024 11:23 AM, Fred. Zwarts wrote:

Op 04.jun.2024 om 18:13 schreef olcott:

Proof that executed HH(DD,DD) and simulated HH(DD,DD) simulate DD
correctly. This proof requires expert knowledge of the C programming >>>>> language and the x86 programming language.

With this expertise it is easy to confirm that both the directly
executed HH(DD,DD) and the simulated executed HH(DD,DD) simulate the >>>>> steps of DD exactly the way that the x86 machine language specifies. >>>>>
If one also has expertise on the mapping from the C source code to the >>>>> x86 assembly language then one also confirms that the x86 version of >>>>> DD is exactly what the C source-code specifies.

01   int DD(int (*x)())
02   {
03     int Halt_Status = HH(x, x);
04     if (Halt_Status)
05         HERE: goto HERE;
06     return Halt_Status;
07   }
08
09   int main()
10   {
11     Output("Input_Halts = ", HH(DD,DD));
12   }

_DD()
[00001db2] 55         push ebp
[00001db3] 8bec       mov ebp,esp
[00001db5] 51         push ecx
[00001db6] 8b4508     mov eax,[ebp+08]
[00001db9] 50         push eax        ; push DD
[00001dba] 8b4d08     mov ecx,[ebp+08]
[00001dbd] 51         push ecx        ; push DD
[00001dbe] e8bff5ffff call 00001382   ; call HH
[00001dc3] 83c408     add esp,+08
[00001dc6] 8945fc     mov [ebp-04],eax
[00001dc9] 837dfc00   cmp dword [ebp-04],+00
[00001dcd] 7402       jz 00001dd1
[00001dcf] ebfe       jmp 00001dcf
[00001dd1] 8b45fc     mov eax,[ebp-04]
[00001dd4] 8be5       mov esp,ebp
[00001dd6] 5d         pop ebp
[00001dd7] c3         ret
Size in bytes:(0038) [00001dd7]

  machine   stack     stack     machine    assembly
  address   address   data      code       language >>>>>   ========  ========  ========  =========  =============
[00001de2][00103292][00000000] 55         push ebp
[00001de3][00103292][00000000] 8bec       mov ebp,esp
[00001de5][0010328e][00001db2] 68b21d0000 push 00001db2 ; push DD
[00001dea][0010328a][00001db2] 68b21d0000 push 00001db2 ; push DD
[00001def][00103286][00001df4] e88ef5ffff call 00001382 ; call HH
New slave_stack at:103336

Begin Local Halt Decider Simulation   Execution Trace Stored at:11333e >>>>> [00001db2][0011332a][0011332e] 55         push ebp         ; DD
line 01
[00001db3][0011332a][0011332e] 8bec       mov ebp,esp      ; DD
line 02
[00001db5][00113326][001032fa] 51         push ecx         ; DD
line 03
[00001db6][00113326][001032fa] 8b4508     mov eax,[ebp+08] ; DD
line 04
[00001db9][00113322][00001db2] 50         push eax         ; push DD
[00001dba][00113322][00001db2] 8b4d08     mov ecx,[ebp+08] ; DD
line 06
[00001dbd][0011331e][00001db2] 51         push ecx         ; push DD
[00001dbe][0011331a][00001dc3] e8bff5ffff call 00001382    ; call HH >>>>> New slave_stack at:14dd5e
[00001db2][0015dd52][0015dd56] 55         push ebp         ; DD
line 01
[00001db3][0015dd52][0015dd56] 8bec       mov ebp,esp      ; DD
line 02
[00001db5][0015dd4e][0014dd22] 51         push ecx         ; DD
line 03
[00001db6][0015dd4e][0014dd22] 8b4508     mov eax,[ebp+08] ; DD
line 04
[00001db9][0015dd4a][00001db2] 50         push eax         ; push DD
[00001dba][0015dd4a][00001db2] 8b4d08     mov ecx,[ebp+08] ; DD
line 06
[00001dbd][0015dd46][00001db2] 51         push ecx         ; push DD
[00001dbe][0015dd42][00001dc3] e8bff5ffff call 00001382    ; call HH >>>>> Local Halt Decider: Infinite Recursion Detected Simulation Stopped

[00001df4][00103292][00000000] 83c408     add esp,+08
[00001df7][0010328e][00000000] 50         push eax
[00001df8][0010328a][00000743] 6843070000 push 00000743
[00001dfd][0010328a][00000743] e8a0e9ffff call 000007a2
Input_Halts = 0
[00001e02][00103292][00000000] 83c408     add esp,+08
[00001e05][00103292][00000000] eb79       jmp 00001e80
[00001e80][00103292][00000000] 33c0       xor eax,eax
[00001e82][00103296][00000018] 5d         pop ebp
[00001e83][0010329a][00000000] c3         ret
Number of Instructions Executed(16829) == 251 Pages

It is clearly a false negative.

Olcott defends a simulating halt decider H. The problem with it is,
that it introduces another halting problem: The H itself does not
halt when simulated by itself. This cause false negatives: many
functions are now diagnosed by H to be non-halting only by the mere
fact that they call H, even if their direct execution does halt.

Clearly you did not pay close enough attention to Mike Terry's
reply to you and/or you lack the required prerequisite skill
in the C programming language and/or the x86 language.

It never has mattered at all that HH(DD,DD) indirectly aborts
a simulation of itself by aborting its simulation of DD.

The directly executed HH sees that neither DD nor its simulation
of itself can possibly halt and that <is> its correct basis for
rejecting DD as non-halting.

It seems you are unable to read. I told you already that Mike's reply
has as a consequence that both HH and DD go in recursive recursion,
so, neither of them reaches its final state.

Try to show how the executed HH(DD,DD) that goes into a final state does
not go into a final state.

Change of subject. The *simulated* HH never reaches its final state. So,
if your simulating termination decider is correct, your HH has
non-halting behaviour.

*This unequivocally proves the behavior of DD correctly simulated by HH* https://liarparadox.org/DD_correctly_simulated_by_HH_is_Proven.pdf

There is no relation with the liar paradox. The simulation does not even process the part where DD contradicts HH.
The non-halting behaviour that HH reports, is a false negative, just as
in the case:

typedef int (*ptr)(); // ptr is pointer to int function in C

int H(ptr p, ptr i);

int main()
{
return H(main, 0);
}

Your logic claims that even the sentence "This is a sentence." is a lie.

--- SoupGate-Win32 v1.05
* Origin: fsxNet Usenet Gateway (21:1/5)

On 2024-06-05 13:49:47 +0000, olcott said:

On 6/5/2024 2:59 AM, Mikko wrote:

On 2024-06-04 16:46:21 +0000, Fred. Zwarts said:

Op 04.jun.2024 om 18:28 schreef olcott:

Heh Mike Terry, please study this to see your mistaken
conclusion of this post:

On 5/30/2024 3:51 PM, Mike Terry wrote:

On 30/05/2024 17:55, olcott wrote:

http://al.howardknight.net/?STYPE=msgid&MSGI=%3CS8CcnRadHexfe8X7nZ2dnZfqnPqdnZ2d%40brightview.co.uk%3E+

Message-ID: <S8CcnRadHexfe8X7nZ2dnZfqnPqdnZ2d@brightview.co.uk>

*Here is your mistaken conclusion*
On 5/30/2024 3:51 PM, Mike Terry wrote:

On 30/05/2024 17:55, olcott wrote:

That HH is not a pure function does not show that
the simulation is incorrect because:

It shows that the simulation is "rubbish" and any
trace produced by it can just be ignored.

Err, that's it.

Mike.

Proof that executed HH(DD,DD) and simulated HH(DD,DD) simulate DD
correctly. This proof requires expert knowledge of the C programming
language and the x86 programming language.

With this expertise it is easy to confirm that both the directly
executed HH(DD,DD) and the simulated executed HH(DD,DD) simulate the
steps of DD exactly the way that the x86 machine language specifies.

*New Paragraph inserted*
We can see that the pair of execution traces derived by the executed
HH(DD,DD) and the simulated HH(DD,DD) (shown below) exactly match
the x86 machine code of DD, (also shown below) thus are proven to be
correct.

If one also has expertise on the mapping from the C source code to the >>>> x86 assembly language then one also confirms that the x86 version of
DD is exactly what the C source-code specifies.

01   int DD(int (*x)())
02   {
03     int Halt_Status = HH(x, x);
04     if (Halt_Status)
05         HERE: goto HERE;
06     return Halt_Status;
07   }
08
09   int main()
10   {
11     Output("Input_Halts = ", HH(DD,DD));
12   }

_DD()
[00001db2] 55         push ebp
[00001db3] 8bec       mov ebp,esp
[00001db5] 51         push ecx
[00001db6] 8b4508     mov eax,[ebp+08]
[00001db9] 50         push eax        ; push DD
[00001dba] 8b4d08     mov ecx,[ebp+08]
[00001dbd] 51         push ecx        ; push DD
[00001dbe] e8bff5ffff call 00001382   ; call HH
[00001dc3] 83c408     add esp,+08
[00001dc6] 8945fc     mov [ebp-04],eax
[00001dc9] 837dfc00   cmp dword [ebp-04],+00
[00001dcd] 7402       jz 00001dd1
[00001dcf] ebfe       jmp 00001dcf
[00001dd1] 8b45fc     mov eax,[ebp-04]
[00001dd4] 8be5       mov esp,ebp
[00001dd6] 5d         pop ebp
[00001dd7] c3         ret
Size in bytes:(0038) [00001dd7]

 machine   stack     stack     machine    assembly
 address   address   data      code       language
 ========  ========  ========  =========  =============
[00001de2][00103292][00000000] 55         push ebp
[00001de3][00103292][00000000] 8bec       mov ebp,esp
[00001de5][0010328e][00001db2] 68b21d0000 push 00001db2 ; push DD
[00001dea][0010328a][00001db2] 68b21d0000 push 00001db2 ; push DD
[00001def][00103286][00001df4] e88ef5ffff call 00001382 ; call HH
New slave_stack at:103336

Begin Local Halt Decider Simulation   Execution Trace Stored at:11333e >>>> [00001db2][0011332a][0011332e] 55         push ebp         ; DD line 01
[00001db3][0011332a][0011332e] 8bec       mov ebp,esp      ; DD line 02
[00001db5][00113326][001032fa] 51         push ecx         ; DD line 03
[00001db6][00113326][001032fa] 8b4508     mov eax,[ebp+08] ; DD line 04
[00001db9][00113322][00001db2] 50         push eax         ; push DD
[00001dba][00113322][00001db2] 8b4d08     mov ecx,[ebp+08] ; DD line 06
[00001dbd][0011331e][00001db2] 51         push ecx         ; push DD
[00001dbe][0011331a][00001dc3] e8bff5ffff call 00001382    ; call HH >>>> New slave_stack at:14dd5e
[00001db2][0015dd52][0015dd56] 55         push ebp         ; DD line 01
[00001db3][0015dd52][0015dd56] 8bec       mov ebp,esp      ; DD line 02
[00001db5][0015dd4e][0014dd22] 51         push ecx         ; DD line 03
[00001db6][0015dd4e][0014dd22] 8b4508     mov eax,[ebp+08] ; DD line 04
[00001db9][0015dd4a][00001db2] 50         push eax         ; push DD
[00001dba][0015dd4a][00001db2] 8b4d08     mov ecx,[ebp+08] ; DD line 06
[00001dbd][0015dd46][00001db2] 51         push ecx         ; push DD
[00001dbe][0015dd42][00001dc3] e8bff5ffff call 00001382    ; call HH >>>> Local Halt Decider: Infinite Recursion Detected Simulation Stopped

[00001df4][00103292][00000000] 83c408     add esp,+08
[00001df7][0010328e][00000000] 50         push eax
[00001df8][0010328a][00000743] 6843070000 push 00000743
[00001dfd][0010328a][00000743] e8a0e9ffff call 000007a2
Input_Halts = 0
[00001e02][00103292][00000000] 83c408     add esp,+08
[00001e05][00103292][00000000] eb79       jmp 00001e80
[00001e80][00103292][00000000] 33c0       xor eax,eax
[00001e82][00103296][00000018] 5d         pop ebp
[00001e83][0010329a][00000000] c3         ret
Number of Instructions Executed(16829) == 251 Pages

This is a perfect example of a false negative. It is explained by the
following:

Olcott defends a simulating halt decider H. The problem with it is,
that it introduces another halting problem: The H itself does not halt
when simulated by itself. This causes false negatives: many functions
are now diagnosed by H to be non-halting only by the mere fact that
they call H, even if their direct execution does halt.

We see in olcott's example above that the simulation of H invokes a
recursive simulation of H.

H even diagnoses itself to be non-halting, which is illustrated in the
following example (where the D that contradicts H is eliminated):

        typedef int (*ptr)();  // ptr is pointer to int function in C

        int H(ptr p, ptr i);

        int main()
        {
          H(main, 0);
        }

That program does not tell what H says. You should instead say

int main()
{
 return H(main, 0);
}

so that the result is returned to the operating systems. Many operating
systems tell the value returned by main or they can be asked about it.

*I was surprised that this worked correctly: here are the details*

int main()
{
Output("Input_Halts = ", HH(main,(ptr)0));
}

machine stack stack machine assembly
address address data code language
======== ======== ======== ========= ============= [00001e42][00103375][00000000] 55 push ebp ; begin main [00001e43][00103375][00000000] 8bec mov ebp,esp [00001e45][00103371][00000000] 6a00 push +00 [00001e47][0010336d][00001e42] 68421e0000 push 00001e42 ; push main [00001e4c][00103369][00001e51] e831f5ffff call 00001382 ; call HH
New slave_stack at:103419

Begin Local Halt Decider Simulation Execution Trace Stored at:113421 [00001e42][0011340d][00113411] 55 push ebp ; begin main [00001e43][0011340d][00113411] 8bec mov ebp,esp [00001e45][00113409][00000000] 6a00 push +00 [00001e47][00113405][00001e42] 68421e0000 push 00001e42 ; push main [00001e4c][00113401][00001e51] e831f5ffff call 00001382 ; call HH
New slave_stack at:14de41
[00001e42][0015de35][0015de39] 55 push ebp ; begin main [00001e43][0015de35][0015de39] 8bec mov ebp,esp [00001e45][0015de31][00000000] 6a00 push +00 [00001e47][0015de2d][00001e42] 68421e0000 push 00001e42 ; push main [00001e4c][0015de29][00001e51] e831f5ffff call 00001382 ; call HH
Local Halt Decider: Infinite Recursion Detected Simulation Stopped

[00001e51][00103375][00000000] 83c408 add esp,+08 [00001e54][00103371][00000000] 50 push eax [00001e55][0010336d][00000743] 6843070000 push 00000743 [00001e5a][0010336d][00000743] e843e9ffff call 000007a2
Input_Halts = 0
[00001e5f][00103375][00000000] 83c408 add esp,+08 [00001e62][00103375][00000000] eb79 jmp 00001edd [00001edd][00103375][00000000] 33c0 xor eax,eax [00001edf][00103379][00000018] 5d pop ebp [00001ee0][0010337d][00000000] c3 ret ; end main
Number of Instructions Executed(12311) == 184 Pages

So main() does halt at its final state at [00001ee0] which proves
that the directly executed HH(main,(ptr)0) called by main() halts
and returns 0;

No, it only proves that HH halts. What it returns requires a different
proof.

--
Mikko

--- SoupGate-Win32 v1.05
* Origin: fsxNet Usenet Gateway (21:1/5)

On 2024-06-06 13:11:34 +0000, olcott said:

On 6/6/2024 3:21 AM, Mikko wrote:

On 2024-06-05 13:49:47 +0000, olcott said:

On 6/5/2024 2:59 AM, Mikko wrote:

On 2024-06-04 16:46:21 +0000, Fred. Zwarts said:

Op 04.jun.2024 om 18:28 schreef olcott:

Heh Mike Terry, please study this to see your mistaken
conclusion of this post:

On 5/30/2024 3:51 PM, Mike Terry wrote:

On 30/05/2024 17:55, olcott wrote:

http://al.howardknight.net/?STYPE=msgid&MSGI=%3CS8CcnRadHexfe8X7nZ2dnZfqnPqdnZ2d%40brightview.co.uk%3E+

Message-ID: <S8CcnRadHexfe8X7nZ2dnZfqnPqdnZ2d@brightview.co.uk>

*Here is your mistaken conclusion*
On 5/30/2024 3:51 PM, Mike Terry wrote:

On 30/05/2024 17:55, olcott wrote:

That HH is not a pure function does not show that
the simulation is incorrect because:

It shows that the simulation is "rubbish" and any
trace produced by it can just be ignored.

Err, that's it.

Mike.

Proof that executed HH(DD,DD) and simulated HH(DD,DD) simulate DD
correctly. This proof requires expert knowledge of the C programming >>>>>> language and the x86 programming language.

With this expertise it is easy to confirm that both the directly
executed HH(DD,DD) and the simulated executed HH(DD,DD) simulate the >>>>>> steps of DD exactly the way that the x86 machine language specifies. >>>>>>
*New Paragraph inserted*
We can see that the pair of execution traces derived by the executed >>>>>> HH(DD,DD) and the simulated HH(DD,DD) (shown below) exactly match
the x86 machine code of DD, (also shown below) thus are proven to be >>>>>> correct.

If one also has expertise on the mapping from the C source code to the >>>>>> x86 assembly language then one also confirms that the x86 version of >>>>>> DD is exactly what the C source-code specifies.

01   int DD(int (*x)())
02   {
03     int Halt_Status = HH(x, x);
04     if (Halt_Status)
05         HERE: goto HERE;
06     return Halt_Status;
07   }
08
09   int main()
10   {
11     Output("Input_Halts = ", HH(DD,DD));
12   }

_DD()
[00001db2] 55         push ebp
[00001db3] 8bec       mov ebp,esp
[00001db5] 51         push ecx
[00001db6] 8b4508     mov eax,[ebp+08]
[00001db9] 50         push eax        ; push DD
[00001dba] 8b4d08     mov ecx,[ebp+08]
[00001dbd] 51         push ecx        ; push DD
[00001dbe] e8bff5ffff call 00001382   ; call HH
[00001dc3] 83c408     add esp,+08
[00001dc6] 8945fc     mov [ebp-04],eax
[00001dc9] 837dfc00   cmp dword [ebp-04],+00
[00001dcd] 7402       jz 00001dd1
[00001dcf] ebfe       jmp 00001dcf
[00001dd1] 8b45fc     mov eax,[ebp-04]
[00001dd4] 8be5       mov esp,ebp
[00001dd6] 5d         pop ebp
[00001dd7] c3         ret
Size in bytes:(0038) [00001dd7]

 machine   stack     stack     machine    assembly
 address   address   data      code       language >>>>>>  ========  ========  ========  =========  =============
[00001de2][00103292][00000000] 55         push ebp
[00001de3][00103292][00000000] 8bec       mov ebp,esp
[00001de5][0010328e][00001db2] 68b21d0000 push 00001db2 ; push DD
[00001dea][0010328a][00001db2] 68b21d0000 push 00001db2 ; push DD
[00001def][00103286][00001df4] e88ef5ffff call 00001382 ; call HH
New slave_stack at:103336

Begin Local Halt Decider Simulation   Execution Trace Stored at:11333e >>>>>> [00001db2][0011332a][0011332e] 55         push ebp         ; DD line 01
[00001db3][0011332a][0011332e] 8bec       mov ebp,esp      ; DD line 02
[00001db5][00113326][001032fa] 51         push ecx         ; DD line 03
[00001db6][00113326][001032fa] 8b4508     mov eax,[ebp+08] ; DD line 04
[00001db9][00113322][00001db2] 50         push eax         ; push DD
[00001dba][00113322][00001db2] 8b4d08     mov ecx,[ebp+08] ; DD line 06
[00001dbd][0011331e][00001db2] 51         push ecx         ; push DD
[00001dbe][0011331a][00001dc3] e8bff5ffff call 00001382    ; call HH >>>>>> New slave_stack at:14dd5e
[00001db2][0015dd52][0015dd56] 55         push ebp         ; DD line 01
[00001db3][0015dd52][0015dd56] 8bec       mov ebp,esp      ; DD line 02
[00001db5][0015dd4e][0014dd22] 51         push ecx         ; DD line 03
[00001db6][0015dd4e][0014dd22] 8b4508     mov eax,[ebp+08] ; DD line 04
[00001db9][0015dd4a][00001db2] 50         push eax         ; push DD
[00001dba][0015dd4a][00001db2] 8b4d08     mov ecx,[ebp+08] ; DD line 06
[00001dbd][0015dd46][00001db2] 51         push ecx         ; push DD
[00001dbe][0015dd42][00001dc3] e8bff5ffff call 00001382    ; call HH >>>>>> Local Halt Decider: Infinite Recursion Detected Simulation Stopped >>>>>>
[00001df4][00103292][00000000] 83c408     add esp,+08
[00001df7][0010328e][00000000] 50         push eax
[00001df8][0010328a][00000743] 6843070000 push 00000743
[00001dfd][0010328a][00000743] e8a0e9ffff call 000007a2
Input_Halts = 0
[00001e02][00103292][00000000] 83c408     add esp,+08
[00001e05][00103292][00000000] eb79       jmp 00001e80
[00001e80][00103292][00000000] 33c0       xor eax,eax
[00001e82][00103296][00000018] 5d         pop ebp
[00001e83][0010329a][00000000] c3         ret
Number of Instructions Executed(16829) == 251 Pages

This is a perfect example of a false negative. It is explained by the >>>>> following:

Olcott defends a simulating halt decider H. The problem with it is,
that it introduces another halting problem: The H itself does not halt >>>>> when simulated by itself. This causes false negatives: many functions >>>>> are now diagnosed by H to be non-halting only by the mere fact that
they call H, even if their direct execution does halt.

We see in olcott's example above that the simulation of H invokes a
recursive simulation of H.

H even diagnoses itself to be non-halting, which is illustrated in the >>>>> following example (where the D that contradicts H is eliminated):

        typedef int (*ptr)();  // ptr is pointer to int function in C

        int H(ptr p, ptr i);

        int main()
        {
          H(main, 0);
        }

That program does not tell what H says. You should instead say

int main()
{
 return H(main, 0);
}

so that the result is returned to the operating systems. Many operating >>>> systems tell the value returned by main or they can be asked about it. >>>>

*I was surprised that this worked correctly: here are the details*

int main()
{
   Output("Input_Halts = ", HH(main,(ptr)0));
}

  machine   stack     stack     machine    assembly
  address   address   data      code       language
  ========  ========  ========  =========  =============
[00001e42][00103375][00000000] 55         push ebp      ; begin main
[00001e43][00103375][00000000] 8bec       mov ebp,esp
[00001e45][00103371][00000000] 6a00       push +00
[00001e47][0010336d][00001e42] 68421e0000 push 00001e42 ; push main
[00001e4c][00103369][00001e51] e831f5ffff call 00001382 ; call HH
New slave_stack at:103419

Begin Local Halt Decider Simulation   Execution Trace Stored at:113421 >>> [00001e42][0011340d][00113411] 55         push ebp      ; begin main
[00001e43][0011340d][00113411] 8bec       mov ebp,esp
[00001e45][00113409][00000000] 6a00       push +00
[00001e47][00113405][00001e42] 68421e0000 push 00001e42 ; push main
[00001e4c][00113401][00001e51] e831f5ffff call 00001382 ; call HH
New slave_stack at:14de41
[00001e42][0015de35][0015de39] 55         push ebp      ; begin main
[00001e43][0015de35][0015de39] 8bec       mov ebp,esp
[00001e45][0015de31][00000000] 6a00       push +00
[00001e47][0015de2d][00001e42] 68421e0000 push 00001e42 ; push main
[00001e4c][0015de29][00001e51] e831f5ffff call 00001382 ; call HH
Local Halt Decider: Infinite Recursion Detected Simulation Stopped

[00001e51][00103375][00000000] 83c408     add esp,+08
[00001e54][00103371][00000000] 50         push eax
[00001e55][0010336d][00000743] 6843070000 push 00000743
[00001e5a][0010336d][00000743] e843e9ffff call 000007a2
Input_Halts = 0
[00001e5f][00103375][00000000] 83c408     add esp,+08
[00001e62][00103375][00000000] eb79       jmp 00001edd
[00001edd][00103375][00000000] 33c0       xor eax,eax
[00001edf][00103379][00000018] 5d         pop ebp
[00001ee0][0010337d][00000000] c3         ret           ; end main
Number of Instructions Executed(12311) == 184 Pages

So main() does halt at its final state at [00001ee0] which proves
that the directly executed HH(main,(ptr)0) called by main() halts
and returns 0;

No, it only proves that HH halts. What it returns requires a different
proof.

Your example was too difficult for you to correctly understand.
Here is a simpler example.

That is no reason to say anything obviously false. If something
is too difficult then you may point out the difficult part and
ask what it means. Parhaps there is just some presentational
problems but some things really are difficult to understand. Most
things discussed here are not very difficult but sometines poorly
presented.

*THE MOST IMPORTANT ASPECT OF MY PROOF*
*THE MOST IMPORTANT ASPECT OF MY PROOF*
*THE MOST IMPORTANT ASPECT OF MY PROOF*

Try any show how this DD can be correctly simulated by any HH
such that this DD reaches past its machine address [00001dbe]

_DD()
[00001e12] 55 push ebp
[00001e13] 8bec mov ebp,esp
[00001e15] 51 push ecx
[00001e16] 8b4508 mov eax,[ebp+08]
[00001e19] 50 push eax ; push DD
[00001e1a] 8b4d08 mov ecx,[ebp+08]
[00001e1d] 51 push ecx ; push DD
[00001e1e] e85ff5ffff call 00001382 ; call HH

*Mike Terry would admit it if he would pay attention*
*He is not a liar*

*This unequivocally proves the behavior of DD correctly simulated by HH* https://liarparadox.org/DD_correctly_simulated_by_HH_is_Proven.pdf

If it is important you must carfully cehck that it is presented
so that what is understood is what you want say.

--
Mikko

--- SoupGate-Win32 v1.05
* Origin: fsxNet Usenet Gateway (21:1/5)

On 6/6/24 9:11 AM, olcott wrote:

On 6/6/2024 3:21 AM, Mikko wrote:

On 2024-06-05 13:49:47 +0000, olcott said:

On 6/5/2024 2:59 AM, Mikko wrote:

On 2024-06-04 16:46:21 +0000, Fred. Zwarts said:

Op 04.jun.2024 om 18:28 schreef olcott:

Heh Mike Terry, please study this to see your mistaken
conclusion of this post:

On 5/30/2024 3:51 PM, Mike Terry wrote:

On 30/05/2024 17:55, olcott wrote:

http://al.howardknight.net/?STYPE=msgid&MSGI=%3CS8CcnRadHexfe8X7nZ2dnZfqnPqdnZ2d%40brightview.co.uk%3E+
Message-ID: <S8CcnRadHexfe8X7nZ2dnZfqnPqdnZ2d@brightview.co.uk>

*Here is your mistaken conclusion*
On 5/30/2024 3:51 PM, Mike Terry wrote:

On 30/05/2024 17:55, olcott wrote:

That HH is not a pure function does not show that
the simulation is incorrect because:

It shows that the simulation is "rubbish" and any
trace produced by it can just be ignored.

Err, that's it.

Mike.

Proof that executed HH(DD,DD) and simulated HH(DD,DD) simulate DD
correctly. This proof requires expert knowledge of the C programming >>>>>> language and the x86 programming language.

With this expertise it is easy to confirm that both the directly
executed HH(DD,DD) and the simulated executed HH(DD,DD) simulate the >>>>>> steps of DD exactly the way that the x86 machine language specifies. >>>>>>
*New Paragraph inserted*
We can see that the pair of execution traces derived by the executed >>>>>> HH(DD,DD) and the simulated HH(DD,DD) (shown below) exactly match
the x86 machine code of DD, (also shown below) thus are proven to be >>>>>> correct.

If one also has expertise on the mapping from the C source code to >>>>>> the
x86 assembly language then one also confirms that the x86 version of >>>>>> DD is exactly what the C source-code specifies.

01   int DD(int (*x)())
02   {
03     int Halt_Status = HH(x, x);
04     if (Halt_Status)
05         HERE: goto HERE;
06     return Halt_Status;
07   }
08
09   int main()
10   {
11     Output("Input_Halts = ", HH(DD,DD));
12   }

_DD()
[00001db2] 55         push ebp
[00001db3] 8bec       mov ebp,esp
[00001db5] 51         push ecx
[00001db6] 8b4508     mov eax,[ebp+08]
[00001db9] 50         push eax        ; push DD
[00001dba] 8b4d08     mov ecx,[ebp+08]
[00001dbd] 51         push ecx        ; push DD
[00001dbe] e8bff5ffff call 00001382   ; call HH
[00001dc3] 83c408     add esp,+08
[00001dc6] 8945fc     mov [ebp-04],eax
[00001dc9] 837dfc00   cmp dword [ebp-04],+00
[00001dcd] 7402       jz 00001dd1
[00001dcf] ebfe       jmp 00001dcf
[00001dd1] 8b45fc     mov eax,[ebp-04]
[00001dd4] 8be5       mov esp,ebp
[00001dd6] 5d         pop ebp
[00001dd7] c3         ret
Size in bytes:(0038) [00001dd7]

 machine   stack     stack     machine    assembly
 address   address   data      code       language >>>>>>  ========  ========  ========  =========  =============
[00001de2][00103292][00000000] 55         push ebp
[00001de3][00103292][00000000] 8bec       mov ebp,esp
[00001de5][0010328e][00001db2] 68b21d0000 push 00001db2 ; push DD
[00001dea][0010328a][00001db2] 68b21d0000 push 00001db2 ; push DD
[00001def][00103286][00001df4] e88ef5ffff call 00001382 ; call HH
New slave_stack at:103336

Begin Local Halt Decider Simulation   Execution Trace Stored
at:11333e
[00001db2][0011332a][0011332e] 55         push ebp         ; DD
line 01
[00001db3][0011332a][0011332e] 8bec       mov ebp,esp      ; DD
line 02
[00001db5][00113326][001032fa] 51         push ecx         ; DD
line 03
[00001db6][00113326][001032fa] 8b4508     mov eax,[ebp+08] ; DD >>>>>> line 04
[00001db9][00113322][00001db2] 50         push eax         ; push DD
[00001dba][00113322][00001db2] 8b4d08     mov ecx,[ebp+08] ; DD >>>>>> line 06
[00001dbd][0011331e][00001db2] 51         push ecx         ; push DD
[00001dbe][0011331a][00001dc3] e8bff5ffff call 00001382    ; call HH >>>>>> New slave_stack at:14dd5e
[00001db2][0015dd52][0015dd56] 55         push ebp         ; DD
line 01
[00001db3][0015dd52][0015dd56] 8bec       mov ebp,esp      ; DD
line 02
[00001db5][0015dd4e][0014dd22] 51         push ecx         ; DD
line 03
[00001db6][0015dd4e][0014dd22] 8b4508     mov eax,[ebp+08] ; DD >>>>>> line 04
[00001db9][0015dd4a][00001db2] 50         push eax         ; push DD
[00001dba][0015dd4a][00001db2] 8b4d08     mov ecx,[ebp+08] ; DD >>>>>> line 06
[00001dbd][0015dd46][00001db2] 51         push ecx         ; push DD
[00001dbe][0015dd42][00001dc3] e8bff5ffff call 00001382    ; call HH >>>>>> Local Halt Decider: Infinite Recursion Detected Simulation Stopped >>>>>>
[00001df4][00103292][00000000] 83c408     add esp,+08
[00001df7][0010328e][00000000] 50         push eax
[00001df8][0010328a][00000743] 6843070000 push 00000743
[00001dfd][0010328a][00000743] e8a0e9ffff call 000007a2
Input_Halts = 0
[00001e02][00103292][00000000] 83c408     add esp,+08
[00001e05][00103292][00000000] eb79       jmp 00001e80
[00001e80][00103292][00000000] 33c0       xor eax,eax
[00001e82][00103296][00000018] 5d         pop ebp
[00001e83][0010329a][00000000] c3         ret
Number of Instructions Executed(16829) == 251 Pages

This is a perfect example of a false negative. It is explained by
the following:

Olcott defends a simulating halt decider H. The problem with it is,
that it introduces another halting problem: The H itself does not
halt when simulated by itself. This causes false negatives: many
functions are now diagnosed by H to be non-halting only by the mere
fact that they call H, even if their direct execution does halt.

We see in olcott's example above that the simulation of H invokes a
recursive simulation of H.

H even diagnoses itself to be non-halting, which is illustrated in
the following example (where the D that contradicts H is eliminated): >>>>>
        typedef int (*ptr)();  // ptr is pointer to int function in C

        int H(ptr p, ptr i);

        int main()
        {
          H(main, 0);
        }

That program does not tell what H says. You should instead say

int main()
{
 return H(main, 0);
}

so that the result is returned to the operating systems. Many operating >>>> systems tell the value returned by main or they can be asked about it. >>>>

*I was surprised that this worked correctly: here are the details*

int main()
{
   Output("Input_Halts = ", HH(main,(ptr)0));
}

  machine   stack     stack     machine    assembly
  address   address   data      code       language
  ========  ========  ========  =========  =============
[00001e42][00103375][00000000] 55         push ebp      ; begin main
[00001e43][00103375][00000000] 8bec       mov ebp,esp
[00001e45][00103371][00000000] 6a00       push +00
[00001e47][0010336d][00001e42] 68421e0000 push 00001e42 ; push main
[00001e4c][00103369][00001e51] e831f5ffff call 00001382 ; call HH
New slave_stack at:103419

Begin Local Halt Decider Simulation   Execution Trace Stored at:113421 >>> [00001e42][0011340d][00113411] 55         push ebp      ; begin main
[00001e43][0011340d][00113411] 8bec       mov ebp,esp
[00001e45][00113409][00000000] 6a00       push +00
[00001e47][00113405][00001e42] 68421e0000 push 00001e42 ; push main
[00001e4c][00113401][00001e51] e831f5ffff call 00001382 ; call HH
New slave_stack at:14de41
[00001e42][0015de35][0015de39] 55         push ebp      ; begin main
[00001e43][0015de35][0015de39] 8bec       mov ebp,esp
[00001e45][0015de31][00000000] 6a00       push +00
[00001e47][0015de2d][00001e42] 68421e0000 push 00001e42 ; push main
[00001e4c][0015de29][00001e51] e831f5ffff call 00001382 ; call HH
Local Halt Decider: Infinite Recursion Detected Simulation Stopped

[00001e51][00103375][00000000] 83c408     add esp,+08
[00001e54][00103371][00000000] 50         push eax
[00001e55][0010336d][00000743] 6843070000 push 00000743
[00001e5a][0010336d][00000743] e843e9ffff call 000007a2
Input_Halts = 0
[00001e5f][00103375][00000000] 83c408     add esp,+08
[00001e62][00103375][00000000] eb79       jmp 00001edd
[00001edd][00103375][00000000] 33c0       xor eax,eax
[00001edf][00103379][00000018] 5d         pop ebp
[00001ee0][0010337d][00000000] c3         ret           ; end main
Number of Instructions Executed(12311) == 184 Pages

So main() does halt at its final state at [00001ee0] which proves
that the directly executed HH(main,(ptr)0) called by main() halts
and returns 0;

No, it only proves that HH halts. What it returns requires a different
proof.

Your example was too difficult for you to correctly understand.
Here is a simpler example.

*THE MOST IMPORTANT ASPECT OF MY PROOF*
*THE MOST IMPORTANT ASPECT OF MY PROOF*
*THE MOST IMPORTANT ASPECT OF MY PROOF*

Try any show how this DD can be correctly simulated by any HH
such that this DD reaches past its machine address [00001dbe]

But, as I said, I won't acknowledge that you are correct, because I am
not willing to put that effort into your worthless claim.

Since partial simulations, or simulation of a different input, don't
prove non-halting behavior of this input, it just doesn't matter.

So, I guess we are stuck until you just die of your cancer.

I am going to take your just repeating of what I have said is worthless
as an admission that you can't think of any way to show that it actually
means something, your admission that this is just the strawman that you
"proof" has been based on for years, that doesn't actually prove what
you claim.

If this statement is the "Most Important" part of your proof, that
doesn't say much, since you can't show that it actually means anything.

_DD()
[00001e12] 55         push ebp
[00001e13] 8bec       mov  ebp,esp
[00001e15] 51         push ecx
[00001e16] 8b4508     mov  eax,[ebp+08]
[00001e19] 50         push eax      ; push DD
[00001e1a] 8b4d08     mov  ecx,[ebp+08]
[00001e1d] 51         push ecx      ; push DD
[00001e1e] e85ff5ffff call 00001382 ; call HH

*Mike Terry would admit it if he would pay attention*
*He is not a liar*

*This unequivocally proves the behavior of DD correctly simulated by HH* https://liarparadox.org/DD_correctly_simulated_by_HH_is_Proven.pdf

--- SoupGate-Win32 v1.05
* Origin: fsxNet Usenet Gateway (21:1/5)

On 2024-06-06 15:06:22 +0000, olcott said:

On 6/6/2024 9:51 AM, Mikko wrote:

On 2024-06-06 13:11:34 +0000, olcott said:

On 6/6/2024 3:21 AM, Mikko wrote:

On 2024-06-05 13:49:47 +0000, olcott said:

On 6/5/2024 2:59 AM, Mikko wrote:

On 2024-06-04 16:46:21 +0000, Fred. Zwarts said:

Op 04.jun.2024 om 18:28 schreef olcott:

Heh Mike Terry, please study this to see your mistaken
conclusion of this post:

On 5/30/2024 3:51 PM, Mike Terry wrote:

On 30/05/2024 17:55, olcott wrote:

http://al.howardknight.net/?STYPE=msgid&MSGI=%3CS8CcnRadHexfe8X7nZ2dnZfqnPqdnZ2d%40brightview.co.uk%3E+

Message-ID: <S8CcnRadHexfe8X7nZ2dnZfqnPqdnZ2d@brightview.co.uk> >>>>>>>>
*Here is your mistaken conclusion*
On 5/30/2024 3:51 PM, Mike Terry wrote:

On 30/05/2024 17:55, olcott wrote:

That HH is not a pure function does not show that
the simulation is incorrect because:

It shows that the simulation is "rubbish" and any
trace produced by it can just be ignored.

Err, that's it.

Mike.

Proof that executed HH(DD,DD) and simulated HH(DD,DD) simulate DD >>>>>>>> correctly. This proof requires expert knowledge of the C programming >>>>>>>> language and the x86 programming language.

With this expertise it is easy to confirm that both the directly >>>>>>>> executed HH(DD,DD) and the simulated executed HH(DD,DD) simulate the >>>>>>>> steps of DD exactly the way that the x86 machine language specifies. >>>>>>>>
*New Paragraph inserted*
We can see that the pair of execution traces derived by the executed >>>>>>>> HH(DD,DD) and the simulated HH(DD,DD) (shown below) exactly match >>>>>>>> the x86 machine code of DD, (also shown below) thus are proven to be >>>>>>>> correct.

If one also has expertise on the mapping from the C source code to the >>>>>>>> x86 assembly language then one also confirms that the x86 version of >>>>>>>> DD is exactly what the C source-code specifies.

01   int DD(int (*x)())
02   {
03     int Halt_Status = HH(x, x);
04     if (Halt_Status)
05         HERE: goto HERE;
06     return Halt_Status;
07   }
08
09   int main()
10   {
11     Output("Input_Halts = ", HH(DD,DD));
12   }

_DD()
[00001db2] 55         push ebp
[00001db3] 8bec       mov ebp,esp
[00001db5] 51         push ecx
[00001db6] 8b4508     mov eax,[ebp+08]
[00001db9] 50         push eax        ; push DD >>>>>>>> [00001dba] 8b4d08     mov ecx,[ebp+08]
[00001dbd] 51         push ecx        ; push DD >>>>>>>> [00001dbe] e8bff5ffff call 00001382   ; call HH
[00001dc3] 83c408     add esp,+08
[00001dc6] 8945fc     mov [ebp-04],eax
[00001dc9] 837dfc00   cmp dword [ebp-04],+00
[00001dcd] 7402       jz 00001dd1
[00001dcf] ebfe       jmp 00001dcf
[00001dd1] 8b45fc     mov eax,[ebp-04]
[00001dd4] 8be5       mov esp,ebp
[00001dd6] 5d         pop ebp
[00001dd7] c3         ret
Size in bytes:(0038) [00001dd7]

 machine   stack     stack     machine    assembly >>>>>>>>  address   address   data      code       language >>>>>>>>  ========  ========  ========  =========  =============
[00001de2][00103292][00000000] 55         push ebp
[00001de3][00103292][00000000] 8bec       mov ebp,esp
[00001de5][0010328e][00001db2] 68b21d0000 push 00001db2 ; push DD >>>>>>>> [00001dea][0010328a][00001db2] 68b21d0000 push 00001db2 ; push DD >>>>>>>> [00001def][00103286][00001df4] e88ef5ffff call 00001382 ; call HH >>>>>>>> New slave_stack at:103336

Begin Local Halt Decider Simulation   Execution Trace Stored at:11333e
[00001db2][0011332a][0011332e] 55         push ebp         ; DD line 01
[00001db3][0011332a][0011332e] 8bec       mov ebp,esp      ; DD line 02
[00001db5][00113326][001032fa] 51         push ecx         ; DD line 03
[00001db6][00113326][001032fa] 8b4508     mov eax,[ebp+08] ; DD line 04
[00001db9][00113322][00001db2] 50         push eax         ; push DD
[00001dba][00113322][00001db2] 8b4d08     mov ecx,[ebp+08] ; DD line 06
[00001dbd][0011331e][00001db2] 51         push ecx         ; push DD
[00001dbe][0011331a][00001dc3] e8bff5ffff call 00001382    ; call HH
New slave_stack at:14dd5e
[00001db2][0015dd52][0015dd56] 55         push ebp         ; DD line 01
[00001db3][0015dd52][0015dd56] 8bec       mov ebp,esp      ; DD line 02
[00001db5][0015dd4e][0014dd22] 51         push ecx         ; DD line 03
[00001db6][0015dd4e][0014dd22] 8b4508     mov eax,[ebp+08] ; DD line 04
[00001db9][0015dd4a][00001db2] 50         push eax         ; push DD
[00001dba][0015dd4a][00001db2] 8b4d08     mov ecx,[ebp+08] ; DD line 06
[00001dbd][0015dd46][00001db2] 51         push ecx         ; push DD
[00001dbe][0015dd42][00001dc3] e8bff5ffff call 00001382    ; call HH
Local Halt Decider: Infinite Recursion Detected Simulation Stopped >>>>>>>>
[00001df4][00103292][00000000] 83c408     add esp,+08
[00001df7][0010328e][00000000] 50         push eax
[00001df8][0010328a][00000743] 6843070000 push 00000743
[00001dfd][0010328a][00000743] e8a0e9ffff call 000007a2
Input_Halts = 0
[00001e02][00103292][00000000] 83c408     add esp,+08
[00001e05][00103292][00000000] eb79       jmp 00001e80
[00001e80][00103292][00000000] 33c0       xor eax,eax
[00001e82][00103296][00000018] 5d         pop ebp
[00001e83][0010329a][00000000] c3         ret
Number of Instructions Executed(16829) == 251 Pages

This is a perfect example of a false negative. It is explained by the >>>>>>> following:

Olcott defends a simulating halt decider H. The problem with it is, >>>>>>> that it introduces another halting problem: The H itself does not halt >>>>>>> when simulated by itself. This causes false negatives: many functions >>>>>>> are now diagnosed by H to be non-halting only by the mere fact that >>>>>>> they call H, even if their direct execution does halt.

We see in olcott's example above that the simulation of H invokes a >>>>>>> recursive simulation of H.

H even diagnoses itself to be non-halting, which is illustrated in the >>>>>>> following example (where the D that contradicts H is eliminated): >>>>>>>
        typedef int (*ptr)();  // ptr is pointer to int function in C

        int H(ptr p, ptr i);

        int main()
        {
          H(main, 0);
        }

That program does not tell what H says. You should instead say

int main()
{
 return H(main, 0);
}

so that the result is returned to the operating systems. Many operating >>>>>> systems tell the value returned by main or they can be asked about it. >>>>>>

*I was surprised that this worked correctly: here are the details*

int main()
{
   Output("Input_Halts = ", HH(main,(ptr)0));
}

  machine   stack     stack     machine    assembly
  address   address   data      code       language
  ========  ========  ========  =========  =============
[00001e42][00103375][00000000] 55         push ebp      ; begin main
[00001e43][00103375][00000000] 8bec       mov ebp,esp
[00001e45][00103371][00000000] 6a00       push +00
[00001e47][0010336d][00001e42] 68421e0000 push 00001e42 ; push main
[00001e4c][00103369][00001e51] e831f5ffff call 00001382 ; call HH
New slave_stack at:103419

Begin Local Halt Decider Simulation   Execution Trace Stored at:113421 >>>>> [00001e42][0011340d][00113411] 55         push ebp      ; begin main
[00001e43][0011340d][00113411] 8bec       mov ebp,esp
[00001e45][00113409][00000000] 6a00       push +00
[00001e47][00113405][00001e42] 68421e0000 push 00001e42 ; push main
[00001e4c][00113401][00001e51] e831f5ffff call 00001382 ; call HH
New slave_stack at:14de41
[00001e42][0015de35][0015de39] 55         push ebp      ; begin main
[00001e43][0015de35][0015de39] 8bec       mov ebp,esp
[00001e45][0015de31][00000000] 6a00       push +00
[00001e47][0015de2d][00001e42] 68421e0000 push 00001e42 ; push main
[00001e4c][0015de29][00001e51] e831f5ffff call 00001382 ; call HH
Local Halt Decider: Infinite Recursion Detected Simulation Stopped

[00001e51][00103375][00000000] 83c408     add esp,+08
[00001e54][00103371][00000000] 50         push eax
[00001e55][0010336d][00000743] 6843070000 push 00000743
[00001e5a][0010336d][00000743] e843e9ffff call 000007a2
Input_Halts = 0
[00001e5f][00103375][00000000] 83c408     add esp,+08
[00001e62][00103375][00000000] eb79       jmp 00001edd
[00001edd][00103375][00000000] 33c0       xor eax,eax
[00001edf][00103379][00000018] 5d         pop ebp
[00001ee0][0010337d][00000000] c3         ret           ; end main
Number of Instructions Executed(12311) == 184 Pages

So main() does halt at its final state at [00001ee0] which proves
that the directly executed HH(main,(ptr)0) called by main() halts
and returns 0;

No, it only proves that HH halts. What it returns requires a different >>>> proof.

Your example was too difficult for you to correctly understand.
Here is a simpler example.

That is no reason to say anything obviously false. If something
is too difficult then you may point out the difficult part and
ask what it means. Parhaps there is just some presentational
problems but some things really are difficult to understand. Most
things discussed here are not very difficult but sometines poorly
presented.

*THE MOST IMPORTANT ASPECT OF MY PROOF*
*THE MOST IMPORTANT ASPECT OF MY PROOF*
*THE MOST IMPORTANT ASPECT OF MY PROOF*

Try any show how this DD can be correctly simulated by any HH
such that this DD reaches past its machine address [00001dbe]

_DD()
[00001e12] 55         push ebp
[00001e13] 8bec       mov  ebp,esp
[00001e15] 51         push ecx
[00001e16] 8b4508     mov  eax,[ebp+08]
[00001e19] 50         push eax      ; push DD
[00001e1a] 8b4d08     mov  ecx,[ebp+08]
[00001e1d] 51         push ecx      ; push DD
[00001e1e] e85ff5ffff call 00001382 ; call HH

*Mike Terry would admit it if he would pay attention*
*He is not a liar*

*This unequivocally proves the behavior of DD correctly simulated by HH* >>> https://liarparadox.org/DD_correctly_simulated_by_HH_is_Proven.pdf

If it is important you must carfully cehck that it is presented
so that what is understood is what you want say.

<Professor Sipser agreed>
If simulating halt decider H correctly simulates its input D
until H correctly determines that its simulated D would never
stop running unless aborted then

H can abort its simulation of D and correctly report that D
specifies a non-halting sequence of configurations.
</Professor Sipser agreed>

// Simplified Linz Ĥ (Linz:1990:319)
// Strachey(1965) CPL translated to C
void P(u32 x)
{
if (H(x, x))
HERE: goto HERE;
}

People here that are experts in the C programming language know that
*P correctly simulated by H cannot possibly stop running unless aborted*
yet lie about this or to try to get away with the strawman deception CHANGE-THE-SUBJECT fake rebuttal.

People here who have recently followed these discussions know that "P
correctly simulated by H cannot possibly stop running unless aborted"
does not confirm or contradict anything Linz and Strachey have said.

--
Mikko

--- SoupGate-Win32 v1.05
* Origin: fsxNet Usenet Gateway (21:1/5)

XPost: sci.logic

On 6/7/24 9:49 AM, olcott wrote:

On 6/7/2024 12:49 AM, Mikko wrote:

On 2024-06-06 15:06:22 +0000, olcott said:

<Professor Sipser agreed>
   If simulating halt decider H correctly simulates its input D
   until H correctly determines that its simulated D would never
   stop running unless aborted then

   H can abort its simulation of D and correctly report that D
   specifies a non-halting sequence of configurations.
</Professor Sipser agreed>

// Simplified Linz Ĥ (Linz:1990:319)
// Strachey(1965) CPL translated to C
void P(u32 x)
{
   if (H(x, x))
     HERE: goto HERE;
}

People here that are experts in the C programming language know that
*P correctly simulated by H cannot possibly stop running unless aborted* >>> yet lie about this or to try to get away with the strawman deception
CHANGE-THE-SUBJECT fake rebuttal.

People here who have recently followed these discussions know that "P
correctly simulated by H cannot possibly stop running unless aborted"
does not confirm or contradict anything Linz and Strachey have said.

When P correctly simulated by H meets this criteria
  If simulating halt decider H correctly simulates its input P
  until H correctly determines that its simulated P would never
  stop running unless aborted then

  H can abort its simulation of P and correctly report that P
  specifies a non-halting sequence of configurations.

Which since in THAT statement "Correctly Simulated" means a simulation
that doesn't stop until it reaches a final state, it is clear that H
never does a correct simulation, so the by H CAN'T be true (and H answer non-halting) and H can't even determine the behavior of any correct
simulation, but only bases is INCORRECT decision on something not
established by that sentence.

My first paper in simulating halt deciders has all of the details
including showing the execution trace of P correctly simulated
by H proves a repeating state thus meets the above criteria:

Begin Local Halt Decider Simulation at Machine Address:c36
 machine   stack     stack     machine    assembly
 address   address   data      code       language
 ========  ========  ========  =========  ============= [00000c36][002117ca][002117ce] 55          push ebp [00000c37][002117ca][002117ce] 8bec        mov ebp,esp [00000c39][002117ca][002117ce] 8b4508      mov eax,[ebp+08] [00000c3c][002117c6][00000c36] 50          push eax       // push P
[00000c3d][002117c6][00000c36] 8b4d08      mov ecx,[ebp+08] [00000c40][002117c2][00000c36] 51          push ecx       // push P
[00000c41][002117be][00000c46] e820fdffff  call 00000966  // call H(P,P)

[00000c36][0025c1f2][0025c1f6] 55          push ebp [00000c37][0025c1f2][0025c1f6] 8bec        mov ebp,esp [00000c39][0025c1f2][0025c1f6] 8b4508      mov eax,[ebp+08] [00000c3c][0025c1ee][00000c36] 50          push eax       // push P
[00000c3d][0025c1ee][00000c36] 8b4d08      mov ecx,[ebp+08] [00000c40][0025c1ea][00000c36] 51          push ecx       // push P
[00000c41][0025c1e6][00000c46] e820fdffff  call 00000966  // call H(P,P) Local Halt Decider: Infinite Recursion Detected Simulation Stopped

*Halting problem undecidability and infinitely nested simulation* https://www.researchgate.net/publication/351947980_Halting_problem_undecidability_and_infinitely_nested_simulation

--- SoupGate-Win32 v1.05
* Origin: fsxNet Usenet Gateway (21:1/5)

On 2024-06-07 13:49:09 +0000, olcott said:

On 6/7/2024 12:49 AM, Mikko wrote:

On 2024-06-06 15:06:22 +0000, olcott said:

<Professor Sipser agreed>
   If simulating halt decider H correctly simulates its input D
   until H correctly determines that its simulated D would never
   stop running unless aborted then

   H can abort its simulation of D and correctly report that D
   specifies a non-halting sequence of configurations.
</Professor Sipser agreed>

// Simplified Linz Ĥ (Linz:1990:319)
// Strachey(1965) CPL translated to C
void P(u32 x)
{
   if (H(x, x))
     HERE: goto HERE;
}

People here that are experts in the C programming language know that
*P correctly simulated by H cannot possibly stop running unless aborted* >>> yet lie about this or to try to get away with the strawman deception
CHANGE-THE-SUBJECT fake rebuttal.

People here who have recently followed these discussions know that "P
correctly simulated by H cannot possibly stop running unless aborted"
does not confirm or contradict anything Linz and Strachey have said.

When P correctly simulated by H meets this criteria
If simulating halt decider H correctly simulates its input P
until H correctly determines that its simulated P would never
stop running unless aborted then

Still unproven whther P ever meets those criteria, in particular
the last "correctly".

H can abort its simulation of P and correctly report that P
specifies a non-halting sequence of configurations.

My first paper in simulating halt deciders has all of the details
including showing the execution trace of P correctly simulated
by H proves a repeating state thus meets the above criteria:

Begin Local Halt Decider Simulation at Machine Address:c36
machine stack stack machine assembly
address address data code language
======== ======== ======== ========= ============= [00000c36][002117ca][002117ce] 55 push ebp [00000c37][002117ca][002117ce] 8bec mov ebp,esp [00000c39][002117ca][002117ce] 8b4508 mov eax,[ebp+08] [00000c3c][002117c6][00000c36] 50 push eax // push P [00000c3d][002117c6][00000c36] 8b4d08 mov ecx,[ebp+08] [00000c40][002117c2][00000c36] 51 push ecx // push P [00000c41][002117be][00000c46] e820fdffff call 00000966 // call H(P,P)

[00000c36][0025c1f2][0025c1f6] 55 push ebp [00000c37][0025c1f2][0025c1f6] 8bec mov ebp,esp [00000c39][0025c1f2][0025c1f6] 8b4508 mov eax,[ebp+08] [00000c3c][0025c1ee][00000c36] 50 push eax // push P [00000c3d][0025c1ee][00000c36] 8b4d08 mov ecx,[ebp+08] [00000c40][0025c1ea][00000c36] 51 push ecx // push P [00000c41][0025c1e6][00000c46] e820fdffff call 00000966 // call H(P,P) Local Halt Decider: Infinite Recursion Detected Simulation Stopped

*Halting problem undecidability and infinitely nested simulation* https://www.researchgate.net/publication/351947980_Halting_problem_undecidability_and_infinitely_nested_simulation

--
Mikko

--- SoupGate-Win32 v1.05
* Origin: fsxNet Usenet Gateway (21:1/5)

On 6/8/24 8:25 AM, olcott wrote:

On 6/8/2024 12:43 AM, Mikko wrote:

On 2024-06-07 13:49:09 +0000, olcott said:

On 6/7/2024 12:49 AM, Mikko wrote:

On 2024-06-06 15:06:22 +0000, olcott said:

<Professor Sipser agreed>
   If simulating halt decider H correctly simulates its input D
   until H correctly determines that its simulated D would never
   stop running unless aborted then

   H can abort its simulation of D and correctly report that D
   specifies a non-halting sequence of configurations.
</Professor Sipser agreed>

// Simplified Linz Ĥ (Linz:1990:319)
// Strachey(1965) CPL translated to C
void P(u32 x)
{
   if (H(x, x))
     HERE: goto HERE;
}

People here that are experts in the C programming language know that >>>>> *P correctly simulated by H cannot possibly stop running unless
aborted*
yet lie about this or to try to get away with the strawman deception >>>>> CHANGE-THE-SUBJECT fake rebuttal.

People here who have recently followed these discussions know that "P
correctly simulated by H cannot possibly stop running unless aborted"
does not confirm or contradict anything Linz and Strachey have said.

When P correctly simulated by H meets this criteria
   If simulating halt decider H correctly simulates its input P
   until H correctly determines that its simulated P would never
   stop running unless aborted then

Still unproven whther P ever meets those criteria, in particular
the last "correctly".

That you lack the mandatory prerequisite knowledge to understand
that this is correct provided zero evidence that this is incorrect.

Just shows you don't understand logic,

NOTHING is established by the fact that you have no evidence that it is incorrect, for lack of evidence is NOT evidence of lack.

So, YOU seem to lack the mandatory prerequisite knowledge of how logic
works to create a real proof.

I incorporate by reference
(a) The x86 language
(b) The notion of an x86 emulator

(c) I provide this complete function

So?

void DDD(int (*x)())
{
  HH(x, x);
}

_DDD()
[00001de2] 55         push ebp
[00001de3] 8bec       mov ebp,esp
[00001de5] 8b4508     mov eax,[ebp+08]
[00001de8] 50         push eax         ; push DD
[00001de9] 8b4d08     mov ecx,[ebp+08]
[00001dec] 51         push ecx         ; push DD
[00001ded] e890f5ffff call 00001382    ; call HH
[00001df2] 83c408     add esp,+08
[00001df5] 5d         pop ebp
[00001df6] c3         ret
Size in bytes:(0021) [00001df6]

Then I state that No DDD correctly emulated by any
x86 emulator H can possibly reach its own [00001df6]
instruction.

Which just proves you don't understand what a proof is.

To anyone having this mandatory prerequisite knowledge
(perhaps not you) every x86 emulation of DDD by any
x86 emulator H continually repeats the first seven lines
of DDD until it crashes due to out-of-memory error.

Which means you just proved that NO HH that meets your requirements can
ever give an answer for this question.

You Claim this not to be true, so that just shows that your system is self-contradictory.

And the apparent issue is that you are changing your definition of
"Correct Simulation" between the two.

Apparently quite intentionally, so it can be considered an act of
deception, commonly called a LIE.

--- SoupGate-Win32 v1.05
* Origin: fsxNet Usenet Gateway (21:1/5)

On 2024-06-08 12:25:35 +0000, olcott said:

On 6/8/2024 12:43 AM, Mikko wrote:

On 2024-06-07 13:49:09 +0000, olcott said:

On 6/7/2024 12:49 AM, Mikko wrote:

On 2024-06-06 15:06:22 +0000, olcott said:

<Professor Sipser agreed>
   If simulating halt decider H correctly simulates its input D
   until H correctly determines that its simulated D would never
   stop running unless aborted then

   H can abort its simulation of D and correctly report that D
   specifies a non-halting sequence of configurations.
</Professor Sipser agreed>

// Simplified Linz Ĥ (Linz:1990:319)
// Strachey(1965) CPL translated to C
void P(u32 x)
{
   if (H(x, x))
     HERE: goto HERE;
}

People here that are experts in the C programming language know that >>>>> *P correctly simulated by H cannot possibly stop running unless aborted* >>>>> yet lie about this or to try to get away with the strawman deception >>>>> CHANGE-THE-SUBJECT fake rebuttal.

People here who have recently followed these discussions know that "P
correctly simulated by H cannot possibly stop running unless aborted"
does not confirm or contradict anything Linz and Strachey have said.

When P correctly simulated by H meets this criteria
   If simulating halt decider H correctly simulates its input P
   until H correctly determines that its simulated P would never
   stop running unless aborted then

Still unproven whther P ever meets those criteria, in particular
the last "correctly".

That you lack the mandatory prerequisite knowledge to understand
that this is correct provided zero evidence that this is incorrect.

Doesn't matter. Much less understanding is needed to see that you have
not proven that P ever meets the criteria agreed by Siplser. Equally
clear is that you have not proven that P never meets those criteria.

I incorporate by reference
(a) The x86 language
(b) The notion of an x86 emulator

(c) I provide this complete function

void DDD(int (*x)())
{
HH(x, x);
}

_DDD()
[00001de2] 55 push ebp
[00001de3] 8bec mov ebp,esp
[00001de5] 8b4508 mov eax,[ebp+08]
[00001de8] 50 push eax ; push DD
[00001de9] 8b4d08 mov ecx,[ebp+08]
[00001dec] 51 push ecx ; push DD
[00001ded] e890f5ffff call 00001382 ; call HH
[00001df2] 83c408 add esp,+08
[00001df5] 5d pop ebp
[00001df6] c3 ret
Size in bytes:(0021) [00001df6]

Then I state that No DDD correctly emulated by any
x86 emulator H can possibly reach its own [00001df6]
instruction.

To anyone having this mandatory prerequisite knowledge
(perhaps not you) every x86 emulation of DDD by any
x86 emulator H continually repeats the first seven lines
of DDD until it crashes due to out-of-memory error.

OK, but insufficient.

--
Mikko

--- SoupGate-Win32 v1.05
* Origin: fsxNet Usenet Gateway (21:1/5)

On 2024-06-09 12:50:22 +0000, olcott said:

On 6/9/2024 2:31 AM, Mikko wrote:

On 2024-06-08 12:25:35 +0000, olcott said:

On 6/8/2024 12:43 AM, Mikko wrote:

On 2024-06-07 13:49:09 +0000, olcott said:

On 6/7/2024 12:49 AM, Mikko wrote:

On 2024-06-06 15:06:22 +0000, olcott said:

<Professor Sipser agreed>
   If simulating halt decider H correctly simulates its input D >>>>>>>    until H correctly determines that its simulated D would never >>>>>>>    stop running unless aborted then

   H can abort its simulation of D and correctly report that D >>>>>>>    specifies a non-halting sequence of configurations.
</Professor Sipser agreed>

// Simplified Linz Ĥ (Linz:1990:319)
// Strachey(1965) CPL translated to C
void P(u32 x)
{
   if (H(x, x))
     HERE: goto HERE;
}

People here that are experts in the C programming language know that >>>>>>> *P correctly simulated by H cannot possibly stop running unless aborted*
yet lie about this or to try to get away with the strawman deception >>>>>>> CHANGE-THE-SUBJECT fake rebuttal.

People here who have recently followed these discussions know that "P >>>>>> correctly simulated by H cannot possibly stop running unless aborted" >>>>>> does not confirm or contradict anything Linz and Strachey have said. >>>>>

When P correctly simulated by H meets this criteria
   If simulating halt decider H correctly simulates its input P
   until H correctly determines that its simulated P would never
   stop running unless aborted then

Still unproven whther P ever meets those criteria, in particular
the last "correctly".

That you lack the mandatory prerequisite knowledge to understand
that this is correct provided zero evidence that this is incorrect.

Doesn't matter. Much less understanding is needed to see that you have
not proven that P ever meets the criteria agreed by Siplser. Equally
clear is that you have not proven that P never meets those criteria.

I incorporate by reference
(a) The x86 language
(b) The notion of an x86 emulator

(c) I provide this complete function

void DDD(int (*x)())
{
   HH(x, x);
}

_DDD()
[00001de2] 55         push ebp
[00001de3] 8bec       mov ebp,esp
[00001de5] 8b4508     mov eax,[ebp+08]
[00001de8] 50         push eax         ; push DD
[00001de9] 8b4d08     mov ecx,[ebp+08]
[00001dec] 51         push ecx         ; push DD
[00001ded] e890f5ffff call 00001382    ; call HH
[00001df2] 83c408     add esp,+08
[00001df5] 5d         pop ebp
[00001df6] c3         ret
Size in bytes:(0021) [00001df6]

Then I state that No DDD correctly emulated by any
x86 emulator H can possibly reach its own [00001df6]
instruction.

To anyone having this mandatory prerequisite knowledge
(perhaps not you) every x86 emulation of DDD by any
x86 emulator H continually repeats the first seven lines
of DDD until it crashes due to out-of-memory error.

OK, but insufficient.

Try and show what is missing.

Truth preseving transformations.

--
Mikko

--- SoupGate-Win32 v1.05
* Origin: fsxNet Usenet Gateway (21:1/5)