XPost: comp.theory, sci.logic

On 2/9/23 11:18 AM, olcott wrote:

*Paul N agrees that P correctly simulated by H never halts*
*thus meeting its halt status criterion measure tautology*
*this proves that H(P,P)==0 is correct*

No, he says that the program output, with your anotations, shows that
the H that does this will create an P(P) that the correct simulaiton
never halts.

This H so described, never aborts its simulaiton, and thus never returns
an answer.

H MUST be a SPECIFIC program, so if you give H the smarts to actually
decide to abort, that logic no longer holds, so you now have a DIFFERNET
H and a DIFFERENT P, and unsound logic.

  (a) 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 (b) H can abort its simulation of D and correctly
  report that D specifies a non-halting sequence of configurations.

Right, and by H thinking that H will correctly simulate until it can
prove that it aborts, and that it is still possibe to abort the
simulation in finite time, it INCORRECTLY aborts its simulation, because
H didn't simulate until it ACTUALLY proved the input wouldn't halt, but
only that it wouldn't halt if H didn't abort its simulation.

Thus, H used a false premise in its logic and got an unsound answer, and
wasn't correct.

This is just an example of you not understanding the basics of logic.

The above words are a tautology in that the meaning of the words proves
that they are true: (b) is a necessary consequence of (a). {never stop running unless aborted} is equivalent to {would never reach is own “return” instruction final state} thus never halts.

In comp.lang.c++
On 6/14/2022 6:47 AM, Paul N wrote:

On Monday, June 13, 2022 at 7:46:22 PM UTC+1, olcott wrote:

Begin Local Halt Decider Simulation Execution Trace Stored at:212352
// H emulates the first seven instructions of P
...[00001352][0021233e][00212342] 55 push ebp              // enter P
...[00001353][0021233e][00212342] 8bec mov ebp,esp
...[00001355][0021233e][00212342] 8b4508 mov eax,[ebp+08]
...[00001358][0021233a][00001352] 50 push eax              // push P
...[00001359][0021233a][00001352] 8b4d08 mov ecx,[ebp+08]
...[0000135c][00212336][00001352] 51 push ecx              // push P
...[0000135d][00212332][00001362] e840feffff call 000011a2 // call H

// The emulated H emulates the first seven instructions of P
...[00001352][0025cd66][0025cd6a] 55 push ebp              // enter P
...[00001353][0025cd66][0025cd6a] 8bec mov ebp,esp
...[00001355][0025cd66][0025cd6a] 8b4508 mov eax,[ebp+08]
...[00001358][0025cd62][00001352] 50 push eax              // push P
...[00001359][0025cd62][00001352] 8b4d08 mov ecx,[ebp+08]
...[0000135c][0025cd5e][00001352] 51 push ecx              // push P
...[0000135d][0025cd5a][00001362] e840feffff call 000011a2 // call H
Local Halt Decider: Infinite Recursion Detected Simulation Stopped

It is completely obvious that when H(P,P) correctly emulates
its input that it must emulate the first seven instructions
of P. Because the seventh instruction of P repeats this
process we can know with complete certainty that the emulated
P never reaches its final “ret” instruction, thus never halts.

Yes, it is clear to us humans watching it that the program is
repeating itself. Thus we can appreciate that it will never reach
the final "ret" - indeed, it won't even get to the infinite loop identified above. But does the computer itself know this? If the
emulator simply emulates the instructions given, it will not
realise that it is doing the same thing over and over again. If
it does look out for this, spotting a repeated state, then it can
tell that the program under consideration will not halt. The answer
to whether it spots this lies in the emulator, which you haven't
shown the code for.

*Here is the code, it compiles under*
*Microsoft Visual Studio Community Edition 2017* https://liarparadox.org/2023_02_07.zip
The current halt status algorithm is in Halt7.c

Right, and H(P,P) returns 0, but P(P) will Halt, so the answer to the
Halting Problem, where the Decider is requried to answer about the
behavior of the program described by its input, is shown to be INCORRECT.

And that you are just a Ignorant Pathological Lying Idiot, since you
explicitly have stated, and not taken back, that H is correct to give an
answer that is different than the definitionally correct right answer.

This has been updated today:
*Simulating Halt Decider Applied to the Halting Theorem* https://www.researchgate.net/publication/364657019_Simulating_Halt_Decider_Applied_to_the_Halting_Theorem

Which is still wrong as explained.

All you are doing is proving that you don't understand the basics of
logic, and admitting that you are just a liar, since these errors have
been pointed out MANY times, and you ignoring them just shows you don't
care about what is actually TRUE.

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

XPost: comp.theory, sci.logic

*Paul N agrees that P correctly simulated by H never halts*
*thus meeting its halt status criterion measure tautology*
*this proves that H(P,P)==0 is correct*

(a) 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 (b) H can abort its simulation of D and correctly
report that D specifies a non-halting sequence of configurations.

The above words are a tautology in that the meaning of the words proves
that they are true: (b) is a necessary consequence of (a). {never stop
running unless aborted} is equivalent to {would never reach is own
“return” instruction final state} thus never halts.

In comp.lang.c++
On 6/14/2022 6:47 AM, Paul N wrote:

On Monday, June 13, 2022 at 7:46:22 PM UTC+1, olcott wrote:

Begin Local Halt Decider Simulation Execution Trace Stored at:212352
// H emulates the first seven instructions of P
...[00001352][0021233e][00212342] 55 push ebp // enter P
...[00001353][0021233e][00212342] 8bec mov ebp,esp
...[00001355][0021233e][00212342] 8b4508 mov eax,[ebp+08]
...[00001358][0021233a][00001352] 50 push eax // push P
...[00001359][0021233a][00001352] 8b4d08 mov ecx,[ebp+08]
...[0000135c][00212336][00001352] 51 push ecx // push P
...[0000135d][00212332][00001362] e840feffff call 000011a2 // call H

// The emulated H emulates the first seven instructions of P
...[00001352][0025cd66][0025cd6a] 55 push ebp // enter P
...[00001353][0025cd66][0025cd6a] 8bec mov ebp,esp
...[00001355][0025cd66][0025cd6a] 8b4508 mov eax,[ebp+08]
...[00001358][0025cd62][00001352] 50 push eax // push P
...[00001359][0025cd62][00001352] 8b4d08 mov ecx,[ebp+08]
...[0000135c][0025cd5e][00001352] 51 push ecx // push P
...[0000135d][0025cd5a][00001362] e840feffff call 000011a2 // call H
Local Halt Decider: Infinite Recursion Detected Simulation Stopped

It is completely obvious that when H(P,P) correctly emulates
its input that it must emulate the first seven instructions
of P. Because the seventh instruction of P repeats this
process we can know with complete certainty that the emulated
P never reaches its final “ret” instruction, thus never halts.

Yes, it is clear to us humans watching it that the program is
repeating itself. Thus we can appreciate that it will never reach
the final "ret" - indeed, it won't even get to the infinite loop
identified above. But does the computer itself know this? If the
emulator simply emulates the instructions given, it will not
realise that it is doing the same thing over and over again. If
it does look out for this, spotting a repeated state, then it can
tell that the program under consideration will not halt. The answer
to whether it spots this lies in the emulator, which you haven't
shown the code for.

*Here is the code, it compiles under*
*Microsoft Visual Studio Community Edition 2017* https://liarparadox.org/2023_02_07.zip
The current halt status algorithm is in Halt7.c

This has been updated today:
*Simulating Halt Decider Applied to the Halting Theorem* https://www.researchgate.net/publication/364657019_Simulating_Halt_Decider_Applied_to_the_Halting_Theorem


--
Copyright 2023 Olcott "Talent hits a target no one else can hit; Genius
hits a target no one else can see." Arthur Schopenhauer

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

XPost: comp.theory, sci.logic

On 2/9/23 12:17 PM, olcott wrote:

On 2/9/2023 10:18 AM, olcott wrote:

*Paul N agrees that P correctly simulated by H never halts*
*thus meeting its halt status criterion measure tautology*
*this proves that H(P,P)==0 is correct*

   (a) 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 (b) H can abort its simulation of D and correctly >>    report that D specifies a non-halting sequence of configurations.

The above words are a tautology in that the meaning of the words
proves that they are true: (b) is a necessary consequence of (a).
{never stop running unless aborted} is equivalent to {would never
reach is own “return” instruction final state} thus never halts.

Nope, not with your understanding of the meaning.

You can only refer to "H's Correct simulation" if H actually DOES such a simulation.

You confuse the different layers of execution.

A correct statement of your "tautology" would be

(a) If simulation Halt Decider H correctly simulates its input D until H correctly derermines that THIS simulation or D would never stop running
unless THIS simulation is aborted, then (b) H can abort its simulation
of D and correctly report that D specifies a computaiton.

<NB: sequence of configurations is just word salad>

Note, key difference is that it refers to THIS simulation, the fact that another copy of H (even if physicaly the same code, but in a different exectuion context) aborts a simulation of the same input is NOT grounds
to call the computation non-halting.

In fact, as I have pointed out before, your currect program structure
defies the problem definition as H is NOT an independent program that is
the equivalent of a Turing Machine with another program and its input
given as a Input, and your D is NOT an independent program representing
a Turing Machine that is given an input.

Your H/D program is NOT seperable in the proper way so it is actually impossible to make it into the Turing Model requried.

Of course, since you have shown you don't understand what a Turing
Machine actually is, that is totally over your head.

If you want to try to translate the Halting Problem from a Turing Model
into a more general computation structure, you need a number of
additional conditios that your setup just doesn't have.

As I have mentioned before, you H itself really needs to have as its
direct input the linked object file with the program to analyze, and the
file to use as the input to that program.

That you don't understand that just shows your ignorance of the topic.

In comp.lang.c++
On 6/14/2022 6:47 AM, Paul N wrote:

On Monday, June 13, 2022 at 7:46:22 PM UTC+1, olcott wrote:

Begin Local Halt Decider Simulation Execution Trace Stored at:212352
// H emulates the first seven instructions of P
...[00001352][0021233e][00212342] 55 push ebp              // enter P
...[00001353][0021233e][00212342] 8bec mov ebp,esp
...[00001355][0021233e][00212342] 8b4508 mov eax,[ebp+08]
...[00001358][0021233a][00001352] 50 push eax              // push P
...[00001359][0021233a][00001352] 8b4d08 mov ecx,[ebp+08]
...[0000135c][00212336][00001352] 51 push ecx              // push P
...[0000135d][00212332][00001362] e840feffff call 000011a2 // call H
;
// The emulated H emulates the first seven instructions of P
...[00001352][0025cd66][0025cd6a] 55 push ebp              // enter P
...[00001353][0025cd66][0025cd6a] 8bec mov ebp,esp
...[00001355][0025cd66][0025cd6a] 8b4508 mov eax,[ebp+08]
...[00001358][0025cd62][00001352] 50 push eax              // push P
...[00001359][0025cd62][00001352] 8b4d08 mov ecx,[ebp+08]
...[0000135c][0025cd5e][00001352] 51 push ecx              // push P
...[0000135d][0025cd5a][00001362] e840feffff call 000011a2 // call H
Local Halt Decider: Infinite Recursion Detected Simulation Stopped
;
It is completely obvious that when H(P,P) correctly emulates
its input that it must emulate the first seven instructions
of P. Because the seventh instruction of P repeats this
process we can know with complete certainty that the emulated
P never reaches its final “ret” instruction, thus never halts.

;
Yes, it is clear to us humans watching it that the program is
repeating itself. Thus we can appreciate that it will never reach
the final "ret" - indeed, it won't even get to the infinite loop
identified above. But does the computer itself know this? If the
emulator simply emulates the instructions given, it will not
realise that it is doing the same thing over and over again. If
it does look out for this, spotting a repeated state, then it can
tell that the program under consideration will not halt. The answer
to whether it spots this lies in the emulator, which you haven't
shown the code for.

*Here is the code, it compiles under*
*Microsoft Visual Studio Community Edition 2017*
https://liarparadox.org/2023_02_07.zip
The current halt status algorithm is in Halt7.c

This has been updated today:
*Simulating Halt Decider Applied to the Halting Theorem*
https://www.researchgate.net/publication/364657019_Simulating_Halt_Decider_Applied_to_the_Halting_Theorem

People that have no interest in an honest dialogue will never
acknowledge that P correctly simulated by H cannot possibly reach its
own final state and terminate normally (AKA halt) no matter what H does.

YOU are the one not interested in a "Honest Dialog"

The problem is that H never does this "correct simulation" of P per the definition, only partial simulation.

Note, a simulator that aborts its simulation does not prove its input
was non-haltign.

P correctly simulated WILL Halt if H(P,P) returns 0. Even you have shown
this.

This proves your statement is incorrect, until you can show how a given
machine can have two DIFFERENT "Correct Simulaitons".

You are failed to show that, so have shown yourself to just be a
Pathological Liar.

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

XPost: comp.theory, sci.logic

On 2/9/2023 10:18 AM, olcott wrote:

*Paul N agrees that P correctly simulated by H never halts*
*thus meeting its halt status criterion measure tautology*
*this proves that H(P,P)==0 is correct*

  (a) 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 (b) H can abort its simulation of D and correctly
  report that D specifies a non-halting sequence of configurations.

The above words are a tautology in that the meaning of the words proves
that they are true: (b) is a necessary consequence of (a). {never stop running unless aborted} is equivalent to {would never reach is own “return” instruction final state} thus never halts.

In comp.lang.c++
On 6/14/2022 6:47 AM, Paul N wrote:

On Monday, June 13, 2022 at 7:46:22 PM UTC+1, olcott wrote:

Begin Local Halt Decider Simulation Execution Trace Stored at:212352
// H emulates the first seven instructions of P
...[00001352][0021233e][00212342] 55 push ebp              // enter P
...[00001353][0021233e][00212342] 8bec mov ebp,esp
...[00001355][0021233e][00212342] 8b4508 mov eax,[ebp+08]
...[00001358][0021233a][00001352] 50 push eax              // push P
...[00001359][0021233a][00001352] 8b4d08 mov ecx,[ebp+08]
...[0000135c][00212336][00001352] 51 push ecx              // push P
...[0000135d][00212332][00001362] e840feffff call 000011a2 // call H

// The emulated H emulates the first seven instructions of P
...[00001352][0025cd66][0025cd6a] 55 push ebp              // enter P
...[00001353][0025cd66][0025cd6a] 8bec mov ebp,esp
...[00001355][0025cd66][0025cd6a] 8b4508 mov eax,[ebp+08]
...[00001358][0025cd62][00001352] 50 push eax              // push P
...[00001359][0025cd62][00001352] 8b4d08 mov ecx,[ebp+08]
...[0000135c][0025cd5e][00001352] 51 push ecx              // push P
...[0000135d][0025cd5a][00001362] e840feffff call 000011a2 // call H
Local Halt Decider: Infinite Recursion Detected Simulation Stopped

It is completely obvious that when H(P,P) correctly emulates
its input that it must emulate the first seven instructions
of P. Because the seventh instruction of P repeats this
process we can know with complete certainty that the emulated
P never reaches its final “ret” instruction, thus never halts.

Yes, it is clear to us humans watching it that the program is
repeating itself. Thus we can appreciate that it will never reach
the final "ret" - indeed, it won't even get to the infinite loop identified above. But does the computer itself know this? If the
emulator simply emulates the instructions given, it will not
realise that it is doing the same thing over and over again. If
it does look out for this, spotting a repeated state, then it can
tell that the program under consideration will not halt. The answer
to whether it spots this lies in the emulator, which you haven't
shown the code for.

*Here is the code, it compiles under*
*Microsoft Visual Studio Community Edition 2017* https://liarparadox.org/2023_02_07.zip
The current halt status algorithm is in Halt7.c

This has been updated today:
*Simulating Halt Decider Applied to the Halting Theorem* https://www.researchgate.net/publication/364657019_Simulating_Halt_Decider_Applied_to_the_Halting_Theorem

People that have no interest in an honest dialogue will never
acknowledge that P correctly simulated by H cannot possibly reach its
own final state and terminate normally (AKA halt) no matter what H does.

--
Copyright 2023 Olcott "Talent hits a target no one else can hit; Genius
hits a target no one else can see." Arthur Schopenhauer

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

XPost: comp.theory, sci.logic

On 2/9/2023 11:17 AM, olcott wrote:

On 2/9/2023 10:18 AM, olcott wrote:

*Paul N agrees that P correctly simulated by H never halts*
*thus meeting its halt status criterion measure tautology*
*this proves that H(P,P)==0 is correct*

   (a) 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 (b) H can abort its simulation of D and correctly >>    report that D specifies a non-halting sequence of configurations.

The above words are a tautology in that the meaning of the words
proves that they are true: (b) is a necessary consequence of (a).
{never stop running unless aborted} is equivalent to {would never
reach is own “return” instruction final state} thus never halts.

In comp.lang.c++
On 6/14/2022 6:47 AM, Paul N wrote:

On Monday, June 13, 2022 at 7:46:22 PM UTC+1, olcott wrote:

Begin Local Halt Decider Simulation Execution Trace Stored at:212352
// H emulates the first seven instructions of P
...[00001352][0021233e][00212342] 55 push ebp              // enter P
...[00001353][0021233e][00212342] 8bec mov ebp,esp
...[00001355][0021233e][00212342] 8b4508 mov eax,[ebp+08]
...[00001358][0021233a][00001352] 50 push eax              // push P
...[00001359][0021233a][00001352] 8b4d08 mov ecx,[ebp+08]
...[0000135c][00212336][00001352] 51 push ecx              // push P
...[0000135d][00212332][00001362] e840feffff call 000011a2 // call H
;
// The emulated H emulates the first seven instructions of P
...[00001352][0025cd66][0025cd6a] 55 push ebp              // enter P
...[00001353][0025cd66][0025cd6a] 8bec mov ebp,esp
...[00001355][0025cd66][0025cd6a] 8b4508 mov eax,[ebp+08]
...[00001358][0025cd62][00001352] 50 push eax              // push P
...[00001359][0025cd62][00001352] 8b4d08 mov ecx,[ebp+08]
...[0000135c][0025cd5e][00001352] 51 push ecx              // push P
...[0000135d][0025cd5a][00001362] e840feffff call 000011a2 // call H
Local Halt Decider: Infinite Recursion Detected Simulation Stopped
;
It is completely obvious that when H(P,P) correctly emulates
its input that it must emulate the first seven instructions
of P. Because the seventh instruction of P repeats this
process we can know with complete certainty that the emulated
P never reaches its final “ret” instruction, thus never halts.

;
Yes, it is clear to us humans watching it that the program is
repeating itself. Thus we can appreciate that it will never reach
the final "ret" - indeed, it won't even get to the infinite loop
identified above. But does the computer itself know this? If the
emulator simply emulates the instructions given, it will not
realise that it is doing the same thing over and over again. If
it does look out for this, spotting a repeated state, then it can
tell that the program under consideration will not halt. The answer
to whether it spots this lies in the emulator, which you haven't
shown the code for.

*Here is the code, it compiles under*
*Microsoft Visual Studio Community Edition 2017*
https://liarparadox.org/2023_02_07.zip
The current halt status algorithm is in Halt7.c

This has been updated today:
*Simulating Halt Decider Applied to the Halting Theorem*
https://www.researchgate.net/publication/364657019_Simulating_Halt_Decider_Applied_to_the_Halting_Theorem

People that have no interest in an honest dialogue will never
acknowledge that P correctly simulated by H cannot possibly reach its
own final state and terminate normally (AKA halt) no matter what H does.

int D1(int (*x)())
{
H(x, x);
return;
}

int main()
{
Output("Input_Halts = ", H(D1,D1));
}

Anyone that is good at software engineering will understand that D1
correctly simulated by H will never reach its own return instruction.


--
Copyright 2023 Olcott "Talent hits a target no one else can hit; Genius
hits a target no one else can see." Arthur Schopenhauer

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

XPost: comp.theory, sci.logic

On 2/9/23 11:40 PM, olcott wrote:

On 2/9/2023 11:17 AM, olcott wrote:

On 2/9/2023 10:18 AM, olcott wrote:

*Paul N agrees that P correctly simulated by H never halts*
*thus meeting its halt status criterion measure tautology*
*this proves that H(P,P)==0 is correct*

   (a) 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 (b) H can abort its simulation of D and correctly >>>    report that D specifies a non-halting sequence of configurations.

The above words are a tautology in that the meaning of the words
proves that they are true: (b) is a necessary consequence of (a).
{never stop running unless aborted} is equivalent to {would never
reach is own “return” instruction final state} thus never halts.

In comp.lang.c++
On 6/14/2022 6:47 AM, Paul N wrote:

On Monday, June 13, 2022 at 7:46:22 PM UTC+1, olcott wrote:

Begin Local Halt Decider Simulation Execution Trace Stored at:212352 >>>  >> // H emulates the first seven instructions of P
...[00001352][0021233e][00212342] 55 push ebp              //

enter P

...[00001353][0021233e][00212342] 8bec mov ebp,esp
...[00001355][0021233e][00212342] 8b4508 mov eax,[ebp+08]
...[00001358][0021233a][00001352] 50 push eax              // push P
...[00001359][0021233a][00001352] 8b4d08 mov ecx,[ebp+08]
...[0000135c][00212336][00001352] 51 push ecx              // push P
...[0000135d][00212332][00001362] e840feffff call 000011a2 // call H >>>  >>
// The emulated H emulates the first seven instructions of P
...[00001352][0025cd66][0025cd6a] 55 push ebp              //

enter P

...[00001353][0025cd66][0025cd6a] 8bec mov ebp,esp
...[00001355][0025cd66][0025cd6a] 8b4508 mov eax,[ebp+08]
...[00001358][0025cd62][00001352] 50 push eax              // push P
...[00001359][0025cd62][00001352] 8b4d08 mov ecx,[ebp+08]
...[0000135c][0025cd5e][00001352] 51 push ecx              // push P
...[0000135d][0025cd5a][00001362] e840feffff call 000011a2 // call H >>>  >> Local Halt Decider: Infinite Recursion Detected Simulation Stopped
;
It is completely obvious that when H(P,P) correctly emulates
its input that it must emulate the first seven instructions
of P. Because the seventh instruction of P repeats this
process we can know with complete certainty that the emulated
P never reaches its final “ret” instruction, thus never halts.

;
Yes, it is clear to us humans watching it that the program is
repeating itself. Thus we can appreciate that it will never reach
the final "ret" - indeed, it won't even get to the infinite loop
identified above. But does the computer itself know this? If the
emulator simply emulates the instructions given, it will not
realise that it is doing the same thing over and over again. If
it does look out for this, spotting a repeated state, then it can
tell that the program under consideration will not halt. The answer
to whether it spots this lies in the emulator, which you haven't
shown the code for.

*Here is the code, it compiles under*
*Microsoft Visual Studio Community Edition 2017*
https://liarparadox.org/2023_02_07.zip
The current halt status algorithm is in Halt7.c

This has been updated today:
*Simulating Halt Decider Applied to the Halting Theorem*
https://www.researchgate.net/publication/364657019_Simulating_Halt_Decider_Applied_to_the_Halting_Theorem

People that have no interest in an honest dialogue will never
acknowledge that P correctly simulated by H cannot possibly reach its
own final state and terminate normally (AKA halt) no matter what H does.

int D1(int (*x)())
{
  H(x, x);
  return;
}

int main()
{
  Output("Input_Halts = ", H(D1,D1));
}

Anyone that is good at software engineering will understand that D1
correctly simulated by H will never reach its own return instruction.

First, the question is not about the simulation by H, but the actual
exectuiton of the inpt program.

Second, the definition of "Correct Simulation" that allows the change to
looing at simulation includes the requirement that "Correct" is "Complete".

Thus, If D1 "Correctly Simulated by H" will never reach its own return instruction then H can never give an answer.

If H gives an answer, it doesn't correctly simulate its input per the definition REQUIRED by your change of question, so can't be the basis of
the answer.

The CORRECT simulaiton done by UTM(D1,D1) does reach its final state
because your H(D1,D1) returns an answer, the the correct answer must be Halting.

ANY system that calls a Halting Computation Non-Halting is Incorrect,
PERIOD.

Since D1(D1) will Halt (if H returns an answer), as will any actual
correct simulation of it, the only correct answer that H can return is
Halting. Your claims that Non-Halting is correct just shows you are STUPID.

You have made a lot of claims, and when ssked to actually prove the
problematic points, you have just ignored those request, showing that
you are intentionally being a PATHOLOGICAL LIAR.

YOU are the "People wit no interest in Honest Dialog", becausse you
never answer the issue brought up by other but just dismiss them because
they don't match your ideas.

This just proves you are an egotistical IDIOT.


As pointd out, the fact that your code is incorrect, and will generate a required diagnostic tells EVERYONE that you post code and make
assertions about it that hasn't actually been tested, or that you
beleive it is ok to run programs that has errors in it.

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

XPost: comp.theory, sci.logic

On 2/9/2023 10:40 PM, olcott wrote:

On 2/9/2023 11:17 AM, olcott wrote:

On 2/9/2023 10:18 AM, olcott wrote:

*Paul N agrees that P correctly simulated by H never halts*
*thus meeting its halt status criterion measure tautology*
*this proves that H(P,P)==0 is correct*

   (a) 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 (b) H can abort its simulation of D and correctly >>>    report that D specifies a non-halting sequence of configurations.

The above words are a tautology in that the meaning of the words
proves that they are true: (b) is a necessary consequence of (a).
{never stop running unless aborted} is equivalent to {would never
reach is own “return” instruction final state} thus never halts.

In comp.lang.c++
On 6/14/2022 6:47 AM, Paul N wrote:

On Monday, June 13, 2022 at 7:46:22 PM UTC+1, olcott wrote:

Begin Local Halt Decider Simulation Execution Trace Stored at:212352 >>>  >> // H emulates the first seven instructions of P
...[00001352][0021233e][00212342] 55 push ebp              //

enter P

...[00001353][0021233e][00212342] 8bec mov ebp,esp
...[00001355][0021233e][00212342] 8b4508 mov eax,[ebp+08]
...[00001358][0021233a][00001352] 50 push eax              // push P
...[00001359][0021233a][00001352] 8b4d08 mov ecx,[ebp+08]
...[0000135c][00212336][00001352] 51 push ecx              // push P
...[0000135d][00212332][00001362] e840feffff call 000011a2 // call H >>>  >>
// The emulated H emulates the first seven instructions of P
...[00001352][0025cd66][0025cd6a] 55 push ebp              //

enter P

...[00001353][0025cd66][0025cd6a] 8bec mov ebp,esp
...[00001355][0025cd66][0025cd6a] 8b4508 mov eax,[ebp+08]
...[00001358][0025cd62][00001352] 50 push eax              // push P
...[00001359][0025cd62][00001352] 8b4d08 mov ecx,[ebp+08]
...[0000135c][0025cd5e][00001352] 51 push ecx              // push P
...[0000135d][0025cd5a][00001362] e840feffff call 000011a2 // call H >>>  >> Local Halt Decider: Infinite Recursion Detected Simulation Stopped
;
It is completely obvious that when H(P,P) correctly emulates
its input that it must emulate the first seven instructions
of P. Because the seventh instruction of P repeats this
process we can know with complete certainty that the emulated
P never reaches its final “ret” instruction, thus never halts.

;
Yes, it is clear to us humans watching it that the program is
repeating itself. Thus we can appreciate that it will never reach
the final "ret" - indeed, it won't even get to the infinite loop
identified above. But does the computer itself know this? If the
emulator simply emulates the instructions given, it will not
realise that it is doing the same thing over and over again. If
it does look out for this, spotting a repeated state, then it can
tell that the program under consideration will not halt. The answer
to whether it spots this lies in the emulator, which you haven't
shown the code for.

*Here is the code, it compiles under*
*Microsoft Visual Studio Community Edition 2017*
https://liarparadox.org/2023_02_07.zip
The current halt status algorithm is in Halt7.c

This has been updated today:
*Simulating Halt Decider Applied to the Halting Theorem*
https://www.researchgate.net/publication/364657019_Simulating_Halt_Decider_Applied_to_the_Halting_Theorem

People that have no interest in an honest dialogue will never
acknowledge that P correctly simulated by H cannot possibly reach its
own final state and terminate normally (AKA halt) no matter what H does.

int D1(int (*x)())
{
  H(x, x);
  return;
}

int main()
{
  Output("Input_Halts = ", H(D1,D1));
}

Anyone that is good at software engineering will understand that D1
correctly simulated by H will never reach its own return instruction.

int D(int (*x)())
{
int Halt_Status = H(x, x);
if (Halt_Status)
HERE: goto HERE;
return Halt_Status;
}

int main()
{
Output("Input_Halts = ", H(D,D));
}

People that are very good at software engineering will understand that
when D is correctly simulated by H that D will never reach its own "if" statement because it remains stuck in recursive simulation in exactly
the same way that D1 remains stuck in recursive simulation.

*straw man*
An intentionally misrepresented proposition that is set up because it is
easier to defeat than an opponent's real argument. https://www.lexico.com/en/definition/straw_man

Dishonest people will use the strawman fallacy and change my words so
that they have a fake basis for rebuttal.

--
Copyright 2023 Olcott "Talent hits a target no one else can hit; Genius
hits a target no one else can see." Arthur Schopenhauer

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

XPost: comp.theory, sci.logic

On 2/10/23 9:28 AM, olcott wrote:

On 2/9/2023 10:40 PM, olcott wrote:

On 2/9/2023 11:17 AM, olcott wrote:

On 2/9/2023 10:18 AM, olcott wrote:

*Paul N agrees that P correctly simulated by H never halts*
*thus meeting its halt status criterion measure tautology*
*this proves that H(P,P)==0 is correct*

   (a) 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 (b) H can abort its simulation of D and
correctly
   report that D specifies a non-halting sequence of configurations. >>>>
The above words are a tautology in that the meaning of the words
proves that they are true: (b) is a necessary consequence of (a).
{never stop running unless aborted} is equivalent to {would never
reach is own “return” instruction final state} thus never halts.

In comp.lang.c++
On 6/14/2022 6:47 AM, Paul N wrote:

On Monday, June 13, 2022 at 7:46:22 PM UTC+1, olcott wrote:

Begin Local Halt Decider Simulation Execution Trace Stored

at:212352

// H emulates the first seven instructions of P
...[00001352][0021233e][00212342] 55 push ebp              //

enter P

...[00001353][0021233e][00212342] 8bec mov ebp,esp
...[00001355][0021233e][00212342] 8b4508 mov eax,[ebp+08]
...[00001358][0021233a][00001352] 50 push eax              //

push P

...[00001359][0021233a][00001352] 8b4d08 mov ecx,[ebp+08]
...[0000135c][00212336][00001352] 51 push ecx              //

push P

...[0000135d][00212332][00001362] e840feffff call 000011a2 //

call H

;
// The emulated H emulates the first seven instructions of P
...[00001352][0025cd66][0025cd6a] 55 push ebp              //

enter P

...[00001353][0025cd66][0025cd6a] 8bec mov ebp,esp
...[00001355][0025cd66][0025cd6a] 8b4508 mov eax,[ebp+08]
...[00001358][0025cd62][00001352] 50 push eax              //

push P

...[00001359][0025cd62][00001352] 8b4d08 mov ecx,[ebp+08]
...[0000135c][0025cd5e][00001352] 51 push ecx              //

push P

...[0000135d][0025cd5a][00001362] e840feffff call 000011a2 //

call H

Local Halt Decider: Infinite Recursion Detected Simulation Stopped >>>>  >>
It is completely obvious that when H(P,P) correctly emulates
its input that it must emulate the first seven instructions
of P. Because the seventh instruction of P repeats this
process we can know with complete certainty that the emulated
P never reaches its final “ret” instruction, thus never halts. >>>>  >

Yes, it is clear to us humans watching it that the program is
repeating itself. Thus we can appreciate that it will never reach
the final "ret" - indeed, it won't even get to the infinite loop
identified above. But does the computer itself know this? If the
emulator simply emulates the instructions given, it will not
realise that it is doing the same thing over and over again. If
it does look out for this, spotting a repeated state, then it can
tell that the program under consideration will not halt. The answer >>>>  > to whether it spots this lies in the emulator, which you haven't
shown the code for.

*Here is the code, it compiles under*
*Microsoft Visual Studio Community Edition 2017*
https://liarparadox.org/2023_02_07.zip
The current halt status algorithm is in Halt7.c

This has been updated today:
*Simulating Halt Decider Applied to the Halting Theorem*
https://www.researchgate.net/publication/364657019_Simulating_Halt_Decider_Applied_to_the_Halting_Theorem

People that have no interest in an honest dialogue will never
acknowledge that P correctly simulated by H cannot possibly reach its
own final state and terminate normally (AKA halt) no matter what H does. >>>

int D1(int (*x)())
{
   H(x, x);
   return;
}

int main()
{
   Output("Input_Halts = ", H(D1,D1));
}

Anyone that is good at software engineering will understand that D1
correctly simulated by H will never reach its own return instruction.

int D(int (*x)())
{
  int Halt_Status = H(x, x);
  if (Halt_Status)
    HERE: goto HERE;
  return Halt_Status;
}

int main()
{
  Output("Input_Halts = ", H(D,D));
}

People that are very good at software engineering will understand that
when D is correctly simulated by H that D will never reach its own "if" statement because it remains stuck in recursive simulation in exactly
the same way that D1 remains stuck in recursive simulation.

So, that means that no H that correctly simulates this input ever
returns an answer, and thus fails to be a decider.


DO you admit that fact?

Or, ard you still claiming your ADMITTED LIE (admited because you fail
to provide the evidence, that is easy to provide if your statement is
true) that H(D,D) acts differently when called by D or by main.

*straw man*
An intentionally misrepresented proposition that is set up because it is easier to defeat than an opponent's real argument. https://www.lexico.com/en/definition/straw_man

Yes, the "Straw Man" is that you can use a PARTIAL SIMULATION by the
decider not reaching the final state as proof that the actual behavior
of the input is non-halting, when the actual behavior, and the actual
correct simulation, is Halting.

Dishonest people will use the strawman fallacy and change my words so
that they have a fake basis for rebuttal.

Right, YOU are dishonest to just IGNORE the FACTS preseted to you.

You are just PROVING that you are just an PATHOLOGICAL LYING IGNORANT
IDIOT that doesn't understand a thing about what he talks about.

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