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.
--- SoupGate-Win32 v1.05
* Origin: fsxNet Usenet Gateway (21:1/5)