Professor Sipser is not aware that he agreed with the essence of my
proof. What he did agree to is a single paragraph on page one of my
paper linked below. This paragraph is the essence of my proof.

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

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.

People that are not Hell bent on being disagreeable realize that the
paragraph that professor Sipser agreed to is a tautology.

People that are Hell bent on being disagreeable indicate that a
simulation is not necessarily correct even if the simulator does
correctly simulate the exact instructions that are specified by the
machine code being simulated.

I challenge them to provide an example of a specific line of machine
code showing this and they dodge because they already know that what
they said is not true.

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

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

olcott
This first sentence is an established fact: When H(D,D) correctly
simulates its input the execution trace of this simulated input proves
that it would never stop running because D continues to call H in
recursive simulation. Then H aborts its simulation of D and returns 0 to
main, indicating that D would never stop running unless aborted. Is H
correct?

ChatGPT
It is a well-established fact that the program H is a variant of the
classic example of the "halting problem", which is used to demonstrate
that there is no general algorithm that can determine, for any given
program and input, whether or not that program halts on that input. In
the specific code you provided, the function D calls itself recursively
through the function H, creating an infinite loop that never halts.
Therefore, if the function H correctly simulates the behavior of D, it
should correctly determine that D never halts, and return 0 to main. So
in this case, H is correct.

Simulating Halt Decider Applied to the Halting Theorem
https://www.researchgate.net/publication/364657019_Simulating_Halt_Decider_Applied_to_the_Halting_Theorem

--
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/27/23 7:07 PM, olcott wrote:
> Professor Sipser is not aware that he agreed with the essence of my
> proof. What he did agree to is a single paragraph on page one of my
> paper linked below. This paragraph is the essence of my proof.
>
> MIT Professor Michael Sipser has agreed that the following verbatim
> paragraph is correct (he has not reviewed or agreed to anything else):
>
>     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.
>
> People that are not Hell bent on being disagreeable realize that the
> paragraph that professor Sipser agreed to is a tautology.
>
> People that are Hell bent on being disagreeable indicate that a
> simulation is not necessarily correct even if the simulator does
> correctly simulate the exact instructions that are specified by the
> machine code being simulated.
>
> I challenge them to provide an example of a specific line of machine
> code showing this and they dodge because they already know that what
> they said is not true.
>
> void D(void (*x)())
> {
>   int Halt_Status = H(x, x);
>   if (Halt_Status)
>     HERE: goto HERE;
>   return;
> }
>
> int main()
> {
>   Output("Input_Halts = ", H(D, D));
> }
>
> olcott
> This first sentence is an established fact: When H(D,D) correctly
> simulates its input the execution trace of this simulated input proves
> that it would never stop running because D continues to call H in
> recursive simulation. Then H aborts its simulation of D and returns 0 to
> main, indicating that D would never stop running unless aborted. Is H
> correct?
>
> ChatGPT
> It is a well-established fact that the program H is a variant of the
> classic example of the "halting problem", which is used to demonstrate
> that there is no general algorithm that can determine, for any given
> program and input, whether or not that program halts on that input. In
> the specific code you provided, the function D calls itself recursively
> through the function H, creating an infinite loop that never halts.
> Therefore, if the function H correctly simulates the behavior of D, it
> should correctly determine that D never halts, and return 0 to main. So
> in this case, H is correct.
>
> Simulating Halt Decider Applied to the Halting Theorem
> https://www.researchgate.net/publication/364657019_Simulating_Halt_Decider_Applied_to_the_Halting_Theorem
>

So, you can confuse the AI just like you have done to yourself.

You still haven't answerd my question, which shows you don't HAVE an
answer and you whole arguement is smoke and mirrors.

Your published code shows that H(D,D) WILL return 0 whether main calls
D(D) which calls H(D,D) and thus D(D) halts, or it main cals H(D,D)
directly,

THus the correct answer to the Halting question is Halting, and thus H
is wrong.

Until you show where that logic is in error, you are just a LIAR.

A Damned Hypocritical Pathological Lying Idiot in particular.