1 view

Skip to first unread message

Feb 14, 2023, 7:57:50 PMFeb 14

to

(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

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

Feb 14, 2023, 9:03:20 PMFeb 14

to

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

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.

>

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

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.

>

> 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

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

>

>

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

>

>

Feb 15, 2023, 9:57:20 AMFeb 15

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.

Feb 15, 2023, 6:57:45 PMFeb 15

to

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.

>

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.

>

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.

>

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

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.

>

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.

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.

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.

Feb 15, 2023, 9:22:50 PMFeb 15

to

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

{

HERE: goto HERE;

return Halt_Status;

}

int main()

{

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

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

Feb 15, 2023, 9:36:59 PMFeb 15

to

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.

Feb 15, 2023, 9:40:00 PMFeb 15

to

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

state on the above basis.

Feb 15, 2023, 9:55:23 PMFeb 15

to

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.

Feb 15, 2023, 10:15:50 PMFeb 15

to

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

by H would never halt.

Feb 15, 2023, 10:20:57 PMFeb 15

to

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.

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.

Feb 15, 2023, 10:28:18 PMFeb 15

to

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.

Feb 15, 2023, 10:42:18 PMFeb 15

to

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.

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.

Feb 16, 2023, 11:59:31 AMFeb 16

to

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

"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

*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

Feb 16, 2023, 6:43:25 PMFeb 16

to

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
description of an arbitrary computer program and an input, whether the

program will finish running, or continue to run forever. "

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.

Reply all

Reply to author

Forward

0 new messages

Search

Clear search

Close search

Google apps

Main menu