PeteOlcott wrote: ↑Mon May 16, 2022 9:05 pm
H(P,P) is answering the question: Does the input to H(P,P) halt?
The answer is 0,No, false, does not halt.
Why is true and false so hard for you?
And H(P,P) == 0 is answering the question is H(P,P) equal to 0?
The answer is either true; or false!
Obviously! Because if P does halt then H(P,P) returns 1.
And 1 == 0 is false.
The correctly simulated input to H(P,P) never reaches its own final state thus does not halt.
The correctly simulated input to H1(P,P) reaches its own final state thus halts.
Where P is this literal string of x86 machine code:
558bec8b4508508b4d0851e840feffff83c40885c07402ebfe5dc3
PeteOlcott wrote: ↑Mon May 16, 2022 9:30 pm
The correctly simulated input to H(P,P) never reaches its own final state thus does not halt.
The correctly simulated input to H1(P,P) reaches its own final state thus halts.
Where P is this literal string of x86 machine code:
558bec8b4508508b4d0851e840feffff83c40885c07402ebfe5dc3
Those are just empyy words. I don't care.
Show me the source code for H in the program language of your choosing.
PeteOlcott wrote: ↑Mon May 16, 2022 9:30 pm
The correctly simulated input to H(P,P) never reaches its own final state thus does not halt.
The correctly simulated input to H1(P,P) reaches its own final state thus halts.
Where P is this literal string of x86 machine code:
558bec8b4508508b4d0851e840feffff83c40885c07402ebfe5dc3
PeteOlcott wrote: ↑Mon May 16, 2022 9:44 pm
I am done, you are just playing head games.
You are the one who's playing games, idiot.
You are hiding the implementation of H from yourself!
That is a ridiculously stupid thing to say because I am the author of H, and the x86utm operating system.
It is also ridiculously stupid to insist on seeing hundreds of pages of code when the following 14
lines of execution trace proves that H(P,P)==0 is correct.
Begin Local Halt Decider Simulation
machine stack stack machine assembly
address address data code language
======== ======== ======== ========= =============
...[000009d6][00211368][0021136c] 55 push ebp // enter P
...[000009d7][00211368][0021136c] 8bec mov ebp,esp
...[000009d9][00211368][0021136c] 8b4508 mov eax,[ebp+08]
...[000009dc][00211364][000009d6] 50 push eax // Push P
...[000009dd][00211364][000009d6] 8b4d08 mov ecx,[ebp+08]
...[000009e0][00211360][000009d6] 51 push ecx // Push P
...[000009e1][0021135c][000009e6] e840feffff call 00000826 // Call H
...[000009d6][0025bd90][0025bd94] 55 push ebp // enter P
...[000009d7][0025bd90][0025bd94] 8bec mov ebp,esp
...[000009d9][0025bd90][0025bd94] 8b4508 mov eax,[ebp+08]
...[000009dc][0025bd8c][000009d6] 50 push eax // Push P
...[000009dd][0025bd8c][000009d6] 8b4d08 mov ecx,[ebp+08]
...[000009e0][0025bd88][000009d6] 51 push ecx // Push P
...[000009e1][0025bd84][000009e6] e840feffff call 00000826 // Call H
Local Halt Decider: Infinite Recursion Detected Simulation Stopped
The fact that P calls the same function from its same machine address with identical input parameters conclusively proves that P is stuck in infinite recursion.
PeteOlcott wrote: ↑Mon May 16, 2022 11:05 pm
If you can't understand 14 lines of simple execution trace you will be able to understand hundreds of pages of complex code much better?
If you understood the 14 lines of simple execution trace you will know that there is no need to see the code.
If you understood that the way you pass the execution trace to your function H (as a string) is vitally important to your claim you would understand why you are wrong.
You don't even understand the difference between pass-by-value and pass-by-reference.
This is pass-by-reference. Because you have no idea what value is in the ecx register.
PeteOlcott wrote: ↑Mon May 16, 2022 11:05 pm
If you can't understand 14 lines of simple execution trace you will be able to understand hundreds of pages of complex code much better?
If you understood the 14 lines of simple execution trace you will know that there is no need to see the code.
If you understood that the way you pass the execution trace to your function H (as a string) is vitally important to your claim you would understand why you are wrong.
You don't even understand the difference between pass-by-value and pass-by-reference.
I pass the freaking address of P to H the same damn way that all strings are ever passed to an C functions.
H only performs a pure simulation of its input until it reaches the 14th line:
Begin Local Halt Decider Simulation
machine stack stack machine assembly
address address data code language
======== ======== ======== ========= =============
...[000009d6][00211368][0021136c] 55 push ebp // enter P
...[000009d7][00211368][0021136c] 8bec mov ebp,esp
...[000009d9][00211368][0021136c] 8b4508 mov eax,[ebp+08]
...[000009dc][00211364][000009d6] 50 push eax // Push P
...[000009dd][00211364][000009d6] 8b4d08 mov ecx,[ebp+08]
...[000009e0][00211360][000009d6] 51 push ecx // Push P
...[000009e1][0021135c][000009e6] e840feffff call 00000826 // Call H
...[000009d6][0025bd90][0025bd94] 55 push ebp // enter P
...[000009d7][0025bd90][0025bd94] 8bec mov ebp,esp
...[000009d9][0025bd90][0025bd94] 8b4508 mov eax,[ebp+08]
...[000009dc][0025bd8c][000009d6] 50 push eax // Push P
...[000009dd][0025bd8c][000009d6] 8b4d08 mov ecx,[ebp+08]
...[000009e0][0025bd88][000009d6] 51 push ecx // Push P
...[000009e1][0025bd84][000009e6] e840feffff call 00000826 // Call H
Local Halt Decider: Infinite Recursion Detected Simulation Stopped
The fact that P calls the same function from its same machine address with identical input parameters conclusively proves that P is stuck in infinite recursion.
PeteOlcott wrote: ↑Mon May 16, 2022 11:16 pm
I pass the freaking address of P to H the same damn way that all strings are ever passed to an C functions.
Yes! The same ADDRESS doesn't mean the same VALUE!
You can change the VALUE at an ADDRESS and then you can call the function P with the SAME ADDRESS but DIFFERENT VALUE.
You are completely oblivious to the distinction between data flow and control flow!!!
PeteOlcott wrote: ↑Mon May 16, 2022 11:16 pm
I pass the freaking address of P to H the same damn way that all strings are ever passed to an C functions.
Do you actually understand the difference between a string and the interpretation of a string as a computer program?
Nowhere in your x86 assembly code is a string representation of P even being passed to H
PeteOlcott wrote: ↑Mon May 16, 2022 11:16 pm
The fact that P calls the same function from its same machine address with identical input parameters conclusively proves that P is stuck in infinite recursion.
Moreso, why are you arguing that P is stuck in an infinite recursion?
Your Halt Decider enters P on the first line.
Your Halt Decider enters P again on the 8th line.
Why isn't that "conclusive proof" that H is stuck?