On 10/11/24 11:35 AM, olcott wrote:
On 10/11/2024 8:14 AM, Richard Damon wrote:
On 10/11/24 8:41 AM, olcott wrote:
On 10/11/2024 4:47 AM, Mikko wrote:
On 2024-10-11 01:55:37 +0000, olcott said:
On 10/9/2024 6:48 PM, Richard Damon wrote:
On 10/9/24 2:46 PM, olcott wrote:
On 10/9/2024 6:46 AM, Richard Damon wrote:
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 weasel words are in incorrect paraphrase of this*
WHAT PARAPHARSE.
DDD emulated by each corresponding HHH that can possibly
exist never returns
No, that means the behavior of the code of DDD when directly
executed. or youy are lying about working on the Halting Problem.
It seems to me that you just said that:
the behavior of DDD emulated by HHH
<is not>
the behavior of DDD emulated by HHH.
At least one could say so because the exptession "the behaviour of DDD >>>> emulated by HHH" can be interpreted in two ways.
It can be interpreted an infinite number of ways when the requirement
that the interpretation be correct is dropped.
And, the only CORRECT interpretation goes by the DEFINITIONS of the
words, which means that "non-termination" is a property of a complete
program (which your "finite-string" for DDD does not express) and that
said program never reaches a terminal state even after an unbounded
number of steps, which this HHH's emulation doesn't do.
So, you are just proving yourself to be a blatant liar.
The x86 machine code of DDD and HHH provides the single correct
way to interpret DDD emulated by HHH.
Right, and that machine code needs to INCLUDE the machine code of HHH,
The source code has always proved that HHH does correctly
emulate itself emulating DDD.
No, it shows that HHH is first NOT a proper decider because it is not a
pure function of its input, because it looks into global memory for
special values.
Second, it does not "correctly emulate" per the definition of comutation
theory where the unadorned term means a COMPLETE emulation that exactly
matches the behavior of the direct execution of the program, thus
omitting the modifier "paertial" makes the statement just a lie,
Thirdly, it decision is being made on an instruction NOT EMULATED, in "deciding" that the instruction "call HHH" will not return, not based on
any truely factual basis, but on the logic that if HHH was a different
program, that doesn't abort, and thus the full code of the actual
program DDD wasn't the full code given to this HHH, that it would a
certain way, and thus it turns out that HHH is basing it decision on an INCORRECT emulation of that instruction.
It also proves that your whole arguement if filled with equivocations
where terms with technical meaning are at times interpreted in other
manners, but the conclusion claimed to apply to the original meaning
that wasn't used.
In other words, your arguement is just built on LIES.
Your negligence in making counter-factual statements to
the contrary on the basis of not bothering to examine this
source-code has always been libelous.
Nope, my claims are FACTUAL, and based on an examination of the code
Your claims are thus proven to by LIES.
Fully operational code is here. https://github.com/plolcott/x86utm/blob/master/Halt7.c
Right, which I have down loaded and examined and determined the errors
that I have pointed out.
Sorry, you are just proving yourself a liar, in part because you don't understand the technical meaning of the terms you are using.
--- SoupGate-Win32 v1.05
* Origin: fsxNet Usenet Gateway (21:1/5)