Simulating halt deciders defeat the halting theorem

[olcott]

(a) If simulating halt decider H correctly simulates its input D until H
correctly determines that its simulated D could not possibly reach its
own "return" statement in a finite number of simulated steps then:

(b) H can abort its simulation of D and correctly report that D
specifies a non-halting sequence of configurations.

When it is understood that (b) is a necessary consequence of (a) and we
can see that (a) has been met then we understand that H(D,D) has
correctly determined the halt state of its input.

001 int D(int (*x)())
002 {
003 int Halt_Status = H(x, x);
004 if (Halt_Status)
005 HERE: goto HERE;
006 return Halt_Status;
007 }
008
009 int main()
010 {
011 Output("Input_Halts = ", H(D,D));
012 Output("Input_Halts = ", D(D));
013 }

*Simulating halt deciders applied to the halting theorem*
The above is fully operational code in the x86utm operating system.

Because H correctly detects that D correctly simulated by H would
continue to call H(D,D) never reaching its own "return" statement H
aborts it simulation of D and returns 0 to main() on line 011.

Because H correctly detects that D correctly simulated by H would
continue to call H(D,D) never reaching its own "return" statement H
aborts it simulation of D and returns 0 to the executed D on line 003.

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

Every recent rebuttal uses the strawman deception to change the subject
away from: { D correctly simulated by H } or denies that (b) is a
necessary consequence of (a).



*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

[Richard Damon]

On 2/14/23 7:57 PM, olcott wrote:
> (a) If simulating halt decider H correctly simulates its input D until H
> correctly determines that its simulated D could not possibly reach its
> own "return" statement in a finite number of simulated steps then:

Eccept that H can never correctly determine this of D, since if the H
that is called by D does ever abort its simulation and returns 0, then D
will halt, thus, since BY DEFINITION, the H we are talking about must be
the same decider, unless you can show that a "Turing Equivalent Program"
can act differently in two call sites, this can't happen.

You have been asked for this evidence, and failed to provide it, thus
you have effectively admitted it is FALSE.

>
> (b) H can abort its simulation of D and correctly report that D
> specifies a non-halting sequence of configurations.


>
> When it is understood that (b) is a necessary consequence of (a) and we
> can see that (a) has been met then we understand that H(D,D) has
> correctly determined the halt state of its input.

but (a) is never true for D

>
> 001 int D(int (*x)())
> 002 {
> 003   int Halt_Status = H(x, x);
> 004   if (Halt_Status)
> 005     HERE: goto HERE;
> 006   return Halt_Status;
> 007 }
> 008
> 009 int main()
> 010 {
> 011   Output("Input_Halts = ", H(D,D));
> 012   Output("Input_Halts = ", D(D));
> 013 }
>
> *Simulating halt deciders applied to the halting theorem*
> The above is fully operational code in the x86utm operating system.
>
> Because H correctly detects that D correctly simulated by H would
> continue to call H(D,D) never reaching its own "return" statement H
> aborts it simulation of D and returns 0 to main() on line 011.

Execpt it doesn't, because H will always abort its simulation too soon,
and an actual correct simulation will reach the return statement,
showing H is incorrect.

>
> Because H correctly detects that D correctly simulated by H would
> continue to call H(D,D) never reaching its own "return" statement H
> aborts it simulation of D and returns 0 to the executed D on line 003.

Except it doesnt.

>
> 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

Right, and since the DEFINITION of Halting is about the ACTUAL BEHAVIOR
of the machine, or equivalently the simulation of it by a ACTUAL UTM,
you arguements about simution by the decider (which isn't a UTM) is just
shwon to be a STRAWMAN, and your entire arguement a big fat LIE.

>
> Every recent rebuttal uses the strawman deception to change the subject
> away from: { D correctly simulated by H } or denies that (b) is a
> necessary consequence of (a).
>
>

Nope, all YOUR arguement are strawman because you don't use the ACTUAL
definiton of Halting.

>
> *Simulating Halt Decider Applied to the Halting Theorem*
> https://www.researchgate.net/publication/364657019_Simulating_Halt_Decider_Applied_to_the_Halting_Theorem
>
>

Just a load of garbage, as proven.

[olcott]

Simulating Halt decider H(D,D) computes the mapping from its inputs to
an accept or reject state based on the behavior of D correctly simulated
by H. H simulates D until H determines that D would never reach its own
"return" statement in any finite number of simulated steps.

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.

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.

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.

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
Address_of_H:1562
[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

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
correctly.

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.

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.

[Richard Damon]

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
actual UTM.

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
> Address_of_H:1562
> [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
> correctly.
>

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
correct.

>
> 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.

[olcott]

On 2/15/2023 7:47 PM, Ben Bacarisse wrote:
> Fritz Feldhase <franz.fri...@gmail.com> writes:
>
>> On Wednesday, February 15, 2023 at 10:32:19 PM UTC+1, Ben Bacarisse wrote:
>>
>>> Me: do you still assert that H(P,P) == false is the "correct" answer
>>> even though P(P) halts?
>>>
>>> PO: Yes that is the correct answer even though P(P) halts.
>>
>> Wow!
>>
>> So for PO H is a "correct halt decider" even if it states that a
>> program P with input P _doesn't halt_, though it _halts_.
>>
>> Well, what can I say?
>
> What indeed. I think this is pretty much the only reply that should be
> made to PO. He may, one day, admit that that was wrong and start to
> build a new waffle mountain, but until then, its game over.
>
>> Seems that all cranks are more or less "the same" (in a certain
>> sense): WM, PO, JG, AP, etc.
>
> In some way yes, but they all disagree with each other when the surface
> is scratched because they all want to be the unique individual who as
> seen clearly where everyone else was blind. I would not be surprised if
> they all had NPD.
>
>> See:
>> https://context.reverso.net/%C3%BCbersetzung/spanisch-englisch/loco%2C+loco
>
> Possibly literally!
>

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));

Output("Input_Halts = ", D(D));
}

None-the-less Ben will not lie about:
*H correctly predicts that D correctly simulated by H would never halt*
*H correctly predicts that D correctly simulated by H would never halt*
*H correctly predicts that D correctly simulated by H would never halt*

[Richard Damon]

So, you aren't working on the Halting Problem so your HH isn't actually
a Halting Decider.

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.


**WHETHER THE PROGRAM WILL FINISH RUNNING**

Note if some sort of somulation by H would never halt, which can't be
"correct" since a "correct simulation" show the actual behavior of the
thing simulated, and it has been shown that D(D) will Halt since H(D,D)
returns 0.

You are just proving you are ignorant of what you are talking about and
are just a patholgocial liar not caring if your words are accurate.

[olcott]

In other words because Ben is not a liar he implicitly affirms that
H(D,D) does correctly compute the mapping from its input to its reject
state on the above basis.

[Richard Damon]

No, he says you THINK "A Correct Halt Decider" can say what you say it
does, even if that isn't the actual definition of a corect halt decider.


Read what he asy again

He says that for YOU, H is correct, ... even if it states that a program
doesn't halt when it halts.

You are just showing you don't understand English.

[olcott]

There are all kinds of way to weasel word around the above two verified
facts that will fool the gullible.

*None-the-less this verified fact remains irrefutable*

H(D,D) does correctly compute the mapping from its input to its reject

state on the basis that H correctly predicts that D correctly simulated
by H would never halt.

[Richard Damon]

Which isn't Halt Deciding but just Peter Olcott's Other Problem (POOP)
deciding.

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 a HALT DECIDER must report on the behavior of whether the ACTUAL
PROGRAM (described by the input) would Halt or not.

D(D) Halts, since H(D,D) returns 0.

THus, for an actual Halt Decider, the correct answer is Halting.

Since you say the "Correct Answer" in Not Halting, the question CAN'T be
the Halting Problem, or you are just proving you are a LIAR.

You H may in fact be a correct POOP decider, which you THINK is a Halt
Decider, but it isn't one.

PERIOD.

All your weasle words to claim otherwise are just revealed to be what
they are, and you are proved to be an idiot as you can't tell the
difference between POOP and Halting.

[olcott]

*Finally a most important key point of agreement*

Now we are at the point where I said that I painted my house white and
people disagree on the basis that the can of paint said that the color
was eggshell.

[Richard Damon]

So, you still think that your POOP is halting, because you don't know
the difference.

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.

This says NOTHING about the decider being able to argue about it being
unable to simulate to a final state.

The ONLY thing that matters is the behavior of the actual machine. PERIOD.

Anything else either must be actually equivalent, so the answer is the
same, or it isn't a correct interpreation.

This is like you saying you painted the house white, but the color is
actually purple.

Your idea of what "Halting" means isn't compatible with the actual
definition in all cases, and H^/P/D is one of the cases it differs. You
are just too blind to be able to tell the difference.

You may THINK its just like White vs Eggshell, but that just shows you
don't actually understand what you are talking about.

Ultimately, you have made the explicit claim that even though D(D)
Halts, that Non-Halting is the correct answer for H to give as a Halt
Decider.

THAT IS WRONG. PERIOD.

Your claim just proves you are either totally ignorant, or a
pathological liar, or most likely BOTH.

[olcott]

On 2/16/2023 8:44 AM, Don Stockbauer wrote:

*Now that I have agreement that the following is a verified fact it*
*becomes much more efficient for others to accurately evaluate my work*

*It is a verified fact that* H(D,D) does correctly compute the mapping

from its input to its reject state on the basis that H correctly

predicts that D correctly simulated by H would never halt (reach its own
"return" statement and terminate normally).

The above paragraph sums up the entire essence the many thousands of
hours of work since 2004. I also show how to apply this to the Peter
Linz (Turing machine based proof in this paper.

*Simulating Halt Deciders Defeat the Halting Theorem*
https://www.researchgate.net/publication/368568464_Simulating_Halt_Deciders_Defeat_the_Halting_Theorem

[Richard Damon]

So, all you have done is proved that you aren't actualy working on a
Halt Decider, as the definiton of a Halt decider is "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. "

Since that isn't the problem you are working on. you are just shown to
be LYING about working on it.

It is clear that you aren't working on the Halting Problem because you
have ADMITTED that even though P(P) will Halt, H(P,P) is correct to say
its input is non-halting, thus it can't be the halt decider of
computability theory.

PERIOD.

Thus, all your words are show to just be LIES.