Re: Two dozen people were simply wrong ---

Op 02.jun.2024 om 21:10 schreef olcott:

On 6/2/2024 2:01 PM, Fred. Zwarts wrote:

Op 02.jun.2024 om 20:57 schreef olcott:

On 6/2/2024 1:51 PM, Fred. Zwarts wrote:

Op 02.jun.2024 om 20:37 schreef olcott:

On 6/2/2024 1:16 PM, Fred. Zwarts wrote:

Op 02.jun.2024 om 16:58 schreef olcott:

On 6/2/2024 4:36 AM, joes wrote:

Am Sat, 01 Jun 2024 17:37:28 -0500 schrieb olcott:
>

On 6/1/2024 5:30 PM, Richard Damon wrote:

On 6/1/24 5:27 PM, olcott wrote:

On 6/1/2024 4:15 PM, Richard Damon wrote:

On 6/1/24 4:35 PM, olcott wrote:

On 6/1/2024 3:29 PM, Richard Damon wrote:

On 6/1/24 12:46 PM, olcott wrote:

On 6/1/2024 11:33 AM, Richard Damon wrote:

On 6/1/24 12:18 PM, olcott wrote:

On 6/1/2024 11:08 AM, Richard Damon wrote:

On 6/1/24 11:58 AM, olcott wrote:

On 6/1/2024 10:46 AM, Richard Damon wrote:

On 6/1/24 10:00 AM, olcott wrote:

>

Every DD correctly simulated by any HH of the infinite set of HH/DD
pairs that match the above template never reaches past its own
simulated line 03 in 1 to ∞ steps of correct simulation of DD by HH.

>
But since the simulation was aborted,

>
*The above never mentions anything about any simulation being aborted*

Not simulating an infinite number of steps of infinite recursion is
incorrect. You always forget this requirement: the simulation must be
complete.

>
When every possible simulation where DD is correctly simulated by HH
never reaches past its own simulated line 03 then we know for sure that
No DD correctly simulated by HH ever halts.

>
Similarly:
>
When every possible simulation where HH is correctly simulated by itself
never reaches its own return then we know for sure that no HH correctly simulated by HH ever halts.
>

>
*I am not going to keep repeating myself, I will simply give up on you*
>
HH(DD,DD) correctly detects that DD correctly simulated by HH cannot
possibly halt because HH keeps calling HH(DD,DD) in recursive
simulation.

>
Similarly HH(DD,DD) correctly detects that HH correctly simulated by HH cannot possibly halt, because HH keeps calling HH(DD,DD) in recursive
simulation.
>

>
HH(DD,DD) correctly simulates DD(DD) that calls HH(DD,DD) in recursive
simulation proving that the directly executed HH(DD,DD) can correctly
reject its input as non-halting.
>
MIT Professor Michael Sipser agreed this verbatim paragraph is correct
(He has neither reviewed nor agreed to anything else in this paper)
>
<Professor Sipser agreed>
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.
</Professor Sipser agreed>
>
The above criteria provides the basis for a correct solution to the halting problem.
>

>
If so, it proves that HH correctly reports that HH does not halt.

 DD simulated by HH cannot halt because it continues to call HH(DD,DD) in recursive simulation until the directly executed HH sees the repeating state of DD and stops its simulation.

HH simulated by HH cannot halt because it continues to start a new simulation of DD in recursive simulation until the directly executed HH sees the repeating state of HH and stops its simulation.
Note, at the moment that DD calls HH in the outer simulation, then HH is in a 'repeated state', but at that same moment DD is not yet in a 'repeated state'. (DD will be in a 'repeated state' later when the called HH starts a new simulation of DD.) This shows that it is first HH that finds itself in a 'repeated state'. It is HH that starts to repeat. Because of that DD repeats, but only because HH repeats.

 The directly executed HH must halt.

Then a correct simulation of HH would also halt. If not, then either the simulation is wrong, or HH does not halt.

Because DD correctly simulated
by HH calls HH(DD,DD) in recursive simulation both the simulated DD
and the simulated HH remain stuck in recursive simulation.
 

But HH correctly simulated by HH starts a new simulation of DD in recursive simulation, therefore both the simulated HH
and the simulated DD remain stuck in recursive simulation.
This shows that DD does not halt, because HH does not halt.