Re: Richard given an official cease-and-desist order regarding counter-factual libelous statements

On 10/11/24 5:44 PM, olcott wrote:

On 10/11/2024 4:31 PM, Richard Damon wrote:

On 10/11/24 5:09 PM, olcott wrote:

On 10/11/2024 3:21 PM, Richard Damon wrote:

On 10/11/24 1:31 PM, olcott wrote:

On 10/11/2024 12:10 PM, Richard Damon wrote:

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

>
The source-code conclusively proves that HHH does correctly
emulate itself emulating DDD. No matter how you deny this
your denial of these exact details <is> libelous.
>
*This is to be taken as an official cease-and-desist order*
>

>
GO ahead an TRY.
>
The counter-suit would ruin you.
>
And, you would need to persuade some lawyer to take your case to even start, and I suspect that would be difficult considering your case.
>
I suspect that in the first deposition you would just create obvious contradiction making you guilty of perjury.
>
Your source code proves that HHH doesn't "Correctly Simulate" per the standard needed to determine halting, as partial simulation are no
>

>
Within software engineering (C and x86 code, not Turing machines)
HHH does correctly emulate itself emulating DDD according to the
semantics of the x86 language.
>
No matter how you try to rebut this verified fact you would meet
the negligence requirement of defamation suits.
https://www.law.cornell.edu/wex/defamation

>
>
Which means for you to claim defamation, you need to prove that my statements are actually false.
>
Since I can show that you statement are incorrect, that can't be shown.
>
Your conclusion can NOT come from your premises except by relying on equivocation, and thus your statement is not correct, and calling it wrong is not a lie, so can not be defamitory.
>

 void DDD()
{
   HHH(DDD);
   return;
}
 I already have several expert witnesses that have attested
to the fact that DDD emulated by the same HHH that it calls
cannot possibly return.

And what do you do when I present the output from your own program that shows that DDD returns.
Then present the definition of Halting as being about the machine itself, and that the definition of the Halting Problem is about the behavior of the machine defined by the input.
And thus, the fact that a partial emulation by HHH does not show that its input is non-halting, especially when the input is halting
Remeber, I HAVE pointed out that if you are willing to admit that you aren't actually talking about the halting problem, and that your results can't just be claimed to work on them, we could look at your alternate theory, but you have refused to release your claim on the theory, because, everyone knows that is where you are trying to go to.

 Maybe suing you for defamation will garner the publicity
that I need. My cancer has gotten worse and the medicine
that they want to put me on may be too risky.

Or make you the laughing stock as you need to testify UNDER OATH about your ideas, where you are questioned DIRECTLY about your ideas.
Remember, in court, you can't just not answer the direct questions.

 

You also need to show a damage to your reputation. You do enough to damage it that my words do not make it worse, I just point out the error im your own words, so maybe you should sue YOURSELF for the defamation.
>

>
When I specify the standard of measure and you use the strawman
error to try to get way with changing the standard of measure
this <is> negligence.

>
You may specify the standard of measure you want to use, but you do it in a way that is internally inconsistent, and in contradiction to your claimed result, which makes it invalid.
>
Pointing out your error is NOT "libalous".
>
>

>

In fact, you source code proves that you claims about it are just lies, as it is not the pure function you claim it to be.
>
>

>
>

>