Re: Simulating Termination Analyzer HHH correctly rejects input DDD

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

On 10/9/2024 1:08 AM, Jeff Barnett wrote:

On 10/8/2024 6:49 AM, Andy Walker wrote:

... after a short break.
>
     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.
>
     Peter -- you surely have better things to do.  No-one sensible
is reading the repetitive stuff.  Decades, and myriads of articles, ago
people here tried to help you knock your points into shape, but anything
sensible is swamped by the insults.  Free advice, worth roughly what you
are paying for it:  step back, and summarise [from scratch, not using HHH
and DDD (etc) without explanation] (a) what it is you think you are trying
to prove and (b) what progress you claim to have made.  No more than one
side of paper.  Assume that people who don't actively insult you are, in
fact, trying to help.

>
And this approach has been tried many times. It makes no more progress than the ones you are criticizing. Just assume the regulars are lonesome, very lonesome and USENET keeps everybody off the deserted streets at night.

 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.

But fails, because you provided it with a proven incorrect pattern

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

Which isn't a correct analysis (but of course, that is just what you do)
Since we know that HHH(DDD) returns 0, it can not be a non-terminating behaivor, but that claim is just a lie.

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

Right, one can not ignore the fact that HHH(DDD) is determined to return 0.

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

More lies. It has been determined that EVERY DDD that calls an HHH(DDD) that returns 0 will halt.
The DDDs that don't return are the ones that call an HHH that never returns an answer.
Your logic is just looking at your LIE based on the fact that the PARTIAL EMULATION BY HHH doesn't reach the end, and in your stupidity you confuse the lack of knowledge in HHH of the terminatation to a factual concept that HHH doesn't.
I guess this meams that you support the claims of Donald Trump that he "won the election" and of the climate change deniers, as they use the same basic logic as you do.
Sorry, but that IS the camp you have placed your self into.

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

Nope, just that you are a liar.

 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.
 

Nope. Proves that DDD() will halt when HHH(DDD) returns 0 and thus that HHH is incorrect.
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