Google Groups no longer supports new Usenet posts or subscriptions. Historical content remains viewable.

Dismiss

2 views

Skip to first unread message

Feb 16, 2023, 3:24:47 PM2/16/23

to

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

}

*Here is my current irrefutable reasoning*

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

Everyone attempting to refute the above verified fact either

uses the strawman deception to change the subject away from

[D correctly simulated by H]

or flat out lies about the behavior of

[D correctly simulated by H]

*Complete halt deciding system* (Visual Studio Project)

https://liarparadox.org/2023_02_07.zip

*Simulating Halt Deciders Defeat the Halting Theorem*

https://www.researchgate.net/publication/368568464_Simulating_Halt_Deciders_Defeat_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

{

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

}

*Here is my current irrefutable reasoning*

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

Everyone attempting to refute the above verified fact either

uses the strawman deception to change the subject away from

[D correctly simulated by H]

or flat out lies about the behavior of

[D correctly simulated by H]

*Complete halt deciding system* (Visual Studio Project)

https://liarparadox.org/2023_02_07.zip

*Simulating Halt Deciders Defeat the Halting Theorem*

https://www.researchgate.net/publication/368568464_Simulating_Halt_Deciders_Defeat_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

Feb 16, 2023, 6:51:56 PM2/16/23

to

On 2/16/23 3:24 PM, olcott wrote:

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

> }

>

> *Here is my current irrefutable reasoning*

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

>

> Everyone attempting to refute the above verified fact either

> uses the strawman deception to change the subject away from

> [D correctly simulated by H]

> or flat out lies about the behavior of

> [D correctly simulated by H]

>

>

>

> *Complete halt deciding system* (Visual Studio Project)

> https://liarparadox.org/2023_02_07.zip

>

> *Simulating Halt Deciders Defeat the Halting Theorem*

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

>

In computability theory, the halting problem is the problem of
> 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));

> }

>

> *Here is my current irrefutable reasoning*

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

>

> Everyone attempting to refute the above verified fact either

> uses the strawman deception to change the subject away from

> [D correctly simulated by H]

> or flat out lies about the behavior of

> [D correctly simulated by H]

>

>

>

> *Complete halt deciding system* (Visual Studio Project)

> https://liarparadox.org/2023_02_07.zip

>

> *Simulating Halt Deciders Defeat the Halting Theorem*

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

>

determining, from a description of an arbitrary computer program and an

input, whether the program will finish running, or continue to run forever.

D(D) Halts

H(D,D) says Non-Halting, thus it is NOT a "Correct Halting Decider of

Computabilyt Theory", and any claim it is can be clearly seen to be a LIE.

Feb 16, 2023, 9:03:11 PM2/16/23

to

On 2/16/2023 2:24 PM, olcott wrote:

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

> }

>

> *Here is my current irrefutable reasoning*

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

>

> Everyone attempting to refute the above verified fact either

> uses the strawman deception to change the subject away from

> [D correctly simulated by H]

> or flat out lies about the behavior of

> [D correctly simulated by H]

>

>

>

> *Complete halt deciding system* (Visual Studio Project)

> https://liarparadox.org/2023_02_07.zip

>

> *Simulating Halt Deciders Defeat the Halting Theorem*

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

>

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

> }

>

> *Here is my current irrefutable reasoning*

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

>

> Everyone attempting to refute the above verified fact either

> uses the strawman deception to change the subject away from

> [D correctly simulated by H]

> or flat out lies about the behavior of

> [D correctly simulated by H]

>

>

>

> *Complete halt deciding system* (Visual Studio Project)

> https://liarparadox.org/2023_02_07.zip

>

> *Simulating Halt Deciders Defeat the Halting Theorem*

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

>

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 it is universally understood (by the definition of a UTM) that D
determining, from a description of an arbitrary computer program and an

input, whether the program will finish running, or continue to run

forever.

correctly simulated by H necessarily demonstrates the actual behavior

specified by this input.

My reviewers already know this... yet disagree with verified facts

anyway so that they can play trollish head games.

Feb 16, 2023, 9:37:58 PM2/16/23

to

H doesn't do that, so H isn't a UTM, and thus H's simulation can not be

a substute for the actual execution of the input, or even the UTM

simulation of the input.

>

> My reviewers already know this... yet disagree with verified facts

> anyway so that they can play trollish head games.

>

and thus your claim that you can use its simulation is just a LIE.

Your continued instance just proves your ignorance.

The actual VERIIFED FACTS, which even you have agreed to is that D(D)

will Halt with your H that returns 0, which means non-halting from

H(D,D), and thus by the definition of a Halt Decider, the correct answer

is Halting,

It is also clear that you claims that Non-Halting is a "Correct Answer"

when you admit that the machine will actually Halt means you are just

LYING about what you are talking about.

PERIOD.

Feb 17, 2023, 9:24:26 AM2/17/23

to

to simulate its input until H correctly determines that D correctly

simulated by H would never halt.

Because H is based on a UTM we know that the behavior that H is

evaluating is the behavior specified by its input.

Feb 17, 2023, 9:43:01 AM2/17/23

to

corredctly determint that D correctly simulated BY A UTM would never halt.

But, because H isn't a UTM, since it DOES abort its simulation before

getting to an end, it is an error to assume that H is a UTM, or in

particular, that D calling H is calling a UTM.

All you have done is show that you don't understand the basics of

programming.

You whole "proof" is based on the LIE that H is just like a UTM, when it

isn't.

Feb 17, 2023, 10:04:25 AM2/17/23

to

that D correctly simulated by H would never reach its own "return"

statement and terminate normally.

Feb 17, 2023, 11:07:05 AM2/17/23

to

That is like saying you are just like an immortal being until you die,

thus you can call yourself immortal.

You don't understand what being something means.

Maybe that is why you have at various times claimed to be "like God"

because you don't understand what that means.

You are not immortal, but maybe immoral due to your past history that

has been revealed.

H is NOT a Halt Decider, because 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 D(D) has been shown to Halt, and you have even admittted that,
arbitrary computer program and an input, whether the program will finish

running, or continue to run forever.

H(D,D) can NOT be a correct halt decider and say non-halting.

Either H isn't correct, or isn't a Halt Decider.

You claim that it is a correct halt decider is just proven to be a LIE

and shows that you are totally ignorant of the topic you are talking about.

0 new messages

Search

Clear search

Close search

Google apps

Main menu