Re: And the Richer Petard Horror Show resumes HHH(DDD)==0

On 10/8/24 9:43 AM, olcott wrote:

On 10/8/2024 7: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.
>

 Thanks for that part.
 

     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.
>

 Most people that "try to help" do so only within the
foundational false assumption that I must be incorrect.

It isn't a "false assumption"
You have made it clear that you are using wrong definitions of words, and thus, when claimed to be in the field you say you are working in, ARE false assumptions.

 The DDD / HHH model is the simplest essence of my key points.
It only requires knowledge of software engineering thus
requires no knowledge of computer science.

And your model of DDD and HHH is based on an incorrect definition of a Program, as you don't consider DDD to include the HHH that it calls.
Thus, your model is just an incorrect lie.

 This is the foundational axiom of my proof:
*Terminating is a property of finite string machine descriptions*

But it must be of the full program, which yours isn't.
Thus, your proof is based on a FALSE ASSUMPTION, that DDD can be described by a finite-string that doesn't fully describe it.

 When I make key clarifications as I have made below those only
glancing at what I say never notice these key clarifications.
 *Simulating Termination Analyzer HHH(DDD) rejects input DDD*
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.

Except that it doesn't detect a correct non-terminating behavior pattern, as that pattern exists in a terminating program, namely this DDD

 HHH recognizes this pattern when HHH emulates itself emulating DDD
 

Which isn't a corrrect pattern, as since HHH *DOES* abort its emulation and return, so does DDD.

void DDD()
{
   HHH(DDD);
   return;
}
 *Terminating is a property of finite string machine descriptions*
One cannot simply ignore the actual behavior specified by the
finite string such that

Right, and since HHH(DDD) represents an actual call to HHH with the parameter of DDD, and since this actual HHH will return 0 for that parameter, the ONLY correct understanding of that call is that it returns 0.

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

No, again you are repeating you same idiotic mistake.
Each of those DDD does return, just after the HHH that was partially emulating it aborted its emulation, because that HHH(DDD) return 0.
You confuse the behavior of the program DDD, that being the actual behavior of ALL the code used by that DDD, that DDD being selected by what DDD HHH was emulating, with the behavior of HHH, as determined by the behavior of its partial emulation of the DDD it was given.
Answering the wrong question is a good way to get the wrong answer.
Of course, you are answering the wrong question because you have chosen to be ignorant of the actual meaning of the words, and have been lying to yourself about what they acutally mean, turning yourself into the ignorance pathological lying idiot you have become.

 Thus each of these HHH emulators that does return 0 correctly
reports the above non-terminating behavior.

Nope, since the actual DDD will return, the only correct answer for HHH to return would be 1
You are just stuck in your false idea that it is ok to lie if that is all you can think to do.

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

And is wrong, and the fact you repeat that claim after being shown this fact show 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 THAT IS JUST OK.