Re: Mike Terry Proves --- How the requirements that Professor Sipser agreed to are exactly met

On 5/20/25 3:12 PM, olcott wrote:

On 5/20/2025 12:51 PM, Fred. Zwarts wrote:

Op 20.mei.2025 om 16:22 schreef olcott:

On 5/20/2025 2:00 AM, Mikko wrote:

On 2025-05-20 04:10:54 +0000, olcott said:
>

On 5/19/2025 5:12 AM, Mikko wrote:

On 2025-05-18 19:18:21 +0000, olcott said:
>

On 5/18/2025 2:08 PM, joes wrote:

Am Sun, 18 May 2025 12:28:05 -0500 schrieb olcott:

On 5/18/2025 10:21 AM, Mike Terry wrote:

On 18/05/2025 10:09, Mikko wrote:

On 2025-05-17 17:15:14 +0000, olcott said:

>

HHH(DDD) does not base its decision on the actual behavior of DDD
after it has aborted its simulation of DDD, instead it bases its
decision on a different HHH/DDD pair that never aborts.

>
This is why HHH does not satisfy "H correctly determines that its
simulated D would never stop running unless aborted". If HHH bases its
decision on anything else than what its actual input actually
specifies it does not decide correctly.
>

Right.  It seems to be a recent innovation in PO's wording that he has
started using the phrase "..bases its decision on a different *HHH/DDD
pair* ..".
>

Thus SHD must report on a different SHD/Infinite_Loop pair where this
hypothetical instance of itself never aborts.

This, the simulator. The input still calls the same real aborting HHH.
>

If H always reports on the behavior of its simulated input after it
aborts then every input including infinite_loop would be determined to
be halting.

Yes, that is why H is wrong.
>

Instead H must report on the hypothetical H/D input pair where the very
same H has been made to not abort its input.

Just no.
>

*H correctly determines that its simulated D*
*would never stop running unless aborted*
by a hypothetical instance of itself that never aborts.

H does stop running when simulated without aborting, because it aborts.
>

>
H is required to report on the behavior of D in the
case where a hypothetical instance of itself never
aborts its simulated D.
>
When the hypothetical H never aborts its simulated D then:
(a) Simulated D  NEVER HALTS
(b) Executed D() NEVER HALTS
(c) Executed H() NEVER HALTS
(d) Everything that H calls NEVER HALTS

>
You forgot
(e) H does not report

>
HHH is required to report, that is why it
must always report on the behavior of the
hypothetical H/D pair and not the actual
behavior of the actual H/D pair for every
non-terminating input.

>
Every decider is required to report. But your (c) above prevents the
hypothetical H from reporting. Therefore the hypothetical H is not a
decider.
>

>
I wish that people would pay attention.
People only glance at a couple of words that I say
then artificially contrive a fake rebuttal.
>
*We are ONLY measuring HHH/DDD against this criteria*
<MIT Professor Sipser agreed to ONLY these verbatim words 10/13/2022>
     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
>

>
We use the same criteria. We see that there is no correct simulation and that H does not correctly determine that its simulated D would never stop running. In fact the input specified to H contains code to abort, so a simulation of this input without abort would lead to a natural halt.
>

 That is merely your lack sufficient software skills.
(a) The outermost (directly executed) HHH sees its
abort criteria met one whole execution trace before
the next inner one.

No it doesn't. It may THINK it has, but it hasn't.

 (b) Every instance of HHH is the same machine code at
the same address thus each HHH has the same behavior.
 (c) Unless the outer HHH aborts its simulation then
none of them do because they all have the same machine
code.
 

But since the outer one DOES, as that is apparently the code that it has, then they all will, and thus all are halting.
HHH needs to look at the input that is there, and that must have the HHH that aborts and returns, as that *IS* the HHH that is there.
Of course, to even do that we neec to fix your DDD to be a program, otherwise HHH can't emulate it past the call instruction.
Here you seem to be violating your stipulation that DDD is just the code of the C function, but now it includes all of the code that it uses (and thus will always be the code for the HHH that gives the final answer, so any "Hypothetical HHH" has to go elsewhere and not disturb the input.