Re: Defining a correct halt decider

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.
HHH cannot correctly report on the AFTER-THE-FACT
behavior that it has aborted its simulation BEFORE-THE-FACT.

Except for the case of pathological self-reference the behavior of the
directly executed machine M is always the same as the correctly
simulated finite string ⟨M⟩.

That sure sounds like a mistake to me.
 

THE EXECUTION TRACE HAS ALWAYS PROVED THAT I AM CORRECT
FOR THREE FREAKING YEARS all the way back when it was
P correctly emulated by D.
I initially took disagreeing with this as despicable
lying bastards playing sadistic head games.
I called Ben this and that is why he is mad at me.
In retrospect it seems that people are so deeply indoctrinated
into the received view that when raw facts stare them right in
the face they honestly cannot see these facts.

That no one has noticed that they can differ does not create an axiom
where they are not allowed to differ.

They were never allowed, that was the definition.
 

When you make a definition that "cows" <are> "airplanes"
gullible sheep will accept it as true.
When you make a definition that halt deciders compute the
mapping from their inputs to the behavior that these inputs
specify
and textbooks say things that seem to disagree with definition
then gullible sheep will agree with the textbooks.

No one noticed that they differ only because everyone rejected the idea
of a simulating halt decider out-of-hand without review.

I think after 3 years that excuse has grown a bit stale.
 

IT REMAINS A VERIFIED FACT THAT DDD EMULATED BY HHH CANNOT
POSSIBLY REACH ITS OWN FINAL HALT STATE, AND PEOPLE STILL
FREAKING LIE EVEN ABOUT THIS MAXIMALLY DUMBED DOWN VERSION:
HHH/DDD OF THIS:
// Original H/P
int P()
{
   int Halt_Status = H(P,P);
   if (Halt_Status)
     HERE: goto HERE;
   return Halt_Status;
}
For three freaking years the gullible sheep on this forum continue
to believe that the pathological relationship of the decider to its input does not change the behavior of this input
*EVEN WHEN IT IS CONCLUSIVELY PROVED THAT IT DOES CHANGE THIS BEHAVIOR*
*EVEN WHEN IT IS CONCLUSIVELY PROVED THAT IT DOES CHANGE THIS BEHAVIOR*
*EVEN WHEN IT IS CONCLUSIVELY PROVED THAT IT DOES CHANGE THIS BEHAVIOR*
--
Copyright 2024 Olcott "Talent hits a target no one else can hit; Genius
hits a target no one else can see." Arthur Schopenhauer