Re: Defining a correct halt decider

Op 04.sep.2024 om 16:03 schreef olcott:

On 9/4/2024 5:40 AM, Fred. Zwarts wrote:

Op 03.sep.2024 om 21:54 schreef olcott:

On 9/3/2024 1:53 PM, joes wrote:

Am Tue, 03 Sep 2024 08:17:56 -0500 schrieb olcott:

On 9/3/2024 3:44 AM, Mikko wrote:

On 2024-09-02 16:06:11 +0000, olcott said:
>

A correct halt decider is a Turing machine T with one accept state and
one reject state such that:
If T is executed with initial tape contents equal to an encoding of
Turing machine X and its initial tape contents Y, and execution of a
real machine X with initial tape contents Y eventually halts, the
execution of T eventually ends up in the accept state and then stops.
If T is executed with initial tape contents equal to an encoding of
Turing machine X and its initial tape contents Y, and execution of a
real machine X with initial tape contents Y does not eventually halt,
the execution of T eventually ends up in the reject state and then
stops.

Your "definition" fails to specify "encoding". There is no standard
encoding of Turing machines and tape contents.
>

That is why I made the isomorphic x86utm system.
By failing to have such a concrete system all kinds of false assumptions
cannot be refuted.

What would those assumptions be?
>

The behavior of DDD emulated by HHH** <is> different than the behavior
of the directly executed DDD** **according to the semantics of the x86
language

How can the same code have different semantics?
>

>
The pathological relationship between DDD and HHH really
cannot be simply ignored as if it does not exist.
>

HHH is required to report on the behavior tat its finite string input
specifies even when this requires HHH to emulate itself emulating DDD.

 > The input specifies an aborting HHH - which you don’t simulate.>
>
void DDD()
{
   HHH(DDD);
   OutputString("This code is unreachable by DDD emulated by HHH");
}
>

DDD never halts unless it reaches its own final halt state. The fact
that the executed HHH halts has nothing to do with this.

Other than that DDD calls HHH?
>

HHH is not allowed to report on the computation that itself is contained
within.

Then it is only partial, and doesn’t even solve the case it was built for.
>

>
int sum(int x, int y);
sum(3,4) is not allowed to report on the sum of 5 + 6
for the same reason. HHH(DDD) cannot report on behavior
that it cannot see.

>
Exactly, so it should not report on halting behaviour if its stops the simulation before the simulation could halt.

 It is very stupid to say that when this proves that DDD emulated by HHH
cannot possibly reach its final halt state.

If it should, but it couldn't then it just failed.
HHH always fails to simulate itself correctly up to the end.
No matter how you try to fix HHH, it will always fail to simulate itself correctly up to the end.
If you don't agree, show how HHH can simulate itself correctly up to the end.