04 int D(ptr x)
05 {
06 int Halt_Status = H(x, x);
07 if (Halt_Status)
08 HERE: goto HERE;
09 return Halt_Status;
10 }
11
12 void main()
13 {
14 H(D,D);
15 }

*Execution Trace*
Line 14: main() invokes H(D,D);

*keeps repeating* (unless aborted)
Line 06: simulated D(D) invokes simulated H(D,D) that simulates D(D)

*Simulation invariant*
*D correctly simulated by H cannot possibly reach past its own line 06*

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

On 1/11/2024 8:22 AM, olcott wrote:
> 04 int D(ptr x)
> 05 {
> 06   int Halt_Status = H(x, x);
> 07   if (Halt_Status)
> 08     HERE: goto HERE;
> 09   return Halt_Status;
> 10 }
> 11
> 12 void main()
> 13 {
> 14   H(D,D);
> 15 }
>
> *Execution Trace*
> Line 14: main() invokes H(D,D);
>
> *keeps repeating* (unless aborted)
> Line 06: simulated D(D) invokes simulated H(D,D) that simulates D(D)
>
> *Simulation invariant*
> *D correctly simulated by H cannot possibly reach past its own line 06*
>

*Every rebuttal to this has always been the pure bluster*
*of dogma with zero supporting exact execution trace*

Try and show how the above execution trace is incorrect such
that D correctly simulated by H reaches its own line 09.

IF A CORRECT EXECUTION TRACE THAT REACHES LINE 09 OF D CANNOT
POSSIBLY BE PROVIDED THAT PROVES THE ABOVE TRACE IS CORRECT.

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

On 1/11/24 15:22, olcott wrote:
> 04 int D(ptr x)
> 05 {
> 06   int Halt_Status = H(x, x);
> 07   if (Halt_Status)
> 08     HERE: goto HERE;
> 09   return Halt_Status;
> 10 }
> 11
> 12 void main()
> 13 {
> 14   H(D,D);
> 15 }
>
> *Execution Trace*
> Line 14: main() invokes H(D,D);
>
> *keeps repeating* (unless aborted)
> Line 06: simulated D(D) invokes simulated H(D,D) that simulates D(D)
>
> *Simulation invariant*
> *D correctly simulated by H cannot possibly reach past its own line 06*
>

The correct simulation of D by H is the same simulation you get when you
simulate D by H1.

Do I really have to simulate D by H1 and then paste the trace, or can
you do that yourself?

On 1/12/2024 12:43 AM, immibis wrote:
> On 1/11/24 15:22, olcott wrote:
>> 04 int D(ptr x)
>> 05 {
>> 06   int Halt_Status = H(x, x);
>> 07   if (Halt_Status)
>> 08     HERE: goto HERE;
>> 09   return Halt_Status;
>> 10 }
>> 11
>> 12 void main()
>> 13 {
>> 14   H(D,D);
>> 15 }
>>
>> *Execution Trace*
>> Line 14: main() invokes H(D,D);
>>
>> *keeps repeating* (unless aborted)
>> Line 06: simulated D(D) invokes simulated H(D,D) that simulates D(D)
>>
>> *Simulation invariant*
>> *D correctly simulated by H cannot possibly reach past its own line 06*
>>
>
> The correct simulation of D by H is the same simulation you get when you
> simulate D by H1.
>
> Do I really have to simulate D by H1 and then paste the trace, or can
> you do that yourself?

It would be a deception to show the correct simulation of D by H1,
as the correct simulation of D by H.

That is like saying I have proof that Bill robbed the liquor
store because I saw Harry do it and Harry is not Bill.

If it is impossible to show a line-by-line execution trace
of the exact sequence of line numbers of D correctly simulated
by H that differs from the one that I provided then that proves
that my execution trace is correct.

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

On 1/12/24 15:24, olcott wrote:
> On 1/12/2024 12:43 AM, immibis wrote:
>> On 1/11/24 15:22, olcott wrote:
>>> 04 int D(ptr x)
>>> 05 {
>>> 06   int Halt_Status = H(x, x);
>>> 07   if (Halt_Status)
>>> 08     HERE: goto HERE;
>>> 09   return Halt_Status;
>>> 10 }
>>> 11
>>> 12 void main()
>>> 13 {
>>> 14   H(D,D);
>>> 15 }
>>>
>>> *Execution Trace*
>>> Line 14: main() invokes H(D,D);
>>>
>>> *keeps repeating* (unless aborted)
>>> Line 06: simulated D(D) invokes simulated H(D,D) that simulates D(D)
>>>
>>> *Simulation invariant*
>>> *D correctly simulated by H cannot possibly reach past its own line 06*
>>>
>>
>> The correct simulation of D by H is the same simulation you get when
>> you simulate D by H1.
>>
>> Do I really have to simulate D by H1 and then paste the trace, or can
>> you do that yourself?
>
> It would be a deception to show the correct simulation of D by H1,
> as the correct simulation of D by H.

It is like saying the correct proof that 1+1=2 is the one which Lisa
Simpson knows.

On 1/12/2024 10:40 AM, immibis wrote:
> On 1/12/24 15:24, olcott wrote:
>> On 1/12/2024 12:43 AM, immibis wrote:
>>> On 1/11/24 15:22, olcott wrote:
>>>> 04 int D(ptr x)
>>>> 05 {
>>>> 06   int Halt_Status = H(x, x);
>>>> 07   if (Halt_Status)
>>>> 08     HERE: goto HERE;
>>>> 09   return Halt_Status;
>>>> 10 }
>>>> 11
>>>> 12 void main()
>>>> 13 {
>>>> 14   H(D,D);
>>>> 15 }
>>>>
>>>> *Execution Trace*
>>>> Line 14: main() invokes H(D,D);
>>>>
>>>> *keeps repeating* (unless aborted)
>>>> Line 06: simulated D(D) invokes simulated H(D,D) that simulates D(D)
>>>>
>>>> *Simulation invariant*
>>>> *D correctly simulated by H cannot possibly reach past its own line 06*
>>>>
>>>
>>> The correct simulation of D by H is the same simulation you get when
>>> you simulate D by H1.
>>>
>>> Do I really have to simulate D by H1 and then paste the trace, or can
>>> you do that yourself?
>>
>> It would be a deception to show the correct simulation of D by H1,
>> as the correct simulation of D by H.
>
> It is like saying the correct proof that 1+1=2 is the one which Lisa
> Simpson knows.
>

When I ask for the execution trace of D correctly simulated by H
then providing any execution trace besides the execution trace of
D correctly simulated by H IS THE WRONG ANSWER.

This is the same as I ask you: "What time is it?"
and you answer with the color of your car.

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

On 1/13/24 03:01, olcott wrote:
> On 1/12/2024 10:40 AM, immibis wrote:
>> On 1/12/24 15:24, olcott wrote:
>>> On 1/12/2024 12:43 AM, immibis wrote:
>>>> On 1/11/24 15:22, olcott wrote:
>>>>> 04 int D(ptr x)
>>>>> 05 {
>>>>> 06   int Halt_Status = H(x, x);
>>>>> 07   if (Halt_Status)
>>>>> 08     HERE: goto HERE;
>>>>> 09   return Halt_Status;
>>>>> 10 }
>>>>> 11
>>>>> 12 void main()
>>>>> 13 {
>>>>> 14   H(D,D);
>>>>> 15 }
>>>>>
>>>>> *Execution Trace*
>>>>> Line 14: main() invokes H(D,D);
>>>>>
>>>>> *keeps repeating* (unless aborted)
>>>>> Line 06: simulated D(D) invokes simulated H(D,D) that simulates D(D)
>>>>>
>>>>> *Simulation invariant*
>>>>> *D correctly simulated by H cannot possibly reach past its own line
>>>>> 06*
>>>>>
>>>>
>>>> The correct simulation of D by H is the same simulation you get when
>>>> you simulate D by H1.
>>>>
>>>> Do I really have to simulate D by H1 and then paste the trace, or
>>>> can you do that yourself?
>>>
>>> It would be a deception to show the correct simulation of D by H1,
>>> as the correct simulation of D by H.
>>
>> It is like saying the correct proof that 1+1=2 is the one which Lisa
>> Simpson knows.
>>
>
> When I ask for the execution trace of D correctly simulated by H
> then providing any execution trace besides the execution trace of
> D correctly simulated by H IS THE WRONG ANSWER.
>
> This is the same as I ask you: "What time is it?"
> and you answer with the color of your car.
>

The Halting Problem asks for a program that determines whether an given
input program will finish running or not.

Your POOH does not accept any input except the hard-coded D (as if it
were an input). This is like I ask for the color of the car and you
reply with the time on the wall.

On 1/12/2024 3:26 PM, wij wrote:
> On 1/13/24 03:01, olcott wrote:
>> On 1/12/2024 10:40 AM, immibis wrote:
>>> On 1/12/24 15:24, olcott wrote:
>>>> On 1/12/2024 12:43 AM, immibis wrote:
>>>>> On 1/11/24 15:22, olcott wrote:
>>>>>> 04 int D(ptr x)
>>>>>> 05 {
>>>>>> 06   int Halt_Status = H(x, x);
>>>>>> 07   if (Halt_Status)
>>>>>> 08     HERE: goto HERE;
>>>>>> 09   return Halt_Status;
>>>>>> 10 }
>>>>>> 11
>>>>>> 12 void main()
>>>>>> 13 {
>>>>>> 14   H(D,D);
>>>>>> 15 }
>>>>>>
>>>>>> *Execution Trace*
>>>>>> Line 14: main() invokes H(D,D);
>>>>>>
>>>>>> *keeps repeating* (unless aborted)
>>>>>> Line 06: simulated D(D) invokes simulated H(D,D) that simulates D(D)
>>>>>>
>>>>>> *Simulation invariant*
>>>>>> *D correctly simulated by H cannot possibly reach past its own
>>>>>> line 06*
>>>>>>
>>>>>
>>>>> The correct simulation of D by H is the same simulation you get
>>>>> when you simulate D by H1.
>>>>>
>>>>> Do I really have to simulate D by H1 and then paste the trace, or
>>>>> can you do that yourself?
>>>>
>>>> It would be a deception to show the correct simulation of D by H1,
>>>> as the correct simulation of D by H.
>>>
>>> It is like saying the correct proof that 1+1=2 is the one which Lisa
>>> Simpson knows.
>>>
>>
>> When I ask for the execution trace of D correctly simulated by H
>> then providing any execution trace besides the execution trace of
>> D correctly simulated by H IS THE WRONG ANSWER.
>>
>> This is the same as I ask you: "What time is it?"
>> and you answer with the color of your car.
>>
>
> The Halting Problem asks for a program that determines whether an given
> input program will finish running or not.
>
> Your POOH does not accept any input except the hard-coded D (as if it
> were an input). This is like I ask for the color of the car and you
> reply with the time on the wall.
>

It is a verified fact that D correctly simulated by H cannot possibly halt.

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

On 1/13/24 05:44, olcott wrote:
> On 1/12/2024 3:26 PM, wij wrote:
>> On 1/13/24 03:01, olcott wrote:
>>> On 1/12/2024 10:40 AM, immibis wrote:
>>>> On 1/12/24 15:24, olcott wrote:
>>>>> On 1/12/2024 12:43 AM, immibis wrote:
>>>>>> On 1/11/24 15:22, olcott wrote:
>>>>>>> 04 int D(ptr x)
>>>>>>> 05 {
>>>>>>> 06   int Halt_Status = H(x, x);
>>>>>>> 07   if (Halt_Status)
>>>>>>> 08     HERE: goto HERE;
>>>>>>> 09   return Halt_Status;
>>>>>>> 10 }
>>>>>>> 11
>>>>>>> 12 void main()
>>>>>>> 13 {
>>>>>>> 14   H(D,D);
>>>>>>> 15 }
>>>>>>>
>>>>>>> *Execution Trace*
>>>>>>> Line 14: main() invokes H(D,D);
>>>>>>>
>>>>>>> *keeps repeating* (unless aborted)
>>>>>>> Line 06: simulated D(D) invokes simulated H(D,D) that simulates D(D)
>>>>>>>
>>>>>>> *Simulation invariant*
>>>>>>> *D correctly simulated by H cannot possibly reach past its own
>>>>>>> line 06*
>>>>>>>
>>>>>>
>>>>>> The correct simulation of D by H is the same simulation you get
>>>>>> when you simulate D by H1.
>>>>>>
>>>>>> Do I really have to simulate D by H1 and then paste the trace, or
>>>>>> can you do that yourself?
>>>>>
>>>>> It would be a deception to show the correct simulation of D by H1,
>>>>> as the correct simulation of D by H.
>>>>
>>>> It is like saying the correct proof that 1+1=2 is the one which Lisa
>>>> Simpson knows.
>>>>
>>>
>>> When I ask for the execution trace of D correctly simulated by H
>>> then providing any execution trace besides the execution trace of
>>> D correctly simulated by H IS THE WRONG ANSWER.
>>>
>>> This is the same as I ask you: "What time is it?"
>>> and you answer with the color of your car.
>>>
>>
>> The Halting Problem asks for a program that determines whether an given
>> input program will finish running or not.
>>
>> Your POOH does not accept any input except the hard-coded D (as if it
>> were an input). This is like I ask for the color of the car and you
>> reply with the time on the wall.
>>
>
> It is a verified fact that D correctly simulated by H cannot possibly halt.
>
>

*** The Halting Problem asks for a program that determines whether an
given input program will finish running or not.***

You kept answering the time on the wall !!!

What does your H,D have anything to do with the Halting Problem?
Your POOH does not decide any given input !!!

On 1/12/2024 3:55 PM, wij wrote:
> On 1/13/24 05:44, olcott wrote:
>> On 1/12/2024 3:26 PM, wij wrote:
>>> On 1/13/24 03:01, olcott wrote:
>>>> On 1/12/2024 10:40 AM, immibis wrote:
>>>>> On 1/12/24 15:24, olcott wrote:
>>>>>> On 1/12/2024 12:43 AM, immibis wrote:
>>>>>>> On 1/11/24 15:22, olcott wrote:
>>>>>>>> 04 int D(ptr x)
>>>>>>>> 05 {
>>>>>>>> 06   int Halt_Status = H(x, x);
>>>>>>>> 07   if (Halt_Status)
>>>>>>>> 08     HERE: goto HERE;
>>>>>>>> 09   return Halt_Status;
>>>>>>>> 10 }
>>>>>>>> 11
>>>>>>>> 12 void main()
>>>>>>>> 13 {
>>>>>>>> 14   H(D,D);
>>>>>>>> 15 }
>>>>>>>>
>>>>>>>> *Execution Trace*
>>>>>>>> Line 14: main() invokes H(D,D);
>>>>>>>>
>>>>>>>> *keeps repeating* (unless aborted)
>>>>>>>> Line 06: simulated D(D) invokes simulated H(D,D) that simulates
>>>>>>>> D(D)
>>>>>>>>
>>>>>>>> *Simulation invariant*
>>>>>>>> *D correctly simulated by H cannot possibly reach past its own
>>>>>>>> line 06*
>>>>>>>>
>>>>>>>
>>>>>>> The correct simulation of D by H is the same simulation you get
>>>>>>> when you simulate D by H1.
>>>>>>>
>>>>>>> Do I really have to simulate D by H1 and then paste the trace, or
>>>>>>> can you do that yourself?
>>>>>>
>>>>>> It would be a deception to show the correct simulation of D by H1,
>>>>>> as the correct simulation of D by H.
>>>>>
>>>>> It is like saying the correct proof that 1+1=2 is the one which
>>>>> Lisa Simpson knows.
>>>>>
>>>>
>>>> When I ask for the execution trace of D correctly simulated by H
>>>> then providing any execution trace besides the execution trace of
>>>> D correctly simulated by H IS THE WRONG ANSWER.
>>>>
>>>> This is the same as I ask you: "What time is it?"
>>>> and you answer with the color of your car.
>>>>
>>>
>>> The Halting Problem asks for a program that determines whether an given
>>> input program will finish running or not.
>>>
>>> Your POOH does not accept any input except the hard-coded D (as if it
>>> were an input). This is like I ask for the color of the car and you
>>> reply with the time on the wall.
>>>
>>
>> It is a verified fact that D correctly simulated by H cannot possibly
>> halt.
>>
>>
>
> *** The Halting Problem asks for a program that determines whether an
> given input program will finish running or not.***
>
>
> You kept answering the time on the wall !!!
>
> What does your H,D have anything to do with the Halting Problem?
> Your POOH does not decide any given input !!!

MIT Professor Michael Sipser agreed that this verbatim paragraph is correct
(a) If simulating halt decider H correctly simulates its input D until H
correctly determines that its simulated D would never stop running
unless aborted then
(b) H can abort its simulation of D and correctly report that D
specifies a non-halting sequence of configurations.

He is the author of the best selling book on the theory of computation.
*D correctly simulated by H would never stop running unless aborted*
(More precisely D correctly simulated by H cannot possibly halt)

https://www.amazon.com/Introduction-Theory-Computation-Michael-Sipser/dp/113318779X

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

On 1/13/24 06:08, olcott wrote:
> On 1/12/2024 3:55 PM, wij wrote:
>> On 1/13/24 05:44, olcott wrote:
>>> On 1/12/2024 3:26 PM, wij wrote:
>>>> On 1/13/24 03:01, olcott wrote:
>>>>> On 1/12/2024 10:40 AM, immibis wrote:
>>>>>> On 1/12/24 15:24, olcott wrote:
>>>>>>> On 1/12/2024 12:43 AM, immibis wrote:
>>>>>>>> On 1/11/24 15:22, olcott wrote:
>>>>>>>>> 04 int D(ptr x)
>>>>>>>>> 05 {
>>>>>>>>> 06   int Halt_Status = H(x, x);
>>>>>>>>> 07   if (Halt_Status)
>>>>>>>>> 08     HERE: goto HERE;
>>>>>>>>> 09   return Halt_Status;
>>>>>>>>> 10 }
>>>>>>>>> 11
>>>>>>>>> 12 void main()
>>>>>>>>> 13 {
>>>>>>>>> 14   H(D,D);
>>>>>>>>> 15 }
>>>>>>>>>
>>>>>>>>> *Execution Trace*
>>>>>>>>> Line 14: main() invokes H(D,D);
>>>>>>>>>
>>>>>>>>> *keeps repeating* (unless aborted)
>>>>>>>>> Line 06: simulated D(D) invokes simulated H(D,D) that simulates
>>>>>>>>> D(D)
>>>>>>>>>
>>>>>>>>> *Simulation invariant*
>>>>>>>>> *D correctly simulated by H cannot possibly reach past its own
>>>>>>>>> line 06*
>>>>>>>>>
>>>>>>>>
>>>>>>>> The correct simulation of D by H is the same simulation you get
>>>>>>>> when you simulate D by H1.
>>>>>>>>
>>>>>>>> Do I really have to simulate D by H1 and then paste the trace,
>>>>>>>> or can you do that yourself?
>>>>>>>
>>>>>>> It would be a deception to show the correct simulation of D by H1,
>>>>>>> as the correct simulation of D by H.
>>>>>>
>>>>>> It is like saying the correct proof that 1+1=2 is the one which
>>>>>> Lisa Simpson knows.
>>>>>>
>>>>>
>>>>> When I ask for the execution trace of D correctly simulated by H
>>>>> then providing any execution trace besides the execution trace of
>>>>> D correctly simulated by H IS THE WRONG ANSWER.
>>>>>
>>>>> This is the same as I ask you: "What time is it?"
>>>>> and you answer with the color of your car.
>>>>>
>>>>
>>>> The Halting Problem asks for a program that determines whether an given
>>>> input program will finish running or not.
>>>>
>>>> Your POOH does not accept any input except the hard-coded D (as if it
>>>> were an input). This is like I ask for the color of the car and you
>>>> reply with the time on the wall.
>>>>
>>>
>>> It is a verified fact that D correctly simulated by H cannot possibly
>>> halt.
>>>
>>>
>>
>> *** The Halting Problem asks for a program that determines whether an
>> given input program will finish running or not.***
>>
>>
>> You kept answering the time on the wall !!!
>>
>> What does your H,D have anything to do with the Halting Problem?
>> Your POOH does not decide any given input !!!
>
> MIT Professor Michael Sipser agreed that this verbatim paragraph is correct
> (a) If simulating halt decider H correctly simulates its input D until H
> correctly determines that its simulated D would never stop running
> unless aborted then
> (b) H can abort its simulation of D and correctly report that D
> specifies a non-halting sequence of configurations.
>
> He is the author of the best selling book on the theory of computation.
> *D correctly simulated by H would never stop running unless aborted*
> (More precisely D correctly simulated by H cannot possibly halt)
>
> https://www.amazon.com/Introduction-Theory-Computation-Michael-Sipser/dp/113318779X
>

If it were true (hardly true), you read a wrong book. See Peter Linz's book.

On 1/12/2024 4:17 PM, wij wrote:
> On 1/13/24 06:08, olcott wrote:
>> On 1/12/2024 3:55 PM, wij wrote:
>>> On 1/13/24 05:44, olcott wrote:
>>>> On 1/12/2024 3:26 PM, wij wrote:
>>>>> On 1/13/24 03:01, olcott wrote:
>>>>>> On 1/12/2024 10:40 AM, immibis wrote:
>>>>>>> On 1/12/24 15:24, olcott wrote:
>>>>>>>> On 1/12/2024 12:43 AM, immibis wrote:
>>>>>>>>> On 1/11/24 15:22, olcott wrote:
>>>>>>>>>> 04 int D(ptr x)
>>>>>>>>>> 05 {
>>>>>>>>>> 06   int Halt_Status = H(x, x);
>>>>>>>>>> 07   if (Halt_Status)
>>>>>>>>>> 08     HERE: goto HERE;
>>>>>>>>>> 09   return Halt_Status;
>>>>>>>>>> 10 }
>>>>>>>>>> 11
>>>>>>>>>> 12 void main()
>>>>>>>>>> 13 {
>>>>>>>>>> 14   H(D,D);
>>>>>>>>>> 15 }
>>>>>>>>>>
>>>>>>>>>> *Execution Trace*
>>>>>>>>>> Line 14: main() invokes H(D,D);
>>>>>>>>>>
>>>>>>>>>> *keeps repeating* (unless aborted)
>>>>>>>>>> Line 06: simulated D(D) invokes simulated H(D,D) that
>>>>>>>>>> simulates D(D)
>>>>>>>>>>
>>>>>>>>>> *Simulation invariant*
>>>>>>>>>> *D correctly simulated by H cannot possibly reach past its own
>>>>>>>>>> line 06*
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> The correct simulation of D by H is the same simulation you get
>>>>>>>>> when you simulate D by H1.
>>>>>>>>>
>>>>>>>>> Do I really have to simulate D by H1 and then paste the trace,
>>>>>>>>> or can you do that yourself?
>>>>>>>>
>>>>>>>> It would be a deception to show the correct simulation of D by H1,
>>>>>>>> as the correct simulation of D by H.
>>>>>>>
>>>>>>> It is like saying the correct proof that 1+1=2 is the one which
>>>>>>> Lisa Simpson knows.
>>>>>>>
>>>>>>
>>>>>> When I ask for the execution trace of D correctly simulated by H
>>>>>> then providing any execution trace besides the execution trace of
>>>>>> D correctly simulated by H IS THE WRONG ANSWER.
>>>>>>
>>>>>> This is the same as I ask you: "What time is it?"
>>>>>> and you answer with the color of your car.
>>>>>>
>>>>>
>>>>> The Halting Problem asks for a program that determines whether an
>>>>> given
>>>>> input program will finish running or not.
>>>>>
>>>>> Your POOH does not accept any input except the hard-coded D (as if it
>>>>> were an input). This is like I ask for the color of the car and you
>>>>> reply with the time on the wall.
>>>>>
>>>>
>>>> It is a verified fact that D correctly simulated by H cannot
>>>> possibly halt.
>>>>
>>>>
>>>
>>> *** The Halting Problem asks for a program that determines whether an
>>> given input program will finish running or not.***
>>>
>>>
>>> You kept answering the time on the wall !!!
>>>
>>> What does your H,D have anything to do with the Halting Problem?
>>> Your POOH does not decide any given input !!!
>>
>> MIT Professor Michael Sipser agreed that this verbatim paragraph is
>> correct
>> (a) If simulating halt decider H correctly simulates its input D until
>> H correctly determines that its simulated D would never stop running
>> unless aborted then
>> (b) H can abort its simulation of D and correctly report that D
>> specifies a non-halting sequence of configurations.
>>
>> He is the author of the best selling book on the theory of computation.
>> *D correctly simulated by H would never stop running unless aborted*
>> (More precisely D correctly simulated by H cannot possibly halt)
>>
>> https://www.amazon.com/Introduction-Theory-Computation-Michael-Sipser/dp/113318779X
>>
>
> If it were true (hardly true), you read a wrong book. See Peter Linz's
> book.

I contacted Professor Sipser directly and still have his
10/13/2022 11:29:23 AM email agreeing to the verbatim words
of that paragraph.

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

On 1/13/24 06:23, olcott wrote:
> On 1/12/2024 4:17 PM, wij wrote:
>> On 1/13/24 06:08, olcott wrote:
>>> On 1/12/2024 3:55 PM, wij wrote:
>>>> On 1/13/24 05:44, olcott wrote:
>>>>> On 1/12/2024 3:26 PM, wij wrote:
>>>>>> On 1/13/24 03:01, olcott wrote:
>>>>>>> On 1/12/2024 10:40 AM, immibis wrote:
>>>>>>>> On 1/12/24 15:24, olcott wrote:
>>>>>>>>> On 1/12/2024 12:43 AM, immibis wrote:
>>>>>>>>>> On 1/11/24 15:22, olcott wrote:
>>>>>>>>>>> 04 int D(ptr x)
>>>>>>>>>>> 05 {
>>>>>>>>>>> 06   int Halt_Status = H(x, x);
>>>>>>>>>>> 07   if (Halt_Status)
>>>>>>>>>>> 08     HERE: goto HERE;
>>>>>>>>>>> 09   return Halt_Status;
>>>>>>>>>>> 10 }
>>>>>>>>>>> 11
>>>>>>>>>>> 12 void main()
>>>>>>>>>>> 13 {
>>>>>>>>>>> 14   H(D,D);
>>>>>>>>>>> 15 }
>>>>>>>>>>>
>>>>>>>>>>> *Execution Trace*
>>>>>>>>>>> Line 14: main() invokes H(D,D);
>>>>>>>>>>>
>>>>>>>>>>> *keeps repeating* (unless aborted)
>>>>>>>>>>> Line 06: simulated D(D) invokes simulated H(D,D) that
>>>>>>>>>>> simulates D(D)
>>>>>>>>>>>
>>>>>>>>>>> *Simulation invariant*
>>>>>>>>>>> *D correctly simulated by H cannot possibly reach past its
>>>>>>>>>>> own line 06*
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> The correct simulation of D by H is the same simulation you
>>>>>>>>>> get when you simulate D by H1.
>>>>>>>>>>
>>>>>>>>>> Do I really have to simulate D by H1 and then paste the trace,
>>>>>>>>>> or can you do that yourself?
>>>>>>>>>
>>>>>>>>> It would be a deception to show the correct simulation of D by H1,
>>>>>>>>> as the correct simulation of D by H.
>>>>>>>>
>>>>>>>> It is like saying the correct proof that 1+1=2 is the one which
>>>>>>>> Lisa Simpson knows.
>>>>>>>>
>>>>>>>
>>>>>>> When I ask for the execution trace of D correctly simulated by H
>>>>>>> then providing any execution trace besides the execution trace of
>>>>>>> D correctly simulated by H IS THE WRONG ANSWER.
>>>>>>>
>>>>>>> This is the same as I ask you: "What time is it?"
>>>>>>> and you answer with the color of your car.
>>>>>>>
>>>>>>
>>>>>> The Halting Problem asks for a program that determines whether an
>>>>>> given
>>>>>> input program will finish running or not.
>>>>>>
>>>>>> Your POOH does not accept any input except the hard-coded D (as if it
>>>>>> were an input). This is like I ask for the color of the car and you
>>>>>> reply with the time on the wall.
>>>>>>
>>>>>
>>>>> It is a verified fact that D correctly simulated by H cannot
>>>>> possibly halt.
>>>>>
>>>>>
>>>>
>>>> *** The Halting Problem asks for a program that determines whether an
>>>> given input program will finish running or not.***
>>>>
>>>>
>>>> You kept answering the time on the wall !!!
>>>>
>>>> What does your H,D have anything to do with the Halting Problem?
>>>> Your POOH does not decide any given input !!!
>>>
>>> MIT Professor Michael Sipser agreed that this verbatim paragraph is
>>> correct
>>> (a) If simulating halt decider H correctly simulates its input D
>>> until H correctly determines that its simulated D would never stop
>>> running unless aborted then
>>> (b) H can abort its simulation of D and correctly report that D
>>> specifies a non-halting sequence of configurations.
>>>
>>> He is the author of the best selling book on the theory of computation.
>>> *D correctly simulated by H would never stop running unless aborted*
>>> (More precisely D correctly simulated by H cannot possibly halt)
>>>
>>> https://www.amazon.com/Introduction-Theory-Computation-Michael-Sipser/dp/113318779X
>>>
>>
>> If it were true (hardly true), you read a wrong book. See Peter Linz's
>> book.
>
> I contacted Professor Sipser directly and still have his
> 10/13/2022 11:29:23 AM email agreeing to the verbatim words
> of that paragraph.
>

1. This is a serious lie, be careful.
2. If it were true, it is still nothing to the Halting Problem.

On 1/12/2024 4:36 PM, wij wrote:
> On 1/13/24 06:23, olcott wrote:
>> On 1/12/2024 4:17 PM, wij wrote:
>>> On 1/13/24 06:08, olcott wrote:
>>>> On 1/12/2024 3:55 PM, wij wrote:
>>>>> On 1/13/24 05:44, olcott wrote:
>>>>>> On 1/12/2024 3:26 PM, wij wrote:
>>>>>>> On 1/13/24 03:01, olcott wrote:
>>>>>>>> On 1/12/2024 10:40 AM, immibis wrote:
>>>>>>>>> On 1/12/24 15:24, olcott wrote:
>>>>>>>>>> On 1/12/2024 12:43 AM, immibis wrote:
>>>>>>>>>>> On 1/11/24 15:22, olcott wrote:
>>>>>>>>>>>> 04 int D(ptr x)
>>>>>>>>>>>> 05 {
>>>>>>>>>>>> 06   int Halt_Status = H(x, x);
>>>>>>>>>>>> 07   if (Halt_Status)
>>>>>>>>>>>> 08     HERE: goto HERE;
>>>>>>>>>>>> 09   return Halt_Status;
>>>>>>>>>>>> 10 }
>>>>>>>>>>>> 11
>>>>>>>>>>>> 12 void main()
>>>>>>>>>>>> 13 {
>>>>>>>>>>>> 14   H(D,D);
>>>>>>>>>>>> 15 }
>>>>>>>>>>>>
>>>>>>>>>>>> *Execution Trace*
>>>>>>>>>>>> Line 14: main() invokes H(D,D);
>>>>>>>>>>>>
>>>>>>>>>>>> *keeps repeating* (unless aborted)
>>>>>>>>>>>> Line 06: simulated D(D) invokes simulated H(D,D) that
>>>>>>>>>>>> simulates D(D)
>>>>>>>>>>>>
>>>>>>>>>>>> *Simulation invariant*
>>>>>>>>>>>> *D correctly simulated by H cannot possibly reach past its
>>>>>>>>>>>> own line 06*
>>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> The correct simulation of D by H is the same simulation you
>>>>>>>>>>> get when you simulate D by H1.
>>>>>>>>>>>
>>>>>>>>>>> Do I really have to simulate D by H1 and then paste the
>>>>>>>>>>> trace, or can you do that yourself?
>>>>>>>>>>
>>>>>>>>>> It would be a deception to show the correct simulation of D by
>>>>>>>>>> H1,
>>>>>>>>>> as the correct simulation of D by H.
>>>>>>>>>
>>>>>>>>> It is like saying the correct proof that 1+1=2 is the one which
>>>>>>>>> Lisa Simpson knows.
>>>>>>>>>
>>>>>>>>
>>>>>>>> When I ask for the execution trace of D correctly simulated by H
>>>>>>>> then providing any execution trace besides the execution trace of
>>>>>>>> D correctly simulated by H IS THE WRONG ANSWER.
>>>>>>>>
>>>>>>>> This is the same as I ask you: "What time is it?"
>>>>>>>> and you answer with the color of your car.
>>>>>>>>
>>>>>>>
>>>>>>> The Halting Problem asks for a program that determines whether an
>>>>>>> given
>>>>>>> input program will finish running or not.
>>>>>>>
>>>>>>> Your POOH does not accept any input except the hard-coded D (as
>>>>>>> if it
>>>>>>> were an input). This is like I ask for the color of the car and you
>>>>>>> reply with the time on the wall.
>>>>>>>
>>>>>>
>>>>>> It is a verified fact that D correctly simulated by H cannot
>>>>>> possibly halt.
>>>>>>
>>>>>>
>>>>>
>>>>> *** The Halting Problem asks for a program that determines whether an
>>>>> given input program will finish running or not.***
>>>>>
>>>>>
>>>>> You kept answering the time on the wall !!!
>>>>>
>>>>> What does your H,D have anything to do with the Halting Problem?
>>>>> Your POOH does not decide any given input !!!
>>>>
>>>> MIT Professor Michael Sipser agreed that this verbatim paragraph is
>>>> correct
>>>> (a) If simulating halt decider H correctly simulates its input D
>>>> until H correctly determines that its simulated D would never stop
>>>> running unless aborted then
>>>> (b) H can abort its simulation of D and correctly report that D
>>>> specifies a non-halting sequence of configurations.
>>>>
>>>> He is the author of the best selling book on the theory of computation.
>>>> *D correctly simulated by H would never stop running unless aborted*
>>>> (More precisely D correctly simulated by H cannot possibly halt)
>>>>
>>>> https://www.amazon.com/Introduction-Theory-Computation-Michael-Sipser/dp/113318779X
>>>>
>>>
>>> If it were true (hardly true), you read a wrong book. See Peter
>>> Linz's book.
>>
>> I contacted Professor Sipser directly and still have his
>> 10/13/2022 11:29:23 AM email agreeing to the verbatim words
>> of that paragraph.
>>
>
> 1. This is a serious lie, be careful.
> 2. If it were true, it is still nothing to the Halting Problem.

*There is a long conversation about this in comp.theory*

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

On 10/13/2022 11:46 AM, olcott wrote:
> 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.

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

On 1/13/24 07:40, olcott wrote:
> On 1/12/2024 4:36 PM, wij wrote:
>> On 1/13/24 06:23, olcott wrote:
>>> On 1/12/2024 4:17 PM, wij wrote:
>>>> On 1/13/24 06:08, olcott wrote:
>>>>> On 1/12/2024 3:55 PM, wij wrote:
>>>>>> On 1/13/24 05:44, olcott wrote:
>>>>>>> On 1/12/2024 3:26 PM, wij wrote:
>>>>>>>> On 1/13/24 03:01, olcott wrote:
>>>>>>>>> On 1/12/2024 10:40 AM, immibis wrote:
>>>>>>>>>> On 1/12/24 15:24, olcott wrote:
>>>>>>>>>>> On 1/12/2024 12:43 AM, immibis wrote:
>>>>>>>>>>>> On 1/11/24 15:22, olcott wrote:
>>>>>>>>>>>>> 04 int D(ptr x)
>>>>>>>>>>>>> 05 {
>>>>>>>>>>>>> 06   int Halt_Status = H(x, x);
>>>>>>>>>>>>> 07   if (Halt_Status)
>>>>>>>>>>>>> 08     HERE: goto HERE;
>>>>>>>>>>>>> 09   return Halt_Status;
>>>>>>>>>>>>> 10 }
>>>>>>>>>>>>> 11
>>>>>>>>>>>>> 12 void main()
>>>>>>>>>>>>> 13 {
>>>>>>>>>>>>> 14   H(D,D);
>>>>>>>>>>>>> 15 }
>>>>>>>>>>>>>
>>>>>>>>>>>>> *Execution Trace*
>>>>>>>>>>>>> Line 14: main() invokes H(D,D);
>>>>>>>>>>>>>
>>>>>>>>>>>>> *keeps repeating* (unless aborted)
>>>>>>>>>>>>> Line 06: simulated D(D) invokes simulated H(D,D) that
>>>>>>>>>>>>> simulates D(D)
>>>>>>>>>>>>>
>>>>>>>>>>>>> *Simulation invariant*
>>>>>>>>>>>>> *D correctly simulated by H cannot possibly reach past its
>>>>>>>>>>>>> own line 06*
>>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> The correct simulation of D by H is the same simulation you
>>>>>>>>>>>> get when you simulate D by H1.
>>>>>>>>>>>>
>>>>>>>>>>>> Do I really have to simulate D by H1 and then paste the
>>>>>>>>>>>> trace, or can you do that yourself?
>>>>>>>>>>>
>>>>>>>>>>> It would be a deception to show the correct simulation of D
>>>>>>>>>>> by H1,
>>>>>>>>>>> as the correct simulation of D by H.
>>>>>>>>>>
>>>>>>>>>> It is like saying the correct proof that 1+1=2 is the one
>>>>>>>>>> which Lisa Simpson knows.
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> When I ask for the execution trace of D correctly simulated by H
>>>>>>>>> then providing any execution trace besides the execution trace of
>>>>>>>>> D correctly simulated by H IS THE WRONG ANSWER.
>>>>>>>>>
>>>>>>>>> This is the same as I ask you: "What time is it?"
>>>>>>>>> and you answer with the color of your car.
>>>>>>>>>
>>>>>>>>
>>>>>>>> The Halting Problem asks for a program that determines whether
>>>>>>>> an given
>>>>>>>> input program will finish running or not.
>>>>>>>>
>>>>>>>> Your POOH does not accept any input except the hard-coded D (as
>>>>>>>> if it
>>>>>>>> were an input). This is like I ask for the color of the car and you
>>>>>>>> reply with the time on the wall.
>>>>>>>>
>>>>>>>
>>>>>>> It is a verified fact that D correctly simulated by H cannot
>>>>>>> possibly halt.
>>>>>>>
>>>>>>>
>>>>>>
>>>>>> *** The Halting Problem asks for a program that determines whether an
>>>>>> given input program will finish running or not.***
>>>>>>
>>>>>>
>>>>>> You kept answering the time on the wall !!!
>>>>>>
>>>>>> What does your H,D have anything to do with the Halting Problem?
>>>>>> Your POOH does not decide any given input !!!
>>>>>
>>>>> MIT Professor Michael Sipser agreed that this verbatim paragraph is
>>>>> correct
>>>>> (a) If simulating halt decider H correctly simulates its input D
>>>>> until H correctly determines that its simulated D would never stop
>>>>> running unless aborted then
>>>>> (b) H can abort its simulation of D and correctly report that D
>>>>> specifies a non-halting sequence of configurations.
>>>>>
>>>>> He is the author of the best selling book on the theory of
>>>>> computation.
>>>>> *D correctly simulated by H would never stop running unless aborted*
>>>>> (More precisely D correctly simulated by H cannot possibly halt)
>>>>>
>>>>> https://www.amazon.com/Introduction-Theory-Computation-Michael-Sipser/dp/113318779X
>>>>>
>>>>
>>>> If it were true (hardly true), you read a wrong book. See Peter
>>>> Linz's book.
>>>
>>> I contacted Professor Sipser directly and still have his
>>> 10/13/2022 11:29:23 AM email agreeing to the verbatim words
>>> of that paragraph.
>>>
>>
>> 1. This is a serious lie, be careful.
>> 2. If it were true, it is still nothing to the Halting Problem.
>
> *There is a long conversation about this in comp.theory*
>
> [Michael Sipser of MIT validates the notion of a simulating halt decider]
>
> On 10/13/2022 11:46 AM, olcott wrote:
> > 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.
>
>

If what you said were true, you believed words of an idiot. However,
this is not important.

The Halting Problem asks for a program that determines whether an given
input program will finish running or not.

The Halting Problem asks for a program that determines whether an given
input program will finish running or not.

The Halting Problem asks for a program that determines whether an given
input program will finish running or not.

On 1/12/2024 5:53 PM, wij wrote:
> On 1/13/24 07:40, olcott wrote:
>> On 1/12/2024 4:36 PM, wij wrote:
>>> On 1/13/24 06:23, olcott wrote:
>>>> On 1/12/2024 4:17 PM, wij wrote:
>>>>> On 1/13/24 06:08, olcott wrote:
>>>>>> On 1/12/2024 3:55 PM, wij wrote:
>>>>>>> On 1/13/24 05:44, olcott wrote:
>>>>>>>> On 1/12/2024 3:26 PM, wij wrote:
>>>>>>>>> On 1/13/24 03:01, olcott wrote:
>>>>>>>>>> On 1/12/2024 10:40 AM, immibis wrote:
>>>>>>>>>>> On 1/12/24 15:24, olcott wrote:
>>>>>>>>>>>> On 1/12/2024 12:43 AM, immibis wrote:
>>>>>>>>>>>>> On 1/11/24 15:22, olcott wrote:
>>>>>>>>>>>>>> 04 int D(ptr x)
>>>>>>>>>>>>>> 05 {
>>>>>>>>>>>>>> 06   int Halt_Status = H(x, x);
>>>>>>>>>>>>>> 07   if (Halt_Status)
>>>>>>>>>>>>>> 08     HERE: goto HERE;
>>>>>>>>>>>>>> 09   return Halt_Status;
>>>>>>>>>>>>>> 10 }
>>>>>>>>>>>>>> 11
>>>>>>>>>>>>>> 12 void main()
>>>>>>>>>>>>>> 13 {
>>>>>>>>>>>>>> 14   H(D,D);
>>>>>>>>>>>>>> 15 }
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> *Execution Trace*
>>>>>>>>>>>>>> Line 14: main() invokes H(D,D);
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> *keeps repeating* (unless aborted)
>>>>>>>>>>>>>> Line 06: simulated D(D) invokes simulated H(D,D) that
>>>>>>>>>>>>>> simulates D(D)
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> *Simulation invariant*
>>>>>>>>>>>>>> *D correctly simulated by H cannot possibly reach past its
>>>>>>>>>>>>>> own line 06*
>>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>> The correct simulation of D by H is the same simulation you
>>>>>>>>>>>>> get when you simulate D by H1.
>>>>>>>>>>>>>
>>>>>>>>>>>>> Do I really have to simulate D by H1 and then paste the
>>>>>>>>>>>>> trace, or can you do that yourself?
>>>>>>>>>>>>
>>>>>>>>>>>> It would be a deception to show the correct simulation of D
>>>>>>>>>>>> by H1,
>>>>>>>>>>>> as the correct simulation of D by H.
>>>>>>>>>>>
>>>>>>>>>>> It is like saying the correct proof that 1+1=2 is the one
>>>>>>>>>>> which Lisa Simpson knows.
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> When I ask for the execution trace of D correctly simulated by H
>>>>>>>>>> then providing any execution trace besides the execution trace of
>>>>>>>>>> D correctly simulated by H IS THE WRONG ANSWER.
>>>>>>>>>>
>>>>>>>>>> This is the same as I ask you: "What time is it?"
>>>>>>>>>> and you answer with the color of your car.
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> The Halting Problem asks for a program that determines whether
>>>>>>>>> an given
>>>>>>>>> input program will finish running or not.
>>>>>>>>>
>>>>>>>>> Your POOH does not accept any input except the hard-coded D (as
>>>>>>>>> if it
>>>>>>>>> were an input). This is like I ask for the color of the car and
>>>>>>>>> you
>>>>>>>>> reply with the time on the wall.
>>>>>>>>>
>>>>>>>>
>>>>>>>> It is a verified fact that D correctly simulated by H cannot
>>>>>>>> possibly halt.
>>>>>>>>
>>>>>>>>
>>>>>>>
>>>>>>> *** The Halting Problem asks for a program that determines
>>>>>>> whether an
>>>>>>> given input program will finish running or not.***
>>>>>>>
>>>>>>>
>>>>>>> You kept answering the time on the wall !!!
>>>>>>>
>>>>>>> What does your H,D have anything to do with the Halting Problem?
>>>>>>> Your POOH does not decide any given input !!!
>>>>>>
>>>>>> MIT Professor Michael Sipser agreed that this verbatim paragraph
>>>>>> is correct
>>>>>> (a) If simulating halt decider H correctly simulates its input D
>>>>>> until H correctly determines that its simulated D would never stop
>>>>>> running unless aborted then
>>>>>> (b) H can abort its simulation of D and correctly report that D
>>>>>> specifies a non-halting sequence of configurations.
>>>>>>
>>>>>> He is the author of the best selling book on the theory of
>>>>>> computation.
>>>>>> *D correctly simulated by H would never stop running unless aborted*
>>>>>> (More precisely D correctly simulated by H cannot possibly halt)
>>>>>>
>>>>>> https://www.amazon.com/Introduction-Theory-Computation-Michael-Sipser/dp/113318779X
>>>>>>
>>>>>
>>>>> If it were true (hardly true), you read a wrong book. See Peter
>>>>> Linz's book.
>>>>
>>>> I contacted Professor Sipser directly and still have his
>>>> 10/13/2022 11:29:23 AM email agreeing to the verbatim words
>>>> of that paragraph.
>>>>
>>>
>>> 1. This is a serious lie, be careful.
>>> 2. If it were true, it is still nothing to the Halting Problem.
>>
>> *There is a long conversation about this in comp.theory*
>>
>> [Michael Sipser of MIT validates the notion of a simulating halt decider]
>>
>> On 10/13/2022 11:46 AM, olcott wrote:
>>  > 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.
>>
>>
>
> If what you said were true, you believed words of an idiot. However,
> this is not important.
>

Professor Sipser is the #1 best selling author of Theory of Computation
textbooks

> The Halting Problem asks for a program that determines whether an given
> input program will finish running or not.
>

*Yes and the directly executed D(D) IS NOT A FREAKING INPUT*

> The Halting Problem asks for a program that determines whether an given
> input program will finish running or not.
>

*Yes and the directly executed D(D) IS NOT A FREAKING INPUT*

> The Halting Problem asks for a program that determines whether an given
> input program will finish running or not.
>

*Yes and the directly executed D(D) IS NOT A FREAKING INPUT*

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

On 1/13/24 07:58, olcott wrote:
> On 1/12/2024 5:53 PM, wij wrote:
>> On 1/13/24 07:40, olcott wrote:
>>> On 1/12/2024 4:36 PM, wij wrote:
>>>> On 1/13/24 06:23, olcott wrote:
>>>>> On 1/12/2024 4:17 PM, wij wrote:
>>>>>> On 1/13/24 06:08, olcott wrote:
>>>>>>> On 1/12/2024 3:55 PM, wij wrote:
>>>>>>>> On 1/13/24 05:44, olcott wrote:
>>>>>>>>> On 1/12/2024 3:26 PM, wij wrote:
>>>>>>>>>> On 1/13/24 03:01, olcott wrote:
>>>>>>>>>>> On 1/12/2024 10:40 AM, immibis wrote:
>>>>>>>>>>>> On 1/12/24 15:24, olcott wrote:
>>>>>>>>>>>>> On 1/12/2024 12:43 AM, immibis wrote:
>>>>>>>>>>>>>> On 1/11/24 15:22, olcott wrote:
>>>>>>>>>>>>>>> 04 int D(ptr x)
>>>>>>>>>>>>>>> 05 {
>>>>>>>>>>>>>>> 06   int Halt_Status = H(x, x);
>>>>>>>>>>>>>>> 07   if (Halt_Status)
>>>>>>>>>>>>>>> 08     HERE: goto HERE;
>>>>>>>>>>>>>>> 09   return Halt_Status;
>>>>>>>>>>>>>>> 10 }
>>>>>>>>>>>>>>> 11
>>>>>>>>>>>>>>> 12 void main()
>>>>>>>>>>>>>>> 13 {
>>>>>>>>>>>>>>> 14   H(D,D);
>>>>>>>>>>>>>>> 15 }
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> *Execution Trace*
>>>>>>>>>>>>>>> Line 14: main() invokes H(D,D);
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> *keeps repeating* (unless aborted)
>>>>>>>>>>>>>>> Line 06: simulated D(D) invokes simulated H(D,D) that
>>>>>>>>>>>>>>> simulates D(D)
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> *Simulation invariant*
>>>>>>>>>>>>>>> *D correctly simulated by H cannot possibly reach past
>>>>>>>>>>>>>>> its own line 06*
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> The correct simulation of D by H is the same simulation
>>>>>>>>>>>>>> you get when you simulate D by H1.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> Do I really have to simulate D by H1 and then paste the
>>>>>>>>>>>>>> trace, or can you do that yourself?
>>>>>>>>>>>>>
>>>>>>>>>>>>> It would be a deception to show the correct simulation of D
>>>>>>>>>>>>> by H1,
>>>>>>>>>>>>> as the correct simulation of D by H.
>>>>>>>>>>>>
>>>>>>>>>>>> It is like saying the correct proof that 1+1=2 is the one
>>>>>>>>>>>> which Lisa Simpson knows.
>>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> When I ask for the execution trace of D correctly simulated by H
>>>>>>>>>>> then providing any execution trace besides the execution
>>>>>>>>>>> trace of
>>>>>>>>>>> D correctly simulated by H IS THE WRONG ANSWER.
>>>>>>>>>>>
>>>>>>>>>>> This is the same as I ask you: "What time is it?"
>>>>>>>>>>> and you answer with the color of your car.
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> The Halting Problem asks for a program that determines whether
>>>>>>>>>> an given
>>>>>>>>>> input program will finish running or not.
>>>>>>>>>>
>>>>>>>>>> Your POOH does not accept any input except the hard-coded D
>>>>>>>>>> (as if it
>>>>>>>>>> were an input). This is like I ask for the color of the car
>>>>>>>>>> and you
>>>>>>>>>> reply with the time on the wall.
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> It is a verified fact that D correctly simulated by H cannot
>>>>>>>>> possibly halt.
>>>>>>>>>
>>>>>>>>>
>>>>>>>>
>>>>>>>> *** The Halting Problem asks for a program that determines
>>>>>>>> whether an
>>>>>>>> given input program will finish running or not.***
>>>>>>>>
>>>>>>>>
>>>>>>>> You kept answering the time on the wall !!!
>>>>>>>>
>>>>>>>> What does your H,D have anything to do with the Halting Problem?
>>>>>>>> Your POOH does not decide any given input !!!
>>>>>>>
>>>>>>> MIT Professor Michael Sipser agreed that this verbatim paragraph
>>>>>>> is correct
>>>>>>> (a) If simulating halt decider H correctly simulates its input D
>>>>>>> until H correctly determines that its simulated D would never
>>>>>>> stop running unless aborted then
>>>>>>> (b) H can abort its simulation of D and correctly report that D
>>>>>>> specifies a non-halting sequence of configurations.
>>>>>>>
>>>>>>> He is the author of the best selling book on the theory of
>>>>>>> computation.
>>>>>>> *D correctly simulated by H would never stop running unless aborted*
>>>>>>> (More precisely D correctly simulated by H cannot possibly halt)
>>>>>>>
>>>>>>> https://www.amazon.com/Introduction-Theory-Computation-Michael-Sipser/dp/113318779X
>>>>>>>
>>>>>>
>>>>>> If it were true (hardly true), you read a wrong book. See Peter
>>>>>> Linz's book.
>>>>>
>>>>> I contacted Professor Sipser directly and still have his
>>>>> 10/13/2022 11:29:23 AM email agreeing to the verbatim words
>>>>> of that paragraph.
>>>>>
>>>>
>>>> 1. This is a serious lie, be careful.
>>>> 2. If it were true, it is still nothing to the Halting Problem.
>>>
>>> *There is a long conversation about this in comp.theory*
>>>
>>> [Michael Sipser of MIT validates the notion of a simulating halt
>>> decider]
>>>
>>> On 10/13/2022 11:46 AM, olcott wrote:
>>>  > 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.
>>>
>>>
>>
>> If what you said were true, you believed words of an idiot. However,
>> this is not important.
>>
>
> Professor Sipser is the #1 best selling author of Theory of Computation
> textbooks
>
>> The Halting Problem asks for a program that determines whether an given
>> input program will finish running or not.
>>
>
> *Yes and the directly executed D(D) IS NOT A FREAKING INPUT*
>
>> The Halting Problem asks for a program that determines whether an given
>> input program will finish running or not.
>>
>
> *Yes and the directly executed D(D) IS NOT A FREAKING INPUT*
>
>> The Halting Problem asks for a program that determines whether an given
>> input program will finish running or not.
>>
>
> *Yes and the directly executed D(D) IS NOT A FREAKING INPUT*
>
>

On 1/12/2024 6:06 PM, wij wrote:
> On 1/13/24 07:58, olcott wrote:
>> On 1/12/2024 5:53 PM, wij wrote:
>>> On 1/13/24 07:40, olcott wrote:
>>>> On 1/12/2024 4:36 PM, wij wrote:
>>>>> On 1/13/24 06:23, olcott wrote:
>>>>>> On 1/12/2024 4:17 PM, wij wrote:
>>>>>>> On 1/13/24 06:08, olcott wrote:
>>>>>>>> On 1/12/2024 3:55 PM, wij wrote:
>>>>>>>>> On 1/13/24 05:44, olcott wrote:
>>>>>>>>>> On 1/12/2024 3:26 PM, wij wrote:
>>>>>>>>>>> On 1/13/24 03:01, olcott wrote:
>>>>>>>>>>>> On 1/12/2024 10:40 AM, immibis wrote:
>>>>>>>>>>>>> On 1/12/24 15:24, olcott wrote:
>>>>>>>>>>>>>> On 1/12/2024 12:43 AM, immibis wrote:
>>>>>>>>>>>>>>> On 1/11/24 15:22, olcott wrote:
>>>>>>>>>>>>>>>> 04 int D(ptr x)
>>>>>>>>>>>>>>>> 05 {
>>>>>>>>>>>>>>>> 06   int Halt_Status = H(x, x);
>>>>>>>>>>>>>>>> 07   if (Halt_Status)
>>>>>>>>>>>>>>>> 08     HERE: goto HERE;
>>>>>>>>>>>>>>>> 09   return Halt_Status;
>>>>>>>>>>>>>>>> 10 }
>>>>>>>>>>>>>>>> 11
>>>>>>>>>>>>>>>> 12 void main()
>>>>>>>>>>>>>>>> 13 {
>>>>>>>>>>>>>>>> 14   H(D,D);
>>>>>>>>>>>>>>>> 15 }
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> *Execution Trace*
>>>>>>>>>>>>>>>> Line 14: main() invokes H(D,D);
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> *keeps repeating* (unless aborted)
>>>>>>>>>>>>>>>> Line 06: simulated D(D) invokes simulated H(D,D) that
>>>>>>>>>>>>>>>> simulates D(D)
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> *Simulation invariant*
>>>>>>>>>>>>>>>> *D correctly simulated by H cannot possibly reach past
>>>>>>>>>>>>>>>> its own line 06*
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> The correct simulation of D by H is the same simulation
>>>>>>>>>>>>>>> you get when you simulate D by H1.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> Do I really have to simulate D by H1 and then paste the
>>>>>>>>>>>>>>> trace, or can you do that yourself?
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> It would be a deception to show the correct simulation of
>>>>>>>>>>>>>> D by H1,
>>>>>>>>>>>>>> as the correct simulation of D by H.
>>>>>>>>>>>>>
>>>>>>>>>>>>> It is like saying the correct proof that 1+1=2 is the one
>>>>>>>>>>>>> which Lisa Simpson knows.
>>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> When I ask for the execution trace of D correctly simulated
>>>>>>>>>>>> by H
>>>>>>>>>>>> then providing any execution trace besides the execution
>>>>>>>>>>>> trace of
>>>>>>>>>>>> D correctly simulated by H IS THE WRONG ANSWER.
>>>>>>>>>>>>
>>>>>>>>>>>> This is the same as I ask you: "What time is it?"
>>>>>>>>>>>> and you answer with the color of your car.
>>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> The Halting Problem asks for a program that determines
>>>>>>>>>>> whether an given
>>>>>>>>>>> input program will finish running or not.
>>>>>>>>>>>
>>>>>>>>>>> Your POOH does not accept any input except the hard-coded D
>>>>>>>>>>> (as if it
>>>>>>>>>>> were an input). This is like I ask for the color of the car
>>>>>>>>>>> and you
>>>>>>>>>>> reply with the time on the wall.
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> It is a verified fact that D correctly simulated by H cannot
>>>>>>>>>> possibly halt.
>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> *** The Halting Problem asks for a program that determines
>>>>>>>>> whether an
>>>>>>>>> given input program will finish running or not.***
>>>>>>>>>
>>>>>>>>>
>>>>>>>>> You kept answering the time on the wall !!!
>>>>>>>>>
>>>>>>>>> What does your H,D have anything to do with the Halting Problem?
>>>>>>>>> Your POOH does not decide any given input !!!
>>>>>>>>
>>>>>>>> MIT Professor Michael Sipser agreed that this verbatim paragraph
>>>>>>>> is correct
>>>>>>>> (a) If simulating halt decider H correctly simulates its input D
>>>>>>>> until H correctly determines that its simulated D would never
>>>>>>>> stop running unless aborted then
>>>>>>>> (b) H can abort its simulation of D and correctly report that D
>>>>>>>> specifies a non-halting sequence of configurations.
>>>>>>>>
>>>>>>>> He is the author of the best selling book on the theory of
>>>>>>>> computation.
>>>>>>>> *D correctly simulated by H would never stop running unless
>>>>>>>> aborted*
>>>>>>>> (More precisely D correctly simulated by H cannot possibly halt)
>>>>>>>>
>>>>>>>> https://www.amazon.com/Introduction-Theory-Computation-Michael-Sipser/dp/113318779X
>>>>>>>>
>>>>>>>
>>>>>>> If it were true (hardly true), you read a wrong book. See Peter
>>>>>>> Linz's book.
>>>>>>
>>>>>> I contacted Professor Sipser directly and still have his
>>>>>> 10/13/2022 11:29:23 AM email agreeing to the verbatim words
>>>>>> of that paragraph.
>>>>>>
>>>>>
>>>>> 1. This is a serious lie, be careful.
>>>>> 2. If it were true, it is still nothing to the Halting Problem.
>>>>
>>>> *There is a long conversation about this in comp.theory*
>>>>
>>>> [Michael Sipser of MIT validates the notion of a simulating halt
>>>> decider]
>>>>
>>>> On 10/13/2022 11:46 AM, olcott wrote:
>>>>  > 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.
>>>>
>>>>
>>>
>>> If what you said were true, you believed words of an idiot. However,
>>> this is not important.
>>>
>>
>> Professor Sipser is the #1 best selling author of Theory of
>> Computation textbooks
>>
>>> The Halting Problem asks for a program that determines whether an given
>>> input program will finish running or not.
>>>
>>
>> *Yes and the directly executed D(D) IS NOT A FREAKING INPUT*
>>
>>> The Halting Problem asks for a program that determines whether an given
>>> input program will finish running or not.
>>>
>>
>> *Yes and the directly executed D(D) IS NOT A FREAKING INPUT*
>>
>>> The Halting Problem asks for a program that determines whether an given
>>> input program will finish running or not.
>>>
>>
>> *Yes and the directly executed D(D) IS NOT A FREAKING INPUT*
>>
>>
>
> D is a function you selected, you already know everything about it
> inside out.

On 1/12/24 9:24 AM, olcott wrote:
> On 1/12/2024 12:43 AM, immibis wrote:
>> On 1/11/24 15:22, olcott wrote:
>>> 04 int D(ptr x)
>>> 05 {
>>> 06   int Halt_Status = H(x, x);
>>> 07   if (Halt_Status)
>>> 08     HERE: goto HERE;
>>> 09   return Halt_Status;
>>> 10 }
>>> 11
>>> 12 void main()
>>> 13 {
>>> 14   H(D,D);
>>> 15 }
>>>
>>> *Execution Trace*
>>> Line 14: main() invokes H(D,D);
>>>
>>> *keeps repeating* (unless aborted)
>>> Line 06: simulated D(D) invokes simulated H(D,D) that simulates D(D)
>>>
>>> *Simulation invariant*
>>> *D correctly simulated by H cannot possibly reach past its own line 06*
>>>
>>
>> The correct simulation of D by H is the same simulation you get when
>> you simulate D by H1.
>>
>> Do I really have to simulate D by H1 and then paste the trace, or can
>> you do that yourself?
>
> It would be a deception to show the correct simulation of D by H1,
> as the correct simulation of D by H.

But it shows that H's simulaiton was not Correct.

>
> That is like saying I have proof that Bill robbed the liquor
> store because I saw Harry do it and Harry is not Bill.

No, if we can prove that Harry did it alone, and is not Bill, then Bill
could not have done it.

>
> If it is impossible to show a line-by-line execution trace
> of the exact sequence of line numbers of D correctly simulated
> by H that differs from the one that I provided then that proves
> that my execution trace is correct.
>
>

Because H doesn't correctly simulate its input.

Your example only shows that an H that does correctly simulates its
input can never answer the question, because to BE a correct simulation,
it can't stop, and thus doesn't answer.

If H aborts, then it no longer matches the criteria that you used to
prove the simulation never halts.

In other words, you are trying to prove something that needs a false
statement to be true for the proof to work.

On 1/12/24 7:43 PM, olcott wrote:
> On 1/12/2024 6:06 PM, wij wrote:
>> On 1/13/24 07:58, olcott wrote:
>>> On 1/12/2024 5:53 PM, wij wrote:
>>>> On 1/13/24 07:40, olcott wrote:
>>>>> On 1/12/2024 4:36 PM, wij wrote:
>>>>>> On 1/13/24 06:23, olcott wrote:
>>>>>>> On 1/12/2024 4:17 PM, wij wrote:
>>>>>>>> On 1/13/24 06:08, olcott wrote:
>>>>>>>>> On 1/12/2024 3:55 PM, wij wrote:
>>>>>>>>>> On 1/13/24 05:44, olcott wrote:
>>>>>>>>>>> On 1/12/2024 3:26 PM, wij wrote:
>>>>>>>>>>>> On 1/13/24 03:01, olcott wrote:
>>>>>>>>>>>>> On 1/12/2024 10:40 AM, immibis wrote:
>>>>>>>>>>>>>> On 1/12/24 15:24, olcott wrote:
>>>>>>>>>>>>>>> On 1/12/2024 12:43 AM, immibis wrote:
>>>>>>>>>>>>>>>> On 1/11/24 15:22, olcott wrote:
>>>>>>>>>>>>>>>>> 04 int D(ptr x)
>>>>>>>>>>>>>>>>> 05 {
>>>>>>>>>>>>>>>>> 06   int Halt_Status = H(x, x);
>>>>>>>>>>>>>>>>> 07   if (Halt_Status)
>>>>>>>>>>>>>>>>> 08     HERE: goto HERE;
>>>>>>>>>>>>>>>>> 09   return Halt_Status;
>>>>>>>>>>>>>>>>> 10 }
>>>>>>>>>>>>>>>>> 11
>>>>>>>>>>>>>>>>> 12 void main()
>>>>>>>>>>>>>>>>> 13 {
>>>>>>>>>>>>>>>>> 14   H(D,D);
>>>>>>>>>>>>>>>>> 15 }
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> *Execution Trace*
>>>>>>>>>>>>>>>>> Line 14: main() invokes H(D,D);
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> *keeps repeating* (unless aborted)
>>>>>>>>>>>>>>>>> Line 06: simulated D(D) invokes simulated H(D,D) that
>>>>>>>>>>>>>>>>> simulates D(D)
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> *Simulation invariant*
>>>>>>>>>>>>>>>>> *D correctly simulated by H cannot possibly reach past
>>>>>>>>>>>>>>>>> its own line 06*
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> The correct simulation of D by H is the same simulation
>>>>>>>>>>>>>>>> you get when you simulate D by H1.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> Do I really have to simulate D by H1 and then paste the
>>>>>>>>>>>>>>>> trace, or can you do that yourself?
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> It would be a deception to show the correct simulation of
>>>>>>>>>>>>>>> D by H1,
>>>>>>>>>>>>>>> as the correct simulation of D by H.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> It is like saying the correct proof that 1+1=2 is the one
>>>>>>>>>>>>>> which Lisa Simpson knows.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>> When I ask for the execution trace of D correctly simulated
>>>>>>>>>>>>> by H
>>>>>>>>>>>>> then providing any execution trace besides the execution
>>>>>>>>>>>>> trace of
>>>>>>>>>>>>> D correctly simulated by H IS THE WRONG ANSWER.
>>>>>>>>>>>>>
>>>>>>>>>>>>> This is the same as I ask you: "What time is it?"
>>>>>>>>>>>>> and you answer with the color of your car.
>>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> The Halting Problem asks for a program that determines
>>>>>>>>>>>> whether an given
>>>>>>>>>>>> input program will finish running or not.
>>>>>>>>>>>>
>>>>>>>>>>>> Your POOH does not accept any input except the hard-coded D
>>>>>>>>>>>> (as if it
>>>>>>>>>>>> were an input). This is like I ask for the color of the car
>>>>>>>>>>>> and you
>>>>>>>>>>>> reply with the time on the wall.
>>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> It is a verified fact that D correctly simulated by H cannot
>>>>>>>>>>> possibly halt.
>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> *** The Halting Problem asks for a program that determines
>>>>>>>>>> whether an
>>>>>>>>>> given input program will finish running or not.***
>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> You kept answering the time on the wall !!!
>>>>>>>>>>
>>>>>>>>>> What does your H,D have anything to do with the Halting Problem?
>>>>>>>>>> Your POOH does not decide any given input !!!
>>>>>>>>>
>>>>>>>>> MIT Professor Michael Sipser agreed that this verbatim
>>>>>>>>> paragraph is correct
>>>>>>>>> (a) If simulating halt decider H correctly simulates its input
>>>>>>>>> D until H correctly determines that its simulated D would never
>>>>>>>>> stop running unless aborted then
>>>>>>>>> (b) H can abort its simulation of D and correctly report that D
>>>>>>>>> specifies a non-halting sequence of configurations.
>>>>>>>>>
>>>>>>>>> He is the author of the best selling book on the theory of
>>>>>>>>> computation.
>>>>>>>>> *D correctly simulated by H would never stop running unless
>>>>>>>>> aborted*
>>>>>>>>> (More precisely D correctly simulated by H cannot possibly halt)
>>>>>>>>>
>>>>>>>>> https://www.amazon.com/Introduction-Theory-Computation-Michael-Sipser/dp/113318779X
>>>>>>>>>
>>>>>>>>
>>>>>>>> If it were true (hardly true), you read a wrong book. See Peter
>>>>>>>> Linz's book.
>>>>>>>
>>>>>>> I contacted Professor Sipser directly and still have his
>>>>>>> 10/13/2022 11:29:23 AM email agreeing to the verbatim words
>>>>>>> of that paragraph.
>>>>>>>
>>>>>>
>>>>>> 1. This is a serious lie, be careful.
>>>>>> 2. If it were true, it is still nothing to the Halting Problem.
>>>>>
>>>>> *There is a long conversation about this in comp.theory*
>>>>>
>>>>> [Michael Sipser of MIT validates the notion of a simulating halt
>>>>> decider]
>>>>>
>>>>> On 10/13/2022 11:46 AM, olcott wrote:
>>>>>  > 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.
>>>>>
>>>>>
>>>>
>>>> If what you said were true, you believed words of an idiot. However,
>>>> this is not important.
>>>>
>>>
>>> Professor Sipser is the #1 best selling author of Theory of
>>> Computation textbooks
>>>
>>>> The Halting Problem asks for a program that determines whether an given
>>>> input program will finish running or not.
>>>>
>>>
>>> *Yes and the directly executed D(D) IS NOT A FREAKING INPUT*
>>>
>>>> The Halting Problem asks for a program that determines whether an given
>>>> input program will finish running or not.
>>>>
>>>
>>> *Yes and the directly executed D(D) IS NOT A FREAKING INPUT*
>>>
>>>> The Halting Problem asks for a program that determines whether an given
>>>> input program will finish running or not.
>>>>
>>>
>>> *Yes and the directly executed D(D) IS NOT A FREAKING INPUT*
>>>
>>>
>>
>> D is a function you selected, you already know everything about it
>> inside out.
>
> H does not reply on that.
> There are all kinds of different sample inputs that H works with.
>
>

On 1/12/2024 6:06 PM, wij wrote:
> On 1/13/24 07:58, olcott wrote:
>> On 1/12/2024 5:53 PM, wij wrote:
>>> On 1/13/24 07:40, olcott wrote:
>>>> On 1/12/2024 4:36 PM, wij wrote:
>>>>> On 1/13/24 06:23, olcott wrote:
>>>>>> On 1/12/2024 4:17 PM, wij wrote:
>>>>>>> On 1/13/24 06:08, olcott wrote:
>>>>>>>> On 1/12/2024 3:55 PM, wij wrote:
>>>>>>>>> On 1/13/24 05:44, olcott wrote:
>>>>>>>>>> On 1/12/2024 3:26 PM, wij wrote:
>>>>>>>>>>> On 1/13/24 03:01, olcott wrote:
>>>>>>>>>>>> On 1/12/2024 10:40 AM, immibis wrote:
>>>>>>>>>>>>> On 1/12/24 15:24, olcott wrote:
>>>>>>>>>>>>>> On 1/12/2024 12:43 AM, immibis wrote:
>>>>>>>>>>>>>>> On 1/11/24 15:22, olcott wrote:
>>>>>>>>>>>>>>>> 04 int D(ptr x)
>>>>>>>>>>>>>>>> 05 {
>>>>>>>>>>>>>>>> 06   int Halt_Status = H(x, x);
>>>>>>>>>>>>>>>> 07   if (Halt_Status)
>>>>>>>>>>>>>>>> 08     HERE: goto HERE;
>>>>>>>>>>>>>>>> 09   return Halt_Status;
>>>>>>>>>>>>>>>> 10 }
>>>>>>>>>>>>>>>> 11
>>>>>>>>>>>>>>>> 12 void main()
>>>>>>>>>>>>>>>> 13 {
>>>>>>>>>>>>>>>> 14   H(D,D);
>>>>>>>>>>>>>>>> 15 }
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> *Execution Trace*
>>>>>>>>>>>>>>>> Line 14: main() invokes H(D,D);
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> *keeps repeating* (unless aborted)
>>>>>>>>>>>>>>>> Line 06: simulated D(D) invokes simulated H(D,D) that
>>>>>>>>>>>>>>>> simulates D(D)
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> *Simulation invariant*
>>>>>>>>>>>>>>>> *D correctly simulated by H cannot possibly reach past
>>>>>>>>>>>>>>>> its own line 06*
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> The correct simulation of D by H is the same simulation
>>>>>>>>>>>>>>> you get when you simulate D by H1.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> Do I really have to simulate D by H1 and then paste the
>>>>>>>>>>>>>>> trace, or can you do that yourself?
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> It would be a deception to show the correct simulation of
>>>>>>>>>>>>>> D by H1,
>>>>>>>>>>>>>> as the correct simulation of D by H.
>>>>>>>>>>>>>
>>>>>>>>>>>>> It is like saying the correct proof that 1+1=2 is the one
>>>>>>>>>>>>> which Lisa Simpson knows.
>>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> When I ask for the execution trace of D correctly simulated
>>>>>>>>>>>> by H
>>>>>>>>>>>> then providing any execution trace besides the execution
>>>>>>>>>>>> trace of
>>>>>>>>>>>> D correctly simulated by H IS THE WRONG ANSWER.
>>>>>>>>>>>>
>>>>>>>>>>>> This is the same as I ask you: "What time is it?"
>>>>>>>>>>>> and you answer with the color of your car.
>>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> The Halting Problem asks for a program that determines
>>>>>>>>>>> whether an given
>>>>>>>>>>> input program will finish running or not.
>>>>>>>>>>>
>>>>>>>>>>> Your POOH does not accept any input except the hard-coded D
>>>>>>>>>>> (as if it
>>>>>>>>>>> were an input). This is like I ask for the color of the car
>>>>>>>>>>> and you
>>>>>>>>>>> reply with the time on the wall.
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> It is a verified fact that D correctly simulated by H cannot
>>>>>>>>>> possibly halt.
>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> *** The Halting Problem asks for a program that determines
>>>>>>>>> whether an
>>>>>>>>> given input program will finish running or not.***
>>>>>>>>>
>>>>>>>>>
>>>>>>>>> You kept answering the time on the wall !!!
>>>>>>>>>
>>>>>>>>> What does your H,D have anything to do with the Halting Problem?
>>>>>>>>> Your POOH does not decide any given input !!!
>>>>>>>>
>>>>>>>> MIT Professor Michael Sipser agreed that this verbatim paragraph
>>>>>>>> is correct
>>>>>>>> (a) If simulating halt decider H correctly simulates its input D
>>>>>>>> until H correctly determines that its simulated D would never
>>>>>>>> stop running unless aborted then
>>>>>>>> (b) H can abort its simulation of D and correctly report that D
>>>>>>>> specifies a non-halting sequence of configurations.
>>>>>>>>
>>>>>>>> He is the author of the best selling book on the theory of
>>>>>>>> computation.
>>>>>>>> *D correctly simulated by H would never stop running unless
>>>>>>>> aborted*
>>>>>>>> (More precisely D correctly simulated by H cannot possibly halt)
>>>>>>>>
>>>>>>>> https://www.amazon.com/Introduction-Theory-Computation-Michael-Sipser/dp/113318779X
>>>>>>>>
>>>>>>>
>>>>>>> If it were true (hardly true), you read a wrong book. See Peter
>>>>>>> Linz's book.
>>>>>>
>>>>>> I contacted Professor Sipser directly and still have his
>>>>>> 10/13/2022 11:29:23 AM email agreeing to the verbatim words
>>>>>> of that paragraph.
>>>>>>
>>>>>
>>>>> 1. This is a serious lie, be careful.
>>>>> 2. If it were true, it is still nothing to the Halting Problem.
>>>>
>>>> *There is a long conversation about this in comp.theory*
>>>>
>>>> [Michael Sipser of MIT validates the notion of a simulating halt
>>>> decider]
>>>>
>>>> On 10/13/2022 11:46 AM, olcott wrote:
>>>>  > 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.
>>>>
>>>>
>>>
>>> If what you said were true, you believed words of an idiot. However,
>>> this is not important.
>>>
>>
>> Professor Sipser is the #1 best selling author of Theory of
>> Computation textbooks
>>
>>> The Halting Problem asks for a program that determines whether an given
>>> input program will finish running or not.
>>>
>>
>> *Yes and the directly executed D(D) IS NOT A FREAKING INPUT*
>>
>>> The Halting Problem asks for a program that determines whether an given
>>> input program will finish running or not.
>>>
>>
>> *Yes and the directly executed D(D) IS NOT A FREAKING INPUT*
>>
>>> The Halting Problem asks for a program that determines whether an given
>>> input program will finish running or not.
>>>
>>
>> *Yes and the directly executed D(D) IS NOT A FREAKING INPUT*
>>
>>
>
> D is a function you selected, you already know everything about it
> inside out.
>
> POOH is not a halting decider.
> The Halting Problem asks for a program that determines whether an given
> input program will finish running or not.
>
> POOH is not a halting decider.
> The Halting Problem asks for a program that determines whether an given
> input program will finish running or not.
>

On 1/12/24 10:18 PM, olcott wrote:
> On 1/12/2024 6:06 PM, wij wrote:
>> On 1/13/24 07:58, olcott wrote:
>>> On 1/12/2024 5:53 PM, wij wrote:
>>>> On 1/13/24 07:40, olcott wrote:
>>>>> On 1/12/2024 4:36 PM, wij wrote:
>>>>>> On 1/13/24 06:23, olcott wrote:
>>>>>>> On 1/12/2024 4:17 PM, wij wrote:
>>>>>>>> On 1/13/24 06:08, olcott wrote:
>>>>>>>>> On 1/12/2024 3:55 PM, wij wrote:
>>>>>>>>>> On 1/13/24 05:44, olcott wrote:
>>>>>>>>>>> On 1/12/2024 3:26 PM, wij wrote:
>>>>>>>>>>>> On 1/13/24 03:01, olcott wrote:
>>>>>>>>>>>>> On 1/12/2024 10:40 AM, immibis wrote:
>>>>>>>>>>>>>> On 1/12/24 15:24, olcott wrote:
>>>>>>>>>>>>>>> On 1/12/2024 12:43 AM, immibis wrote:
>>>>>>>>>>>>>>>> On 1/11/24 15:22, olcott wrote:
>>>>>>>>>>>>>>>>> 04 int D(ptr x)
>>>>>>>>>>>>>>>>> 05 {
>>>>>>>>>>>>>>>>> 06   int Halt_Status = H(x, x);
>>>>>>>>>>>>>>>>> 07   if (Halt_Status)
>>>>>>>>>>>>>>>>> 08     HERE: goto HERE;
>>>>>>>>>>>>>>>>> 09   return Halt_Status;
>>>>>>>>>>>>>>>>> 10 }
>>>>>>>>>>>>>>>>> 11
>>>>>>>>>>>>>>>>> 12 void main()
>>>>>>>>>>>>>>>>> 13 {
>>>>>>>>>>>>>>>>> 14   H(D,D);
>>>>>>>>>>>>>>>>> 15 }
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> *Execution Trace*
>>>>>>>>>>>>>>>>> Line 14: main() invokes H(D,D);
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> *keeps repeating* (unless aborted)
>>>>>>>>>>>>>>>>> Line 06: simulated D(D) invokes simulated H(D,D) that
>>>>>>>>>>>>>>>>> simulates D(D)
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> *Simulation invariant*
>>>>>>>>>>>>>>>>> *D correctly simulated by H cannot possibly reach past
>>>>>>>>>>>>>>>>> its own line 06*
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> The correct simulation of D by H is the same simulation
>>>>>>>>>>>>>>>> you get when you simulate D by H1.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> Do I really have to simulate D by H1 and then paste the
>>>>>>>>>>>>>>>> trace, or can you do that yourself?
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> It would be a deception to show the correct simulation of
>>>>>>>>>>>>>>> D by H1,
>>>>>>>>>>>>>>> as the correct simulation of D by H.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> It is like saying the correct proof that 1+1=2 is the one
>>>>>>>>>>>>>> which Lisa Simpson knows.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>> When I ask for the execution trace of D correctly simulated
>>>>>>>>>>>>> by H
>>>>>>>>>>>>> then providing any execution trace besides the execution
>>>>>>>>>>>>> trace of
>>>>>>>>>>>>> D correctly simulated by H IS THE WRONG ANSWER.
>>>>>>>>>>>>>
>>>>>>>>>>>>> This is the same as I ask you: "What time is it?"
>>>>>>>>>>>>> and you answer with the color of your car.
>>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> The Halting Problem asks for a program that determines
>>>>>>>>>>>> whether an given
>>>>>>>>>>>> input program will finish running or not.
>>>>>>>>>>>>
>>>>>>>>>>>> Your POOH does not accept any input except the hard-coded D
>>>>>>>>>>>> (as if it
>>>>>>>>>>>> were an input). This is like I ask for the color of the car
>>>>>>>>>>>> and you
>>>>>>>>>>>> reply with the time on the wall.
>>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> It is a verified fact that D correctly simulated by H cannot
>>>>>>>>>>> possibly halt.
>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> *** The Halting Problem asks for a program that determines
>>>>>>>>>> whether an
>>>>>>>>>> given input program will finish running or not.***
>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> You kept answering the time on the wall !!!
>>>>>>>>>>
>>>>>>>>>> What does your H,D have anything to do with the Halting Problem?
>>>>>>>>>> Your POOH does not decide any given input !!!
>>>>>>>>>
>>>>>>>>> MIT Professor Michael Sipser agreed that this verbatim
>>>>>>>>> paragraph is correct
>>>>>>>>> (a) If simulating halt decider H correctly simulates its input
>>>>>>>>> D until H correctly determines that its simulated D would never
>>>>>>>>> stop running unless aborted then
>>>>>>>>> (b) H can abort its simulation of D and correctly report that D
>>>>>>>>> specifies a non-halting sequence of configurations.
>>>>>>>>>
>>>>>>>>> He is the author of the best selling book on the theory of
>>>>>>>>> computation.
>>>>>>>>> *D correctly simulated by H would never stop running unless
>>>>>>>>> aborted*
>>>>>>>>> (More precisely D correctly simulated by H cannot possibly halt)
>>>>>>>>>
>>>>>>>>> https://www.amazon.com/Introduction-Theory-Computation-Michael-Sipser/dp/113318779X
>>>>>>>>>
>>>>>>>>
>>>>>>>> If it were true (hardly true), you read a wrong book. See Peter
>>>>>>>> Linz's book.
>>>>>>>
>>>>>>> I contacted Professor Sipser directly and still have his
>>>>>>> 10/13/2022 11:29:23 AM email agreeing to the verbatim words
>>>>>>> of that paragraph.
>>>>>>>
>>>>>>
>>>>>> 1. This is a serious lie, be careful.
>>>>>> 2. If it were true, it is still nothing to the Halting Problem.
>>>>>
>>>>> *There is a long conversation about this in comp.theory*
>>>>>
>>>>> [Michael Sipser of MIT validates the notion of a simulating halt
>>>>> decider]
>>>>>
>>>>> On 10/13/2022 11:46 AM, olcott wrote:
>>>>>  > 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.
>>>>>
>>>>>
>>>>
>>>> If what you said were true, you believed words of an idiot. However,
>>>> this is not important.
>>>>
>>>
>>> Professor Sipser is the #1 best selling author of Theory of
>>> Computation textbooks
>>>
>>>> The Halting Problem asks for a program that determines whether an given
>>>> input program will finish running or not.
>>>>
>>>
>>> *Yes and the directly executed D(D) IS NOT A FREAKING INPUT*
>>>
>>>> The Halting Problem asks for a program that determines whether an given
>>>> input program will finish running or not.
>>>>
>>>
>>> *Yes and the directly executed D(D) IS NOT A FREAKING INPUT*
>>>
>>>> The Halting Problem asks for a program that determines whether an given
>>>> input program will finish running or not.
>>>>
>>>
>>> *Yes and the directly executed D(D) IS NOT A FREAKING INPUT*
>>>
>>>
>>
>> D is a function you selected, you already know everything about it
>> inside out.
>>
>> POOH is not a halting decider.
>> The Halting Problem asks for a program that determines whether an given
>> input program will finish running or not.
>>
>> POOH is not a halting decider.
>> The Halting Problem asks for a program that determines whether an given
>> input program will finish running or not.
>>
>
> H does not *RELY* on that.
> There are all kinds of different sample inputs that H works with.
>
>

On 1/13/24 11:18, olcott wrote:
> On 1/12/2024 6:06 PM, wij wrote:
>> On 1/13/24 07:58, olcott wrote:
>>> On 1/12/2024 5:53 PM, wij wrote:
>>>> On 1/13/24 07:40, olcott wrote:
>>>>> On 1/12/2024 4:36 PM, wij wrote:
>>>>>> On 1/13/24 06:23, olcott wrote:
>>>>>>> On 1/12/2024 4:17 PM, wij wrote:
>>>>>>>> On 1/13/24 06:08, olcott wrote:
>>>>>>>>> On 1/12/2024 3:55 PM, wij wrote:
>>>>>>>>>> On 1/13/24 05:44, olcott wrote:
>>>>>>>>>>> On 1/12/2024 3:26 PM, wij wrote:
>>>>>>>>>>>> On 1/13/24 03:01, olcott wrote:
>>>>>>>>>>>>> On 1/12/2024 10:40 AM, immibis wrote:
>>>>>>>>>>>>>> On 1/12/24 15:24, olcott wrote:
>>>>>>>>>>>>>>> On 1/12/2024 12:43 AM, immibis wrote:
>>>>>>>>>>>>>>>> On 1/11/24 15:22, olcott wrote:
>>>>>>>>>>>>>>>>> 04 int D(ptr x)
>>>>>>>>>>>>>>>>> 05 {
>>>>>>>>>>>>>>>>> 06   int Halt_Status = H(x, x);
>>>>>>>>>>>>>>>>> 07   if (Halt_Status)
>>>>>>>>>>>>>>>>> 08     HERE: goto HERE;
>>>>>>>>>>>>>>>>> 09   return Halt_Status;
>>>>>>>>>>>>>>>>> 10 }
>>>>>>>>>>>>>>>>> 11
>>>>>>>>>>>>>>>>> 12 void main()
>>>>>>>>>>>>>>>>> 13 {
>>>>>>>>>>>>>>>>> 14   H(D,D);
>>>>>>>>>>>>>>>>> 15 }
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> *Execution Trace*
>>>>>>>>>>>>>>>>> Line 14: main() invokes H(D,D);
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> *keeps repeating* (unless aborted)
>>>>>>>>>>>>>>>>> Line 06: simulated D(D) invokes simulated H(D,D) that
>>>>>>>>>>>>>>>>> simulates D(D)
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> *Simulation invariant*
>>>>>>>>>>>>>>>>> *D correctly simulated by H cannot possibly reach past
>>>>>>>>>>>>>>>>> its own line 06*
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> The correct simulation of D by H is the same simulation
>>>>>>>>>>>>>>>> you get when you simulate D by H1.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> Do I really have to simulate D by H1 and then paste the
>>>>>>>>>>>>>>>> trace, or can you do that yourself?
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> It would be a deception to show the correct simulation of
>>>>>>>>>>>>>>> D by H1,
>>>>>>>>>>>>>>> as the correct simulation of D by H.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> It is like saying the correct proof that 1+1=2 is the one
>>>>>>>>>>>>>> which Lisa Simpson knows.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>> When I ask for the execution trace of D correctly simulated
>>>>>>>>>>>>> by H
>>>>>>>>>>>>> then providing any execution trace besides the execution
>>>>>>>>>>>>> trace of
>>>>>>>>>>>>> D correctly simulated by H IS THE WRONG ANSWER.
>>>>>>>>>>>>>
>>>>>>>>>>>>> This is the same as I ask you: "What time is it?"
>>>>>>>>>>>>> and you answer with the color of your car.
>>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> The Halting Problem asks for a program that determines
>>>>>>>>>>>> whether an given
>>>>>>>>>>>> input program will finish running or not.
>>>>>>>>>>>>
>>>>>>>>>>>> Your POOH does not accept any input except the hard-coded D
>>>>>>>>>>>> (as if it
>>>>>>>>>>>> were an input). This is like I ask for the color of the car
>>>>>>>>>>>> and you
>>>>>>>>>>>> reply with the time on the wall.
>>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> It is a verified fact that D correctly simulated by H cannot
>>>>>>>>>>> possibly halt.
>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> *** The Halting Problem asks for a program that determines
>>>>>>>>>> whether an
>>>>>>>>>> given input program will finish running or not.***
>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> You kept answering the time on the wall !!!
>>>>>>>>>>
>>>>>>>>>> What does your H,D have anything to do with the Halting Problem?
>>>>>>>>>> Your POOH does not decide any given input !!!
>>>>>>>>>
>>>>>>>>> MIT Professor Michael Sipser agreed that this verbatim
>>>>>>>>> paragraph is correct
>>>>>>>>> (a) If simulating halt decider H correctly simulates its input
>>>>>>>>> D until H correctly determines that its simulated D would never
>>>>>>>>> stop running unless aborted then
>>>>>>>>> (b) H can abort its simulation of D and correctly report that D
>>>>>>>>> specifies a non-halting sequence of configurations.
>>>>>>>>>
>>>>>>>>> He is the author of the best selling book on the theory of
>>>>>>>>> computation.
>>>>>>>>> *D correctly simulated by H would never stop running unless
>>>>>>>>> aborted*
>>>>>>>>> (More precisely D correctly simulated by H cannot possibly halt)
>>>>>>>>>
>>>>>>>>> https://www.amazon.com/Introduction-Theory-Computation-Michael-Sipser/dp/113318779X
>>>>>>>>>
>>>>>>>>
>>>>>>>> If it were true (hardly true), you read a wrong book. See Peter
>>>>>>>> Linz's book.
>>>>>>>
>>>>>>> I contacted Professor Sipser directly and still have his
>>>>>>> 10/13/2022 11:29:23 AM email agreeing to the verbatim words
>>>>>>> of that paragraph.
>>>>>>>
>>>>>>
>>>>>> 1. This is a serious lie, be careful.
>>>>>> 2. If it were true, it is still nothing to the Halting Problem.
>>>>>
>>>>> *There is a long conversation about this in comp.theory*
>>>>>
>>>>> [Michael Sipser of MIT validates the notion of a simulating halt
>>>>> decider]
>>>>>
>>>>> On 10/13/2022 11:46 AM, olcott wrote:
>>>>>  > 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.
>>>>>
>>>>>
>>>>
>>>> If what you said were true, you believed words of an idiot. However,
>>>> this is not important.
>>>>
>>>
>>> Professor Sipser is the #1 best selling author of Theory of
>>> Computation textbooks
>>>
>>>> The Halting Problem asks for a program that determines whether an given
>>>> input program will finish running or not.
>>>>
>>>
>>> *Yes and the directly executed D(D) IS NOT A FREAKING INPUT*
>>>
>>>> The Halting Problem asks for a program that determines whether an given
>>>> input program will finish running or not.
>>>>
>>>
>>> *Yes and the directly executed D(D) IS NOT A FREAKING INPUT*
>>>
>>>> The Halting Problem asks for a program that determines whether an given
>>>> input program will finish running or not.
>>>>
>>>
>>> *Yes and the directly executed D(D) IS NOT A FREAKING INPUT*
>>>
>>>
>>
>> D is a function you selected, you already know everything about it
>> inside out.
>>
>> POOH is not a halting decider.
>> The Halting Problem asks for a program that determines whether an given
>> input program will finish running or not.
>>
>> POOH is not a halting decider.
>> The Halting Problem asks for a program that determines whether an given
>> input program will finish running or not.
>>
>
> H does not *RELY* on that.
> There are all kinds of different sample inputs that H works with.
>
>

On 1/12/24 20:01, olcott wrote:
> On 1/12/2024 10:40 AM, immibis wrote:
>> On 1/12/24 15:24, olcott wrote:
>>> On 1/12/2024 12:43 AM, immibis wrote:
>>>>
>>>> The correct simulation of D by H is the same simulation you get when
>>>> you simulate D by H1.
>>>>
>>>
>>> It would be a deception to show the correct simulation of D by H1,
>>> as the correct simulation of D by H.
>>
>> It is like saying the correct proof that 1+1=2 is the one which Lisa
>> Simpson knows.
>
> This is the same as I ask you: "What time is it?"
> and you answer with the color of your car.
>

No, it's like I ask you "what's the execution trace?" and you answer
"it's the one in my github repository."

On 1/12/24 23:08, olcott wrote:
> On 1/12/2024 3:55 PM, wij wrote:
>>
>> You kept answering the time on the wall !!!
>>
>> What does your H,D have anything to do with the Halting Problem?
>> Your POOH does not decide any given input !!!
>
> MIT Professor Michael Sipser agreed that this verbatim paragraph is correct
> (a) If simulating halt decider H correctly simulates its input D until H
> correctly determines that its simulated D would never stop running
> unless aborted then
> (b) H can abort its simulation of D and correctly report that D
> specifies a non-halting sequence of configurations.
It's correct. The H you wrote is different from the H in the paragraph.
Calling two different programs by the same letter doesn't make them the
same.