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

Dismiss

0 views

Skip to first unread message

Feb 20, 2023, 1:39:07 PM2/20/23

to

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

{

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

Feb 20, 2023, 7:20:37 PM2/20/23

to

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

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.

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.

>

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.

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.

>

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.

Feb 20, 2023, 7:46:47 PM2/20/23

to

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

>

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.

Feb 20, 2023, 8:10:10 PM2/20/23

to

correctly simulated by simulating halt decider H.

Feb 20, 2023, 8:55:03 PM2/20/23

to

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
an input, whether the program will finish running, or continue to run

forever.

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.

>

>

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.

Feb 20, 2023, 9:22:28 PM2/20/23

to

above definition necessary requires that D simulated by H derives an

execution trace that is not specified by its input...

Feb 20, 2023, 9:32:40 PM2/20/23

to

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.

Feb 20, 2023, 9:53:10 PM2/20/23

to

*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

Feb 20, 2023, 10:06:37 PM2/20/23

to

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
input, whether the program will finish running, or continue to run forever.

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.

Feb 20, 2023, 10:28:46 PM2/20/23

to

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.

Feb 20, 2023, 10:38:36 PM2/20/23

to

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
program and an input, whether the program will finish running, or

continue to run forever.

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.

Feb 20, 2023, 11:08:12 PM2/20/23

to

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.

Feb 20, 2023, 11:21:55 PM2/20/23

to

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
input, whether the program will finish running, or continue to run forever.

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.

Feb 20, 2023, 11:44:06 PM2/20/23

to

Feb 21, 2023, 7:03:28 AM2/21/23

to

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?

Feb 21, 2023, 10:38:20 AM2/21/23

to

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.

Feb 21, 2023, 6:45:54 PM2/21/23

to

DEFINITOIN.

>

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

>

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

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.

>

How does your idea handle the Busy Beaver issue?

0 new messages

Search

Clear search

Close search

Google apps

Main menu