Re: V5 --- Professor Sipser

On 8/22/24 1:22 PM, olcott wrote:

On 8/22/2024 11:59 AM, joes wrote:

Am Thu, 22 Aug 2024 08:36:33 -0500 schrieb olcott:

On 8/22/2024 8:21 AM, joes wrote:

Am Thu, 22 Aug 2024 07:59:59 -0500 schrieb olcott:

On 8/22/2024 3:16 AM, Fred. Zwarts wrote:

Op 22.aug.2024 om 06:22 schreef olcott:

<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 H can abort its simulation of D
       and correctly report that D specifies a non-halting sequence of
       configurations.
</MIT Professor Sipser agreed to ONLY these verbatim words 10/13/2022>
We swap the word "determines" for "predicts"
When we swap thew word "halt decider" for "termination analyzer" the
above is translated from computer science into software engineering.

bla bla

The second half proves that this is the H that aborts that is making
the prediction of the behavior of D when emulated by a hypothetical
version of itself then never aborts.

But still emulating a D that calls an aborting H.
>

THIS EXACTLY MATCHES THE SIPSER APPROVED CRITERIA The finite
HHH(DDD)
emulates itself emulating DDD exactly once and this is sufficient
for this HHH to predict what a different HHH(DDD) do that never
aborted its emulation of its input.

But that different hypothetical HHH is a non-input.

It is also not the simulator (since they are the same).

HHH is supposed to predict what the behavior of DDD would be if it did
not abort its emulation of DDD that is what the words that Professor
agreed to mean.

If IT didn’t abort DDD calling its aborting self.

I don't know how you twist words to get that. HHH is required to predict
the behavior of DDD as if every HHH had its abort code removed.

No; only if the same goes for the outermost one (but that doesn’t halt).
Otherwise it is not simulating itself.
>

 It <is> emulating the exact same code at the exact same
machine address exactly twice.

Which isn't a *CORRECT EMULATION* of the input PROGRAM wich calls HHH so HHH needs to emulate THAT, not DDD again.

 

Do you still not understand that HHH should predict the behaviour of
its input? Why does the HHH have an input, if it is correct to
predict the behaviour of a non-input?
Are you still cheating with the Root variable to change the input in
a non-input?