Hx(Px,Px)==0 is proven to be correct (refuting halting problem proofs) V2sci

2 views
Skip to first unread message

olcott

unread,
Sep 16, 2022, 12:17:22 PMSep 16
to
void Px(ptr x)
{
int Halt_Status = Hx(x, x);
if (Halt_Status)
HERE: goto HERE;
return;
}

int main()
{
Output("Input_Halts = ", Hx(Px, Px));
}

*Understanding the above code proves this*
There are zero elements of infinite set of Hx/Px pairs such that the
correct *partial or complete* simulation of Px by Hx reaches the final
state of Px.

*THIS LOGICALLY FOLLOWS (as a subset) FROM ABOVE*
(A) Every element of the infinite set of Hx/Px pairs that does a correct
and complete simulation of its input never reaches the final state of
this input.

*THIS IS THE DEFINITION OF A UTM THUS KNOWN TO BE TRUE*
(B) A correct and complete simulation of Px by Hx derives the actual
behavior of Px.

*THIS LOGICALLY FOLLOWS FROM (A) AND (B) PREMISES*
(C) The actual behavior of this input never reaches the final state of
this input.

When the criteria for a simulating halt decider (SHD) is to correctly
predict that its complete and correct simulation of its input would
never reach the final state of this simulated input then:

void Infinite_Loop()
{
HERE: goto HERE;
}
*H0(Infinite_Loop)==0 // is correct*

void Infinite_Recursion(int N)
{
Infinite_Recursion(N);
}
*H(Infinite_Recursion, 0x777)==0 // is correct*

Every Hx that returns zero correctly predicts that every Px correctly
and completely simulated by any Hx never reaches the final state of Px.
*Hx(Px,Px)==0 // is correct*

computation that halts … the Turing machine will halt whenever it enters
a final state. (Linz:1990:234)

The particular instance of Hx named H and contained in Halt7.c does
correctly predict
that the arguments to H(P,P) cannot possibly reach their own final
state. H makes this
prediction on the basis of correctly matching a correct
infinite-behavior pattern.

*complete halt deciding system including*
*(a) x86utm operating system*
*(b) complete x86 emulator*
*(c) All of the various halt deciders and their inputs are contained in
Halt7.c*
https://liarparadox.org/2022_09_07.zip

This system currently only compiles under:
Microsoft Visual Studio Community 2017
https://visualstudio.microsoft.com/vs/older-downloads/

*Halting problem proofs refuted on the basis of software engineering* ?
https://www.researchgate.net/publication/361701808_Halting_problem_proofs_refuted_on_the_basis_of_software_engineering


Linz, Peter 1990. An Introduction to Formal Languages and Automata.
Lexington/Toronto: D. C. Heath and Company. (317-320)

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

olcott

unread,
Sep 16, 2022, 12:38:14 PMSep 16
to
On 9/16/2022 11:25 AM, Ben Bacarisse wrote:
> olcott <polc...@gmail.com> writes:
>
>> void Px(ptr x)
>> {
>> int Halt_Status = Hx(x, x);
>
> And so on...
>
> Just a heads-up: this thread is not about C or C++ and if you feel the
> need to reply do so on comp.theory (Followup-To set). The OP also set
> followup-to (so kudos there), but he's just fishing for new people to
> talk to, as all but one have stopped replying on comp.theory. If you
> feel the urge, I invite to review his >18-year history of posting on
> this topic first.
>

No one has found any error in the above and have given up responding on
this basis because they were only ever interested in forming rebuttals
to my work.

I post to comp.lang.c and comp.lang.c++ because the proof that my work
is correct can now be understood on the basis of ordinary software
engineering in these two languages.

Mr Flibble

unread,
Sep 16, 2022, 7:09:34 PMSep 16
to
On Fri, 16 Sep 2022 11:17:18 -0500
olcott <polc...@gmail.com> wrote:

> void Px(ptr x)
> {
> int Halt_Status = Hx(x, x);
> if (Halt_Status)
> HERE: goto HERE;
> return;
> }
>
> int main()
> {
> Output("Input_Halts = ", Hx(Px, Px));
> }
>
> *Understanding the above code proves this*
> There are zero elements of infinite set of Hx/Px pairs such that the
> correct *partial or complete* simulation of Px by Hx reaches the
> final state of Px.

Your Hx gives an incorrect halting decision if Px is rewritten as:

void Px(ptr x)
{
int Halt_Status = Hx(x, x);
(void)Halt_Status;
return;
}

It is patently obvious to everyone except you that if Hx is a valid
halt decider then it must return a value to Px meaning Px will then
halt. Your Hx gives a halting decision of non-halting which is
erroneous.

/Flibble

Mr Flibble

unread,
Sep 16, 2022, 9:06:41 PMSep 16
to
On Fri, 16 Sep 2022 18:37:03 -0500
olcott <polc...@gmail.com> wrote:
> Why are you deliberately cross-posting when follow-up is explicitly
> set of comp.theory?

I am deliberately cross-posting to the same newsgroups that you
originally posted to which to me seems entirely appropriate, and I have
done so again; if you don't like it then you shouldn't cross-post in
the first place.

>
> When my pure function halt decider determines the halt status of the
> above input it aborts this input before the call to itself is even
> executed.
>
> If you believe that a function that was never even executed must
> return a value then you must be nuts.
>
> If you can't see that the return value from Hx is unreachable from
> the correctly simulated Px then you must be incompetent.

A correct simulation of Px would show that Px halts: your simulation
is incorrect because your halting decider is broken.

/Flibble

Mr Flibble

unread,
Sep 17, 2022, 10:22:57 AMSep 17
to
On Fri, 16 Sep 2022 20:10:57 -0500
olcott <polc...@gmail.com> wrote:
> Since you have been made fully aware that extensive cross-posting to
> these groups can permanently kill these groups you are a spiteful
> jackass.

Pointing out your mistakes to your audience isn't being a spiteful
jackass, it is an honourable public service.

/Flibble

Reply all
Reply to author
Forward
0 new messages