Re: Halt deciders

[olcott]

On 10/17/2022 4:30 AM, Fred. Zwarts wrote:
> I have been following the discussions about Halt deciders with interest.
> As a retired software designer and developer, I have a lot of practical
> experience, but not much theoretical education, although the theoretical
> background is very interesting. I learned a lot. I would like to verify
> that I understand it correctly. Could you point out any errors in the
> summary below?
>
> 1) (Definition of halt) A program X with input Y is said to halt if it
> reaches its end condition after a finite number of steps. It does not
> halt if it continues to execute infinitely.
> (So, X(Y) either halts, or it does not halt.)
> (It is irrelevant whether the end condition is reached in the 'normal'
> way, or by other means, e.g. an unhandled 'exception'.)
>
> 2) (Definition of halt decider) A halt decider H is a program that,
> given a program X with input Y decides, after a finite number of steps,
> whether X(Y) halts or not.
> (H(X,Y) itself must halt after a finite number of steps. It must return
> either 1 if X(Y) halts, or 0 if X(Y) does not halt, where 1 and 0 are a
> convention, which could also be two other arbitrary values.)

*Professor Sipser has agreed to these verbatim words* (and no more)
If simulating halt decider H correctly simulates its input D until H
correctly determines that its simulated D would never stop running
unless aborted then H can abort its simulation of D and correctly report
that D specifies a non-halting sequence of configurations.

An alternative definition for a halt decider approved by MIT Professor
Michael Sipser (author of the best selling book on the theory of
computation)
https://www.amazon.com/Introduction-Theory-Computation-Sipser/dp/8131525295
is shown above and paraphrased below:

Would D correctly simulated by H ever stop running if not aborted?
Is proven on page 3 of this paper to be "no" thus perfectly meeting the
Sipser approved criteria shown above.

*Rebutting the Sipser Halting Problem Proof*
https://www.researchgate.net/publication/364302709_Rebutting_the_Sipser_Halting_Problem_Proof



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

On 10/17/2022 7:43 AM, Mikko wrote:

> On 2022-10-17 09:30:56 +0000, Fred. Zwarts said:
>
>> I have been following the discussions about Halt deciders with
>> interest. As a retired software designer and developer, I have a lot
>> of practical experience, but not much theoretical education, although
>> the theoretical background is very interesting. I learned a lot. I
>> would like to verify that I understand it correctly. Could you point
>> out any errors in the summary below?
>>
>> 1) (Definition of halt) A program X with input Y is said to halt if it
>> reaches its end condition after a finite number of steps. It does not
>> halt if it continues to execute infinitely.
>> (So, X(Y) either halts, or it does not halt.)
>> (It is irrelevant whether the end condition is reached in the 'normal'
>> way, or by other means, e.g. an unhandled 'exception'.)
>

> Definitions vary a little among authors. Usually the halting problem and
> other computability problems define that "program" is a Turing machine.
> The exact definition of "halt" varies but often it means that the execution
> has reached a situation where there is no rule specifying what to do next.
> With other definitions one must check whether it is possible that the
> execution neither halts nor runs forever.

>
>> 2) (Definition of halt decider) A halt decider H is a program that,
>> given a program X with input Y decides, after a finite number of
>> steps, whether X(Y) halts or not.
>> (H(X,Y) itself must halt after a finite number of steps. It must
>> return either 1 if X(Y) halts, or 0 if X(Y) does not halt, where 1 and
>> 0 are a convention, which could also be two other arbitrary values.)
>

> The halt decider must be a program in the same sense as the programs it
> examines are programs. Usually the requirement is that the required halt
> decider is a Turing machine and its input is a description of a Turing
> machine.
>
>>  From 1 and 2 it follows:
>>
>> 3) If X(Y) halts, then H must return 1. If H does not return 1 in a
>> finite number of steps, it might return another interesting result,
>> but it is not a halt decider. (Not returning 1 includes returning
>> other values, not halting, or throwing 'exceptions'.)
>>
>> 4) If X(Y) does not halt, then H must return 0. If it does not return
>> 0 in a finite number of steps, it might return another interesting
>> result, but it is not a halt decider. (Not returning 0 includes
>> returning other values, not halting, or throwing 'exceptions'.)
>
> Another way to say the same is that H is not a halt decider
> if there is some X and some Y such that
> - X(Y) halts and H(X,Y) returns 0
> - X(Y) does not halt and H(X,Y) returns 1
> - H(X,Y) returns something that is neither 0 nor 1
> - H(X,Y) does not return anything
>
>> Paradoxical program:
>
> Also called "pathological program"
>
>> 5) It is always possible to construct a program P, that uses code with
>> the same logic as H, in order to do the opposite of what H(P,P) returns.
>> (P does not necessarily need to use the exact same code as H does,
>> amongst others it could use a modified copy of H, or a simulation of H.)
>>
>>  From 5 it follows that a general halt decider that works for any X
>> and Y does not exist:
>>
>>  From 3, 4 and 5 it follows:
>>
>> 6) If P(P) halts, then H should return 1, but if H would do so, P(P)
>> would not halt.
>>
>> 7) If P(P) does not halt, H should return 0, but if H would do so,
>> P(P) would halt.
>>
>> 8) If P(P) halts and H does not return 1 after a finite number of
>> steps, then H is not a halt decider.
>> (The result could nevertheless be interesting for other purposes.)
>> (It is irrelevant what causes P(P) to halt.)
>>
>> 9) If P(P) does not halt and H does not return 0 after a finite number
>> of steps, then H is not a halt decider.
>> (The result could nevertheless be interesting for other purposes.)
>
> All that is correct.
>
> Mikko

[olcott]

On 10/17/2022 6:55 AM, wij wrote:

> On Monday, 17 October 2022 at 17:30:59 UTC+8, Fred. Zwarts wrote:
>> I have been following the discussions about Halt deciders with interest.
>> As a retired software designer and developer, I have a lot of practical
>> experience, but not much theoretical education, although the theoretical
>> background is very interesting. I learned a lot. I would like to verify
>> that I understand it correctly. Could you point out any errors in the
>> summary below?
>>
>> 1) (Definition of halt) A program X with input Y is said to halt if it
>> reaches its end condition after a finite number of steps. It does not
>> halt if it continues to execute infinitely.
>> (So, X(Y) either halts, or it does not halt.)
>> (It is irrelevant whether the end condition is reached in the 'normal'
>> way, or by other means, e.g. an unhandled 'exception'.)
>

> Basically, yes. The HP (most formal one) is specified using TM.
> A TM halts means it reaches designated final state. This is equivalent to a
> program 'returns' (whatever, you define the 'final state').
> OTHER conditions are non-halting.

>
>> 2) (Definition of halt decider) A halt decider H is a program that,
>> given a program X with input Y decides, after a finite number of steps,
>> whether X(Y) halts or not.
>> (H(X,Y) itself must halt after a finite number of steps. It must return
>> either 1 if X(Y) halts, or 0 if X(Y) does not halt, where 1 and 0 are a
>> convention, which could also be two other arbitrary values.)
>

> I find it not quite simple to define 'halt decider', probably not necessary.
> So, I say any program X that tries to test whether a given program (as X's input)
> halts or not is a 'halt decider'.

>
>> From 1 and 2 it follows:
>>
>> 3) If X(Y) halts, then H must return 1. If H does not return 1 in a
>> finite number of steps, it might return another interesting result, but
>> it is not a halt decider. (Not returning 1 includes returning other
>> values, not halting, or throwing 'exceptions'.)
>

> Yes, according to the definition (a failed halt decider)

>
>> 4) If X(Y) does not halt, then H must return 0. If it does not return 0
>> in a finite number of steps, it might return another interesting result,
>> but it is not a halt decider. (Not returning 0 includes returning other
>> values, not halting, or throwing 'exceptions'.)
>>
>

> Yes, according to the definition (a failed halt decider)
>
>> Paradoxical program:

>>
>> 5) It is always possible to construct a program P, that uses code with
>> the same logic as H, in order to do the opposite of what H(P,P) returns.
>> (P does not necessarily need to use the exact same code as H does,
>> amongst others it could use a modified copy of H, or a simulation of H.)
>>
>> From 5 it follows that a general halt decider that works for any X and
>> Y does not exist:
>>
>> From 3, 4 and 5 it follows:
>

> There are many details, but yes, you are correct.

>
>> 6) If P(P) halts, then H should return 1, but if H would do so, P(P)
>> would not halt.
>

> Correct.

>
>> 7) If P(P) does not halt, H should return 0, but if H would do so, P(P)
>> would halt.
>

> Correct.

>
>> 8) If P(P) halts and H does not return 1 after a finite number of steps,
>> then H is not a halt decider.
>> (The result could nevertheless be interesting for other purposes.)
>> (It is irrelevant what causes P(P) to halt.)
>>
>> 9) If P(P) does not halt and H does not return 0 after a finite number
>> of steps, then H is not a halt decider.
>> (The result could nevertheless be interesting for other purposes.)
>

> H is not the halt decider the Halting Problem specifies (a failed halt decider).

*Professor Sipser has agreed to these verbatim words* (and no more)
If simulating halt decider H correctly simulates its input D until H
correctly determines that its simulated D would never stop running
unless aborted then H can abort its simulation of D and correctly report
that D specifies a non-halting sequence of configurations.

An alternative definition for a halt decider approved by MIT Professor
Michael Sipser (author of the best selling book on the theory of
computation)
https://www.amazon.com/Introduction-Theory-Computation-Sipser/dp/8131525295
is shown above and paraphrased below:

Would D correctly simulated by H ever stop running if not aborted?
Is proven on page 3 of this paper to be "no" thus perfectly meeting the
Sipser approved criteria shown above.

*Rebutting the Sipser Halting Problem Proof*
https://www.researchgate.net/publication/364302709_Rebutting_the_Sipser_Halting_Problem_Proof

This is applied to the Peter Linz Halting Problem proof on page 4 of the
above paper.

[olcott]

On 10/17/2022 7:47 AM, Dennis Bush wrote:

> On Monday, October 17, 2022 at 5:30:59 AM UTC-4, Fred. Zwarts wrote:
>> I have been following the discussions about Halt deciders with interest.
>> As a retired software designer and developer, I have a lot of practical
>> experience, but not much theoretical education, although the theoretical
>> background is very interesting. I learned a lot. I would like to verify
>> that I understand it correctly. Could you point out any errors in the
>> summary below?
>>
>> 1) (Definition of halt) A program X with input Y is said to halt if it
>> reaches its end condition after a finite number of steps. It does not
>> halt if it continues to execute infinitely.
>> (So, X(Y) either halts, or it does not halt.)
>> (It is irrelevant whether the end condition is reached in the 'normal'
>> way, or by other means, e.g. an unhandled 'exception'.)
>>

>> 2) (Definition of halt decider) A halt decider H is a program that,
>> given a program X with input Y decides, after a finite number of steps,
>> whether X(Y) halts or not.
>> (H(X,Y) itself must halt after a finite number of steps. It must return
>> either 1 if X(Y) halts, or 0 if X(Y) does not halt, where 1 and 0 are a
>> convention, which could also be two other arbitrary values.)
>>

>> From 1 and 2 it follows:
>>
>> 3) If X(Y) halts, then H must return 1. If H does not return 1 in a
>> finite number of steps, it might return another interesting result, but
>> it is not a halt decider. (Not returning 1 includes returning other
>> values, not halting, or throwing 'exceptions'.)
>>

>> 4) If X(Y) does not halt, then H must return 0. If it does not return 0
>> in a finite number of steps, it might return another interesting result,
>> but it is not a halt decider. (Not returning 0 includes returning other
>> values, not halting, or throwing 'exceptions'.)
>>

>> Paradoxical program:
>>
>> 5) It is always possible to construct a program P, that uses code with
>> the same logic as H, in order to do the opposite of what H(P,P) returns.
>> (P does not necessarily need to use the exact same code as H does,
>> amongst others it could use a modified copy of H, or a simulation of H.)
>>
>> From 5 it follows that a general halt decider that works for any X and
>> Y does not exist:
>>
>> From 3, 4 and 5 it follows:
>>

>> 6) If P(P) halts, then H should return 1, but if H would do so, P(P)
>> would not halt.
>>

>> 7) If P(P) does not halt, H should return 0, but if H would do so, P(P)
>> would halt.
>>

>> 8) If P(P) halts and H does not return 1 after a finite number of steps,
>> then H is not a halt decider.
>> (The result could nevertheless be interesting for other purposes.)
>> (It is irrelevant what causes P(P) to halt.)
>>
>> 9) If P(P) does not halt and H does not return 0 after a finite number
>> of steps, then H is not a halt decider.
>> (The result could nevertheless be interesting for other purposes.)
>

> Your understanding is correct. To sum things up, the halting function (using the mathematical notion of a function), performs the following mapping:
>
> For *any* algorithm (i.e. a fixed immutable sequence of instructions) X and input Y:
> H(X,Y)==1 if and only if X(Y) halts, and
> H(X,Y)==0 if and only if X(Y) does not halt
>
> And the halting problem proofs show that this mapping is not computable, i.e. it is impossible for an algorithm to compute this mapping.

[olcott]

On 10/17/2022 9:49 AM, Dennis Bush wrote:

> And he agreed to those words based on their commonly known meanings, not your alternate weasel-word meanings.
>
> The conventional definition of "correctly simulating" means that the simulated behavior EXACTLY matches the behavior of direct execution.
I have proven an exception to this rule:

int Sipser_D(int (*M)())
{
if ( Sipser_H(M, M) )
return 0;
return 1;
}

For the infinite set of H/D pairs:
Every correct simulation of D by H will never reach the final state of D
because D specifies recursive simulation to H.

This is proven on page 3 thus refuting your claim.

*Rebutting the Sipser Halting Problem Proof*
https://www.researchgate.net/publication/364302709_Rebutting_the_Sipser_Halting_Problem_Proof

[olcott]

On 10/17/2022 10:16 AM, Dennis Bush wrote:

> That's not a rule. It's a definition.

>
>
>>
>> int Sipser_D(int (*M)())
>> {
>> if ( Sipser_H(M, M) )
>> return 0;
>> return 1;
>> }
>>
>> For the infinite set of H/D pairs:
>> Every correct simulation of D by H will never reach the final state of D
>> because D specifies recursive simulation to H.
>

> So in other words your Sipser_H is computing the PO-halting function:
>

*The PO-halting function is now Sipser approved*

*Professor Sipser has agreed to these verbatim words* (and no more)
If simulating halt decider H correctly simulates its input D until H
correctly determines that its simulated D would never stop running
unless aborted then H can abort its simulation of D and correctly report
that D specifies a non-halting sequence of configurations.

*A paraphrase of a portion of the above paragraph*

Would D correctly simulated by H ever stop running if not aborted?

The answer of "no" is proved on page 3 of this paper.

*Rebutting the Sipser Halting Problem Proof*
https://www.researchgate.net/publication/364302709_Rebutting_the_Sipser_Halting_Problem_Proof

Professor Sipser has specifically approved the abstract to this paper.

[olcott]

On 10/17/2022 10:40 AM, Dennis Bush wrote:

> No it's not, because he used the actual meaning of the words and not your weasel-worded definitions. Using the real definitions,

*Professor Sipser has agreed to these verbatim words* (and no more)
If simulating halt decider H correctly simulates its input D until H
correctly determines that its simulated D would never stop running
unless aborted then H can abort its simulation of D and correctly report
that D specifies a non-halting sequence of configurations.

*A paraphrase of a portion of the above paragraph*
Would D correctly simulated by H ever stop running if not aborted?

The answer of "no" is proved on page 3 of this paper.

*Rebutting the Sipser Halting Problem Proof*
https://www.researchgate.net/publication/364302709_Rebutting_the_Sipser_Halting_Problem_Proof

*Still no rebuttal of page 3 because you know that page 3 is correct*

[olcott]

On 10/17/2022 10:47 AM, Dennis Bush wrote:

> You still seem to think that because you have an H that partially computes the PO-halting function that it has anything to do with the halting function. It does not.
>
> So anything that does not address whether the halting function is computable is irrelevant.

Anyone that is sufficiently technically competent can verify that H does
correctly determine the halt status of D correctly simulated by H.

This proves that the conventional proofs that rely on D doing the
opposite of whatever H decides have been refuted by the notion of a
simulating halt decider.

This does not prove that the halting problem has been solved.

[olcott]

On 10/17/2022 11:00 AM, Andy Walker wrote:
> On 17/10/2022 13:43, Mikko wrote:
> {Fred. Zwarts:]

>>> Paradoxical program:
>> Also called "pathological program"
>

>     Just an additional comment.  The use of words such as
> "paradoxical", "pathological", "impossible", ... conveys to the
> unwary reader a notion that these programs are difficult, or
> unreasonable, in some way.  Not so;  they are merely counter-
> examples.  *If* you claim to have a program "H" that [you claim]
> is a "halt decider", *then*, sorry, your claim is incorrect, and
> /here/ is a program "P" on which "H" fails [where "here" denotes
> the standard "do the opposite" construction much discussed here].

*Professor Sipser has agreed to these verbatim words* (and no more)
If simulating halt decider H correctly simulates its input D until H
correctly determines that its simulated D would never stop running
unless aborted then H can abort its simulation of D and correctly report
that D specifies a non-halting sequence of configurations.

The above notion of a simulating halt decider defeats this "do the
opposite" construction as proven on page 3:

*Rebutting the Sipser Halting Problem Proof*
https://www.researchgate.net/publication/364302709_Rebutting_the_Sipser_Halting_Problem_Proof

[olcott]

On 10/17/2022 11:00 AM, Dennis Bush wrote:

> No one is denying that you're able to compute a subset of the PO-halting function. The halting problem proofs are about the halting function.

>
>>
>> This proves that the conventional proofs that rely on D doing the
>> opposite of whatever H decides have been refuted by the notion of a
>> simulating halt decider.
>

> The conventional proofs are making claims about the halting function, not the PO-halting function, therefore claims about the PO-halting function are irrelevant.

*Professor Sipser has agreed to these verbatim words* (and no more)
If simulating halt decider H correctly simulates its input D until H
correctly determines that its simulated D would never stop running
unless aborted then H can abort its simulation of D and correctly report
that D specifies a non-halting sequence of configurations.

int Sipser_D(int (*M)())
{
if ( Sipser_H(M, M) )
return 0;
return 1;
}

This notion of a simulating halt decider is proven to correctly
determine the halt status of Sipser_D by Sipser_H.

*Rebutting the Sipser Halting Problem Proof*
https://www.researchgate.net/publication/364302709_Rebutting_the_Sipser_Halting_Problem_Proof

[olcott]

On 10/17/2022 11:25 AM, Dennis Bush wrote:

>> [ repeat of previously refuted statement ]

>>
>> int Sipser_D(int (*M)())
>> {
>> if ( Sipser_H(M, M) )
>> return 0;
>> return 1;
>> }
>> This notion of a simulating halt decider is proven to correctly
>> determine the halt status of Sipser_D by Sipser_H.
>> *Rebutting the Sipser Halting Problem Proof*
>> https://www.researchgate.net/publication/364302709_Rebutting_the_Sipser_Halting_Problem_Proof
>

> In other words, you can compute a subset of the PO-halting function. And since the halting problem proofs make claims about the halting function, claims about the PO-halting function are irrelevant.

The halting problem proofs make claims about the halting function on the
basis that the halt status of Sipser_D cannot be correctly determined by
Sipser_H. The notion of a simulating halt decider removes that basis
thus causing all of these conventional proofs to fail.

[Python]

Demented kook Peter Olcott wrote:
> On 10/17/2022 11:25 AM, Dennis Bush wrote:

...

>> In other words, you can compute a subset of the PO-halting function.
>> And since the halting problem proofs make claims about the halting
>> function, claims about the PO-halting function are irrelevant.
>
> The halting problem proofs make claims about the halting function on the
> basis that the halt status of Sipser_D cannot be correctly determined by
> Sipser_H. The notion of a simulating halt decider removes that basis
> thus causing all of these conventional proofs to fail.
>

So now you're only claiming that you only have a "partial" halt
decider... LOL.

Whatever, this "partial halt-decider" does not simulates properly
its problematic argument (the D built on it) and MOREOVER fail to
properly state if this argument halts or not when executed.

H(D,D) returns 0 (non-halting) while D(D), when actually ran, halts.

None of your attempts to obfuscate the subject can change that.

[olcott]

On 10/17/2022 11:33 AM, Dennis Bush wrote:

> Correct: the halting function maps D to halting but Sipser_H maps D to non-halting, so it is unable to compute the halting function.

*Professor Sipser has agreed to these verbatim words* (and no more)
If simulating halt decider H correctly simulates its input D until H
correctly determines that its simulated D would never stop running
unless aborted then H can abort its simulation of D and correctly report
that D specifies a non-halting sequence of configurations.

Thus professor Sipser has agreed that the above H does compute the
halting function for the above D.

Professor Sipser has specifically approved the abstract to this paper:

*Rebutting the Sipser Halting Problem Proof*
https://www.researchgate.net/publication/364302709_Rebutting_the_Sipser_Halting_Problem_Proof

[Mr Flibble]

If H is a Flibble Signaling Decider then H will correctly simulate its
input D however if H is an Olcott Simulation Detector H will not
correctly simulate its input D as the only correct simulation of D is
for the simulation to behave as if D(D) was directly executed.

/Flibble

[olcott]

On 10/17/2022 10:23 AM, Ben Bacarisse wrote:
> ...D(D) would not halt unless H stops the simulation.
> H /can/ correctly determine this silly criterion
> (in this one case)...

*Professor Sipser has agreed to these verbatim words* (and no more)
If simulating halt decider H correctly simulates its input D until H
correctly determines that its simulated D would never stop running
unless aborted then H can abort its simulation of D and correctly report
that D specifies a non-halting sequence of configurations.

Thus it seems to me (I may be wrong) that Ben agrees that when the
Sipser approved criteria are applied that Sipser_H does correctly
determine the halt status of Sipser_D.

[olcott]

On 10/17/2022 11:45 AM, Mr Flibble wrote:

On 10/17/2022 10:23 AM, Ben Bacarisse wrote:
> ...D(D) would not halt unless H stops the simulation.
> H /can/ correctly determine this silly criterion
> (in this one case)...

*Professor Sipser has agreed to these verbatim words* (and no more)
If simulating halt decider H correctly simulates its input D until H
correctly determines that its simulated D would never stop running
unless aborted then H can abort its simulation of D and correctly report
that D specifies a non-halting sequence of configurations.

Thus it seems to me (I may be wrong) that Ben agrees that when the

Sipser approved criteria are applied that Sipser_H does correctly
determine the halt status of Sipser_D.

[olcott]

On 10/17/2022 11:51 AM, Dennis Bush wrote:

>> Professor Sipser has specifically approved the abstract to this paper:
>> *Rebutting the Sipser Halting Problem Proof*
>> https://www.researchgate.net/publication/364302709_Rebutting_the_Sipser_Halting_Problem_Proof
>

> Claims about the PO-halting function are irrelevant to claims about the computability of the halting function. Answering a different question doesn't make the original question answerable.

>

On 10/17/2022 10:23 AM, Ben Bacarisse wrote:
> ...D(D) would not halt unless H stops the simulation.
> H /can/ correctly determine this silly criterion
> (in this one case)...

*Professor Sipser has agreed to these verbatim words* (and no more)
If simulating halt decider H correctly simulates its input D until H
correctly determines that its simulated D would never stop running
unless aborted then H can abort its simulation of D and correctly report
that D specifies a non-halting sequence of configurations.

Thus it seems to me (I may be wrong) that Ben agrees that when the

Sipser approved criteria are applied that Sipser_H does correctly
determine the halt status of Sipser_D.

[olcott]

On 10/17/2022 12:13 PM, Dennis Bush wrote:

>> [ repeat of previously refuted claim ]

>> Thus it seems to me (I may be wrong) that Ben agrees that when the
>> Sipser approved criteria are applied that Sipser_H does correctly
>> determine the halt status of Sipser_D.
>

> It's determining the PO-halt status (i.e. mapping the PO-halting function), not the halt status (i.e. mapping the halting function).
>
> The halting problem proofs only care about the latter, so the former is irrelevant.

*Professor Sipser has agreed to these verbatim words* (and no more)
If simulating halt decider H correctly simulates its input D until H
correctly determines that its simulated D would never stop running
unless aborted then H can abort its simulation of D and correctly report
that D specifies a non-halting sequence of configurations.

The above seems to be saying that professor Sipser (author of the best

selling book on the theory of computation)
https://www.amazon.com/Introduction-Theory-Computation-Sipser/dp/8131525295

agrees that H does correctly compute the halting function of D.

Ben also seems to agree that Sipser_H does compute the halting function
of Sipser_D, yet only within the Sipser approved criteria.

[olcott]

On 10/17/2022 12:57 PM, Dennis Bush wrote:

>>> It's determining the PO-halt status (i.e. mapping the PO-halting function), not the halt status (i.e. mapping the halting function).
>>>
>>> The halting problem proofs only care about the latter, so the former is irrelevant.
>>

>> [ repeat of previously refuted statement ]
>

> The halting problem proofs state that the halting function:

>
> For *any* algorithm (i.e. a fixed immutable sequence of instructions) X and input Y:
> H(X,Y)==1 if and only if X(Y) halts, and
> H(X,Y)==0 if and only if X(Y) does not halt
>

> Is not a computable function, therefore claims about the PO-halting function are irrelevant.

*Professor Sipser has agreed to these verbatim words* (and no more)
If simulating halt decider H correctly simulates its input D until H
correctly determines that its simulated D would never stop running
unless aborted then H can abort its simulation of D and correctly report
that D specifies a non-halting sequence of configurations.

That prior work in this field totally ignored the notion of a simulating
halt decider and thus defined halt status criteria that continues to
ignore this notion is superseded and overruled once the notion of a
simulating halt decider has been validated and affirmed as shown above.

[Fred. Zwarts]

Op 17.okt..2022 om 16:29 schreef olcott:

It is not clear to me what you want to say and why you left out my other
points from the quote. You quote only the definitions. You left out the
points that follow from the definitions. What does that mean. Don't you
agree with the definitions, or is something wrong with the other points?

[Sergi o]

you may not get anymore clarity from him. Separation of functions, I/Os, and variables, is a first step in clarifying the problem.
your 1 and 2 above are good initial starts, but no feedback from him. So perhaps he is not used to working in SW groups, or confused, or likes problem
definition to remain obscure.

[olcott]

On 10/17/2022 3:29 PM, Ben Bacarisse wrote:

> Dennis Bush <dbush....@gmail.com> writes:
>
>> On Monday, October 17, 2022 at 11:31:41 AM UTC-4, olcott wrote:
>

>>> *The PO-halting function is now Sipser approved*
>>

>> No it's not, because he used the actual meaning of the words and not
>> your weasel-worded definitions.
>

> PO's actions are outrageous. It's one thing to go insulting the likes
> of me -- I was foolish enough to try to reason with him -- but dragging
> Professor Sipser into this nonsense is unconscionable.
>
> Whatever PO may now claim has been "approved", Sipser thought he was
> agreeing to some minor remark. In no way does me endorse any of PO's
> wacky ideas. PO must, at some level, know that he is dishonestly
> abusing someone kind enough to reply to what looked like an innocent
> technical enquiry.
>
> However, the result is that the search engines will now dredge you PO's
> garbage in association with Sipsers good name. And every post
> (including, I know, this one) strengthens this association in the search
> sites' algorithms.
>
> PO will never see sense, so the /only/ way to stop this getting worse is
> to stop replying. Please, I implore you all, don't reply to any more
> posts on this topic. Imagine if it where you. Make to day the last day
> you take any PO post seriously.
>

*Professor Sipser has agreed to these verbatim words* (*and no more*)

If simulating halt decider H correctly simulates its input D until H
correctly determines that its simulated D would never stop running
unless aborted then H can abort its simulation of D and correctly report
that D specifies a non-halting sequence of configurations.

On 10/17/2022 10:23 AM, Ben Bacarisse wrote:
> ...D(D) would not halt unless H stops the simulation.
> H /can/ correctly determine this silly criterion
> (in this one case)...

[olcott]

On 10/17/2022 1:44 PM, Fred. Zwarts wrote:

Because the above seems to agree with my definition of a simulating halt
decider other definitions that do not apply to simulating halt deciders
are irrelevant.

If I claim that a boat can transport you across the water of a lake to
the other side when someone claims that I am wrong because an automobile
cannot transport you across the water of a lake this is the strawman error.

[olcott]

On 10/17/2022 1:55 PM, Dennis Bush wrote:

>> That prior work in this field totally ignored the notion of a simulating
>> halt decider
>

> Because a simulating halt decider is not a halt decider since it maps a subset the PO-halting function instead of the halting function.
>

Because a simulating halt decider does not exactly match the notion of a
halt decider found is textbooks it may seem to mean that a simulating
halt decider is not a halt decider to those that only learn these things
by rote and have no actual depth of understanding.

*Professor Sipser has agreed to these verbatim words* (*and no more*)

If simulating halt decider H correctly simulates its input D until H
correctly determines that its simulated D would never stop running
unless aborted then H can abort its simulation of D and correctly report
that D specifies a non-halting sequence of configurations.

In other words professor Sipser seems to agree that the above is a
correct notion of a halt decider.

[olcott]

On 10/17/2022 3:29 PM, Ben Bacarisse wrote:
> Dennis Bush <dbush....@gmail.com> writes:
>

>> On Monday, October 17, 2022 at 11:31:41 AM UTC-4, olcott wrote:
>

>>> *The PO-halting function is now Sipser approved*
>>

>> No it's not, because he used the actual meaning of the words and not
>> your weasel-worded definitions.
>

> PO's actions are outrageous. It's one thing to go insulting the likes
> of me -- I was foolish enough to try to reason with him -- but dragging
> Professor Sipser into this nonsense is unconscionable.
>
> Whatever PO may now claim has been "approved", Sipser thought he was
> agreeing to some minor remark. In no way does me endorse any of PO's
> wacky ideas. PO must, at some level, know that he is dishonestly
> abusing someone kind enough to reply to what looked like an innocent
> technical enquiry.
>
> However, the result is that the search engines will now dredge you PO's
> garbage in association with Sipsers good name. And every post
> (including, I know, this one) strengthens this association in the search
> sites' algorithms.
>
> PO will never see sense, so the /only/ way to stop this getting worse is
> to stop replying. Please, I implore you all, don't reply to any more
> posts on this topic. Imagine if it where you. Make to day the last day
> you take any PO post seriously.
>

*Professor Sipser has agreed to these verbatim words* (and no more)
If simulating halt decider H correctly simulates its input D until H
correctly determines that its simulated D would never stop running
unless aborted then H can abort its simulation of D and correctly report
that D specifies a non-halting sequence of configurations.

On 10/17/2022 10:23 AM, Ben Bacarisse wrote:
> ...D(D) would not halt unless H stops the simulation.
> H /can/ correctly determine this silly criterion
> (in this one case)...

[olcott]

On 10/17/2022 4:50 PM, Dennis Bush wrote:

> It therefore has no relevance to the halting problem, as the halting problem is about whether the halting function:

>
> For *any* algorithm (i.e. a fixed immutable sequence of instructions) X and input Y:
> H(X,Y)==1 if and only if X(Y) halts, and
> H(X,Y)==0 if and only if X(Y) does not halt
>

> Is a computable function.

Yes everyone that learns by rote and has no depth of understanding would
agree with that because the notion of a simulating halt decider has been
ignored by all of the textbooks in the field.

A simulating halt decider (SHD) correctly maps its finite string inputs
to an accept or reject state on the basis of the actual behavior
specified by this finite string as measured by its correct simulation of
this finite string, THUS IS NECESSARILY A HALT DECIDER FOR THESE INPUTS.

A SHD maps all of its inputs to the same accept or reject state that any
other halt decider would map to except for the conventional "impossible"
inputs.

[olcott]

On 10/17/2022 5:46 PM, Dennis Bush wrote:

> FALSE. A simulating halt decider maps a subset of the PO-Halting function:
>
> For a function X with input Y and a function H which simulates X:
> POH(H,X,Y)==1 if and only if there exists an implementation of H that can simulate X(Y) to completion
> POH(H,X,Y)==0 if and only if there does not exist an implementation of H that can simulate X(Y) to completion
> Hx is a PO-halt decider if and only if Hx(X,Y) == POH(Hx,X,Y)
>
> While a halt decider maps the halting function:

>
> For *any* algorithm (i.e. a fixed immutable sequence of instructions) X and input Y:
> H(X,Y)==1 if and only if X(Y) halts, and
> H(X,Y)==0 if and only if X(Y) does not halt
>

> These are clearly different functions that don't even have the same number of inputs.

>
>>
>> A SHD maps all of its inputs to the same accept or reject state that any
>> other halt decider would map to except for the conventional "impossible"
>> inputs.
>

> In other words, a simulating halt decider is not a halt decider because it doesn't map the halting function:

>
> For *any* algorithm (i.e. a fixed immutable sequence of instructions) X and input Y:
> H(X,Y)==1 if and only if X(Y) halts, and
> H(X,Y)==0 if and only if X(Y) does not halt
>

> And is therefore irrelevant to the halting problem.

Sure and like I already said anyone that only learns-by-rote has no
basis to evaluate this differently.

Because professor Sipser knows these things much deeper than by rote
memorization he can correctly evaluate cases where the learned-by-rote
definition can be correctly adapted.

[olcott]

On 10/17/2022 6:51 PM, Dennis Bush wrote:

> Answering a different question doesn't make the original question go away.
*Unless this "different" question is determined to be equivalent*
Learned-by-rote people have no way to assess equivalence.

[Richard Damon]

But since it isn't, it isn't, and your claims that it is are proven to
be a lie.

If it WAS equivalent then H(P,P) would need to return 1 if P(P) Halts.

Since P(P) DOES Halt, and you have admitted it, the fact that you claim
H(P,P) returning 0 says you criteria is NOT equivalent.

Thus you claim that it is shows you don't know what you are talking about.

PROOF POSITIVE.

Your own words prove you to be wrong.

[Fred. Zwarts]

Op 17.okt..2022 om 23:22 schreef olcott:

I was not talking about simulating halt deciders, but about halt
deciders. Since we seem to agree that they are not the same, I have to
conclude that your contribution is irrelevant.

> If I claim that a boat can transport you across the water of a lake to
> the other side when someone claims that I am wrong because an automobile
> cannot transport you across the water of a lake this is the strawman error.
>

If I claim that an automobile is unable to cross the water, then your
remark that a boat can do it, is irrelevant.
Trying to deny it is dangerous, because then people could try to cross
the water with a automobile.

[olcott]

That is the same as saying that airplanes do not fly because cars do not
fly and we were talking about cars.

The innovation of a simulating is the only element required to defeat
the conventional halting problem proofs.

*Professor Sipser has agreed to these verbatim words* (and no more)

If simulating halt decider *H correctly simulates its input D until H*
*correctly determines that its simulated D would never stop running*
*unless aborted* then H can abort its simulation of D and correctly

report that D specifies a non-halting sequence of configurations.

>> If I claim that a boat can transport you across the water of a lake to
>> the other side when someone claims that I am wrong because an
>> automobile cannot transport you across the water of a lake this is the
>> strawman error.
>>
>
> If I claim that an automobile is unable to cross the water, then your
> remark that a boat can do it, is irrelevant.
> Trying to deny it is dangerous, because then people could try to cross
> the water with a automobile.
>

[Fred. Zwarts]

Op 18.okt..2022 om 17:02 schreef olcott:

If we are talking about cars, it is irrelevant to change the subject to
airplanes.
But if you think your car is an airplane, it is dangerous to try to fly
with it.

[olcott]

If simulating halt decider *H correctly simulates its input D until H*
*correctly determines that its simulated D would never stop running*
*unless aborted* then H can abort its simulation of D and correctly

report that D specifies a non-halting sequence of configurations.

Seems to be saying that a simulating halt decider does correctly
determine the halt status of its input.

The only requirement for a halt decider is that it does correctly
determine the halt status of its inputs.

[Fred. Zwarts]

Op 18.okt..2022 om 21:46 schreef olcott:

I started this thread with a question about Halt Deciders. I included a
definition (see above). Why do you keep changing the subject to things
with other definitions? Cars, airplanes, simulating halt deciders,
boats, automobiles? Please, stay at the subject.

[olcott]

The above quote seems to say that a simulating halt decider does
correctly determine the halt status of the input that it simulates.

Professor Sipser is the author of the best selling book on the theory of
computation would seem to have the knowledge required to approve
alternative definitions for halt deciders.

https://www.amazon.com/Introduction-Theory-Computation-Sipser/dp/8131525295

Only the notion of a simulating halt decider defeats the conventional HP
proofs. To insist on definitions that cannot defeat these proofs seems a
little silly.

[Fred. Zwarts]

Op 19.okt..2022 om 19:01 schreef olcott:

So, your contribution is irrelevant, because you want to change
definitions and you cannot show any error in the 9 points I was asking
about.
Don't change the subject, please.

[olcott]

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. Alan Turing proved in 1936 that a general algorithm to solve
the halting problem for all possible program-input pairs cannot exist.

For any program H that might determine if programs halt, a
"pathological" program D, called with some input, can pass its own
source and its input to H and then specifically do the opposite of what
H predicts D will do. No H can exist that handles this case.
https://en.wikipedia.org/wiki/Halting_problem

H(D,D) correctly simulates its input D until H correctly determines that
its simulated D would never stop running unless aborted thus exactly
matching the Wikipedia definition of an H can that handles this case.

[Python]

Disgusting Dishonest Crank Peter Olcott (burn in Hell!) wrote:
> H correctly determines that its simulated D would never stop

Nevertheless D halts.

Either the determination is not correct or the simulation is
not correct. PERIOD.

[Fred. Zwarts]

Op 19.okt..2022 om 19:28 schreef olcott:

Your H returns 0, but D halts. Again you changed the subject.
I am interested in the halting problem using a halt decider with the
given definition. I am not interested in your problem.

Considering that:

1) You are unable to understand simple English sentences, such as 'don't
change the subject',
2) You arbitrarily snip relevant and significant parts from your quotations,
3) Your text production seems to be limited to almost only the small
domain of your simulating halt decider,
4) You keep repeating the same paragraphs, sentences, sentence fragments
and words with little variation and with little logic consistency, often
not related to the text your are replying to,

I came to the conclusion that you failed to pass the Turing test for
intelligence.
It seems that your texts are produced by a rather simple piece of
software, which uses a source of a limited set of paragraphs, sentence
fragments and words. This source seems to be updated a few times a year.
The production of texts seems to be triggered by a combination of a
random generator and some keywords in the texts you reply to.

Since I don't like to be fooled in public by a piece of software I have
decided to ignore your contributions, unless some real intelligence is
displayed.

[olcott]

You continue to look for a black dog in the kitchen by looking for a
white cat in the living room because you only understand these things on
the basis of learned-by-rote.

That the behavior of the input D correctly simulated by H is validated
as the correct basis for a halt status decision prevents anyone from
correctly disagreeing with this basis within this validated basis.

[Mr Flibble]

If D(D) halts then H(D,D) should return a decision of halts (1).

/Flibble

[olcott]

One would think so until one looked at all of the details.

[Mr Flibble]

[olcott]