And if that doesn't match the Halting Behavior of the actual function
then it isn't computing that Halting Function so it isn't a "Halt Decider.
D(D) Halts since H(D,D) returns 0, thus Halting(D,D) is True, thus the
CORRECT answer from H if it is an actual Halt Decider is 1, so H is
INCORRECT in its decision of H(D,D).
> All halt deciders are intended to correctly predict the behavior of non-
> terminating inputs. No halt decider ever continues to simulate its
> input after it has correctly detected a repeating state.
Right, but it needs to CORRECTLY determine the answer, which if H(D,D)
returns 0, and thus D(D) will halt, means H(D,D) SHOULD have returned 1.
> Halfwit morons can't seem to understand this. These incredibly stupid
> people seem to believe that the only way to detect infinite behavior is
> to continue to simulate the non-halting input forever.
And NO-WIT OLCOTTS don't understand that the decider needs to answer
Halting if the input would Halt when run or correctly simulated by an
D(D) Halts since H(D,D) Returns 0, thus the CORRECT answer for H(D,D) is
1, and H was incorrect.
To claim 0 is the correct answer is to show that the claimant is a liar.
> People with a modicum of technical competence will understand that when
> D calls H(D,D) to simulate itself again that this simulated D cannot
> possibly reach its own "return" statement in any finite number of steps.
Right, because H aborrs its simulation before the CORRECT simulation
reaches that final state, which is what actually matters.
It is only your strawman that tries to refer to the PARTIAL simulation
done by H as the bases that even comes close to your claims
> I have shown this in x86 assembly language so that it is perfectly
> unambiguously clear yet even highly skilled people seemed to have
> totally forgotten this lost art.
> H: Begin Simulation Execution Trace Stored at:113109
> [00001d12][001130f5][001130f9] 55 push ebp ; begin D
> [00001d13][001130f5][001130f9] 8bec mov ebp,esp
> [00001d15][001130f1][001030c5] 51 push ecx
> [00001d16][001130f1][001030c5] 8b4508 mov eax,[ebp+08]
> [00001d19][001130ed][00001d12] 50 push eax ; push address
> of D
> [00001d1a][001130ed][00001d12] 8b4d08 mov ecx,[ebp+08]
> [00001d1d][001130e9][00001d12] 51 push ecx ; push address
> of D
> [00001d1e][001130e5][00001d23] e83ff8ffff call 00001562 ; call H
> H: Infinitely Recursive Simulation Detected Simulation Stopped
And if H is correct about that, then H can never abort its simulation,
so H lies.
If H does abort its simulation, it is incorrect about its conclusion
that this is an infinitely recursive simulation.
H just doesn't understand the behavior of the H that it is simulating.
> We can see that the first seven instructions of D simulated by H
> precisely match the first seven instructions of the x86 source-code of
> D. This conclusively proves that these instructions were simulated
So, we see that D will call an H that will simulate D again, and since
we now know that H WILL abort its simulation when it gets to the call to
H, we know that there is no infinite simulation loop, but that it will
be aborted by H.
Until you can show that the two identical H's will actually behave
differently, you are just claiming a lie.
This has been asked before, and you have failed to answer, thus showing
that you admit you can't prove your claim, and it is just a fabricaiton
and a lie
> Anyone sufficiently technically competent in the x86 programming
> language will agree that the above execution trace of D simulated by H
> shows that D will never reach its own "return" statement.
Which just proves that it is impossible for H to correct simulate this
input to prove that it is Halting.
Your proof is just that the whole category of such deciders can never be
> H detects that D is calling itself with the exact same arguments that H
> was called with and there are no conditional branch instructions from
> the beginning of D to its call to H that can possibly escape the
> repetition of this recursive simulation.
No, we KNOW that a CORRECT AND COMPLETE simulation of the input. not
able to be done by H, will see the excape if H gives the answer 0, thus
H is incorrect for the ACTUAL requriement.
It is only "correct" for your "strawman" requirement, which proves that
that your claimed equivalent requirement is not actually equivalent by
is just a strawman.
You are just proving your stupidity.