A simulating halt decider correctly predicts what the behavior of its
input would be if this simulated input never had its simulation aborted.
It does this by correctly recognizing several non-halting behavior
patterns in a finite number of steps of correct simulation.

When simulating halt decider H correctly predicts that directly executed
D(D) would continue to run forever unless H aborts its simulation of D
this directly applies to 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.

For any program H that might determine whether 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.
https://en.wikipedia.org/wiki/Halting_problem

*That (a) proves (b) is a tautology*
(a) 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

(b) H can abort its simulation of D and correctly report that D
specifies a non-halting sequence of configurations.

*To make the details 100% concrete Sipser D and H are encoded as C*
*functions. The exact same rebuttal equally applies to Turing machines*

int Sipser_D(int (*M)())
{ int DoesHalt = H(M, M); // *Rejects when Sipser_D fails to accept*
if (DoesHalt)
return 0;
return 1;
}

int main()
{ // *never stops running unless H aborts its simulation*
Sipser_D(Sipser_D);
}

When Sipser_D calls H to simulate itself this comparable to calling H to
call itself and can result in something like infinite recursion. Because
there are no control flow instructions in Sipser_D to stop this the
recursive simulation continues until H aborts it.

When the simulation of D is aborted this is comparable to a divide by
zero error thus is not construed as D halting.

--
Copyright 2023 Olcott "Talent hits a target no one else can hit; Genius
hits a target no one else can see." Arthur Schopenhauer

On 3/2/2023 1:34 PM, olcott wrote:
> A simulating halt decider correctly predicts what the behavior of its
> input would be if this simulated input never had its simulation aborted.
> It does this by correctly recognizing several non-halting behavior
> patterns in a finite number of steps of correct simulation.
>
> When simulating halt decider H correctly predicts that directly executed
> D(D) would continue to run forever unless H aborts its simulation of D
> this directly applies to 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.
>
>    For any program H that might determine whether 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.
>    https://en.wikipedia.org/wiki/Halting_problem
>
> *That (a) proves (b) is a tautology*
> (a) 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
>
> (b) H can abort its simulation of D and correctly report that D
> specifies a non-halting sequence of configurations.
>
> *To make the details 100% concrete Sipser D and H are encoded as C*
> *functions. The exact same rebuttal equally applies to Turing machines*
>
> int Sipser_D(int (*M)())
> {
>   int DoesHalt = H(M, M); // *Rejects when Sipser_D fails to accept*
>   if (DoesHalt)
>     return 0;
>   return 1;
> }
>
> int main()
> {
> // *never stops running unless H aborts its simulation*
>   Sipser_D(Sipser_D);
> }
>
> When Sipser_D calls H to simulate itself this comparable to calling H to
> call itself and can result in something like infinite recursion. Because
> there are no control flow instructions in Sipser_D to stop this the
> recursive simulation continues until H aborts it.
>
> When the simulation of D is aborted this is comparable to a divide by
> zero error thus is not construed as D halting.
>

*Rebutting the Sipser Halting Problem Proof V2*
https://www.researchgate.net/publication/368874440_Rebutting_the_Sipser_Halting_Problem_Proof_V2

--
Copyright 2023 Olcott "Talent hits a target no one else can hit; Genius
hits a target no one else can see." Arthur Schopenhauer

On 3/2/23 2:34 PM, olcott wrote:
> A simulating halt decider correctly predicts what the behavior of its
> input would be if this simulated input never had its simulation aborted.
> It does this by correctly recognizing several non-halting behavior
> patterns in a finite number of steps of correct simulation.

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

So a Halt Decider, of whatever sub-type needs to determine what the
actual machine described by its input will ACTULLY do with the provided
input.

The ability to substitute a "simulation" is only valid with a proper
definition of simulation such that the answer provided by that
simulation matchs that actual behavior.

>
> When simulating halt decider H correctly predicts that directly executed
> D(D) would continue to run forever unless H aborts its simulation of D
> this directly applies to the halting theorem.

Nope,

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

Right, and since D(D) Halts because H(D,D) returns 0, the only correct
answer is Halting.

>
>    For any program H that might determine whether 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.
>    https://en.wikipedia.org/wiki/Halting_problem

Right, which since that "Pathological" program is, by DEFINITION, VALID,
for H to be correct, it needs to

>
> *That (a) proves (b) is a tautology*

Nope. Only under the correct defiitions of the terms.

Which is proven to not be the case (or incorrectly applied) since D(D)
does Halt when H(D,D) returns 0, which is BY DEFINITION incorrect, and
you claim it shows it is correct.

The problem is with your setup, the "simulation" being the same as
direct execution over the hypothetical cases fails, so the "proof" H
uses is UNSOUND.

> (a) 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
>
> (b) H can abort its simulation of D and correctly report that D
> specifies a non-halting sequence of configurations.
>
> *To make the details 100% concrete Sipser D and H are encoded as C*
> *functions. The exact same rebuttal equally applies to Turing machines*
>
> int Sipser_D(int (*M)())
> {
>   int DoesHalt = H(M, M); // *Rejects when Sipser_D fails to accept*
>   if (DoesHalt)
>     return 0;
>   return 1;
> }
>
> int main()
> {
> // *never stops running unless H aborts its simulation*
>   Sipser_D(Sipser_D);
> }
>

But Sipser_D DOES Halt Running if H(Sipser_D, Sipser_D) returns an answer,

So, either H is incorrect about determining the input doesn't actually
halt, or H iteself fails to be a decider.

Note, "Halting" isn't based on "if not aborted", especaiily when the
decided machine has been changed from refering to the ACTUAL H that is
clained correct, to whatever H is trying to decide it.

So, your arguemnt is just shown to be built on a FALSEHOOD.

> When Sipser_D calls H to simulate itself this comparable to calling H to
> call itself and can result in something like infinite recursion. Because
> there are no control flow instructions in Sipser_D to stop this the
> recursive simulation continues until H aborts it.
>

So you ADMIT that you H doesn't meet its requirements to always provide
an answer?

> When the simulation of D is aborted this is comparable to a divide by
> zero error thus is not construed as D halting.
>

IF it is, then you are just admitting that your H has "underfined
behavior" and is thus not actually a decider.

When the H(D,D) called by main aborts it simulation of its input, that
does not directly say anything about the actual behavior of the machine
that the input represents.

Just like if you are given the first N numbers of a sequence, you can't
tell for certain what the next number of the sequence must be.

The point here is that since it is established that you H(D,D) DOES
abort and return 0, and the DEFINITOIN of the Halting Problem is to look
at the behavior of the actual machine, we can show that this means that
the actual behavior of D(D) is to halt and return the value 1, so H(D,D)
is just incorrect.

It doesn't matter that SOME OTHER D', built on SOME OTHER H' that is
sort of like H but doesn't abort, never halts, H wasn't given D' but D,
which is built on the H that does abort and return 0.

You are just showing your total ignorance of the meaning of the words in
the field.

On 3/2/2023 7:35 PM, olcott wrote:
> On 3/2/2023 1:34 PM, olcott wrote:
>> A simulating halt decider correctly predicts what the behavior of its
>> input would be if this simulated input never had its simulation aborted.
>> It does this by correctly recognizing several non-halting behavior
>> patterns in a finite number of steps of correct simulation.
>>
>> When simulating halt decider H correctly predicts that directly executed
>> D(D) would continue to run forever unless H aborts its simulation of D
>> this directly applies to 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.
>>
>>     For any program H that might determine whether 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.
>>     https://en.wikipedia.org/wiki/Halting_problem
>>
>> *That (a) proves (b) is a tautology*
>> (a) 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
>>
>> (b) H can abort its simulation of D and correctly report that D
>> specifies a non-halting sequence of configurations.
>>
>> *To make the details 100% concrete Sipser D and H are encoded as C*
>> *functions. The exact same rebuttal equally applies to Turing machines*
>>
>> int Sipser_D(int (*M)())
>> {
>>    int DoesHalt = H(M, M); // *Rejects when Sipser_D fails to accept*
>>    if (DoesHalt)
>>      return 0;
>>    return 1;
>> }
>>
>> int main()
>> {
>> // *never stops running unless H aborts its simulation*
>>    Sipser_D(Sipser_D);
>> }
>>
>> When Sipser_D calls H to simulate itself this comparable to calling H to
>> call itself and can result in something like infinite recursion. Because
>> there are no control flow instructions in Sipser_D to stop this the
>> recursive simulation continues until H aborts it.
>>
>> When the simulation of D is aborted this is comparable to a divide by
>> zero error thus is not construed as D halting.
>>
>
> *Rebutting the Sipser Halting Problem Proof V2*
> https://www.researchgate.net/publication/368874440_Rebutting_the_Sipser_Halting_Problem_Proof_V2
>

When both the correct simulation of the input to H(D,D) and the direct
execution of D(D) would never stop running unless H aborts its
simulation of D *only liars will disagree* that H is necessarily
correct to reject its input as non-halting.

--
Copyright 2023 Olcott "Talent hits a target no one else can hit; Genius
hits a target no one else can see." Arthur Schopenhauer

> When both the correct simulation of the input to H(D,D) and the direct
> execution of D(D) would never stop running unless H aborts its
> simulation of D  *only liars will disagree* that H is necessarily
> correct to reject its input as non-halting.
>

No, because H DOES abort it simulation, D DOES Halt.

NOTHING can abort the direct simulation of D(D), and it Halts [because
your H does abort its own simulation of its description of D(D)], so the
only correct answer about its halting is that it Halts.

You can't look at the input that isn't there, that just shows that YOU
are the LIAR.

If your only proof is to imagine a world that disagrees with reality,
you have lost it.

On 3/2/2023 9:32 PM, olcott wrote:
> On 3/2/2023 7:35 PM, olcott wrote:
>> On 3/2/2023 1:34 PM, olcott wrote:
>>> A simulating halt decider correctly predicts what the behavior of its
>>> input would be if this simulated input never had its simulation aborted.
>>> It does this by correctly recognizing several non-halting behavior
>>> patterns in a finite number of steps of correct simulation.
>>>
>>> When simulating halt decider H correctly predicts that directly executed
>>> D(D) would continue to run forever unless H aborts its simulation of D
>>> this directly applies to 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.
>>>
>>>     For any program H that might determine whether 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.
>>>     https://en.wikipedia.org/wiki/Halting_problem
>>>
>>> *That (a) proves (b) is a tautology*
>>> (a) 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
>>>
>>> (b) H can abort its simulation of D and correctly report that D
>>> specifies a non-halting sequence of configurations.
>>>
>>> *To make the details 100% concrete Sipser D and H are encoded as C*
>>> *functions. The exact same rebuttal equally applies to Turing machines*
>>>
>>> int Sipser_D(int (*M)())
>>> {
>>>    int DoesHalt = H(M, M); // *Rejects when Sipser_D fails to accept*
>>>    if (DoesHalt)
>>>      return 0;
>>>    return 1;
>>> }
>>>
>>> int main()
>>> {
>>> // *never stops running unless H aborts its simulation*
>>>    Sipser_D(Sipser_D);
>>> }
>>>
>>> When Sipser_D calls H to simulate itself this comparable to calling H to
>>> call itself and can result in something like infinite recursion. Because
>>> there are no control flow instructions in Sipser_D to stop this the
>>> recursive simulation continues until H aborts it.
>>>
>>> When the simulation of D is aborted this is comparable to a divide by
>>> zero error thus is not construed as D halting.
>>>
>>
>> *Rebutting the Sipser Halting Problem Proof V2*
>> https://www.researchgate.net/publication/368874440_Rebutting_the_Sipser_Halting_Problem_Proof_V2
>>
>
> When both the correct simulation of the input to H(D,D) and the direct
> execution of D(D) would never stop running unless H aborts its
> simulation of D  *only liars will disagree* that H is necessarily
> correct to reject its input as non-halting.
>

Simulating halt deciders must abort the simulation of all inputs that
would otherwise never stop running otherwise they would be unable to
report the halt status of non-halting inputs.

It is also axiomatically true that any input that would never stop
running unless aborted by a simulating halt decider is necessarily
correctly determined to be non-halting by this simulating halt decider.

*Professor Sipser understood this. It has always been a tautology*

--
Copyright 2023 Olcott "Talent hits a target no one else can hit; Genius
hits a target no one else can see." Arthur Schopenhauer

On 3/2/23 11:05 PM, olcott wrote:

> Simulating halt deciders must abort the simulation of all inputs that
> would otherwise never stop running otherwise they would be unable to
> report the halt status of non-halting inputs.
>
> It is also axiomatically true that any input that would never stop
> running unless aborted by a simulating halt decider is necessarily
> correctly determined to be non-halting by this simulating halt decider.
>
> *Professor Sipser understood this. It has always been a tautology*
>
>

No, you just don't understand what he said. Note, the "axiom" you are
quoting requries conditions that are not true in your system, the
indepence of the decider and "the input". That was one of the first
things I mentioned to you, but you rejected it because you are too ignorant.

You are just showing that your do not understand any of the basics of
the field of Computation Theory or even basic Logic.

Your continued refusal to actually reply to the rebuttals but just to
yourself just demonstart that you don't actually have a rebuttal, but
are just seaching for the right words to try to convincingly say your
falsehood, and that you understand that you have no actual grounds to
rebut the rebuttals aimed at your logic.

You life is revealed to be one big lie and your work to be worthless.

On 3/2/23 11:05 PM, olcott wrote:
> On 3/2/2023 9:32 PM, olcott wrote:
>> On 3/2/2023 7:35 PM, olcott wrote:
>>> On 3/2/2023 1:34 PM, olcott wrote:
>>>> A simulating halt decider correctly predicts what the behavior of its
>>>> input would be if this simulated input never had its simulation
>>>> aborted.
>>>> It does this by correctly recognizing several non-halting behavior
>>>> patterns in a finite number of steps of correct simulation.
>>>>
>>>> When simulating halt decider H correctly predicts that directly
>>>> executed
>>>> D(D) would continue to run forever unless H aborts its simulation of D
>>>> this directly applies to 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.
>>>>
>>>>     For any program H that might determine whether 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.
>>>>     https://en.wikipedia.org/wiki/Halting_problem
>>>>
>>>> *That (a) proves (b) is a tautology*
>>>> (a) 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
>>>>
>>>> (b) H can abort its simulation of D and correctly report that D
>>>> specifies a non-halting sequence of configurations.
>>>>
>>>> *To make the details 100% concrete Sipser D and H are encoded as C*
>>>> *functions. The exact same rebuttal equally applies to Turing machines*
>>>>
>>>> int Sipser_D(int (*M)())
>>>> {
>>>>    int DoesHalt = H(M, M); // *Rejects when Sipser_D fails to accept*
>>>>    if (DoesHalt)
>>>>      return 0;
>>>>    return 1;
>>>> }
>>>>
>>>> int main()
>>>> {
>>>> // *never stops running unless H aborts its simulation*
>>>>    Sipser_D(Sipser_D);
>>>> }
>>>>
>>>> When Sipser_D calls H to simulate itself this comparable to calling
>>>> H to
>>>> call itself and can result in something like infinite recursion.
>>>> Because
>>>> there are no control flow instructions in Sipser_D to stop this the
>>>> recursive simulation continues until H aborts it.
>>>>
>>>> When the simulation of D is aborted this is comparable to a divide by
>>>> zero error thus is not construed as D halting.
>>>>
>>>
>>> *Rebutting the Sipser Halting Problem Proof V2*
>>> https://www.researchgate.net/publication/368874440_Rebutting_the_Sipser_Halting_Problem_Proof_V2
>>>
>>
>> When both the correct simulation of the input to H(D,D) and the direct
>> execution of D(D) would never stop running unless H aborts its
>> simulation of D  *only liars will disagree* that H is necessarily
>> correct to reject its input as non-halting.
>>
>
> Simulating halt deciders must abort the simulation of all inputs that
> would otherwise never stop running otherwise they would be unable to
> report the halt status of non-halting inputs.
>
> It is also axiomatically true that any input that would never stop
> running unless aborted by a simulating halt decider is necessarily
> correctly determined to be non-halting by this simulating halt decider.
>
> *Professor Sipser understood this. It has always been a tautology*
>

Also note reading closely, you have changed your words, and thus you are
no longer claiming the same thing you use to, and now you H is incorrect
again.

This can be shown as follows:

Take as a given your H that does abort at the point that it does, and
the D built on it. (Note, D does not use the decide deciding on it, it
always uses H)

Make another simulating halt decider HH (new name, since new decider),
that waits a lot longer (or forever) to decide to abort on that D, then
the simulation of HH(D,D) does reach a final state, and thus H(D,D) was
incorrect to determine that it does not halt.

Since your "a simulating halt decider" doesn't need to refer to the same
decider as "this simulating halt decider" you have gotten back to
statements that just prove your logic to be wrong. Your error has always
been requiring that the "correct simulation" be from "this decider"
which ends up not doing what it needs to do to qualify as an answer.

On 3/2/23 11:05 PM, olcott wrote:

> Simulating halt deciders must abort the simulation of all inputs that
> would otherwise never stop running otherwise they would be unable to
> report the halt status of non-halting inputs.
>
> It is also axiomatically true that any input that would never stop
> running unless aborted by a simulating halt decider is necessarily
> correctly determined to be non-halting by this simulating halt decider.
>
> *Professor Sipser understood this. It has always been a tautology*
>
>

Note, your use of axiomatically here just shows that you do not
understand what a formal system is.

In formal systems, things are not true because they seem to be
"axiomatically true", but because either they ARE axioms, or can be
actually proven from the axioms.

Your statement you statement is based on is NOT something that needs to
be taken as an axiom, because in the proper systems, it can actually be
proven.

On 3/2/2023 10:05 PM, olcott wrote:
> On 3/2/2023 9:32 PM, olcott wrote:
>> On 3/2/2023 7:35 PM, olcott wrote:
>>> On 3/2/2023 1:34 PM, olcott wrote:
>>>> A simulating halt decider correctly predicts what the behavior of its
>>>> input would be if this simulated input never had its simulation
>>>> aborted.
>>>> It does this by correctly recognizing several non-halting behavior
>>>> patterns in a finite number of steps of correct simulation.
>>>>
>>>> When simulating halt decider H correctly predicts that directly
>>>> executed
>>>> D(D) would continue to run forever unless H aborts its simulation of D
>>>> this directly applies to 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.
>>>>
>>>>     For any program H that might determine whether 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.
>>>>     https://en.wikipedia.org/wiki/Halting_problem
>>>>
>>>> *That (a) proves (b) is a tautology*
>>>> (a) 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
>>>>
>>>> (b) H can abort its simulation of D and correctly report that D
>>>> specifies a non-halting sequence of configurations.
>>>>
>>>> *To make the details 100% concrete Sipser D and H are encoded as C*
>>>> *functions. The exact same rebuttal equally applies to Turing machines*
>>>>
>>>> int Sipser_D(int (*M)())
>>>> {
>>>>    int DoesHalt = H(M, M); // *Rejects when Sipser_D fails to accept*
>>>>    if (DoesHalt)
>>>>      return 0;
>>>>    return 1;
>>>> }
>>>>
>>>> int main()
>>>> {
>>>> // *never stops running unless H aborts its simulation*
>>>>    Sipser_D(Sipser_D);
>>>> }
>>>>
>>>> When Sipser_D calls H to simulate itself this comparable to calling
>>>> H to
>>>> call itself and can result in something like infinite recursion.
>>>> Because
>>>> there are no control flow instructions in Sipser_D to stop this the
>>>> recursive simulation continues until H aborts it.
>>>>
>>>> When the simulation of D is aborted this is comparable to a divide by
>>>> zero error thus is not construed as D halting.
>>>>
>>>
>>> *Rebutting the Sipser Halting Problem Proof V2*
>>> https://www.researchgate.net/publication/368874440_Rebutting_the_Sipser_Halting_Problem_Proof_V2
>>>
>>
>> When both the correct simulation of the input to H(D,D) and the direct
>> execution of D(D) would never stop running unless H aborts its
>> simulation of D  *only liars will disagree* that H is necessarily
>> correct to reject its input as non-halting.
>>
>
> Simulating halt deciders must abort the simulation of all inputs that
> would otherwise never stop running otherwise they would be unable to
> report the halt status of non-halting inputs.
>
> It is also axiomatically true that any input that would never stop
> running unless aborted by a simulating halt decider is necessarily
> correctly determined to be non-halting by this simulating halt decider.
>
> *Professor Sipser understood this. It has always been a tautology*
>
>

Any idiot can see that neither Sipser_D(Sipser_D) nor Sipser_D correctly
simulated by H would ever stop running unless H aborts its simulation of
Sipser_D, it takes an actual liar to deny this.

Since you already admitted that P(P) would never stop running unless H
aborted its simulation of P you prove to be that liar.

If the last remaining rebuttal is simply denying what is obvious to
every competent software engineer then my words have become irrefutable.

--
Copyright 2023 Olcott "Talent hits a target no one else can hit; Genius
hits a target no one else can see." Arthur Schopenhauer

On 3/3/23 10:19 AM, olcott wrote:

> Any idiot can see that neither Sipser_D(Sipser_D) nor Sipser_D correctly
> simulated by H would ever stop running unless H aborts its simulation of
> Sipser_D, it takes an actual liar to deny this.

Yes, but since H DOES abort its simulation, that isn't applicable.

The fact that since H(Sipser_D,Sipser_D) aborts its simulation and
returns 0 means that Sipser_D(Sipser_D) does return 1, means that H is
just WRONG, and the logic used to claim it correct is just WRONG and
based on lies.

In fact, a simple analysis of Sipser_D shows that it can not be
non-halting except for H failing to meet its requirements.

>
> Since you already admitted that P(P) would never stop running unless H
> aborted its simulation of P you prove to be that liar.

No, YOUR qre, since Halting isn't based on "needs to be aborted" but on
the actual behavior of the actual machine.

So, any H that returns 0 for H(D,D) is just wrong, as those D(D) will halt.

Yes, if H(D,D) never aborts its simulation and thus never answer, those
D(D), which are different machines, will not halt, but H is still not
right as those H (which are different deciders than the previous
paragraphs) never answer.
>
> If the last remaining rebuttal is simply denying what is obvious to
> every competent software engineer then my words have become irrefutable.
>
>

Nope, you are just proving yourself to be an idiot that KNOWS he is
wrong but refuses to accept it.

This is clear because you refuse to actually try to refute the errors
pointed out in your logic, which effectively admits that you can't show
how those rebuttals are incorrect.

On 2023-03-02 19:34:19 +0000, olcott said:

> *To make the details 100% concrete Sipser D and H are encoded as C*

To make the details 100% concrete the programs should be encoded as
Turing machines or as inputs to an Universal Turing Machine. C leaves
many details ambiguous so a program is allowed to produce different
results in different implementations.

Mikko

On 3/3/2023 9:39 AM, Richard Damon wrote:
> On 3/3/23 10:19 AM, olcott wrote:
>
>> Any idiot can see that neither Sipser_D(Sipser_D) nor Sipser_D correctly
>> simulated by H would ever stop running unless H aborts its simulation of
>> Sipser_D, it takes an actual liar to deny this.
>
> Yes, but since H DOES abort its simulation, that isn't applicable.
>
> The fact that since H(Sipser_D,Sipser_D) aborts its simulation and
> returns 0 means that Sipser_D(Sipser_D) does return 1, means that H is
> just WRONG, and the logic used to claim it correct is just WRONG and
> based on lies.
>
> In fact, a simple analysis of Sipser_D shows that it can not be
> non-halting except for H failing to meet its requirements.
>
>>
>> Since you already admitted that P(P) would never stop running unless H
>> aborted its simulation of P you prove to be that liar.
>
>
> No, YOUR qre, since Halting isn't based on "needs to be aborted" but on
> the actual behavior of the actual machine.
>
> So, any H that returns 0 for H(D,D) is just wrong, as those D(D) will halt.
>
> Yes, if H(D,D) never aborts its simulation and thus never answer, those
> D(D), which are different machines, will not halt, but H is still not
> right as those H (which are different deciders than the previous
> paragraphs) never answer.
>>
>> If the last remaining rebuttal is simply denying what is obvious to
>> every competent software engineer then my words have become irrefutable.
>>
>>
>
> Nope, you are just proving yourself to be an idiot that KNOWS he is
> wrong but refuses to accept it.
>
> This is clear because you refuse to actually try to refute the errors
> pointed out in your logic, which effectively admits that you can't show
> how those rebuttals are incorrect.

*That (a) proves (b) has always been a tautology*
(a) 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

(b) H can abort its simulation of D and correctly report that D
specifies a non-halting sequence of configurations.

For three years everyone consistently disagreed that (a) proves (b) even
though has always been a tautology. It can be known with 100% logically
justified complete certainty that anyone disagreeing with a tautology is
ALWAYS wrong.

There are only two hypothetical possibilities for the abort behavior of
H where D is correctly simulated by H:
(1) H aborts its simulation of D at some point.
(2) H never aborts its simulation of D.

No one is going to buy your deceptive shell game when every possible
definition of H is divided into two mutually exclusive subsets.

*This system of reasoning is infallible in that it can have no gaps*
*Categorically exhaustive reasoning has no gaps, every element of the*
*infinite set is fully accounted for*

Every element of the infinite set of definitions of H in subset (2) has
the property that D never stops running, thus
"its simulated D would never stop running unless aborted" is proven.

Now that the key crux of the computer science of my proof has been
validated: "(a) proves (b)" reviewers are stuck with disagreeing with
the easily verified software engineering of this proof or no rebuttal is
possible.

It seems quite foolish to disagree with easily verified facts.

--
Copyright 2023 Olcott "Talent hits a target no one else can hit; Genius
hits a target no one else can see." Arthur Schopenhauer

On 2023-03-02 19:34:19 +0000, olcott said:

> int Sipser_D(int (*M)())
> {
> int DoesHalt = H(M, M); // *Rejects when Sipser_D fails to accept*
> if (DoesHalt)
> return 0;
> return 1;
> }

If that program does not return then H is not a halt decider.

If Sipser_D(Sipser_D) returns 1 then H is not a halt decider.

Mikko

On 3/3/23 11:35 AM, Mikko wrote:
> On 2023-03-02 19:34:19 +0000, olcott said:
>
>> *To make the details 100% concrete Sipser D and H are encoded as C*
>
> To make the details 100% concrete the programs should be encoded as
> Turing machines or as inputs to an Universal Turing Machine. C leaves
> many details ambiguous so a program is allowed to produce different
> results in different implementations.
>
> Mikko
>

Yes, one of the big issues with his "C" encoding is it is easy to create
things that are not Turing Machine equivalents and not actually
computations. Dealing with computations in such "Higher Level" requries
care, and is in fact the power of Turing Machines, as all "Sub-Routines"
in a Turing Machine are them selves Turing Machines and computations.
The same is not true in Higher Level Languages.

In fact, his D does this, as the way he has done it, D, rather than
calling the "Halt Decider" that is claimed to correctly decider it, it
is calling the Halt Decider that IS deciding it at the moment that
happens to be temporarily called H, which is impossible to do in an
actual computation, as what that machine is isn't an input to the machine.

This is what given him his erroneous result. His D is NOT the required
compuation, and isn't a computation at all.

The fact that this was pointed out to him years ago and he ignored it
just shows he doesn't care about the truth and doesn't understand what
he is working with.

On 3/3/23 11:37 AM, olcott wrote:
> On 3/3/2023 9:39 AM, Richard Damon wrote:
>> On 3/3/23 10:19 AM, olcott wrote:
>>
>>> Any idiot can see that neither Sipser_D(Sipser_D) nor Sipser_D correctly
>>> simulated by H would ever stop running unless H aborts its simulation of
>>> Sipser_D, it takes an actual liar to deny this.
>>
>> Yes, but since H DOES abort its simulation, that isn't applicable.
>>
>> The fact that since H(Sipser_D,Sipser_D) aborts its simulation and
>> returns 0 means that Sipser_D(Sipser_D) does return 1, means that H is
>> just WRONG, and the logic used to claim it correct is just WRONG and
>> based on lies.
>>
>> In fact, a simple analysis of Sipser_D shows that it can not be
>> non-halting except for H failing to meet its requirements.
>>
>>>
>>> Since you already admitted that P(P) would never stop running unless H
>>> aborted its simulation of P you prove to be that liar.
>>
>>
>> No, YOUR qre, since Halting isn't based on "needs to be aborted" but
>> on the actual behavior of the actual machine.
>>
>> So, any H that returns 0 for H(D,D) is just wrong, as those D(D) will
>> halt.
>>
>> Yes, if H(D,D) never aborts its simulation and thus never answer,
>> those D(D), which are different machines, will not halt, but H is
>> still not right as those H (which are different deciders than the
>> previous paragraphs) never answer.
>>>
>>> If the last remaining rebuttal is simply denying what is obvious to
>>> every competent software engineer then my words have become irrefutable.
>>>
>>>
>>
>> Nope, you are just proving yourself to be an idiot that KNOWS he is
>> wrong but refuses to accept it.
>>
>> This is clear because you refuse to actually try to refute the errors
>> pointed out in your logic, which effectively admits that you can't
>> show how those rebuttals are incorrect.
>
> *That (a) proves (b) has always been a tautology*
> (a) 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
>
> (b) H can abort its simulation of D and correctly report that D
> specifies a non-halting sequence of configurations.
>

So prove that (a) actually occurs for the H in question.

Remember, H is a SINGLE decider.

Since it aborts its simulation, you can not prove anything about what it
would do if it does something it does not do.

You logic is based on a FALSE PREMISE.

You logic is based on needing to prove the LIAR's PARADOX has a value.

> For three years everyone consistently disagreed that (a) proves (b) even
> though has always been a tautology. It can be known with 100% logically
> justified complete certainty that anyone disagreeing with a tautology is
> ALWAYS wrong.

But it is only a "tautology" in the sense that "If one equals two, then
Olcott is a Genius" is a tautology.

>
> There are only two hypothetical possibilities for the abort behavior of
> H where D is correctly simulated by H:

And when you do that, you are changing H and D, and thus one doesn't
tell about the other.

> (1) H aborts its simulation of D at some point.

At which point D(D) becomes Halting, a fact that H doesn't understand,
and H is thus incorrect in its reasoning, because H INCORRECT thinks its
D is the same D as in your (2) case. Remember the PROGRAM D includes the
routine H as part of it, so changing H changes D, so H didn't analysis
the program given to it.

> (2) H never aborts its simulation of D.

Which is a different D, and yes, in THIS case, THIS D is non-halting,
but THIS H never gives that answer.

>
> No one is going to buy your deceptive shell game when every possible
> definition of H is divided into two mutually exclusive subsets.

Yes, and in every one of those cases H is WRONG about the D that comes
from THAT subset.

All you are showing is that an H in one subset might be able to answer
about a D built on the H in a different subset. Since the proof is based
on an H deciding on a D built from itself, that never is the cas.

>
> *This system of reasoning is infallible in that it can have no gaps*
> *Categorically exhaustive reasoning has no gaps, every element of the*
> *infinite set is fully accounted for*

Nope, you have gaps, because you mix up the inputs from the wrong cases.

You don't ever give your case (1) H the case (1) D to correctly decide on.

>
> Every element of the infinite set of definitions of H in subset (2) has
> the property that D never stops running, thus
> "its simulated D would never stop running unless aborted" is proven.

Nope. In case (1) a simulated D WOULD stop running when properly
simulated by a proper decider. That fact that H aborts it doesn't matter.

If you restrict the simulation to only by the decider, then your
"tautology" fails to be a true statement as it is not using a correct
definition of Halting.

>
> Now that the key crux of the computer science of my proof has been
> validated: "(a) proves (b)" reviewers are stuck with disagreeing with
> the easily verified software engineering of this proof or no rebuttal is
> possible.
>
> It seems quite foolish to disagree with easily verified facts.
>

Yes, it does, like that fact that even you admit that D(D) Halts (and
returns 1 for Sipser) when H(D,D) returns 0, and the fact that Halting
in Computability Theory is based on the behavior of the actual machine,
says that H(D,D) returning non-halting can not possibly be correct.

THIS IS DEFINITION.

To say it isn't true just makes you a LIAR.

On 3/3/2023 10:35 AM, Mikko wrote:
> On 2023-03-02 19:34:19 +0000, olcott said:
>
>> *To make the details 100% concrete Sipser D and H are encoded as C*
>
> To make the details 100% concrete the programs should be encoded as
> Turing machines or as inputs to an Universal Turing Machine. C leaves
> many details ambiguous so a program is allowed to produce different
> results in different implementations.
>
> Mikko
>

I am going for the wider audience that includes software engineers as
well as computer scientists. To apply the proof on the first page of my
paper to Turing machines one simply refers to the Turing machine based D
and H of the Sisper proof where H is a Turing machine based simulating
halt decider.

It is easier to see that the Sipser_D specifies what is essentially
infinite recursion to H because there is no infinite loop to confuse
people.

This reasoning is easier to see as C functions, yet once the C functions
are understood then it is obvious that the same reasoning also applies
to the Turing machines.

The second page of my proof in anchored in the Peter Linz Turing machine
based proof thus only refers to the Turing machines. I wrote this as
simply as possible and so that it can be understood without needing to
look at the actual Linz proof.

This new paper only needs two pages to prove its point two different
ways. All of the other pages involving x86 code have been dropped as too
difficult for the typical reader to understand.

Rebutting the Sipser Halting Problem Proof V2
https://www.researchgate.net/publication/368874440_Rebutting_the_Sipser_Halting_Problem_Proof_V2

--
Copyright 2023 Olcott "Talent hits a target no one else can hit; Genius
hits a target no one else can see." Arthur Schopenhauer

On 3/3/2023 10:37 AM, olcott wrote:
> On 3/3/2023 9:39 AM, Richard Damon wrote:
>> On 3/3/23 10:19 AM, olcott wrote:
>>
>>> Any idiot can see that neither Sipser_D(Sipser_D) nor Sipser_D correctly
>>> simulated by H would ever stop running unless H aborts its simulation of
>>> Sipser_D, it takes an actual liar to deny this.
>>
>> Yes, but since H DOES abort its simulation, that isn't applicable.
>>
>> The fact that since H(Sipser_D,Sipser_D) aborts its simulation and
>> returns 0 means that Sipser_D(Sipser_D) does return 1, means that H is
>> just WRONG, and the logic used to claim it correct is just WRONG and
>> based on lies.
>>
>> In fact, a simple analysis of Sipser_D shows that it can not be
>> non-halting except for H failing to meet its requirements.
>>
>>>
>>> Since you already admitted that P(P) would never stop running unless H
>>> aborted its simulation of P you prove to be that liar.
>>
>>
>> No, YOUR qre, since Halting isn't based on "needs to be aborted" but
>> on the actual behavior of the actual machine.
>>
>> So, any H that returns 0 for H(D,D) is just wrong, as those D(D) will
>> halt.
>>
>> Yes, if H(D,D) never aborts its simulation and thus never answer,
>> those D(D), which are different machines, will not halt, but H is
>> still not right as those H (which are different deciders than the
>> previous paragraphs) never answer.
>>>
>>> If the last remaining rebuttal is simply denying what is obvious to
>>> every competent software engineer then my words have become irrefutable.
>>>
>>>
>>
>> Nope, you are just proving yourself to be an idiot that KNOWS he is
>> wrong but refuses to accept it.
>>
>> This is clear because you refuse to actually try to refute the errors
>> pointed out in your logic, which effectively admits that you can't
>> show how those rebuttals are incorrect.
>
> *That (a) proves (b) has always been a tautology*
> (a) 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
>
> (b) H can abort its simulation of D and correctly report that D
> specifies a non-halting sequence of configurations.
>
> For three years everyone consistently disagreed that (a) proves (b) even
> though has always been a tautology. It can be known with 100% logically
> justified complete certainty that anyone disagreeing with a tautology is
> ALWAYS wrong.
>
> There are only two hypothetical possibilities for the abort behavior of
> H where D is correctly simulated by H:
> (1) H aborts its simulation of D at some point.
> (2) H never aborts its simulation of D.
>
> No one is going to buy your deceptive shell game when every possible
> definition of H is divided into two mutually exclusive subsets.
>
> *This system of reasoning is infallible in that it can have no gaps*
> *Categorically exhaustive reasoning has no gaps, every element of the*
> *infinite set is fully accounted for*
>
> Every element of the infinite set of definitions of H in subset (2) has
> the property that D never stops running, thus
> "its simulated D would never stop running unless aborted" is proven.
>
> Now that the key crux of the computer science of my proof has been
> validated: "(a) proves (b)" reviewers are stuck with disagreeing with
> the easily verified software engineering of this proof or no rebuttal is
> possible.
>
> It seems quite foolish to disagree with easily verified facts.
>
>

That it is impossible to prove things to liars is no actual rebuttal at
all. It cannot even be proved that 2 + 3 = 5 to liars because liars are
free to disagree that 2 is a number.

It is the case that for every element of the infinite set of definitions
of H where D is correctly simulated by H and H never aborts its
simulation of D that D never stops running.

*This conclusively proves*
"its simulated D would never stop running unless aborted"

--
Copyright 2023 Olcott "Talent hits a target no one else can hit; Genius
hits a target no one else can see." Arthur Schopenhauer

On 3/3/2023 10:46 AM, Mikko wrote:
> On 2023-03-02 19:34:19 +0000, olcott said:
>
>> int Sipser_D(int (*M)())
>> {
>>    int DoesHalt = H(M, M); // *Rejects when Sipser_D fails to accept*
>>    if (DoesHalt)
>>      return 0;
>>    return 1;
>> }
>
> If that program does not return then H is not a halt decider.
>
> If Sipser_D(Sipser_D) returns 1 then H is not a halt decider.
>
> Mikko
>

int main()
{ H(Sipser_D, Sipser_D);
}

Since everyone knows that it is incorrect for any function called in
what is essentially infinite recursion to return to its caller your
requirement of incorrect behavior is an incorrect requirement.

Because Sipser_D(Sipser_D) would never stop running unless H aborts its
simulation of Sipser_D, this conclusively proves that H correctly
determines:

“from a description of an arbitrary computer program and an input,
whether the program will finish running, or continue to run
forever”. https://en.wikipedia.org/wiki/Halting_problem

--
Copyright 2023 Olcott "Talent hits a target no one else can hit; Genius
hits a target no one else can see." Arthur Schopenhauer

On 3/3/23 12:18 PM, olcott wrote:

> That it is impossible to prove things to liars is no actual rebuttal at
> all. It cannot even be proved that 2 + 3 = 5 to liars because liars are
> free to disagree that 2 is a number.

But no one is dispute an actual fact, EXCEPT YOU

YOU are the one that tries to refute that the correct answer for a Halt
Decider when given an input that you accept Halts, is Halting.

So, you are just admitting you are the LIAR.

>
> It is the case that for every element of the infinite set of definitions
> of H where D is correctly simulated by H and H never aborts its
> simulation of D that D never stops running.

So?

In every element of that infinite set, either H(D,D) never answers, so
it wrong, or if H(D,D) returns 0, and thus D(D) Halts, so by the actual
definitoin of Halting, H is wrong.

So, all you have established is that NO "Simulating Halt Decider" built
on your template in that infinite set gets the right answer.

You claim that you have proved a incorrect answer to be a correct
answer, when in actuality, you are just pointing out that you H is
answering the WRONG question, because it presumes the input is a machine
the input isn't (one based on a different H that it is based on).

>
> *This conclusively proves*
> "its simulated D would never stop running unless aborted"
>
>

So, that isn't the definiton of Halting.

It can be an alternate definition in some systems, but you can't
establish the required basis to make that work in your system, so you
can't use it.

In particular, your D and H are not independent of each other like they
need to be,

Remember, D is defined to use the Halt Decider that is claimed to
correct decider it, NOT the halt decider that is currently deciding it.

That is at each instance, a singular machine.

Again, not replying to the message which is pointing out your error, you
are in effect, acknowledging that you don't have a way to refute the
claimed error.

On 3/3/23 12:06 PM, olcott wrote:
> On 3/3/2023 10:35 AM, Mikko wrote:
>> On 2023-03-02 19:34:19 +0000, olcott said:
>>
>>> *To make the details 100% concrete Sipser D and H are encoded as C*
>>
>> To make the details 100% concrete the programs should be encoded as
>> Turing machines or as inputs to an Universal Turing Machine. C leaves
>> many details ambiguous so a program is allowed to produce different
>> results in different implementations.
>>
>> Mikko
>>
>
> I am going for the wider audience that includes software engineers as
> well as computer scientists. To apply the proof on the first page of my
> paper to Turing machines one simply refers to the Turing machine based D
> and H of the Sisper proof where H is a Turing machine based simulating
> halt decider.

So, you think the only way you can prove that you are right about the
problem it to reach out to people that don't understand that actu

>
> It is easier to see that the Sipser_D specifies what is essentially
> infinite recursion to H because there is no infinite loop to confuse
> people.

Right, which means that Sipser_D CAN'T be non-halting if H meets its
requirement, so H deciding it is CAN'T be correct.

>
> This reasoning is easier to see as C functions, yet once the C functions
> are understood then it is obvious that the same reasoning also applies
> to the Turing machines.

Nope, the problem is that you are using program structures that can not
be then divided into the two required independent machines. This has
been pointed out to you before, and ignored (because you seem to not
understand it).

>
> The second page of my proof in anchored in the Peter Linz Turing machine
> based proof thus only refers to the Turing machines. I wrote this as
> simply as possible and so that it can be understood without needing to
> look at the actual Linz proof.

Right, and you drop the specifications on the two paths, that emdedded_H
must go to qy if the input represent a halting machine, and to qn only
if it is a non-halting machine. Your omittion just shows you don't
understand the importance of actually knowing what you are supposed to do.

And it presumes that copies of embedded_H and H don't do the same thing,
even though they are copies of each other, and thus embedded_H isn't
actually the required copy of H.

Since you say embedded_H goes to qn, that means that H^ is halting, and
thus embedded_H, which by it specification, must have gone to qy, which
it didn't, so it failed to meet its specifiaction,

Note, there is NO link back from qx to q0, you are confusing simulation
with calling.

>
> This new paper only needs two pages to prove its point two different
> ways. All of the other pages involving x86 code have been dropped as too
> difficult for the typical reader to understand.
>
> Rebutting the Sipser Halting Problem Proof V2
> https://www.researchgate.net/publication/368874440_Rebutting_the_Sipser_Halting_Problem_Proof_V2
>
>

Right, and the errors have been pointed out and ignored by you, showing
you are too stupid to undertand what you are talking about.

On 3/3/23 12:59 PM, olcott wrote:
> On 3/3/2023 10:46 AM, Mikko wrote:
>> On 2023-03-02 19:34:19 +0000, olcott said:
>>
>>> int Sipser_D(int (*M)())
>>> {
>>>    int DoesHalt = H(M, M); // *Rejects when Sipser_D fails to accept*
>>>    if (DoesHalt)
>>>      return 0;
>>>    return 1;
>>> }
>>
>> If that program does not return then H is not a halt decider.
>>
>> If Sipser_D(Sipser_D) returns 1 then H is not a halt decider.
>>
>> Mikko
>>
>
> int main()
> {
>   H(Sipser_D, Sipser_D);
> }
>
> Since everyone knows that it is incorrect for any function called in
> what is essentially infinite recursion to return to its caller your
> requirement of incorrect behavior is an incorrect requirement.

Requirement can not be "incorrect", they can only be unmeetable.

You just proved that you don't understand what requriements are.

>
> Because Sipser_D(Sipser_D) would never stop running unless H aborts its
> simulation of Sipser_D, this conclusively proves that H correctly
> determines:
>
>    “from a description of an arbitrary computer program and an input,
>     whether the program will finish running, or continue to run
>     forever”. https://en.wikipedia.org/wiki/Halting_problem
>
>

But since H DOES abort its simulation and return 0, Sipser_D(Sipser_D)
DOES return 1, and thus H(Sipser_D, Sipser_D) is INCORRECT to return 0,
but needed to have returned 1 to be correct.

And thus, YOU ARE PROVEN TO BE A LIAR to claim it was correct.

On 3/3/2023 11:59 AM, olcott wrote:
> On 3/3/2023 10:46 AM, Mikko wrote:
>> On 2023-03-02 19:34:19 +0000, olcott said:
>>
>>> int Sipser_D(int (*M)())
>>> {
>>>    int DoesHalt = H(M, M); // *Rejects when Sipser_D fails to accept*
>>>    if (DoesHalt)
>>>      return 0;
>>>    return 1;
>>> }
>>
>> If that program does not return then H is not a halt decider.
>>
>> If Sipser_D(Sipser_D) returns 1 then H is not a halt decider.
>>
>> Mikko
>>
>
> int main()
> {
>   H(Sipser_D, Sipser_D);
> }
>
> Since everyone knows that it is incorrect for any function called in
> what is essentially infinite recursion to return to its caller your
> requirement of incorrect behavior is an incorrect requirement.
>
> Because Sipser_D(Sipser_D) would never stop running unless H aborts its
> simulation of Sipser_D, this conclusively proves that H correctly
> determines:
>
>    “from a description of an arbitrary computer program and an input,
>     whether the program will finish running, or continue to run
>     forever”. https://en.wikipedia.org/wiki/Halting_problem

"Would never stop running" is a correct definition of non-halting.

"Would never stop running unless aborted" is a correct criteria for a
simulating halt decider that must abort its simulation of non-
terminating inputs so that it can report that they would not halt.

--
Copyright 2023 Olcott "Talent hits a target no one else can hit; Genius
hits a target no one else can see." Arthur Schopenhauer

On 3/3/2023 1:14 PM, olcott wrote:
> On 3/3/2023 11:59 AM, olcott wrote:
>> On 3/3/2023 10:46 AM, Mikko wrote:
>>> On 2023-03-02 19:34:19 +0000, olcott said:
>>>
>>>> int Sipser_D(int (*M)())
>>>> {
>>>>    int DoesHalt = H(M, M); // *Rejects when Sipser_D fails to accept*
>>>>    if (DoesHalt)
>>>>      return 0;
>>>>    return 1;
>>>> }
>>>
>>> If that program does not return then H is not a halt decider.
>>>
>>> If Sipser_D(Sipser_D) returns 1 then H is not a halt decider.
>>>
>>> Mikko
>>>
>>
>> int main()
>> {
>>    H(Sipser_D, Sipser_D);
>> }
>>
>> Since everyone knows that it is incorrect for any function called in
>> what is essentially infinite recursion to return to its caller your
>> requirement of incorrect behavior is an incorrect requirement.
>>
>> Because Sipser_D(Sipser_D) would never stop running unless H aborts its
>> simulation of Sipser_D, this conclusively proves that H correctly
>> determines:
>>
>>     “from a description of an arbitrary computer program and an input,
>>      whether the program will finish running, or continue to run
>>      forever”. https://en.wikipedia.org/wiki/Halting_problem
>
> "Would never stop running" is a correct definition of non-halting.
>
> "Would never stop running unless aborted" is a correct criteria for a
> simulating halt decider that must abort its simulation of non-
> terminating inputs so that it can report that they would not halt.
>

Requirements can be incorrect when they require any analytical
impossibility.

--
Copyright 2023 Olcott "Talent hits a target no one else can hit; Genius
hits a target no one else can see." Arthur Schopenhauer

On 3/3/23 2:14 PM, olcott wrote:
> On 3/3/2023 11:59 AM, olcott wrote:
>> On 3/3/2023 10:46 AM, Mikko wrote:
>>> On 2023-03-02 19:34:19 +0000, olcott said:
>>>
>>>> int Sipser_D(int (*M)())
>>>> {
>>>>    int DoesHalt = H(M, M); // *Rejects when Sipser_D fails to accept*
>>>>    if (DoesHalt)
>>>>      return 0;
>>>>    return 1;
>>>> }
>>>
>>> If that program does not return then H is not a halt decider.
>>>
>>> If Sipser_D(Sipser_D) returns 1 then H is not a halt decider.
>>>
>>> Mikko
>>>
>>
>> int main()
>> {
>>    H(Sipser_D, Sipser_D);
>> }
>>
>> Since everyone knows that it is incorrect for any function called in
>> what is essentially infinite recursion to return to its caller your
>> requirement of incorrect behavior is an incorrect requirement.
>>
>> Because Sipser_D(Sipser_D) would never stop running unless H aborts its
>> simulation of Sipser_D, this conclusively proves that H correctly
>> determines:
>>
>>     “from a description of an arbitrary computer program and an input,
>>      whether the program will finish running, or continue to run
>>      forever”. https://en.wikipedia.org/wiki/Halting_problem
>
> "Would never stop running" is a correct definition of non-halting.

Right, of the ACTUAL MACHINE.

>
> "Would never stop running unless aborted" is a correct criteria for a
> simulating halt decider that must abort its simulation of non-
> terminating inputs so that it can report that they would not halt.
>

Nope, not if it disagrees with "the machine would never stop running",
or you are admitting that your Simulating Halt Deciders are not Halt
Deciders.

Note, if you build actual Turing Machines or actual equivalents of them,
and the "Unless aborted" is interpreted as the simulation wouldn't halt
even if THIS COPY of the decider was replaced with a UTM that simulates
and never stops, then YES, you new definition can work. The problem is
your computation system doesn't meet that requirement because you have
intertwined the decider and the machine to be decided so you can't do that.