Simulating Halt Deciders Defeat the Halting Theorem V2

[olcott]

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

When simulating halt decider H is applied to the conventional (otherwise
impossible) input D ordinary software engineering conclusively proves
that D correctly simulated by H cannot possibly reach its own return
statement and terminate normally (AKA halt).

A simulating halt decider H correctly predicts whether or not D
correctly simulated by H would ever reach its own final state.

The ultimate measure of a correct simulation is that the execution trace
behavior of the simulated input exactly matches the behavior that the
input machine code specifies.

https://www.researchgate.net/publication/368568464_Simulating_Halt_Deciders_Defeat_the_Halting_Theorem

Disagreeing with the above verified facts is only possible through
dishonesty or incompetence.

Whether or not the above directly applies to the halting theorem is the
only actually open issue.

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

[Richard Damon]

On 2/20/23 1:39 PM, olcott wrote:
> int D(int (*x)())
> {
>   int Halt_Status = H(x, x);
>   if (Halt_Status)
>     HERE: goto HERE;
>   return Halt_Status;
> }
>
> When simulating halt decider H is applied to the conventional (otherwise
> impossible) input D ordinary software engineering conclusively proves
> that D correctly simulated by H cannot possibly reach its own return
> statement and terminate normally (AKA halt).

Nope, since D(D) Halt, by the conventional definition of a "Correct
Simulation", such a COrrect Simulation must indicate that D(D) will
Halt, thus and simulation that show otherwise is BY DEFINITION incorrect.

>
> A simulating halt decider H correctly predicts whether or not D
> correctly simulated by H would ever reach its own final state.

So, since in computability theory, the halting problem is the problem of
determining, from a description of an arbitrary computer program and an
input, whether the program will finish running, or continue to run
forever. And we know that D(D) Halts, the correct answer for a Halt
Decider given a description of D(D) would be halting, if H is "correct"
to say non-halting, it must not be a Halt Decider/

>
> The ultimate measure of a correct simulation is that the execution trace
> behavior of the simulated input exactly matches the behavior that the
> input machine code specifies.
>

And H mis-simulates the call to H, as it seem to assume it is calling a
function that behaves differently than what H actually does.

That or it starts from a "Correct" (but incomplete) simulation and then
does not "Correctly Determine" the results from there.

> https://www.researchgate.net/publication/368568464_Simulating_Halt_Deciders_Defeat_the_Halting_Theorem
>
> Disagreeing with the above verified facts is only possible through
> dishonesty or incompetence.

Disagreeing with the verified fact that D(D) Halts and thus the only
correct answer for H(D,D) if H is actually a Halt Decider is Halting
shows that YOU are dishonest AND incompetent.

>
> Whether or not the above directly applies to the halting theorem is the
> only actually open issue.
>

So, you ADMIT that you don't know if it applies to the Halting Theorem,
even though you claim it to be a correct answer for something you claim
is a Halt Decider by the definition of the Problem (which it isn't).

You adding this disclaim is just proof that you know your logic is
false, and you are trying to leave some weasle room to get out of your
bald faced lies.

[olcott]

On 2/20/2023 12:39 PM, olcott wrote:
> int D(int (*x)())
> {
>   int Halt_Status = H(x, x);
>   if (Halt_Status)
>     HERE: goto HERE;
>   return Halt_Status;
> }
>
> When simulating halt decider H is applied to the conventional (otherwise
> impossible) input D ordinary software engineering conclusively proves
> that D correctly simulated by H cannot possibly reach its own return
> statement and terminate normally (AKA halt).
>
> A simulating halt decider H correctly predicts whether or not D
> correctly simulated by H would ever reach its own final state.
>
> The ultimate measure of a correct simulation is that the execution trace
> behavior of the simulated input exactly matches the behavior that the
> input machine code specifies.
>
> https://www.researchgate.net/publication/368568464_Simulating_Halt_Deciders_Defeat_the_Halting_Theorem
>
> Disagreeing with the above verified facts is only possible through
> dishonesty or incompetence.
>
> Whether or not the above directly applies to the halting theorem is the
> only actually open issue.
>

*I had to tighten my language a little bit*
When the ultimate measure of correct simulation is that the execution
trace of the simulated input exactly matches the behavior that the input
machine description specifies then: It is an easily verified fact that
every counter-example input to the halting theorem D cannot possibly
reach its own simulated final state in any finite number of steps.

Most of my reviewers deceptively talk about non-inputs when they already
know that deciders only operate on inputs.

[olcott]

reach its own simulated final state in any finite number of steps when
correctly simulated by simulating halt decider H.

[Richard Damon]

Which it isn't if you want to use the fact that "Correct Simulation"
gives the same resutls as direct execution, so you are admitting you
aren't actually working on the Halting Problem anymore, since you are no
longer using a critiria that is equivalnt to Halting.

Remember, I\in computability theory, the halting problem is the problem

of determining, from a description of an arbitrary computer program and
an input, whether the program will finish running, or continue to run
forever.

Thus, it is ALWAYS the behavior of the actual execution of the program
that matters, anything else is only usable if it is actually equivalent.

>
> Most of my reviewers deceptively talk about non-inputs when they already
> know that deciders only operate on inputs.
>
>

No, YOU talk about "Non-Inputs", since the H that your H assumes it sees
is not the H that is actually given, thus it isn't answering about the
input that was actually given. (Remember, the code of the H that D calls
is part of the input)

The "Input" is the description of the Turing Machine and Input to be
decided on, and the problem is to determine what that Turing Machine
would do when given that input.

it is NOT about some non-UTM partial simulation of the input done by the
decider, THAT is just your POOP.

[olcott]

Any alternative definition for "correct simulation" that contradicts the
above definition necessary requires that D simulated by H derives an
execution trace that is not specified by its input...

[Richard Damon]

Nope. You don't seem to know what "Specified by its input" actually means.

The whole value of Pi can be considered "Specified by the input" "Pi".

Since the DEFINITION of what a Halt Decider is supposed to answer is the
behavior of the actual machine specified by its input, THAT behavior is
what the input specifies, even if H can't actually compute that.

You seem to confuse "Specified" and "Is Computable"

I guess that just shows your ignorance.

[olcott]

Anyone with sufficient software engineering skill knows that
*D simulated by H cannot possibly correctly reach its ret instruction*
Everyone else lacks sufficient software engineering skill or lies

_D()
[00001d12] 55 push ebp
[00001d13] 8bec mov ebp,esp
[00001d15] 51 push ecx
[00001d16] 8b4508 mov eax,[ebp+08]
[00001d19] 50 push eax // push D
[00001d1a] 8b4d08 mov ecx,[ebp+08]
[00001d1d] 51 push ecx // push D
[00001d1e] e83ff8ffff call 00001562 // call H
[00001d23] 83c408 add esp,+08
[00001d26] 8945fc mov [ebp-04],eax
[00001d29] 837dfc00 cmp dword [ebp-04],+00
[00001d2d] 7402 jz 00001d31
[00001d2f] ebfe jmp 00001d2f
[00001d31] 8b45fc mov eax,[ebp-04]
[00001d34] 8be5 mov esp,ebp
[00001d36] 5d pop ebp
[00001d37] c3 ret

[Richard Damon]

Which means you are admitting that you are not working on the Halting
Probelem.

Remeber, in computability theory, the halting problem is the problem of

determining, from a description of an arbitrary computer program and an
input, whether the program will finish running, or continue to run forever.

Thus, the Halting Problem isn't about the simulation done by the
decider, but the actual behavior of the program in question.

Since D(D) will "Halt" since H(D,D) will return 0 by your stipulation,
this means that the CORRECT answer by the definition is Halting.

Since your definition says the correct answer for your problem is
non-halting, it can't actually be the Halting Problem.


You seem to not understand that a problem with a conflicting answer
can't be the same as the original problem, thus your problem is shown to
just be a POOPy strawman and all you work to be worthless.

[olcott]

*THIS IS NOW A VERIFIED FACT*
Because H and D have the required "do the opposite of whatever the halt
decider decides" relationship H does correctly determine the halt status
of the halting problem proof's previously impossible input.

[Richard Damon]

Nope, remember In computability theory, the halting problem is the

problem of determining, from a description of an arbitrary computer
program and an input, whether the program will finish running, or
continue to run forever.

Thus, it doesn't actually matter what H decides about the simulation it
does, what matters is what the machine described by the input does.
SInce D(D) Halts, the only correcgt answer is Halting, so H can not be a
correct halt decider since it says non-halting.

Thus, you are shown just to be a pathological liar that continually
claims that Non-Halting is the correct answer to a problem whose answer
is Halting.

You do it based on your LIE that your strawman criteria is somehow
"equivalent" to the Halting critiria even though you acknoledge that
there answers are different for this problem.

Things that have a noticable difference are not equivalent about the
thing that they differ in. Your thinking that they are is in fact, one
of the definitions of insanity, in this case, I think it is a
pathological inabilitty to actually understand what is Truth.

[olcott]

Now that the previously impossible input has been correctly determined
to be non-halting the halting theorem loses its entire basis.

The halting theorem does not prove that a set of input pairs cannot be
divided into halting and not halting. It only proves that one criterion
measure for dividing these pairs does not always work.

[Richard Damon]

Remeber, In computability theory, the halting problem is the problem of

determining, from a description of an arbitrary computer program and an
input, whether the program will finish running, or continue to run forever.

So the division into Halting and Not Halting is based on the direct
execution of the machine described, not some simulation that shows
something different.

Thus you have NOT shown that the problem can be solved, you have only
showed that you are too stupid to understand the problem.

Since D(D) Halts, it can not be correct for H(D,D) to say non-halting,
BY DEFINITION, and any claim otherwise is just proven to be a LIE, and
you to be an ignorant pathological lying idiot.

All you have done over the last decades is to prove that you don't knwo
a thing about all the stuff you have been talking about.

Even if at some point there were some interesting points in your
arguments, you have posioned them with your pathetic lying.

[olcott]

*A famous theorem with a false conclusion ceases to be a famous theorem*

[Richard Damon]

So, you don't understand the meaning of "Definition".

Yes, if you redefine to something worthless, what "Hatling" Means,
perhaps you can show that one proof doesn't work, but you have NOT shown
that you can actually solve your POOPy Haltig Problem.

Some simple tests show that by YOUR definition, your Halt Decider does
not halt for a large class of input, at least by its own criteria, so
that means it claims that it is not a decider.



Note also, You still haven't shown that the existing proof is invalid,
as you can still not gove an actual correct answer per its definition.
so your final statement is shown to be incorrect. You have NOT shown its
conclusion to be incorrect, just that you can't read its statement and
understand what it says, because you are just too stupid.

Are we allowed to redefine YOUR statements in the same way to show who
you actually are?

[olcott]

It is a verified fact that H correctly predicts that D correctly
simulated by H would never reach its own final state and terminate
normally, thus H does correctly decide halting for its input D.

Every counter-example input to every proof of the halting theorem can be
treated this same way.

[Richard Damon]

Ad that ONE criteria is the actual criteria for a machine halt, BY
DEFINITOIN.

>
> *A famous theorem with a false conclusion ceases to be a famous theorem*

And a FALSE theorem based on a FALSE premsie is jus FALSE.

>
> It is a verified fact that H correctly predicts that D correctly
> simulated by H would never reach its own final state and terminate
> normally, thus H does correctly decide halting for its input D.

Nope, H does NOT correctly predict what its correct prediction would do,
since it doesn't do what it is predicted to do.

You are just proving your insanity.

>
> Every counter-example input to every proof of the halting theorem can be
> treated this same way.
>

Nope, which also shows your stupidity.

How does your idea handle the Busy Beaver issue?