Re: HHH(DDD)==0

On 10/9/24 7:06 AM, olcott wrote:

On 10/9/2024 5:08 AM, Mikko wrote:

On 2024-10-09 03:47:10 +0000, olcott said:
>

On 10/8/2024 7:49 AM, Andy Walker wrote:
 > Richard -- no-one sane carries on an extended discussion with
 > someone they [claim to] consider a "stupid liar".  So which are you?
 > Not sane?  Or stupid enough to try to score points off someone who is
 > incapable of conceding them?  Or lying when you describe Peter?  You
 > must surely have better things to do.  Meanwhile, you surely noticed
 > that Peter is running rings around you.
>
I am incapable of conceding this self-evident truth:
>
   DDD emulated by each corresponding HHH that can possibly
   exist never returns

>
That is not self-evident or even meaningful without a definition of
"each corresponding HHH".
>

An HHH/DDD pair such that DDD calls its own emulator.

Thus additting that each of those DDD are different, and that HHH must look at the exact DDD that calls it, which means that the HHH(DDD) that it sees being called will do what it does.

 HHH is an emulating termination analyzer that takes the machine
address of DDD as input then emulates the x86 machine language
of DDD until a non-terminating behavior pattern is recognized.

Or a false pattern that you have put into the list.

 HHH recognizes this pattern when HHH emulates itself emulating DDD
 void DDD()
{
   HHH(DDD);
   return;
}

Which is the false pattern.
Since it was specified that this HHH is the same HHH as is currently running, and eventually we will see that this HHH(DDD) will return 0, we know as a proven fact that that HHH(DDD) will do also, and thus it is just a LIE that this patterns shows non-terminating behavior.

 One cannot simply ignore the actual behavior specified by the
finite string x86 machine language of DDD such that

Right, and that is that HHH(DDD) returns 0, and thus this string must represent a halting decider.
That you try to make this HHH(DDD) refer to some other program just shows that you are nothing but a liar.

 DDD emulated by each corresponding HHH that can possibly
exist never returns

Execpt that it does, proving you are just an idiotic liar.
You just confuse the actual DDD with the "fantasy" of the partial emulation of DDD by HHH, that you do because you dopn't understand what either Truth or Knowledge actually are and just muddle them to try to justify your lies.

 thus each of the directly executed HHH emulators that does
return 0 correctly reports the above non-terminating behavior.

Which is a lie, since we showed that the above was NOT non-terminationg behavior, but the product of a liar that doesn't know what he is talking about.

 https://github.com/plolcott/x86utm x86utm operating system
 Every executed HHH that returns 0 correctly reports that
DDD emulated by its corresponding HHH never returns.
 

You are just showing that
PPPP   EEEEE  TTTTT  EEEEE  RRRR
P   P  E        T    E      R   R
P   P  E        T    E      R   R
PPPP   EEEEE    T    EEEEE  RRRR
P      E        T    E      R R
P      E        T    E      R  R
P      EEEEE    T    EEEEE  R   R
  OOO   L       CCC    OOO   TTTTT  TTTTT
O   O  L      C   C  O   O    T      T
O   O  L      C      O   O    T      T
O   O  L      C      O   O    T      T
O   O  L      C      O   O    T      T
O   O  L      C   C  O   O    T      T
  OOO   LLLLL   CCC    OOO     T      T
L     IIIII  EEEEE   SSS
L       I    E      S   S
L       I    E      S
L       I    EEEEE   SSS
L       I    E          S
L       I    E      S   S
LLLLL IIIII  EEEEE   SSS
AND THINKS IT IS OK