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

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

"Fred. Zwarts" <F.Zwarts@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.

On 10/12/2022 10:54 AM, 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 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
>      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?
>

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

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

On 10/12/2022 11:46 AM, Ben Bacarisse wrote:
> "Fred. Zwarts" <F.Zwarts@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.
>

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>

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

On Wed, 12 Oct 2022 10:08:20 -0500
olcott <polcott2@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

On 10/12/2022 12:24 PM, Mr Flibble wrote:
> On Wed, 12 Oct 2022 10:08:20 -0500
> olcott <polcott2@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.

--
Copyright 2022 Pete Olcott

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

On Wed, 12 Oct 2022 12:38:31 -0500
olcott <none-ya@beez-waxes.com> wrote:

> On 10/12/2022 12:24 PM, Mr Flibble wrote:
> > On Wed, 12 Oct 2022 10:08:20 -0500
> > olcott <polcott2@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.

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:

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

On 10/12/2022 12:52 PM, Mr Flibble wrote:
> On Wed, 12 Oct 2022 12:38:31 -0500
> olcott <none-ya@beez-waxes.com> wrote:
>
>> On 10/12/2022 12:24 PM, Mr Flibble wrote:
>>> On Wed, 12 Oct 2022 10:08:20 -0500
>>> olcott <polcott2@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.
>
> 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:
>
> void Px(void (*x)())
> {
> (void) H(x, x);
> return;
> }
>
> The correct simulation of Px above is to simulate Px halting.
>

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

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

On Wed, 12 Oct 2022 13:04:17 -0500
olcott <polcott2@gmail.com> wrote:

> On 10/12/2022 12:52 PM, Mr Flibble wrote:
> > On Wed, 12 Oct 2022 12:38:31 -0500
> > olcott <none-ya@beez-waxes.com> wrote:
> >
> >> On 10/12/2022 12:24 PM, Mr Flibble wrote:
> >>> On Wed, 12 Oct 2022 10:08:20 -0500
> >>> olcott <polcott2@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.
> >
> > 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:
> >
> > void Px(void (*x)())
> > {
> > (void) H(x, x);
> > return;
> > }
> >
> > The correct simulation of Px above is to simulate Px halting.
> >
>
> 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 ...

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

/Flibble

On 10/12/2022 1:07 PM, Mr Flibble wrote:
> On Wed, 12 Oct 2022 13:04:17 -0500
> olcott <polcott2@gmail.com> wrote:
>
>> On 10/12/2022 12:52 PM, Mr Flibble wrote:
>>> On Wed, 12 Oct 2022 12:38:31 -0500
>>> olcott <none-ya@beez-waxes.com> wrote:
>>>
>>>> On 10/12/2022 12:24 PM, Mr Flibble wrote:
>>>>> On Wed, 12 Oct 2022 10:08:20 -0500
>>>>> olcott <polcott2@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.
>>>
>>> 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:
>>>
>>> void Px(void (*x)())
>>> {
>>> (void) H(x, x);
>>> return;
>>> }
>>>
>>> The correct simulation of Px above is to simulate Px halting.
>>>
>>
>> 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 ...
>
> Yes indeed it must be a correct simulation and a correct simulation of
> Px is to simulate Px halting.
>
> /Flibble
>

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.

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

On Wed, 12 Oct 2022 13:25:34 -0500
olcott <polcott2@gmail.com> wrote:

> On 10/12/2022 1:07 PM, Mr Flibble wrote:
> > On Wed, 12 Oct 2022 13:04:17 -0500
> > olcott <polcott2@gmail.com> wrote:
> >
> >> On 10/12/2022 12:52 PM, Mr Flibble wrote:
> >>> On Wed, 12 Oct 2022 12:38:31 -0500
> >>> olcott <none-ya@beez-waxes.com> wrote:
> >>>
> >>>> On 10/12/2022 12:24 PM, Mr Flibble wrote:
> >>>>> On Wed, 12 Oct 2022 10:08:20 -0500
> >>>>> olcott <polcott2@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.
> >>>
> >>> 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:
> >>>
> >>> void Px(void (*x)())
> >>> {
> >>> (void) H(x, x);
> >>> return;
> >>> }
> >>>
> >>> The correct simulation of Px above is to simulate Px halting.
> >>>
> >>
> >> 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 ...
> >
> > Yes indeed it must be a correct simulation and a correct simulation
> > of Px is to simulate Px halting.
> >
> > /Flibble
> >
>
> Sipser agreed that the correct simulation of Px by H is the correct
> measure of the behavior of Px.

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

On 10/12/2022 1:30 PM, Mr Flibble wrote:
> On Wed, 12 Oct 2022 13:25:34 -0500
> olcott <polcott2@gmail.com> wrote:
>
>> On 10/12/2022 1:07 PM, Mr Flibble wrote:
>>> On Wed, 12 Oct 2022 13:04:17 -0500
>>> olcott <polcott2@gmail.com> wrote:
>>>
>>>> On 10/12/2022 12:52 PM, Mr Flibble wrote:
>>>>> On Wed, 12 Oct 2022 12:38:31 -0500
>>>>> olcott <none-ya@beez-waxes.com> wrote:
>>>>>
>>>>>> On 10/12/2022 12:24 PM, Mr Flibble wrote:
>>>>>>> On Wed, 12 Oct 2022 10:08:20 -0500
>>>>>>> olcott <polcott2@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.
>>>>>
>>>>> 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:
>>>>>
>>>>> void Px(void (*x)())
>>>>> {
>>>>> (void) H(x, x);
>>>>> return;
>>>>> }
>>>>>
>>>>> The correct simulation of Px above is to simulate Px halting.
>>>>>
>>>>
>>>> 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 ...
>>>
>>> Yes indeed it must be a correct simulation and a correct simulation
>>> of Px is to simulate Px halting.
>>>
>>> /Flibble
>>>
>>
>> Sipser agreed that the correct simulation of Px by H is the correct
>> measure of the behavior of Px.
>
> 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
>

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.

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

On Wed, 12 Oct 2022 14:17:35 -0500
olcott <polcott2@gmail.com> wrote:

> On 10/12/2022 1:30 PM, Mr Flibble wrote:
> > On Wed, 12 Oct 2022 13:25:34 -0500
> > olcott <polcott2@gmail.com> wrote:
> >
> >> On 10/12/2022 1:07 PM, Mr Flibble wrote:
> >>> On Wed, 12 Oct 2022 13:04:17 -0500
> >>> olcott <polcott2@gmail.com> wrote:
> >>>
> >>>> On 10/12/2022 12:52 PM, Mr Flibble wrote:
> >>>>> On Wed, 12 Oct 2022 12:38:31 -0500
> >>>>> olcott <none-ya@beez-waxes.com> wrote:
> >>>>>
> >>>>>> On 10/12/2022 12:24 PM, Mr Flibble wrote:
> >>>>>>> On Wed, 12 Oct 2022 10:08:20 -0500
> >>>>>>> olcott <polcott2@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.
> >>>>>
> >>>>> 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:
> >>>>>
> >>>>> void Px(void (*x)())
> >>>>> {
> >>>>> (void) H(x, x);
> >>>>> return;
> >>>>> }
> >>>>>
> >>>>> The correct simulation of Px above is to simulate Px halting.
> >>>>>
> >>>>
> >>>> 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 ...
> >>>
> >>> Yes indeed it must be a correct simulation and a correct
> >>> simulation of Px is to simulate Px halting.
> >>>
> >>> /Flibble
> >>>
> >>
> >> Sipser agreed that the correct simulation of Px by H is the correct
> >> measure of the behavior of Px.
> >
> > 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
> >
>
> 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.

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

On 10/12/2022 2:26 PM, Mr Flibble wrote:
> On Wed, 12 Oct 2022 14:17:35 -0500
> olcott <polcott2@gmail.com> wrote:
>
>> On 10/12/2022 1:30 PM, Mr Flibble wrote:
>>> On Wed, 12 Oct 2022 13:25:34 -0500
>>> olcott <polcott2@gmail.com> wrote:
>>>
>>>> On 10/12/2022 1:07 PM, Mr Flibble wrote:
>>>>> On Wed, 12 Oct 2022 13:04:17 -0500
>>>>> olcott <polcott2@gmail.com> wrote:
>>>>>
>>>>>> On 10/12/2022 12:52 PM, Mr Flibble wrote:
>>>>>>> On Wed, 12 Oct 2022 12:38:31 -0500
>>>>>>> olcott <none-ya@beez-waxes.com> wrote:
>>>>>>>
>>>>>>>> On 10/12/2022 12:24 PM, Mr Flibble wrote:
>>>>>>>>> On Wed, 12 Oct 2022 10:08:20 -0500
>>>>>>>>> olcott <polcott2@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.
>>>>>>>
>>>>>>> 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:
>>>>>>>
>>>>>>> void Px(void (*x)())
>>>>>>> {
>>>>>>> (void) H(x, x);
>>>>>>> return;
>>>>>>> }
>>>>>>>
>>>>>>> The correct simulation of Px above is to simulate Px halting.
>>>>>>>
>>>>>>
>>>>>> 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 ...
>>>>>
>>>>> Yes indeed it must be a correct simulation and a correct
>>>>> simulation of Px is to simulate Px halting.
>>>>>
>>>>> /Flibble
>>>>>
>>>>
>>>> Sipser agreed that the correct simulation of Px by H is the correct
>>>> measure of the behavior of Px.
>>>
>>> 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
>>>
>>
>> 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.
>
> 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
>

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.

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

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.

On Wed, 12 Oct 2022 14:32:41 -0500
olcott <polcott2@gmail.com> wrote:

> On 10/12/2022 2:26 PM, Mr Flibble wrote:
> > On Wed, 12 Oct 2022 14:17:35 -0500
> > olcott <polcott2@gmail.com> wrote:
> >
> >> On 10/12/2022 1:30 PM, Mr Flibble wrote:
> >>> On Wed, 12 Oct 2022 13:25:34 -0500
> >>> olcott <polcott2@gmail.com> wrote:
> >>>
> >>>> On 10/12/2022 1:07 PM, Mr Flibble wrote:
> >>>>> On Wed, 12 Oct 2022 13:04:17 -0500
> >>>>> olcott <polcott2@gmail.com> wrote:
> >>>>>
> >>>>>> On 10/12/2022 12:52 PM, Mr Flibble wrote:
> >>>>>>> On Wed, 12 Oct 2022 12:38:31 -0500
> >>>>>>> olcott <none-ya@beez-waxes.com> wrote:
> >>>>>>>
> >>>>>>>> On 10/12/2022 12:24 PM, Mr Flibble wrote:
> >>>>>>>>> On Wed, 12 Oct 2022 10:08:20 -0500
> >>>>>>>>> olcott <polcott2@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.
> >>>>>>>
> >>>>>>> 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:
> >>>>>>>
> >>>>>>> void Px(void (*x)())
> >>>>>>> {
> >>>>>>> (void) H(x, x);
> >>>>>>> return;
> >>>>>>> }
> >>>>>>>
> >>>>>>> The correct simulation of Px above is to simulate Px halting.
> >>>>>>>
> >>>>>>
> >>>>>> 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 ...
> >>>>>
> >>>>> Yes indeed it must be a correct simulation and a correct
> >>>>> simulation of Px is to simulate Px halting.
> >>>>>
> >>>>> /Flibble
> >>>>>
> >>>>
> >>>> Sipser agreed that the correct simulation of Px by H is the
> >>>> correct measure of the behavior of Px.
> >>>
> >>> 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
> >>>
> >>
> >> 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.
> >
> > 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
> >
>
> 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.

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

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

On 10/12/2022 2:50 PM, Mr Flibble wrote:
> On Wed, 12 Oct 2022 14:32:41 -0500
> olcott <polcott2@gmail.com> wrote:
>
>> On 10/12/2022 2:26 PM, Mr Flibble wrote:
>>> On Wed, 12 Oct 2022 14:17:35 -0500
>>> olcott <polcott2@gmail.com> wrote:
>>>
>>>> On 10/12/2022 1:30 PM, Mr Flibble wrote:
>>>>> On Wed, 12 Oct 2022 13:25:34 -0500
>>>>> olcott <polcott2@gmail.com> wrote:
>>>>>
>>>>>> On 10/12/2022 1:07 PM, Mr Flibble wrote:
>>>>>>> On Wed, 12 Oct 2022 13:04:17 -0500
>>>>>>> olcott <polcott2@gmail.com> wrote:
>>>>>>>
>>>>>>>> On 10/12/2022 12:52 PM, Mr Flibble wrote:
>>>>>>>>> On Wed, 12 Oct 2022 12:38:31 -0500
>>>>>>>>> olcott <none-ya@beez-waxes.com> wrote:
>>>>>>>>>
>>>>>>>>>> On 10/12/2022 12:24 PM, Mr Flibble wrote:
>>>>>>>>>>> On Wed, 12 Oct 2022 10:08:20 -0500
>>>>>>>>>>> olcott <polcott2@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.
>>>>>>>>>
>>>>>>>>> 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:
>>>>>>>>>
>>>>>>>>> void Px(void (*x)())
>>>>>>>>> {
>>>>>>>>> (void) H(x, x);
>>>>>>>>> return;
>>>>>>>>> }
>>>>>>>>>
>>>>>>>>> The correct simulation of Px above is to simulate Px halting.
>>>>>>>>>
>>>>>>>>
>>>>>>>> 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 ...
>>>>>>>
>>>>>>> Yes indeed it must be a correct simulation and a correct
>>>>>>> simulation of Px is to simulate Px halting.
>>>>>>>
>>>>>>> /Flibble
>>>>>>>
>>>>>>
>>>>>> Sipser agreed that the correct simulation of Px by H is the
>>>>>> correct measure of the behavior of Px.
>>>>>
>>>>> 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
>>>>>
>>>>
>>>> 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.
>>>
>>> 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
>>>
>>
>> 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.
>
> 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
>

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.

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?

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

--
Copyright 2022 Pete Olcott

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

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.

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.

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

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.

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