2 views

Skip to first unread message

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

{

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

Sep 16, 2022, 12:38:14 PMSep 16

to

On 9/16/2022 11:25 AM, Ben Bacarisse wrote:

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

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

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

void Px(ptr x)

{

int Halt_Status = Hx(x, x);

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

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

olcott <polc...@gmail.com> wrote:

> 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

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

olcott <polc...@gmail.com> wrote:

> 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

Search

Clear search

Close search

Google apps

Main menu