Michael Sipser of MIT validates the notion of a simulating halt decider

[olcott]

Professor Michael Sipser of MIT said that this verbatim paragraph looks
correct:

If H does correctly determine that its correct simulation
of D would never stop running unless aborted, would it be
correct for H to abort this simulation and report that D
specifies a non-halting sequence of configurations?

This validates the idea of a simulating halt decider referenced in this
paper.

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


Professor Sipser has not had the time to carefully review this paper
presented to him.

*The exact words posted above have been approved by Michael Sipser*


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

[Fred. Zwarts]

Op 12.okt..2022 om 17:08 schreef olcott:

> Professor Michael Sipser of MIT said that this verbatim paragraph looks
> correct:
>
>    If H does correctly determine that its correct simulation
>    of D would never stop running unless aborted, would it be
>    correct for H to abort this simulation and report that D
>    specifies a non-halting sequence of configurations?
>
> This validates the idea of a simulating halt decider referenced in this
> paper.
>
> *Rebutting the Sipser Halting Problem Proof*
> https://www.researchgate.net/publication/364302709_Rebutting_the_Sipser_Halting_Problem_Proof
>
> Professor Sipser has not had the time to carefully review this paper
> presented to him.
>
> *The exact words posted above have been approved by Michael Sipser*
>
>

And what does he say about:

If H does incorrectly determine that its incorrect simulation

[Ben Bacarisse]

"Fred. Zwarts" <F.Zw...@KVI.nl> writes:

> Op 12.okt..2022 om 17:08 schreef olcott:
>> Professor Michael Sipser of MIT said that this verbatim paragraph looks correct:
>>    If H does correctly determine that its correct simulation
>>    of D would never stop running unless aborted, would it be
>>    correct for H to abort this simulation and report that D
>>    specifies a non-halting sequence of configurations?
>> This validates the idea of a simulating halt decider referenced in this
>> paper.
>> *Rebutting the Sipser Halting Problem Proof*
>> https://www.researchgate.net/publication/364302709_Rebutting_the_Sipser_Halting_Problem_Proof
>> Professor Sipser has not had the time to carefully review this paper
>> presented to him.
>> *The exact words posted above have been approved by Michael Sipser*
>>
>
> And what does he say about:

Oh please don't draw the good professor into this any further!

> If H does incorrectly determine that its incorrect simulation
> of D would never stop running unless aborted, would it be
> correct for H to abort this simulation and report that D
> specifies a non-halting sequence of configurations?

You need to remove the deceptive subjunctive "would ... unless" to get
something not open to PO's dishonest re-interpretation. Whatever H
"would" do "unless" it does what it actually does is irrelevant. H(P,P)
returns 0 and P(P) halts. 0 is the wrong answer for a halting
computation.

--
Ben.

[olcott]

This validates that the behavior of D correctly simulated by H is the
correct behavior that H must report on, thus affirming that the notion
of a simulating halt decider is correct.

Complete halt deciding system (Visual Studio Project) Sipser version.
(a) x86utm operating system
(b) x86 emulator adapted from libx86emu to compile under Windows
(c) Several halt deciders and their sample inputs contained within Halt7.c
https://liarparadox.org/2022_10_08.zip

Ordinary software engineering verifies the simulation of Sipser_D by
Sipser_H is correct. Ordinary software engineering also verifies that
Sipser_H does correctly determine that Sipser_D is stuck in what would
otherwise be infinitely recursive simulation unless H aborts its
simulation of Sipser_D.

As can be seen from the above quote Professor Sipser has agreed that
this would be the correct basis for Sipser_H to report that Sipser_D
specifies a non-halting sequence of configurations.

[olcott]

Professor Sipser essentially validates the same notion of a simulating
halt decider that I have had all along:

When-so-ever simulating halt decider H correctly determines that its
correct simulation of its input D would never stop running unless
aborted then it is always correct for H to abort its simulation of D and
report that D specifies a non-halting sequence of configurations.

<quoted email>
Professor Sipser:

Here is what I would like to say:

Professor Michael Sipser of MIT said that this verbatim paragraph looks
correct:

If H does correctly determine that its correct simulation
of D would never stop running unless aborted, would it be
correct for H to abort this simulation and report that D
specifies a non-halting sequence of configurations?

This validates the idea of a simulating halt decider referenced in this
paper.

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


Professor Sipser has not had the time to carefully review this paper
presented to him.

</quoted email>

<quoted reply>
Looks ok. Thanks for checking.
</quoted reply>

[Mr Flibble]

On Wed, 12 Oct 2022 10:08:20 -0500
olcott <polc...@gmail.com> wrote:

> Professor Michael Sipser of MIT said that this verbatim paragraph
> looks correct:
>
> If H does correctly determine that its correct simulation
> of D would never stop running unless aborted, would it be
> correct for H to abort this simulation and report that D
> specifies a non-halting sequence of configurations?
>
> This validates the idea of a simulating halt decider referenced in
> this paper.
>
> *Rebutting the Sipser Halting Problem Proof*
> https://www.researchgate.net/publication/364302709_Rebutting_the_Sipser_Halting_Problem_Proof
>
>
> Professor Sipser has not had the time to carefully review this paper
> presented to him.
>
> *The exact words posted above have been approved by Michael Sipser*

Whilst the paragraph you sent to Sipser is correct the crucial detail
that you are glossing over is that you do NOT perform a correct
simulation for all inputs:

void Px(void (*x)())
{
(void) H(x, x);
return;
}

The correct simulation of Px above is to simulate Px halting.

Sipser confirms that the Flibble Signaling Halt Decider (TM) is a
solution however it does not confirm that the Olcott Simulation
Detector is a valid halt decider.

/Flibble

[olcott]

On 10/12/2022 12:24 PM, Mr Flibble wrote:
> On Wed, 12 Oct 2022 10:08:20 -0500
> olcott <polc...@gmail.com> wrote:
>
>> Professor Michael Sipser of MIT said that this verbatim paragraph
>> looks correct:
>>
>> If H does correctly determine that its correct simulation
>> of D would never stop running unless aborted, would it be
>> correct for H to abort this simulation and report that D
>> specifies a non-halting sequence of configurations?
>>
>> This validates the idea of a simulating halt decider referenced in
>> this paper.
>>
>> *Rebutting the Sipser Halting Problem Proof*
>> https://www.researchgate.net/publication/364302709_Rebutting_the_Sipser_Halting_Problem_Proof
>>
>>
>> Professor Sipser has not had the time to carefully review this paper
>> presented to him.
>>
>> *The exact words posted above have been approved by Michael Sipser*
>
> Whilst the paragraph you sent to Sipser is correct the crucial detail
> that you are glossing over is that you do NOT perform a correct
> simulation for all inputs:
>

Complete halt deciding system (Visual Studio Project) Sipser version.
(a) x86utm operating system
(b) x86 emulator adapted from libx86emu to compile under Windows
(c) Several halt deciders and their sample inputs contained within Halt7.c
https://liarparadox.org/2022_10_08.zip

Anyone with sufficient software engineering skill can easily verify that
Sipser_D is correctly simulated by Sipser_H and that Sipser_D remains
stuck in infinitely recursive simulation unless and until Sipser_H
aborts its correct simulation of Sipser_D.

[Mr Flibble]

You chose to not fully address my reply by snipping the important part
so I will give you another chance:

Whilst the paragraph you sent to Sipser is correct the crucial detail
that you are glossing over is that you do NOT perform a correct
simulation for all inputs:

[olcott]

Not at all. It must be a correct simulation of the actual input by the
simulating halt decider.

int main() { H(Px,Px); }
(a) The executed H simulates Px that calls a simulated H
(b) that simulates Px that calls a simulated H
(c) that simulates Px that calls a simulated H ...

[Mr Flibble]

Yes indeed it must be a correct simulation and a correct simulation of
Px is to simulate Px halting.

/Flibble

[olcott]

Sipser agreed that the correct simulation of Px by H is the correct
measure of the behavior of Px.

When we look at the above execution trace of: int main() { H(Px,Px); }
We see that Px remains stuck in recursive simulation until H aborts this
simulation.

[Mr Flibble]

On Wed, 12 Oct 2022 13:25:34 -0500

Of course he did but you don't do a correct simulation of Px: a
correct simulation of Px is to simulate Px halting as that is how Px
behaves.

/Flibble

[olcott]

A correct simulation of Px by H derives the execution trace that I
specified. Every line of the execution trace of the x86 emulation of Px
by H precisely corresponds to exactly what the x86 source code of Px
specifies.

void Px(void (*x)())
{
(void) H(x, x);
return;
}

int main()
{
Output("Input_Halts = ", H(Px, Px));
}

_Px()
[00001256] 55 push ebp
[00001257] 8bec mov ebp,esp
[00001259] 8b4508 mov eax,[ebp+08]
[0000125c] 50 push eax // push 2nd arg to H
[0000125d] 8b4d08 mov ecx,[ebp+08]
[00001260] 51 push ecx // push 1st arg to H
[00001261] e8b0fcffff call 00000f16 // call H
[00001266] 83c408 add esp,+08
[00001269] 5d pop ebp
[0000126a] c3 ret
Size in bytes:(0021) [0000126a]

H: Begin Simulation Execution Trace Stored at:111fcb
Address_of_H:f16
[00001256][00111fb7][00111fbb] 55 push ebp
[00001257][00111fb7][00111fbb] 8bec mov ebp,esp
[00001259][00111fb7][00111fbb] 8b4508 mov eax,[ebp+08]
[0000125c][00111fb3][00001256] 50 push eax // push Px
[0000125d][00111fb3][00001256] 8b4d08 mov ecx,[ebp+08]
[00001260][00111faf][00001256] 51 push ecx // push Px
[00001261][00111fab][00001266] e8b0fcffff call 00000f16 // call H
H: Infinitely Recursive Simulation Detected Simulation Stopped

We can see that the execution trace of the first six instructions of Px
exactly matches the x86 source-code of Px. We can also see that Px was
about to call H(Px,Px) again and this would repeat the cycle of the
first six instructions of Px.

[Mr Flibble]

On Wed, 12 Oct 2022 14:17:35 -0500

There are various methods of simulating an input: you have chosen an
incorrect method of simulation; if we substitute your H for another H
which uses a correct method of simulation, Px will correctly halt.

An SHD which uses a correct method of simulation would be the Flibble
Signaling Halt Decider (TM).

/Flibble

[olcott]

Everyone that is sufficiently technically competent at software
engineering can verify that H does correctly simulate Px on the basis
that the line-by-line execution trace of the simulation of Px by H
exactly matches the line-by-line x86 source-code of Px.

People that are not sufficiently technically competent might use
double-talk, misdirection and vagueness to provide a baseless rebuttal.

[dklei...@gmail.com]

On Wednesday, October 12, 2022 at 8:08:23 AM UTC-7, olcott wrote:
> Professor Michael Sipser of MIT said that this verbatim paragraph looks
> correct:
>
> If H does correctly determine that its correct simulation
> of D would never stop running unless aborted, would it be
> correct for H to abort this simulation and report that D
> specifies a non-halting sequence of configurations?
>

You are attempting to use the argument from authority.
That's a loser. My opinion is just as good as Sipser's.
But
Cleaning up you statement:
"If H determines that its simulation of D would never
stop running, might H abort the simulation and report
that D specifies a non-halting machine? "

This is true. But H cannot determine in every case that
the simulation will not stop running and therefore does
not itself alwaysstop running.

[Mr Flibble]

On Wed, 12 Oct 2022 14:32:41 -0500

A valid halt decider MUST return a decision to its caller, in this case
Px, in finite time; Px will then halt, correctly. Your H does not do
this so is not a valid halt decider.

/Flibble

[olcott]

On 10/12/2022 2:32 PM, dklei...@gmail.com wrote:
> On Wednesday, October 12, 2022 at 8:08:23 AM UTC-7, olcott wrote:
>> Professor Michael Sipser of MIT said that this verbatim paragraph looks
>> correct:
>>
>> If H does correctly determine that its correct simulation
>> of D would never stop running unless aborted, would it be
>> correct for H to abort this simulation and report that D
>> specifies a non-halting sequence of configurations?
>>
> You are attempting to use the argument from authority.

Argument from authority, also authoritative argument and appeal to
authority, is an inductive reasoning argument that often takes the form
of a statistical syllogism. Although certain classes of argument from
authority can constitute strong inductive arguments, the appeal to
authority is often applied fallaciously. Fallacious examples of using
the appeal include: ⁕cases where the authority is not a subject-matter
expert https://www.definitions.net/definition/argument+from+authority

> That's a loser. My opinion is just as good as Sipser's.

And likewise your opinion about brain surgery is just as good as the
opinion of the world's best brain surgeons ???

> But
> Cleaning up you statement:
> "If H determines that its simulation of D would never
> stop running, might H abort the simulation and report
> that D specifies a non-halting machine? "
>

H might do anything including ignoring its input and and playing a game
of tic-tac-toe with itself.

When-so-ever simulating halt decider H correctly determines that its
correct simulation of its input D would never stop running unless

aborted then it is always correct for H to abort its simulation of D and
report that D specifies a non-halting sequence of configurations.

> This is true. But H cannot determine in every case that
> the simulation will not stop running and therefore does
> not itself alwaysstop running.

I was only referring to Sipser's own H and D.

That Professor Sipser agrees with the essential definition of a
simulating halt decider seems to be an effective rebuttal to everyone
here that is not in the same ball park of subject matter expertise.

My purpose in getting Sipser's agreement on this key point is to
establish enough credibility to get other world renown subject matter
experts to review my work. A consensus of these subject matter experts
would seem to form strong evidence that I am correct.

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

[olcott]

Subject matter experts would disagree on the basis of seeing that the
call to H from Px is never executed and by examining the simulated
execution trace of Px by H compared to the x86 source-code of Px.

[dklei...@gmail.com]

On Wednesday, October 12, 2022 at 1:03:17 PM UTC-7, olcott wrote:
> On 10/12/2022 2:32 PM, dklei...@gmail.com wrote:
> > On Wednesday, October 12, 2022 at 8:08:23 AM UTC-7, olcott wrote:
> >> Professor Michael Sipser of MIT said that this verbatim paragraph looks
> >> correct:
> >>
> >> If H does correctly determine that its correct simulation
> >> of D would never stop running unless aborted, would it be
> >> correct for H to abort this simulation and report that D
> >> specifies a non-halting sequence of configurations?
> >>
> > You are attempting to use the argument from authority.
>
> Argument from authority, also authoritative argument and appeal to
> authority, is an inductive reasoning argument that often takes the form
> of a statistical syllogism. Although certain classes of argument from
> authority can constitute strong inductive arguments, the appeal to
> authority is often applied fallaciously. Fallacious examples of using
> the appeal include: ⁕cases where the authority is not a subject-matter
> expert https://www.definitions.net/definition/argument+from+authority
>
> > That's a loser. My opinion is just as good as Sipser's.
>
> And likewise your opinion about brain surgery is just as good as the
> opinion of the world's best brain surgeons ???
>

My opinion about brain surgery is just as good as Sipser's.

[Richard Damon]

On 10/12/22 11:08 AM, olcott wrote:
> Professor Michael Sipser of MIT said that this verbatim paragraph looks
> correct:
>
>    If H does correctly determine that its correct simulation
>    of D would never stop running unless aborted, would it be
>    correct for H to abort this simulation and report that D
>    specifies a non-halting sequence of configurations?
>
> This validates the idea of a simulating halt decider referenced in this
> paper.
>
> *Rebutting the Sipser Halting Problem Proof*
> https://www.researchgate.net/publication/364302709_Rebutting_the_Sipser_Halting_Problem_Proof
>
>
> Professor Sipser has not had the time to carefully review this paper
> presented to him.
>
> *The exact words posted above have been approved by Michael Sipser*
>
>

IF I drop by and ask him face to face, will he confirm this?

Did you explain YOUR definiton of "corrcct simulation"? I.E. the
GLOBALLY replacing of H with a pure simulator, even for the copy in the
input?

[olcott]

Probably yet your opinion** about the theory of computation is probably
not even in the ballpark of carrying the same weight as the opinion of
Professor Sipser.

** and everyone else here: Ben, Andre, Mike, Kaz

[Richard Damon]

On 10/12/22 4:03 PM, olcott wrote:
> On 10/12/2022 2:32 PM, dklei...@gmail.com wrote:
>> On Wednesday, October 12, 2022 at 8:08:23 AM UTC-7, olcott wrote:
>>> Professor Michael Sipser of MIT said that this verbatim paragraph looks
>>> correct:
>>>
>>> If H does correctly determine that its correct simulation
>>> of D would never stop running unless aborted, would it be
>>> correct for H to abort this simulation and report that D
>>> specifies a non-halting sequence of configurations?
>>>
>> You are attempting to use the argument from authority.
>
> Argument from authority, also authoritative argument and appeal to
> authority, is an inductive reasoning argument that often takes the form
> of a statistical syllogism. Although certain classes of argument from
> authority can constitute strong inductive arguments, the appeal to
> authority is often applied fallaciously. Fallacious examples of using
> the appeal include: ⁕cases where the authority is not a subject-matter
> expert https://www.definitions.net/definition/argument+from+authority

So, you AGREE that you are using a fallcious argument?

You do understand that just because one person, even if they are
knowledgeable in the field says something, that is not actually PROOF of
the statement.

>
>> That's a loser. My opinion is just as good as Sipser's.
>
> And likewise your opinion about brain surgery is just as good as the
> opinion of the world's best brain surgeons ???
>
>> But
>> Cleaning up you statement:
>> "If H determines that its simulation of D would never
>> stop running, might H abort the simulation and report
>> that D specifies a non-halting machine? "
>>
>
> H might do anything including ignoring its input and and playing a game
> of tic-tac-toe with itself.
>
> When-so-ever simulating halt decider H correctly determines that its
> correct simulation of its input D would never stop running unless
> aborted then it is always correct for H to abort its simulation of D and
> report that D specifies a non-halting sequence of configurations.

And since D Halts, H(D) returing 0 is wrong.

Note, H does NOT correctly determint that its correct simulation of its
input would never halt, but that the correct simulation by H' of D'
would never halt.

In fact, we can show that the correct simulation of D by H' WILL Halt,
so H is incorrect.

FAIL.

>
>> This is true. But H cannot determine in every case that
>> the simulation will not stop running and therefore does
>> not itself alwaysstop running.
>
> I was only referring to Sipser's own H and D.
>
> That Professor Sipser agrees with the essential definition of a
> simulating halt decider seems to be an effective rebuttal to everyone
> here that is not in the same ball park of subject matter expertise.

An I suspect that you didn't show him the full context of your
statement, and when shown that he will change his minde.

This just shows that you are someone competent at deception to
unsuspecting victims.

>
> My purpose in getting Sipser's agreement on this key point is to
> establish enough credibility to get other world renown subject matter
> experts to review my work. A consensus of these subject matter experts
> would seem to form strong evidence that I am correct.
>
> *Rebutting the Sipser Halting Problem Proof*
> https://www.researchgate.net/publication/364302709_Rebutting_the_Sipser_Halting_Problem_Proof
>
>

You still fail.

[olcott]

On 10/12/2022 5:37 PM, Richard Damon wrote:
> On 10/12/22 11:08 AM, olcott wrote:
>> Professor Michael Sipser of MIT said that this verbatim paragraph
>> looks correct:

<quoted email to professor Sipser>

Here is what I would like to say:

Professor Michael Sipser of MIT said that this verbatim paragraph looks
correct:

If H does correctly determine that its correct simulation
of D would never stop running unless aborted, would it be
correct for H to abort this simulation and report that D
specifies a non-halting sequence of configurations?

This validates the idea of a simulating halt decider referenced in this
paper.

Rebutting the Sipser Halting Problem Proof

https://www.researchgate.net/publication/364302709_Rebutting_the_Sipser_Halting_Problem_Proof

Professor Sipser has not had the time to carefully review this paper
presented to him.

</quoted email to professor Sipser>

<quoted reply from professor Sipser>

Looks ok. Thanks for checking.

</quoted reply from professor Sipser>

>
> IF I drop by and ask him face to face, will he confirm this?
>

Yes.

[olcott]

On 10/12/2022 5:42 PM, Richard Damon wrote:
> On 10/12/22 4:03 PM, olcott wrote:
>> On 10/12/2022 2:32 PM, dklei...@gmail.com wrote:
>>> On Wednesday, October 12, 2022 at 8:08:23 AM UTC-7, olcott wrote:
>>>> Professor Michael Sipser of MIT said that this verbatim paragraph looks
>>>> correct:
>>>>
>>>> If H does correctly determine that its correct simulation
>>>> of D would never stop running unless aborted, would it be
>>>> correct for H to abort this simulation and report that D
>>>> specifies a non-halting sequence of configurations?
>>>>
>>> You are attempting to use the argument from authority.
>>
>> Argument from authority, also authoritative argument and appeal to
>> authority, is an inductive reasoning argument that often takes the
>> form of a statistical syllogism. Although certain classes of argument
>> from authority can constitute strong inductive arguments, the appeal
>> to authority is often applied fallaciously. Fallacious examples of
>> using the appeal include: ⁕cases where the authority is not a
>> subject-matter expert
>> https://www.definitions.net/definition/argument+from+authority
>
> So, you AGREE that you are using a fallcious argument?
>
> You do understand that just because one person, even if they are
> knowledgeable in the field says something, that is not actually PROOF of
> the statement.

Even a universal consensus of every living being on the planet is not
proof. The agreement of one world class expert in the field is enough to
get other world class experts to spend a few minutes looking it over.

>>
>>> That's a loser. My opinion is just as good as Sipser's.
>>
>> And likewise your opinion about brain surgery is just as good as the
>> opinion of the world's best brain surgeons ???
>>
>>> But
>>> Cleaning up you statement:
>>> "If H determines that its simulation of D would never
>>> stop running, might H abort the simulation and report
>>> that D specifies a non-halting machine? "
>>>
>>
>> H might do anything including ignoring its input and and playing a
>> game of tic-tac-toe with itself.
>>
>> When-so-ever simulating halt decider H correctly determines that its
>> correct simulation of its input D would never stop running unless
>> aborted then it is always correct for H to abort its simulation of D
>> and report that D specifies a non-halting sequence of configurations.
>
> And since D Halts, H(D) returing 0 is wrong.
>
> Note, H does NOT correctly determint that its correct simulation of its
> input would never halt, but that the correct simulation by H' of D'
> would never halt.

Professor Sipser agrees that the behavior D simulated by H is the
correct measure for the halt status decision by H of D.

I worked on this for two years full time after I knew his email address
and phone number so that I could minimize the use of his time validating
my work.

Validating the notion of a simulating halt decider was the last sticking
point. This key element needed a world class expert to weigh in on.

[olcott]

Professor Sipser agrees that the behavior of D correctly simulated by
H is the correct behavior to analyze when H derives its halt status for D.

When H correctly determines that its simulation of D would never stop
running unless aborted H is correct to abort its simulation of D and reject this input.

[Keith Thompson]

Would Professor Sipser agree that you have refuted his halting problem
proof?

If I understand this correctly, it does not support the idea that a
general "simulating halt decider" can actually exist.

In the above, let D be a program that may or may not halt, and let H be
an observer who attempts to determine whether or not D halts.
Concretely, let D be this C program or equivalent:

int main(void) { while (1) { } }

and I'll be H. I can observe D. I can simulate it until I get bored,
which won't take long (one iteration, two iterations, three iterations,
zzzzzzzzz). I can, while simulating it, conclude that it will never
halt, abort the simulation, and report that it never halts. It wouldn't
be difficult to automate the process in a way that works for this simple
case.

In other words, a halt decider that works correctly for *some* programs
is entirely possible. Nobody disputes that, and the statement that you
report Dr. Sipser made is consistent with that.

What is impossible is a *general* halt decider that can report the halt
status for *any* program.

For example, it would be easy to write a program (assuming unbounded
memory resources) that halts if and only if Goldbach's conjecture is
false. If a general halt decider (simulating or not) existed, it could
be applied to such a program and solve Goldbach's conjecture.

(Goldbach's conjecture is that every even number greater than 2 is the
sum of 2 prime numbers. It has been demonstrated for values up to
4*10^18, but not proven or disproven in general.)

The part you seem to be handwaving over is *how* a simulating halt
decider is able to determine, in *all* cases, that a computation does
not halt. That is what has been proven to be impossible.

(My characterization of "handwaving" might be unfair. I have not read
everything you've posted here, and I have read very little of your
writings elsewhere that you've cited.)

Your premise is

If H does correctly determine that its correct simulation of D would

never stop running unless aborted ...

Of course the conclusion follows IF H does what you say. That's
trivial. You would need to demonstrate that H can *always* do so, for
any D.

It would be useful, I suppose, to study your own writings that you've
cited and point out precisely where you went wrong. I personally have
neither the time nor the expertise to do so.

But let me give you a simple challenge:

Write or obtain a program that, assuming unbounded memory, will halt if
and only if Goldbach's conjecture is false. Use whatever language is
most convenient.

Apply your simulating halt decider to this program. The result should
be either "yes, it halts" or "no, it doesn't halt".

Post here and tell us whether Goldbach's conjecture is true or false.
Show your work.

I believe you will be unable to do this.

(It's theoretically possible that someone could prove or disprove
Goldbach's conjecture without solving the halting problem. That would
be very interesting, but I doubt that anyone here has the expertise to
do so.)

--
Keith Thompson (The_Other_Keith) Keith.S.T...@gmail.com
Working, but not speaking, for Philips
void Void(void) { Void(); } /* The recursive call of the void */

[Richard Damon]

Did you explain that YOUR definition of "Correctly Simulated" included
changing the definition of the copy of H in D to also be a pure smulator?

If you don't answer a clear YES, then you are admitting that you were
being deceptive.

>
> I worked on this for two years full time after I knew his email address
> and phone number so that I could minimize the use of his time validating
> my work.
>
> Validating the notion of a simulating halt decider was the last sticking
> point. This key element needed a world class expert to weigh in on.
>

Maybe I should drop by his office and show him your papers.

I think you are guilty of lying.

[olcott]

He agrees

Professor Sipser agrees that my original notion of a simulating halt
decider is correct. This is the key element of all of my proofs.

Simulating halt decider H correctly simulates its input D until H
correctly determines that D would never stop running unless aborted.
Then H is correct to abort its simulation and reject D.

He has > 250 students in his class so he did not have the time to
analyze more than this.

> If I understand this correctly, it does not support the idea that a
> general "simulating halt decider" can actually exist.
>
> In the above, let D be a program that may or may not halt, and let H be
> an observer who attempts to determine whether or not D halts.
> Concretely, let D be this C program or equivalent:
>
> int main(void) { while (1) { } }
>
> and I'll be H. I can observe D. I can simulate it until I get bored,
> which won't take long (one iteration, two iterations, three iterations,
> zzzzzzzzz). I can, while simulating it, conclude that it will never
> halt, abort the simulation, and report that it never halts. It wouldn't
> be difficult to automate the process in a way that works for this simple
> case.
>

H detects a repeating state in D.

> In other words, a halt decider that works correctly for *some* programs
> is entirely possible. Nobody disputes that, and the statement that you
> report Dr. Sipser made is consistent with that.
>
> What is impossible is a *general* halt decider that can report the halt
> status for *any* program.
>
> For example, it would be easy to write a program (assuming unbounded
> memory resources) that halts if and only if Goldbach's conjecture is
> false. If a general halt decider (simulating or not) existed, it could
> be applied to such a program and solve Goldbach's conjecture.
>
> (Goldbach's conjecture is that every even number greater than 2 is the
> sum of 2 prime numbers. It has been demonstrated for values up to
> 4*10^18, but not proven or disproven in general.)
>
> The part you seem to be handwaving over is *how* a simulating halt
> decider is able to determine, in *all* cases, that a computation does
> not halt. That is what has been proven to be impossible.
>

It need not handle all cases, it only need handle the "impossible" input
then all of the conventional proofs have been defeated.

[olcott]

This is a typo:
> He agrees
>

*Professor Sipser did not review my proof*
*he only agrees with the following*

> Professor Sipser agrees that my original notion of a simulating halt
> decider is correct. This is the key element of all of my proofs.
>
> Simulating halt decider H correctly simulates its input D until H
> correctly determines that D would never stop running unless aborted.
> Then H is correct to abort its simulation and reject D.
>
> He has > 250 students in his class so he did not have the time to
> analyze more than this.
>

[Richard Damon]

No, because you CHANGED D by changig the H it calls to not abort.

The ACTUAL D calls H which simultes D till it calls H(D) and them aborts.

H never actually SAW a repeating state, it just presumes it.

If H doesn't abort at that point, then it needs to simulate the actual
code of H simulating D, and again, it won't ever see this reach a state
that it reached before.

If it doesn't abort, it will never answer, but if it does abort and
return 0, it makes the actual behavior of D to be halts, so it did not
CORRECTLY show that a CORRECT simulation will be non-halting.

[Richard Damon]

And probably was not shown what you mean by those terms, thus you are
guilty of lying by deception.

Note, you haven't actually shown that H CORRECTLY simulates its input
until it CORRECTLY deteremines that D would never stop running.

Your logic looks at a DIFFERENT D then the actual one.

Thus you don't meet the conditions of the premises of your statement, so
you don't get the conclusion.

You have to show that it is CORRECT with D being the D that calls the H
that is making the decision.

You logic always make D be based on a different H.

YOU FAIL.

[olcott]

What professor Sipser agreed to is quoted below:

>>
>> I worked on this for two years full time after I knew his email
>> address and phone number so that I could minimize the use of his time
>> validating my work.
>>
>> Validating the notion of a simulating halt decider was the last
>> sticking point. This key element needed a world class expert to weigh
>> in on.
>>
>
> Maybe I should drop by his office and show him your papers.

I forgot you are an MIT grad.

*He has already seen the link to my rebuttal of his diagonal proof*
(see below) All of my other papers are way too verbose.

It would be great if you could get him to spend time on carefully
analyzing this 1.5 page paper. It may only take him 15 minutes of
intense concentration. He understands and accepts the notion of a
simulating halt decider. This is my most important breakthrough.

<quoted email to professor Sipser>

Professor Sipser:

Here is what I would like to say:

Professor Michael Sipser of MIT said that this verbatim paragraph looks
correct:

If H does correctly determine that its correct simulation
of D would never stop running unless aborted, would it be
correct for H to abort this simulation and report that D
specifies a non-halting sequence of configurations?

This validates the idea of a simulating halt decider referenced in this
paper.

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

Professor Sipser has not had the time to carefully review this paper
presented to him.
</quoted email to professor Sipser>

<quoted reply from professor Sipser>
Looks ok. Thanks for checking.
</quoted reply from professor Sipser>

[olcott]

This is simply beyond your software engineering technical competence.
I told you how you can learn about these things and you refused.

[Keith Thompson]

Given your tendency to include all quoted text in your followups, it's
remarkable that you've carefully deleted the challenge that I presented.

Here it is again:

========================================

But let me give you a simple challenge:

Write or obtain a program that, assuming unbounded memory, will halt if
and only if Goldbach's conjecture is false. Use whatever language is
most convenient.

Apply your simulating halt decider to this program. The result should
be either "yes, it halts" or "no, it doesn't halt".

Post here and tell us whether Goldbach's conjecture is true or false.
Show your work.

I believe you will be unable to do this.

(It's theoretically possible that someone could prove or disprove
Goldbach's conjecture without solving the halting problem. That would
be very interesting, but I doubt that anyone here has the expertise to
do so.)

========================================

Are you able to respond to this challenge? Will you do so?

And one more point of clarification. You've been claiming for many
years to have refuted the proofs that the halting problem cannot be
solved. Do you claim that you can solve the halting problem, or is your
claim merely that the existing proofs are flawed?

Can you actually solve the halting problem?

[olcott]

This is off topic and invalid. I don't want to say how it is invalid
because it is off topic.

[Philip White]

On Wednesday, October 12, 2022 at 11:08:23 AM UTC-4, olcott wrote:
> Professor Michael Sipser of MIT said that this verbatim paragraph looks
> correct:
>

> If H does correctly determine that its correct simulation
> of D would never stop running unless aborted, would it be
> correct for H to abort this simulation and report that D
> specifies a non-halting sequence of configurations?
>
> This validates the idea of a simulating halt decider referenced in this
> paper.
>

> *Rebutting the Sipser Halting Problem Proof*

> https://www.researchgate.net/publication/364302709_Rebutting_the_Sipser_Halting_Problem_Proof
>
>
> Professor Sipser has not had the time to carefully review this paper
> presented to him.
>

> *The exact words posted above have been approved by Michael Sipser*
>
>

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

Peter,

I read your paper. The problem is, the machine that you specified might be able to tell that this is the "provably non-halting Turing machine" that you specified...the H machine might have its exact C or TM-indexing source code recognized by the machine D that could be re-coded (your source code for D would just loop forever in your paper), but the Halting Problem is to decide all instances of the halting problem, not just one such instance. The key issue is, if you had a set of, say, one million halting problem instances, and a database of correct answers, you *could* write a TM that would decide them all correctly...you could just look up the source code in the database and determine if the algorithm is provably non-halting, or you could simulate it until it is finished running and conclude that it is halting. The issue is, the Halting Problem is about all, countably infinitely many instances of the Halting problem...all Turing machines and all (let's say) binary inputs. Turing's proof showed that there is no algorithm that achieves this.

I'm happy to answer any questions you may have about this. In practice, there are very good algorithms that are "almost completely correct" for the Halting Problem, but such algorithms are very difficult to devise, and I would not share mine...it is very valuable. At the same time, there is a priori proof, based on very reasonable assumptions, that, based on deductive reasoning and simple logical conventions, there is no single algorithm that solves *all* Halting Problem instances correctly.

Again, please let me know if you have more questions; I have a few weeks to answer, and I understand your motives a little better for posting about this...I have a mental health condition and had thought you were conducting an elaborate satire previously when I wrote back to you. (I think things like that a lot when I have health issues, but I think I get you more clearly now...you seem sincere.)

-Philip White (philipw...@gmail.com)

[Richard Damon]

Which means you still need to prove that H is CORRECT in determining
that the ACTUAL INPUT would ever stop if correctly simulated (by H or
whatever).

Note, he han't agrees that you get to change the code of the H that D
calls, so that H still will abort its simulation if this H does
eventually abort, and that breaks

And you still have the problem of proving that H "correctly determines"
since the input is FIXED to be using the definition of the H that does
abort, since that IS the code that the H that it is calling uses.

Note, that in the past I have even agreed that if H can CORRECTLY
determine that THE correct simulation of the input won't halt, then it
is correct to abort.

The problem you run into is that if H is defined to abort this pattern,
then it NEVER does the complete simulation to show that it wouldn't
abort, so condtions based on the behavior of solely this H become
non-helpful as non-existant thing don't prove properties of the existant.

It isn't that H can be correct answering if it is correct in determining
that is the issue, that is a Tautology, it is try to show your
(incorrect) idea that H can answer about an input based on the altered
version of H instead of the actual input, and as you have pointed out,
it is a lying bastard who forces H to decide on something which isn't
the input, so H can only decide on the input base on the ORIGINAL (i.e.
aborting) version of H since that IS what it is given by the template.

That is where you fail.

[Richard Damon]

No, the truth is beyound YOUR understanding.

I suspect I have a much stronger software background than you.

Even though my job title isn't "Software", I am still considered one of
the top Software Designers in the company I work for.

As I remember, you are currently unemployed.

[olcott]

Thanks for your review.

A simulating halt decider defeats all of the conventional halting
problem proofs (now even including the diagonal argument as my most
recent breakthrough). It does this by correctly construing all of the
conventional "impossible" inputs as specifying the recursive simulation
non-halting behavior pattern.

MIT Professor Michael Sipser has just validated my original notion of a
simulating halt decider.

[olcott]

As I have said previously you cannot begin to understand this aspect
until after you grok all of the details of how H recognizes this
infinite recursion:

void Infinite_Recursion(u32 N)
{
Infinite_Recursion(N);
}

That you refuse to do that simply proves that you are not sincere.
These details are contained in Halt7.c

Complete halt deciding system (Visual Studio Project) Sipser version.
(a) x86utm operating system
(b) x86 emulator adapted from libx86emu to compile under Windows
(c) Several halt deciders and their sample inputs contained within Halt7.c
https://liarparadox.org/2022_10_08.zip

[Richard Damon]

Actually, the Halting Problem Proof shows that NO prospective Halt
Decider can answer correctly about the machine built on it by this pattern.

No H can correctly decide on the H^ built by that method, because what
ever it decides, H^ will do the opposite, since it can use the algorithm
of H to know what H will do when deciding on it. It can do this because
computations are deterministic, and thus predictable.

Olcott's LIE is that he CLAIMS to build the "impossible machine" by the
pattern, but then redefines this so that the "corrcect simulation" of
this machine is actually the results of correctly simulating a DIFFERENT
machine.

It is well know that you can often decide on the H^ machine built on a
DIFFERENT decider than yourself, so he isn't showing anything new, he
just uses deception to try to make you think that those two are the same
machine.

It just shows he doesn't understand what a Turing Machine actually is,
or by extension what a Computation or an Algorithm (as used in
Computation Theory) is.

[olcott]

I am 67 and retired.

If you are a top software designer then you can see how infinite
recursion is correctly detected in less than 30 minutes. Look in the
Halt7.c file for these details.

Complete halt deciding system (Visual Studio Project) Sipser version.
(a) x86utm operating system
(b) x86 emulator adapted from libx86emu to compile under Windows
(c) Several halt deciders and their sample inputs contained within Halt7.c
https://liarparadox.org/2022_10_08.zip

I suspect that you are a top software designer, this makes your review
of my work all that much more disingenuous.

[Philip White]

You're welcome.

> ... It does this by correctly construing all of the

> conventional "impossible" inputs as specifying the recursive simulation
> non-halting behavior pattern.
>

Which inputs are impossible? Do you mean inputs that are impossible to decide correctly, i.e., pair <M,I> such that M,I doesn't halt (any halting pair can be decided via direct simulation)? You say that these inputs are "construed" as "specifying the recursive simulation non-halting behavior pattern"...the problem is, how will you do this? In order to somehow rebut the halting problem proof, you would need to have a specific algorithm that solves the halting problem every time. If you can't produce that algorithm, it is unlikely that you have a correct proof. It's like if you claimed P = NP non-constructively; either you must produce a correct algorithm that works (and prove that it works, which is often not all that hard), or present a non-constructive proof, where you present a deductive reasoning argument that the algorithm *must* exist. Vaguely stating something about construing some things as other things is not a proof. If you have an intuition about it, that might be neat, but you need to be specific and write something that can be construed as a formal proof--or shorthand for it--to get accepted.

> MIT Professor Michael Sipser has just validated my original notion of a
> simulating halt decider.

Yes, Michael Sipser is an authority on TCS.

-Philip White (philipw...@gmail.com)

[Richard Damon]

No, I fully understand how that works, but it seems YOU don't because
you don't understand the exact conditions required.


The fact that you don't actually try to explain the EXACT rule you are
using for that (with reference or proof) shows that it is YOU who don't
understand.

I have pointed out the error in the rule you claim, but you don't
understand and still repeat without any support.

You are just proving you don't understand what it means to actually
prove something,

>
> Complete halt deciding system (Visual Studio Project) Sipser version.
> (a) x86utm operating system
> (b) x86 emulator adapted from libx86emu to compile under Windows
> (c) Several halt deciders and their sample inputs contained within Halt7.c
> https://liarparadox.org/2022_10_08.zip
>
>

Right, and that program PROVES you wrong as I have described.

It shows that P(P) Halts, and thus H(P,P) should have returned 1 instead
of 0


You are just too dumb to understand.

You are just proving you aren't actually working on the Halting Problem.

YOU FAIL

[Richard Damon]

likely because you couldn't keep a job.

I am 66 and still have many years I can work.

>
> If you are a top software designer then you can see how infinite
> recursion is correctly detected in less than 30 minutes. Look in the
> Halt7.c file for these details.

IT can detect the infinite recursion in the machines that DO have it.

YOu use the wrong rules so you get false positives, as proven by the
fact that P(P) will finish even though you claim it has infinite recursion.

You "arguements" just show a total lack of understand how computers
actually work.

>
> Complete halt deciding system (Visual Studio Project) Sipser version.
> (a) x86utm operating system
> (b) x86 emulator adapted from libx86emu to compile under Windows
> (c) Several halt deciders and their sample inputs contained within Halt7.c
> https://liarparadox.org/2022_10_08.zip
>
> I suspect that you are a top software designer, this makes your review
> of my work all that much more disingenuous.
>

Why, the fact that I point out the clear error in yor code?

You are just showing how BAD of a programmer you are to not understand
the basics of requirements.

You are just showing how bad you are at understanding truth.

You are just showing how much of a liar you are.

YOU FAIL.

[Richard Damon]

And since they don't, it doesn't

And, from what you have said, he hasn't actually validated your key
point, and thus you still have nothing.

Unless you pointed out that your processing cause the input to use the
altered version of H, he hasn't aggreed to your logic.

YOU FAIL.

[olcott]

It is not me it is you that refuse to look at the code.

[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 P, called with some input, can pass its own
source and its input to H and then specifically do the opposite of
what H predicts P will do. *No H can exist that handles this case*
https://en.wikipedia.org/wiki/Halting_problem

// P does the opposite of whatever H decides
void P(ptr x)
{
int Halt_Status = H(x, x);
if (Halt_Status) // if H(P,P) reports that its input halts
HERE: goto HERE; // P loops and never halts
return; // else P halts
}

int main()
{
Output("Input_Halts = ", H(P, P));
}

H recognizes the recursive simulation of P using the same criteria that
it uses to recognize this:

void Infinite_Recursion(u32 N)
{
Infinite_Recursion(N);

[Ben Bacarisse]

I emailed him to let him know what PO is doing. I don't want to share a
private conversation, but let's just say the exchange went exactly as
you would expect.

--
Ben.

[Richard Damon]

Why do you say that I refuse to look at the code. Haven't I pointed out
the error in logic of that code?

That just shows how little you value truth, making statements with NO
proof, and actually against the evidence.

You are just proving your duplicity, and stupidity.

[B.H.]

Yes, that's exactly right. The key is, "arbitrary" is a word that mathematicians use to mean that "it can be any element from the set." So, if someone writes, "Fix an arbitrary x in the set S such that P(x) is true," where P is some property, then that could be re-written as the logically equivalent statement, "For all x in S, P(x) is true." That is why the Halting Problem proof applies to *all* of the Turing machines in the set of all Turing machines.

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

I'm not sure how you defined "pathological," but yes, everything you've said so far is exactly correct.

-Philip White (philipw...@gmail.com)

[Richard Damon]

So I don't need to drop by campus and talk to him?

[olcott]

No.

> I emailed him to let him know what PO is doing. I don't want to share a
> private conversation, but let's just say the exchange went exactly as
> you would expect.
>

You confirmed that he talked to me that is good.

He gave me his permission to quote him. Since he validated the most
important aspect of my proof without examining any of the other details
I am sure that he must still believe that I am incorrect about my HP
rebuttal. That is OK he has > 250 students. That he validated the most
essential aspect of my proof gives me a key threshold of credibility.

*A paraphrase of the words that he agreed to*
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 aborts its simulation of D and correctly reports
that D specifies a non-halting sequence of configurations.

[olcott]

Wikipedia just explained how they defined pathological and then I
provided the pathological source code below.

[olcott]

Go ahead and talk to him, get him to spend 15 minutes on my 1.5 page
paper. He can skip page 2. The only thing they he does not quite fully
understand is the recursive simulation that I demonstrate on page 1.

The first half of page 1 is simply my quotes of his words. He only
really needs to focus on the bottom half of page 1.

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

[Otto J. Makela]

olcott <polc...@gmail.com> wrote:

> Professor Michael Sipser of MIT said that this verbatim paragraph
> looks correct:

...

> Professor Sipser has not had the time to carefully review this paper
> presented to him.

I've worked at a mathematics department where we continuously got
messages from people convinced they have squared the circle, or other
similar mathematical impossibilities favored by pseudomathematicians.
Professor Spiser's answer looks somewhat similar to the answers we gave
out to these people.

Another common approach is to misapprehend standard
mathematical methods, and to insist that the use or knowledge
of higher mathematics is somehow cheating or misleading
(e.g., the denial of Cantor's diagonal argument or Gödel's
incompleteness theorems).
-- https://en.wikipedia.org/wiki/Pseudomathematics
--
/* * * Otto J. Makela <o...@iki.fi> * * * * * * * * * */
/* Phone: +358 40 765 5772, ICBM: N 60 10' E 24 55' */
/* Mail: Mechelininkatu 26 B 27, FI-00100 Helsinki */
/* * * Computers Rule 01001111 01001011 * * * * * * */

[Ben Bacarisse]

I don't think you /need/ to and, if it were me, I'd worry that this has
already taken up more of his time than he'd want. But if you think it's
worthwhile...

--
Ben.

[Richard Damon]

No, I do't need to talk to him to try to "convince" him of something
that is incorrect.

Your ultimate problem is that you don't understand what you are talking
about and have basic misunderstanding of how programs and requirements work.

There is ONE correct answer to does a given machine Halt, and one
correct answer to the behavior of the input.

When you say that H correctly deteremines that its simulation will not
complete, what that actually means to people who understand, is that if
we gave this input to an actual complete simulator, it would not halt,
or if we change this one invocation of H (and somehow not change any
other invocations in the system) to not abort, that THIS new machine
would run forever.

It does NOT mean if we change H to a different machine, and thus change
other invocations of H, for example in the input, that the results is
shown to be non-halting.

If you understood how Turing Machines actually worked, you could see why
that is. THe fact that you seem incapable of understanding Turing
Machines, is your downfall here.

It should be noted that your infinite recursion arguement is just
fatally flawed. Infinite Recursion (or whatever) doesn't mean that it
would run until it decides to stop. You seem to miss the fundamental
fact that BECAUSE H is coded to stop its simulation, becomes PART of the
definition of P/D and thus this program DOES decide to stop itself, and
thus in not infinite in behavior,

The fact that you think it is ok to change the code that part of the
input, or even not understanding that changing H does that, just shows
your ignorance of how things work.

Perhaps the problem is your flawed "First Principles" approach, where
you don't bother to learn the actual rules for a system, but try to
imagine what they "should" be. The problem is you are too stupid to see
the problems that come out of your "First Principle Creation" of a
system. You are just showing your stupidity.

You have FAILED. You have shown your ignorance. You have shown that you
need to use deception to try and get people to believe parts of your
logic. You have shown that you don't understand how Truth works, or even
how to discuss things using Natural Language.

You have killed your reputation and buried it under the giant mound of
your falsehoods.

[olcott]

On 10/13/2022 2:47 AM, Otto J. Makela wrote:
> olcott <polc...@gmail.com> wrote:
>
>> Professor Michael Sipser of MIT said that this verbatim paragraph
>> looks correct:
> ...
>> Professor Sipser has not had the time to carefully review this paper
>> presented to him.
>
> I've worked at a mathematics department where we continuously got
> messages from people convinced they have squared the circle, or other
> similar mathematical impossibilities favored by pseudomathematicians.
> Professor Spiser's answer looks somewhat similar to the answers we gave
> out to these people.
>
> Another common approach is to misapprehend standard
> mathematical methods, and to insist that the use or knowledge
> of higher mathematics is somehow cheating or misleading
> (e.g., the denial of Cantor's diagonal argument or Gödel's
> incompleteness theorems).
> -- https://en.wikipedia.org/wiki/Pseudomathematics

*Professor Sipser has agreed to this definition of halt decider*

If H does correctly determine that its correct simulation

of D would never stop running unless aborted, then it
would be correct for H to abort this simulation and report
that D specifies a non-halting sequence of configurations.

When that is applied to this

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

Sipser_H correctly recognizes that its correctly simulated Sipser_D
would never stop running unless this simulation is aborted.

Everyone here knows that this last sentence is true, and Professor
Sipser's affirmation above allows Sipser_H to correctly determine that
Sipser_D is non-halting.

[olcott]

*Professor Sipser has agreed with this*

If H does correctly determine that its correct simulation

of D would never stop running unless aborted, then it
would be correct for H to abort this simulation and report
that D specifies a non-halting sequence of configurations.

Thus negating your only objection.

[Python]

Peter Olcott, demented crank, wrote:
..

> *Professor Sipser has agreed with this*
> If H does correctly determine that its correct simulation
> of D would never stop running unless aborted, then it
> would be correct for H to abort this simulation and report
> that D specifies a non-halting sequence of configurations.

sigh... he correctly agreed with a tautology "if it *correctly*
determine whatever then it would be correct to report it".

He did so to get rid of the annoying crank you are. He should
have guessed that your will use this dishonestly.

This cannot support your idiotic claim that H reporting P
to be non-halting while it is obvious that P is halting,
from its very definition.

[Mr Flibble]

On Wed, 12 Oct 2022 17:39:41 -0500
olcott <non...@beez-waxes.com> wrote:

> On 10/12/2022 5:23 PM, dklei...@gmail.com wrote:

> > On Wednesday, October 12, 2022 at 1:03:17 PM UTC-7, olcott wrote:
> >> On 10/12/2022 2:32 PM, dklei...@gmail.com wrote:

> >>> On Wednesday, October 12, 2022 at 8:08:23 AM UTC-7, olcott wrote:
> >>>
> >>>> Professor Michael Sipser of MIT said that this verbatim
> >>>> paragraph looks correct:
> >>>>

> >>>> If H does correctly determine that its correct simulation

> >>>> of D would never stop running unless aborted, would it be

> >>>> correct for H to abort this simulation and report that D

> >>>> specifies a non-halting sequence of configurations?
> >>>>
> >>> You are attempting to use the argument from authority.
> >>
> >> Argument from authority, also authoritative argument and appeal to
> >> authority, is an inductive reasoning argument that often takes the
> >> form of a statistical syllogism. Although certain classes of
> >> argument from authority can constitute strong inductive arguments,
> >> the appeal to authority is often applied fallaciously. Fallacious
> >> examples of using the appeal include: ⁕cases where the authority
> >> is not a subject-matter expert
> >> https://www.definitions.net/definition/argument+from+authority

> >>> That's a loser. My opinion is just as good as Sipser's.
> >>
> >> And likewise your opinion about brain surgery is just as good as
> >> the opinion of the world's best brain surgeons ???
> >>

> > My opinion about brain surgery is just as good as Sipser's.
> >
>
> Probably yet your opinion** about the theory of computation is
> probably not even in the ballpark of carrying the same weight as the
> opinion of Professor Sipser.
>
> ** and everyone else here: Ben, Andre, Mike, Kaz

Appeal to authority is a logical fallacy. Prove your argument is sound
using facts and logic in your own words.

/Flibble

[Philip White]

OK, so this article?:

https://en.wikipedia.org/wiki/Pathology

Did you indicate that pathological is essentially "progressing?" If you could explain how your algorithm is somehow pathological, that would help people to understand if you claim to have a specific argument establishing that the Halting Problem proof is incorrect.

If you would provide more detail, I could give more analytical feedback on your idea...I have a very good background in math, and I know CS too. I can stay with this for now and keep trying to help...I have plenty of time and can try to go back and forth and explain and/or debate issues with your algorithm, if you're willing to get more deeply into it. It sounds like you have sort of a "perimeter defense" up and might be "testing" people to see if they will accept your initial claims. If you are willing to accept the possibility that I might not agree with your initial claims but will still explain the deeper aspects of your approach, according to me, then I would encourage you to keep asking me to help analyze your idea.

I won't have unlimited time in the future, but I do have lots of time now.

-Philip White (philipw...@gmail.com)

[olcott]

Professor Sipser agreed that the behavior of the input D correctly
simulated by H is the correct behavior to measure.

[olcott]

I have already shown that and appeal to the authority of a qualified
expert in the field is inductively sound.

MIT Professor Michael Sipser has agreed that the following verbatim
paragraph is correct (he has not agreed to anything else in this paper):

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.

When one accepts this definition of a simulating halt decider then my
code shows that H correctly determines the halt status of D.

When one rejects that definition of a simulating halt decider then my
proof loses its required basis.

[Mr Flibble]

On Thu, 13 Oct 2022 11:46:22 -0500

No. Appeal to authority is a logical fallacy; doesn't matter who the
authority is.

/Flibble

[olcott]

That would mean that going to your garbage man about brain surgery is
just as good as going to a brain surgeon.

If everyone in the universe agreed with me then this would not be proof
that am correct.

If a universal consensus of all of the experts in the field agreed with
me then this would be strong evidence that I am correct.

That one qualified expert in the field agrees with me that is enough
credibility to get other qualified experts to review this same single
point of agreement.

[Jeff Barnett]

Isn't the "brushoff with implied agreement" a method to decrank one's
mailbox that was mentioned in Dudley's "The Trisectors"? Can't find my
copy to check it out.
--
Jeff Barnett

[olcott]

Professor Sipser specifically approved this precise verbiage as the
abstract to my paper, linked below:

<Sipser approved abstract>

MIT Professor Michael Sipser has agreed that the following verbatim
paragraph is correct (he has not agreed to anything else in this paper):

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.
</Sipser approved abstract>

to this paper:

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

[Keith Thompson]

olcott <polc...@gmail.com> writes:
[...]

> *Professor Sipser has agreed to this definition of halt decider*
> If H does correctly determine that its correct simulation
> of D would never stop running unless aborted, then it
> would be correct for H to abort this simulation and report
> that D specifies a non-halting sequence of configurations.

[...]

Does that imply that he agreed that a halt decider is possible?

I'm sure you think he did, but did he agree to that explicitly?

--
Keith Thompson (The_Other_Keith) Keith.S.T...@gmail.com
Working, but not speaking, for Philips
void Void(void) { Void(); } /* The recursive call of the void */

[Mr Flibble]

That is all fine and dandy but it seems I need to remind you again that
your Olcott Simulation Detector does not correctly simulate all inputs
and as a result does not give a correct halting decision for all inputs.

/Flibble

[olcott]

On 10/13/2022 12:42 PM, Keith Thompson wrote:
> olcott <polc...@gmail.com> writes:
> [...]
>> *Professor Sipser has agreed to this definition of halt decider*
>> If H does correctly determine that its correct simulation
>> of D would never stop running unless aborted, then it
>> would be correct for H to abort this simulation and report
>> that D specifies a non-halting sequence of configurations.
> [...]
>
> Does that imply that he agreed that a halt decider is possible?
>
> I'm sure you think he did, but did he agree to that explicitly?
>

Professor Sipser specifically approved this exact verbiage as the
abstract to my paper, linked below at 11:29:23 AM today:

<Sipser approved abstract>
MIT Professor Michael Sipser has agreed that the following verbatim
paragraph is correct (he has not agreed to anything else in this paper):

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.

</Sipser approved abstract>

to this paper:

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

[olcott]

Strawman error.

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 P, called with some input, can pass its own
source and its input to H and then specifically do the opposite of
what H predicts P will do. *No H can exist that handles this case*
https://en.wikipedia.org/wiki/Halting_problem

Refuting the above and all of the conventional HP proofs only requires
an H that correctly handles that case.

[Python]

And your H fail to report correctly the behavior of P. Even you admit
so. FAIL.

How can you be that stupid Peter ?

[Keith Thompson]

What is the point of repeating what you wrote earlier? You didn't
answer my question. (I suspect you know that, and are being
deliberately evasive.)

If two distinct prime numbers are both even, then the difference between
them is a non-zero even number. I'm guessing that Professor Sipser
would agree with that statement, but it would not imply that he agrees
that there are two distinct even prime numbers.

Similarly, I see no evidence that Professor Sipser agrees that a
"simulating halt decider" is possible, only a trivial agreement about
what would happen if it were possible.

[olcott]

My H does report on the basis that Professor Sipser has agreed to. If
you have not yet noticed this then perhaps you only care about rebuttal
and do not care about an honest dialogue?

[Python]

Lying sinner Peter Olcott wrote:
..

>> And your H fail to report correctly the behavior of P. Even you admit
>> so. FAIL.
>>
>> How can you be that stupid Peter ?
>>
>
> My H does report on the basis that Professor Sipser has agreed to. If
> you have not yet noticed this then perhaps you only care about rebuttal
> and do not care about an honest dialogue?
>

Your H reports P to be non-halting. P halts. Pr Sipser never agreed that
such an H could be a valid halt decider. Stop lying Peter.

[olcott]

Not at all. Professor Sipser agrees that the behavior of the input D
correctly simulated by simulating halt decider H is the correct behavior
for H to base its halt status decision on.

This has been the only remaining sticking point.

[Mr Flibble]

A halt decider is not a halt decider if it cannot give a correct
halting decision for ALL inputs.

/Flibble

[olcott]

My simulating halt decider H correctly reports that its correct
simulation of D must be aborted or the simulated D would never stop
running. *This is verified on the basis of software engineering*

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

[olcott]

Technically that is true yet calling H a halt determiner would be too
difficult for most people. We could say that H is a halt decider for
every element in its domain. This may be too difficult for software
engineers. My target audience is computer scientists and software
engineers.

[Python]

Lying sinner Pter Olcott wrote:
> On 10/13/2022 1:34 PM, Python wrote:
>> Lying sinner Peter Olcott wrote:
>> ..
>>>> And your H fail to report correctly the behavior of P. Even you admit
>>>> so. FAIL.
>>>>
>>>> How can you be that stupid Peter ?
>>>>
>>>
>>> My H does report on the basis that Professor Sipser has agreed to. If
>>> you have not yet noticed this then perhaps you only care about
>>> rebuttal and do not care about an honest dialogue?
>>>
>>
>> Your H reports P to be non-halting. P halts. Pr Sipser never agreed that
>> such an H could be a valid halt decider. Stop lying Peter.
> My simulating halt decider H correctly reports that its correct
> simulation of D must be aborted or the simulated D would never stop
> running. *This is verified on the basis of software engineering*
>
> *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.

Which is a void tautology "if it is correct then it is correct"...
He just wanted to get rid of you, troll and crank.

And still:

Your H reports P to be non-halting. P halts. Pr Sipser never agreed that
such an H could be a valid halt decider. Stop lying Peter.

You'll burn in Hell, according to your own rules.

[Mr Flibble]

On Thu, 13 Oct 2022 13:49:28 -0500

In its domain??? What a load of bollocks.

/Flibble

[Ben Bacarisse]

Jeff Barnett <j...@notatt.com> writes:

> Isn't the "brushoff with implied agreement" a method to decrank one's
> mailbox that was mentioned in Dudley's "The Trisectors"? Can't find my
> copy to check it out.

No, I think Dudley explicitly says not to do that. His two
recommendations are to be flattering while plainly pointing out the
error in the end result without engaging with the argument in any way.
For PO that would be "I see you have thought long and hard about this
problem and you have come up with some ingenious ideas. However, H(P,P)
== 0 is not the correct answer if P(P) is a halting computation."

His other suggestion is to write a reply that is "harsh, scathing and
designed to make the writer hate you". I can't imagine Professor Sipser
taking that option.

--
Ben.

[olcott]

P does not halt when we apply the Sipser approved criteria.
You are not applying the Sipser approved criteria.

[olcott]

When we apply the Sipser approved criteria then H(P,P)==0 is correct.

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

[Python]

Disgusting liar, Peter Olcott wrote:
> On 10/13/2022 1:51 PM, Python wrote:
..

>> And still:
>>
>> Your H reports P to be non-halting. P halts.
>
> P does not halt when we apply the Sipser approved criteria.

This is utterly asinine, Sipser "approved criteria" is something
you've made up, moreover using his name. You should feel ASHAMED
Peter.

P(P) halts, PERIOD.

You are quite a disgusting kind of person Peter, you know?

[olcott]

On 10/13/2022 1:58 PM, Python wrote:
> Disgusting liar, Peter Olcott wrote:
>> On 10/13/2022 1:51 PM, Python wrote:
> ..
>>> And still:
>>>
>>> Your H reports P to be non-halting. P halts.
>>
>> P does not halt when we apply the Sipser approved criteria.
>
> This is utterly asinine, Sipser "approved criteria" is something
> you've made up, moreover using his name. You should feel ASHAMED
> Peter.
>
> P(P) halts, PERIOD.

*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 H does not care about anything besides the behavior of its input
when this input is correctly simulated by H.

[Python]

Disgusting liar, Peter Olcott wrote:
> On 10/13/2022 1:58 PM, Python wrote:
>> Disgusting liar, Peter Olcott wrote:
>>> On 10/13/2022 1:51 PM, Python wrote:
>> ..
>>>> And still:
>>>>
>>>> Your H reports P to be non-halting. P halts.
>>>
>>> P does not halt when we apply the Sipser approved criteria.
>>
>> This is utterly asinine, Sipser "approved criteria" is something
>> you've made up, moreover using his name. You should feel ASHAMED
>> Peter.
>>
>> P(P) halts, PERIOD.
>
> *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 H does not care about anything besides the behavior of its input
> when this input is correctly simulated by H.
>

So your H incorrectly simulates P, this is what you are saying? You
make less and less sense every single day Peter...

Anyway, still H reports incorrectly that P is non halting while
P halts. Your H is still wrong.

[Fred. Zwarts]

Op 12.okt..2022 om 17:08 schreef olcott:

> Professor Michael Sipser of MIT said that this verbatim paragraph looks
> correct:
>

>    If H does correctly determine that its correct simulation
>    of D would never stop running unless aborted, would it be
>    correct for H to abort this simulation and report that D
>    specifies a non-halting sequence of configurations?

This is a tautology. If H is correct, then it would be correct.

So, what remains for you is to prove that H is correct. Most people here
think that your H incorrectly determines that its incorrect simulation
would never stop running. In that case, Michael Sipser's saying does not
apply.
So, this information of Michael Sipser does not bring us any further.
You still have to prove that your H is correct, before you can use it.
Up to now, nobody seems to accept your proof.

[olcott]

On 10/13/2022 2:06 PM, Python wrote:
> Disgusting liar, Peter Olcott wrote:
>> On 10/13/2022 1:58 PM, Python wrote:
>>> Disgusting liar, Peter Olcott wrote:
>>>> On 10/13/2022 1:51 PM, Python wrote:
>>> ..
>>>>> And still:
>>>>>
>>>>> Your H reports P to be non-halting. P halts.
>>>>
>>>> P does not halt when we apply the Sipser approved criteria.
>>>
>>> This is utterly asinine, Sipser "approved criteria" is something
>>> you've made up, moreover using his name. You should feel ASHAMED
>>> Peter.
>>>
>>> P(P) halts, PERIOD.
>>
>> *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 H does not care about anything besides the behavior of its input
>> when this input is correctly simulated by H.
>>
>
> So your H incorrectly simulates P, this is what you are saying? You
> make less and less sense every single day Peter...
>

That H correctly simulates its input can be easily verified by every
sufficiently competent software engineer: It is verified that the
line-by-line execution trace of P produced by H exactly matches what the
line-by-line x86 source-code of P specifies.

> Anyway, still H reports incorrectly that P is non halting while
> P halts. Your H is still wrong.

No according to the Sipser approved criteria. That you ignore this is an
indication of bias thus less than no rebuttal at all.

[olcott]

On 10/13/2022 2:07 PM, Fred. Zwarts wrote:
> Op 12.okt..2022 om 17:08 schreef olcott:
>> Professor Michael Sipser of MIT said that this verbatim paragraph
>> looks correct:
>>
>>     If H does correctly determine that its correct simulation
>>     of D would never stop running unless aborted, would it be
>>     correct for H to abort this simulation and report that D
>>     specifies a non-halting sequence of configurations?
>
> This is a tautology. If H is correct, then it would be correct.
>

Everyone here has disagreed that H can base its halt status decision on
the fact that its correct simulation of this input would never stop
running.

> So, what remains for you is to prove that H is correct. Most people here
> think that your H incorrectly determines that its incorrect simulation

That H correctly simulates its input can be easily verified by every
sufficiently competent software engineer: It is verified that the
line-by-line execution trace of P produced by H exactly matches what the
line-by-line x86 source-code of P specifies.

> would never stop running. In that case, Michael Sipser's saying does not
> apply.
> So, this information of Michael Sipser does not bring us any further.
> You still have to prove that your H is correct, before you can use it.
> Up to now, nobody seems to accept your proof.
>

[Ben Bacarisse]

"Fred. Zwarts" <F.Zw...@KVI.nl> writes:

> Op 12.okt..2022 om 17:08 schreef olcott:
>> Professor Michael Sipser of MIT said that this verbatim paragraph looks correct:
>>    If H does correctly determine that its correct simulation
>>    of D would never stop running unless aborted, would it be
>>    correct for H to abort this simulation and report that D
>>    specifies a non-halting sequence of configurations?
>
> This is a tautology. If H is correct, then it would be correct.

It's not exactly a tautology. H reporting based on whether "its correct
simulation of D never stops" would be a trivial truism, but with the
added "would" and "unless" the statement is, at best, a vague
hypothetical. However, we all know what PO means by this deceptive
wording because his ruse has been laid bare many times: it's about H
determining the behaviour of a D constructed from a different H (with
"line 15 commented out" in PO's most explicit confession).

> So, what remains for you is to prove that H is correct.

What? No! What remains is for everybody to point out that H(P,P) == 0
is incorrect because P(P) is a halting computation. Why do you want to
encourage PO to prove that H gives the wrong answer? We know it does.
I'll take his word that it does as sufficient evidence that he's wrong.

--
Ben.

[Fred. Zwarts]

Op 13.okt..2022 om 21:19 schreef olcott:

> On 10/13/2022 2:07 PM, Fred. Zwarts wrote:
>> Op 12.okt..2022 om 17:08 schreef olcott:
>>> Professor Michael Sipser of MIT said that this verbatim paragraph
>>> looks correct:
>>>
>>>     If H does correctly determine that its correct simulation
>>>     of D would never stop running unless aborted, would it be
>>>     correct for H to abort this simulation and report that D
>>>     specifies a non-halting sequence of configurations?
>>
>> This is a tautology. If H is correct, then it would be correct.
>>
>
> Everyone here has disagreed that H can base its halt status decision on
> the fact that its correct simulation of this input would never stop
> running.

No, nobody accepted that it was a correct simulation, so the premise for
Michael Sipser would not be valid in that case.

>
>> So, what remains for you is to prove that H is correct. Most people
>> here think that your H incorrectly determines that its incorrect
>> simulation
>
> That H correctly simulates its input can be easily verified by every
> sufficiently competent software engineer: It is verified that the
> line-by-line execution trace of P produced by H exactly matches what the
> line-by-line x86 source-code of P specifies.

Yes, everybody accepts that a few lines are correctly simulated.
Most people do not accept the logic that if a few lines are simulated
then the behaviour of the whole function is correctly simulated. In
particular, the line where P calls H is essential for the behaviour of
P, but one thinks that it is not correctly simulated.

>> would never stop running. In that case, Michael Sipser's saying does
>> not apply.
>> So, this information of Michael Sipser does not bring us any further.
>> You still have to prove that your H is correct, before you can use it.
>> Up to now, nobody seems to accept your proof.
>>

The sentence approved by Michael Sipser starts with a premise (If ...).
You duty is to prove that your H fits this premise. You can not reverse
it and conclude from his approval that the premise is correct.

[olcott]

On 10/13/2022 2:24 PM, Ben Bacarisse wrote:
> "Fred. Zwarts" <F.Zw...@KVI.nl> writes:
>
>> Op 12.okt..2022 om 17:08 schreef olcott:
>>> Professor Michael Sipser of MIT said that this verbatim paragraph looks correct:
>>>    If H does correctly determine that its correct simulation
>>>    of D would never stop running unless aborted, would it be
>>>    correct for H to abort this simulation and report that D
>>>    specifies a non-halting sequence of configurations?
>>
>> This is a tautology. If H is correct, then it would be correct.
>
> It's not exactly a tautology. H reporting based on whether "its correct
> simulation of D never stops" would be a trivial truism, but with the
> added "would" and "unless" the statement is, at best, a vague
> hypothetical. However, we all know what PO means by this deceptive
> wording because his ruse has been laid bare many times: it's about H
> determining the behaviour of a D constructed from a different H (with
> "line 15 commented out" in PO's most explicit confession).
>
>> So, what remains for you is to prove that H is correct.
>
> What? No! What remains is for everybody to point out that H(P,P) == 0
> is incorrect because P(P) is a halting computation.

It is only the behavior of the input P correctly simulated by H that is
the correct basis for a halt status decision by H.

> Why do you want to
> encourage PO to prove that H gives the wrong answer? We know it does.
> I'll take his word that it does as sufficient evidence that he's wrong.
>

--

[Keith Thompson]

What exactly does your "Not at all" refer to? I wrote three paragraphs
of text (and you've deleted the line breaks between the paragraphs for
some reason; please don't do that). I can't tell what you're
disagreeing with.

As far as I can tell, Professor Sipser has agreed that *if* a halt
decider could exist, it would exhibit certain behavior. That's a
trivial and uncontroversial statement.

You seem to want people to infer that Professor Sipser agrees with you
that a halt decider is possible, or at least that you've discovered
something significant about the halting problem, but you won't quite say
so explicitly.

By all means, continue to reply as evasively as you have so far. But if
you want me to continue posting, you'll need to write something
interesting and/or responsive to something I've written.

[olcott]

On 10/13/2022 2:28 PM, Fred. Zwarts wrote:
> Op 13.okt..2022 om 21:19 schreef olcott:
>> On 10/13/2022 2:07 PM, Fred. Zwarts wrote:
>>> Op 12.okt..2022 om 17:08 schreef olcott:
>>>> Professor Michael Sipser of MIT said that this verbatim paragraph
>>>> looks correct:
>>>>
>>>>     If H does correctly determine that its correct simulation
>>>>     of D would never stop running unless aborted, would it be
>>>>     correct for H to abort this simulation and report that D
>>>>     specifies a non-halting sequence of configurations?
>>>
>>> This is a tautology. If H is correct, then it would be correct.
>>>
>>
>> Everyone here has disagreed that H can base its halt status decision
>> on the fact that its correct simulation of this input would never stop
>> running.
>
> No, nobody accepted that it was a correct simulation, so the premise for
> Michael Sipser would not be valid in that case.
>
>>
>>> So, what remains for you is to prove that H is correct. Most people
>>> here think that your H incorrectly determines that its incorrect
>>> simulation
>>
>> That H correctly simulates its input can be easily verified by every
>> sufficiently competent software engineer: It is verified that the
>> line-by-line execution trace of P produced by H exactly matches what
>> the line-by-line x86 source-code of P specifies.
>
> Yes, everybody accepts that a few lines are correctly simulated.

Great!

> Most people do not accept the logic that if a few lines are simulated
> then the behaviour of the whole function is correctly simulated. In
> particular, the line where P calls H is essential for the behaviour of
> P, but one thinks that it is not correctly simulated.
>

The criteria is that H simulates P until H correctly determines that
this simulation would never stop running unless aborted.

void P(ptr x)
{
int Halt_Status = H(x, x);
if (Halt_Status)
HERE: goto HERE;
return;
}

int main()
{
Output("Input_Halts = ", H(P, P));
}

(a) Executed H simulates P
(b) that calls a simulated H that simulates P
(c) that calls a simulated H that simulates P...

Until H sees this repeating pattern aborts its simulation of P and
rejects P as specifying a non-halting sequence of configurations.

>>> would never stop running. In that case, Michael Sipser's saying does
>>> not apply.
>>> So, this information of Michael Sipser does not bring us any further.
>>> You still have to prove that your H is correct, before you can use it.
>>> Up to now, nobody seems to accept your proof.
>>>
>
> The sentence approved by Michael Sipser starts with a premise (If ...).
> You duty is to prove that your H fits this premise. You can not reverse
> it and conclude from his approval that the premise is correct.
>

Yes it does.
The rest of the points can be proved by ordinary software engineering.

Since this is the same definition of a simulating halt decider that I
have been using for two years all of my prior posts still hold.

[olcott]

Not at all. Professor Sipser agrees that the behavior of the input D
correctly simulated by simulating halt decider H is the correct behavior
for H to base its halt status decision on.

This has been the only remaining sticking point.

[B.H.]

On Thursday, October 13, 2022 at 1:26:09 PM UTC-4, olcott wrote:
> On 10/13/2022 11:47 AM, Mr Flibble wrote:
> > On Thu, 13 Oct 2022 11:46:22 -0500
> > olcott <non...@beez-waxes.com> wrote:
> >
> >> On 10/13/2022 11:17 AM, Mr Flibble wrote:
> >>> On Wed, 12 Oct 2022 17:39:41 -0500
> >>> olcott <non...@beez-waxes.com> wrote:
> >>>
> >>>> On 10/12/2022 5:23 PM, dklei...@gmail.com wrote:
> >>>>> On Wednesday, October 12, 2022 at 1:03:17 PM UTC-7, olcott wrote:
> >>>>>
> >>>>>> On 10/12/2022 2:32 PM, dklei...@gmail.com wrote:
> >>>>>>> On Wednesday, October 12, 2022 at 8:08:23 AM UTC-7, olcott

> >>>>>>> wrote:
> >>>>>>>> Professor Michael Sipser of MIT said that this verbatim
> >>>>>>>> paragraph looks correct:
> >>>>>>>>

> >>>>>>>> If H does correctly determine that its correct simulation

> >>>>>>>> of D would never stop running unless aborted, would it be

> >>>>>>>> correct for H to abort this simulation and report that D

> >>>>>>>> specifies a non-halting sequence of configurations?
> >>>>>>>>
> >>>>>>> You are attempting to use the argument from authority.
> >>>>>>
> >>>>>> Argument from authority, also authoritative argument and appeal
> >>>>>> to authority, is an inductive reasoning argument that often
> >>>>>> takes the form of a statistical syllogism. Although certain
> >>>>>> classes of argument from authority can constitute strong
> >>>>>> inductive arguments, the appeal to authority is often applied
> >>>>>> fallaciously. Fallacious examples of using the appeal include:
> >>>>>> ⁕cases where the authority is not a subject-matter expert
> >>>>>> https://www.definitions.net/definition/argument+from+authority
> >>>>>>> That's a loser. My opinion is just as good as Sipser's.
> >>>>>>
> >>>>>> And likewise your opinion about brain surgery is just as good as
> >>>>>> the opinion of the world's best brain surgeons ???
> >>>>>>
> >>>>> My opinion about brain surgery is just as good as Sipser's.
> >>>>>
> >>>>
> >>>> Probably yet your opinion** about the theory of computation is
> >>>> probably not even in the ballpark of carrying the same weight as
> >>>> the opinion of Professor Sipser.
> >>>>
> >>>> ** and everyone else here: Ben, Andre, Mike, Kaz
> >>>
> >>> Appeal to authority is a logical fallacy. Prove your argument is
> >>> sound using facts and logic in your own words.
> >>>
> >>> /Flibble
> >>>
> >>
> >> I have already shown that and appeal to the authority of a qualified
> >> expert in the field is inductively sound.
> >
> > No. Appeal to authority is a logical fallacy; doesn't matter who the
> > authority is.
> >
> > /Flibble
> >
> That would mean that going to your garbage man about brain surgery is
> just as good as going to a brain surgeon.
>

...I think I now understand Peter Olcott better. Perhaps he is a paid-off high-ranking member of the "f*** Philip White club," and this is all a costly signal from some well-monied person that I am not to be helped, liked or appreciated?

Whatever. A lot of my enemies have very dumb tactics that waste resources and do nothing beyond that.

-Philip White (philipw...@gmail.com)




> If everyone in the universe agreed with me then this would not be proof
> that am correct.
>
> If a universal consensus of all of the experts in the field agreed with
> me then this would be strong evidence that I am correct.
>
> That one qualified expert in the field agrees with me that is enough
> credibility to get other qualified experts to review this same single
> point of agreement.