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:But fails, because you provided it with a proven incorrect >>>>>>>>>> pattern
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. >>>>>>>>>>
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*
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:But fails, because you provided it with a proven incorrect >>>>>>>>>>>> pattern
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. >>>>>>>>>>>>
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
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.
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.
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:But fails, because you provided it with a proven incorrect >>>>>>>>>>>> pattern
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. >>>>>>>>>>>>
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
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.
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.
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:WHAT PARAPHARSE.
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:HHH is an emulating termination analyzer that takes the >>>>>>>>>>>>>>> machine
... 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. >>>>>>>>>>>>>>>
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* >>>>>>>>>>>>
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.
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.
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.
On 10/11/2024 4:55 PM, Richard Damon wrote:
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:WHAT PARAPHARSE.
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* >>>>>>>>>>>>>>
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.
void DDD()
{
HHH(DDD);
return;
}
There are a pair of C functions having x86 code that
specifies that DDD correctly emulated by HHH cannot
possibly return.
Two software engineers with MSCS have agreed with this.
That you try to get away with changing the subject to
rebut this is the kind of strawman deception actual
malice (much more than ordinary negligence) than loses
defamation cases.
On 10/11/2024 5:20 PM, Richard Damon wrote:
On 10/11/24 6:09 PM, olcott wrote:
On 10/11/2024 4:55 PM, Richard Damon wrote:
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:WHAT PARAPHARSE.
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* >>>>>>>>>>>>>>>>
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.
void DDD()
{
HHH(DDD);
return;
}
There are a pair of C functions having x86 code that
specifies that DDD correctly emulated by HHH cannot
possibly return.
No, it shows that HHH can not correctly emulate DDD and return an answer.
That you can't even pay attention to the fact that we are
only talking about the behavior of DDD emulated by HHH and
not talking about whether or not HHH returns a value would
seem to be a good incompetence defense to defamation.
On 10/11/2024 5:20 PM, Richard Damon wrote:
O
No, it shows that HHH can not correctly emulate DDD and return an answer.
That you can't even pay attention to the fact that we are
only talking about the behavior of DDD emulated by HHH and
not talking about whether or not HHH returns a value would
seem to be a good incompetence defense to defamation.
On 10/12/2024 3:29 AM, Mikko wrote:
On 2024-10-11 22:34:13 +0000, olcott said:
On 10/11/2024 5:20 PM, Richard Damon wrote:
O
No, it shows that HHH can not correctly emulate DDD and return an
answer.
That you can't even pay attention to the fact that we are
only talking about the behavior of DDD emulated by HHH and
not talking about whether or not HHH returns a value would
seem to be a good incompetence defense to defamation.
You are not paying attention to the fact that DDD returns if and only
if HHH(DDD) returns, so the qestions whether HHH returns and wehther
DDD returns are essentially the same.
My key advantage is that I pay much more attention than anyone
else here does.
void DDD()
{
HHH(DDD);
return;
}
When HHH is an x86 emulation based termination analyzer
then each DDD emulated by any HHH that it calls never returns.
Each of the directly executed HHH emulator/analyzers that returns
0 correctly reports the above non-terminating behavior of its input.
On 10/11/2024 5:20 PM, Richard Damon wrote:Whether HHH returns a value seems to be important for determining whether
On 10/11/24 6:09 PM, olcott wrote:
On 10/11/2024 4:55 PM, Richard Damon wrote:
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:
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,
That you can't even pay attention to the fact that we are only talkingNo, it shows that HHH can not correctly emulate DDD and return anThere are a pair of C functions having x86 code that specifies thatAnd what do you do when I present the output from your own programI already have several expert witnesses that have attested to theWhich means for you to claim defamation, you need to prove that my >>>>>> statements are actually false.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.GO ahead an TRY. The counter-suit would ruin you.The source-code conclusively proves that HHH does correctlyThe source code has always proved that HHH does correctly >>>>>>>>>>> emulate itself emulating DDD.No, it shows that HHH is first NOT a proper decider
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*
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
No matter how you try to rebut this verified fact you would meet >>>>>>> the negligence requirement of defamation suits.
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.
fact that DDD emulated by the same HHH that it calls cannot possibly >>>>> return.
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.
DDD correctly emulated by HHH cannot possibly return.
answer.
about the behavior of DDD emulated by HHH and not talking about whether
or not HHH returns a value would seem to be a good incompetence defense
to defamation.
On 10/12/2024 2:29 PM, joes wrote:
Am Fri, 11 Oct 2024 17:34:13 -0500 schrieb olcott:
On 10/11/2024 5:20 PM, Richard Damon wrote:Whether HHH returns a value seems to be important for determining whether
On 10/11/24 6:09 PM, olcott wrote:
On 10/11/2024 4:55 PM, Richard Damon wrote:
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:
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,
That you can't even pay attention to the fact that we are only talkingNo, it shows that HHH can not correctly emulate DDD and return anThere are a pair of C functions having x86 code that specifies thatAnd what do you do when I present the output from your own program >>>>>> that shows that DDD returns.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.Which means for you to claim defamation, you need to prove that my >>>>>>>> statements are actually false.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.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.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.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
*This is to be taken as an official cease-and-desist order* >>>>>>>>>> GO ahead an TRY. The counter-suit would ruin you.
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
No matter how you try to rebut this verified fact you would meet >>>>>>>>> the negligence requirement of defamation suits.
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.
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.
DDD correctly emulated by HHH cannot possibly return.
answer.
about the behavior of DDD emulated by HHH and not talking about whether
or not HHH returns a value would seem to be a good incompetence defense
to defamation.
it is, in fact, a decider.
I have not even gotten to that point yet.
My point HERE AND NOW is that DDD emulated by every
HHH that can possibly exist cannot possibly reach
its own return instruction NO MATTER WHAT HHH DOES.
On 10/12/2024 2:29 PM, joes wrote:If it's not, all the rest doesn't matter for the halting problem.
Am Fri, 11 Oct 2024 17:34:13 -0500 schrieb olcott:I have not even gotten to that point yet.
On 10/11/2024 5:20 PM, Richard Damon wrote:Whether HHH returns a value seems to be important for determining
On 10/11/24 6:09 PM, olcott wrote:
On 10/11/2024 4:55 PM, Richard Damon wrote:
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:
That you can't even pay attention to the fact that we are only talkingNo, it shows that HHH can not correctly emulate DDD and return anThere are a pair of C functions having x86 code that specifies thatAnd what do you do when I present the output from your own program >>>>>> that shows that DDD returns.I already have several expert witnesses that have attested to the >>>>>>> fact that DDD emulated by the same HHH that it calls cannotWhich means for you to claim defamation, you need to prove that >>>>>>>> my statements are actually false.Within software engineering (C and x86 code, not TuringAnd, you would need to persuade some lawyer to take your case >>>>>>>>>> to even start, and I suspect that would be difficultThe 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.No, it shows that HHH is first NOT a proper deciderThe source code has always proved that HHH does correctly >>>>>>>>>>>>> emulate itself emulating DDD.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,
*This is to be taken as an official cease-and-desist order* >>>>>>>>>> GO ahead an TRY. The counter-suit would ruin you.
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
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.
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.
possibly return.
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.
DDD correctly emulated by HHH cannot possibly return.
answer.
about the behavior of DDD emulated by HHH and not talking about
whether or not HHH returns a value would seem to be a good
incompetence defense to defamation.
whether it is, in fact, a decider.
My point HERE AND NOW is that DDD emulated by every HHH that canYes, it depends on HHH. HHH cannot simulate DDD to its termination.
possibly exist cannot possibly reach its own return instruction NO
MATTER WHAT HHH DOES.
On 10/12/2024 3:29 AM, Mikko wrote:
On 2024-10-11 22:34:13 +0000, olcott said:
On 10/11/2024 5:20 PM, Richard Damon wrote:
O
No, it shows that HHH can not correctly emulate DDD and return an answer. >>>That you can't even pay attention to the fact that we are
only talking about the behavior of DDD emulated by HHH and
not talking about whether or not HHH returns a value would
seem to be a good incompetence defense to defamation.
You are not paying attention to the fact that DDD returns if and only
if HHH(DDD) returns, so the qestions whether HHH returns and wehther
DDD returns are essentially the same.
My key advantage is that I pay much more attention than anyone
else here does.
On 10/12/2024 2:29 PM, joes wrote:
Am Fri, 11 Oct 2024 17:34:13 -0500 schrieb olcott:
On 10/11/2024 5:20 PM, Richard Damon wrote:Whether HHH returns a value seems to be important for determining whether
On 10/11/24 6:09 PM, olcott wrote:
On 10/11/2024 4:55 PM, Richard Damon wrote:
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:
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,
That you can't even pay attention to the fact that we are only talkingNo, it shows that HHH can not correctly emulate DDD and return anThere are a pair of C functions having x86 code that specifies thatAnd what do you do when I present the output from your own program >>>>>> that shows that DDD returns.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.Which means for you to claim defamation, you need to prove that my >>>>>>>> statements are actually false.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.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.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.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
*This is to be taken as an official cease-and-desist order* >>>>>>>>>> GO ahead an TRY. The counter-suit would ruin you.
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
No matter how you try to rebut this verified fact you would meet >>>>>>>>> the negligence requirement of defamation suits.
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.
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.
DDD correctly emulated by HHH cannot possibly return.
answer.
about the behavior of DDD emulated by HHH and not talking about whether
or not HHH returns a value would seem to be a good incompetence defense
to defamation.
it is, in fact, a decider.
I have not even gotten to that point yet.
My point HERE AND NOW is that DDD emulated by every
HHH that can possibly exist cannot possibly reach
its own return instruction NO MATTER WHAT HHH DOES.
On 10/12/2024 5:08 PM, joes wrote:
Am Sat, 12 Oct 2024 14:44:06 -0500 schrieb olcott:
On 10/12/2024 2:29 PM, joes wrote:If it's not, all the rest doesn't matter for the halting problem.
Am Fri, 11 Oct 2024 17:34:13 -0500 schrieb olcott:I have not even gotten to that point yet.
On 10/11/2024 5:20 PM, Richard Damon wrote:Whether HHH returns a value seems to be important for determining
On 10/11/24 6:09 PM, olcott wrote:
On 10/11/2024 4:55 PM, Richard Damon wrote:
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:
That you can't even pay attention to the fact that we are only talking >>>>> about the behavior of DDD emulated by HHH and not talking aboutNo, it shows that HHH can not correctly emulate DDD and return anThere are a pair of C functions having x86 code that specifies that >>>>>>> DDD correctly emulated by HHH cannot possibly return.And what do you do when I present the output from your own program >>>>>>>> that shows that DDD returns.I already have several expert witnesses that have attested to the >>>>>>>>> fact that DDD emulated by the same HHH that it calls cannotWhich means for you to claim defamation, you need to prove that >>>>>>>>>> my statements are actually false.Within software engineering (C and x86 code, not TuringAnd, you would need to persuade some lawyer to take your case >>>>>>>>>>>> to even start, and I suspect that would be difficult*This is to be taken as an official cease-and-desist order* >>>>>>>>>>>> GO ahead an TRY. The counter-suit would ruin you.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.The source code has always proved that HHH does correctly >>>>>>>>>>>>>>> emulate itself emulating DDD.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,
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
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.
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.
possibly return.
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.
answer.
whether or not HHH returns a value would seem to be a good
incompetence defense to defamation.
whether it is, in fact, a decider.
My point HERE AND NOW is that DDD emulated by every HHH that canYes, it depends on HHH. HHH cannot simulate DDD to its termination.
possibly exist cannot possibly reach its own return instruction NO
MATTER WHAT HHH DOES.
That is the same as saying that people are limited
in their ability to calculate the diameter of a square.
On 10/12/2024 5:08 PM, joes wrote:DDD terminates.
Am Sat, 12 Oct 2024 14:44:06 -0500 schrieb olcott:That is the same as saying that people are limited in their ability to calculate the diameter of a square.
On 10/12/2024 2:29 PM, joes wrote:If it's not, all the rest doesn't matter for the halting problem.
Am Fri, 11 Oct 2024 17:34:13 -0500 schrieb olcott:I have not even gotten to that point yet.
On 10/11/2024 5:20 PM, Richard Damon wrote:Whether HHH returns a value seems to be important for determining
On 10/11/24 6:09 PM, olcott wrote:
On 10/11/2024 4:55 PM, Richard Damon wrote:
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:
That you can't even pay attention to the fact that we are onlyNo, it shows that HHH can not correctly emulate DDD and return anThere are a pair of C functions having x86 code that specifiesAnd what do you do when I present the output from your ownI already have several expert witnesses that have attested to >>>>>>>>> the fact that DDD emulated by the same HHH that it calls cannot >>>>>>>>> possibly return.Which means for you to claim defamation, you need to prove that >>>>>>>>>> my statements are actually false.Within software engineering (C and x86 code, not TuringAnd, you would need to persuade some lawyer to take your case >>>>>>>>>>>> to even start, and I suspect that would be difficult*This is to be taken as an official cease-and-desist order* >>>>>>>>>>>> GO ahead an TRY. The counter-suit would ruin you.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.The source code has always proved that HHH does correctly >>>>>>>>>>>>>>> emulate itself emulating DDD.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,
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
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.
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.
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.
that DDD correctly emulated by HHH cannot possibly return.
answer.
talking about the behavior of DDD emulated by HHH and not talking
about whether or not HHH returns a value would seem to be a good
incompetence defense to defamation.
whether it is, in fact, a decider.
My point HERE AND NOW is that DDD emulated by every HHH that canYes, it depends on HHH. HHH cannot simulate DDD to its termination.
possibly exist cannot possibly reach its own return instruction NO
MATTER WHAT HHH DOES.
On 10/12/2024 3:25 PM, Richard Damon wrote:
On 10/12/24 3:44 PM, olcott wrote:
On 10/12/2024 2:29 PM, joes wrote:
Am Fri, 11 Oct 2024 17:34:13 -0500 schrieb olcott:
On 10/11/2024 5:20 PM, Richard Damon wrote:Whether HHH returns a value seems to be important for determining
On 10/11/24 6:09 PM, olcott wrote:
On 10/11/2024 4:55 PM, Richard Damon wrote:
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:
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,
That you can't even pay attention to the fact that we are only talking >>>>> about the behavior of DDD emulated by HHH and not talking aboutNo, it shows that HHH can not correctly emulate DDD and return anThere are a pair of C functions having x86 code that specifies that >>>>>>> DDD correctly emulated by HHH cannot possibly return.And what do you do when I present the output from your own program >>>>>>>> that shows that DDD returns.I already have several expert witnesses that have attested to the >>>>>>>>> fact that DDD emulated by the same HHH that it calls cannotWhich means for you to claim defamation, you need to prove >>>>>>>>>> that myWithin software engineering (C and x86 code, not TuringAnd, you would need to persuade some lawyer to take your >>>>>>>>>>>> case to*This is to be taken as an official cease-and-desist order* >>>>>>>>>>>> GO ahead an TRY. The counter-suit would ruin you.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.
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
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.
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.
possibly
return.
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.
answer.
whether
or not HHH returns a value would seem to be a good incompetence
defense
to defamation.
whether
it is, in fact, a decider.
I have not even gotten to that point yet.
My point HERE AND NOW is that DDD emulated by every
HHH that can possibly exist cannot possibly reach
its own return instruction NO MATTER WHAT HHH DOES.
And you need to fix the equivocation
There is no equivocation what-so-ever in my statement.
What I said has a perfectly unequivocal meaning.
in your statement, so you can see why your logic doesn't work so you
can try to fix it to move on.
YOU are the one that wants to stick to the equivical statement,
because lying by equivocation seems to be your only path forward.
You don't seem to even understand what the term "equivocal" means.
You are just proving that you are actually working on the liars side,
by trying to get people to accept logic that accepts lies as ok.
https://www.merriam-webster.com/dictionary/lie
1a: (verb) to be or to stay at rest in a horizontal position
1b: (verb) to assume a horizontal position —often used with down
1: (noun) chiefly British : lay sense 6
1: (verb) to make an untrue statement with intent to deceive
1a: (noun) an assertion of something known or believed by the speaker or writer to be untrue with intent to deceive
1b: (noun) an untrue or inaccurate statement that may or may not be
believed true by the speaker or writer
On 10/13/2024 2:57 AM, Mikko wrote:
On 2024-10-12 09:57:32 +0000, olcott said:
On 10/12/2024 3:29 AM, Mikko wrote:
On 2024-10-11 22:34:13 +0000, olcott said:
On 10/11/2024 5:20 PM, Richard Damon wrote:
O
No, it shows that HHH can not correctly emulate DDD and return an
answer.
That you can't even pay attention to the fact that we are
only talking about the behavior of DDD emulated by HHH and
not talking about whether or not HHH returns a value would
seem to be a good incompetence defense to defamation.
You are not paying attention to the fact that DDD returns if and only
if HHH(DDD) returns, so the qestions whether HHH returns and wehther
DDD returns are essentially the same.
My key advantage is that I pay much more attention than anyone
else here does.
Perahps to something but not to the fact that DDD returns if and only
if HHH(DDD) returns, so the questions whether HHH returns and whether DDD
returns are essentially the same.
I am not and never have been claiming anything about incorrect
paraphrases of these exact words:
*HHH rejects DDD as non terminating*
void DDD()
{
HHH(DDD);
return;
}
When HHH is an x86 emulation based termination analyzer
then each DDD emulated by any HHH that it calls never returns.
Each of the directly executed HHH emulator/analyzers that returns
0 correctly reports the above non-terminating behavior of its input.
*Fully operational code is here* https://github.com/plolcott/x86utm/blob/master/Halt7.c https:// github.com/plolcott/x86utm
On 10/13/2024 3:06 AM, Mikko wrote:
On 2024-10-12 19:44:06 +0000, olcott said:
My point HERE AND NOW is that DDD emulated by every
HHH that can possibly exist cannot possibly reach
its own return instruction NO MATTER WHAT HHH DOES.
That does not mean anything as long as you don't define "every HHH"
void DDD()
{
HHH(DDD);
return;
}
The only requirement for HHH is that it is an emulator that
emulates more than zero steps of DDD. HHH also must be able
to emulate itself emulating DDD.
so that one can determine whether a HHH that emulates whatever is
given as input except that instead of emulating its own code (it
it is called) as "return 1;" only is included in "every HHH".
This is out-of-scope. The scope is already 100% fully
specified above.
On 10/13/2024 3:10 AM, Mikko wrote:
On 2024-10-12 22:49:03 +0000, olcott said:
On 10/12/2024 5:08 PM, joes wrote:
Am Sat, 12 Oct 2024 14:44:06 -0500 schrieb olcott:
On 10/12/2024 2:29 PM, joes wrote:If it's not, all the rest doesn't matter for the halting problem.
Am Fri, 11 Oct 2024 17:34:13 -0500 schrieb olcott:I have not even gotten to that point yet.
On 10/11/2024 5:20 PM, Richard Damon wrote:Whether HHH returns a value seems to be important for determining
On 10/11/24 6:09 PM, olcott wrote:
On 10/11/2024 4:55 PM, Richard Damon wrote:
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:
That you can't even pay attention to the fact that we are only talking >>>>>>> about the behavior of DDD emulated by HHH and not talking aboutNo, it shows that HHH can not correctly emulate DDD and return an >>>>>>>> answer.There are a pair of C functions having x86 code that specifies that >>>>>>>>> DDD correctly emulated by HHH cannot possibly return.And what do you do when I present the output from your own program >>>>>>>>>> that shows that DDD returns.Which means for you to claim defamation, you need to prove that >>>>>>>>>>>> my statements are actually false.Within software engineering (C and x86 code, not Turing >>>>>>>>>>>>> machines)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.*This is to be taken as an official cease-and-desist order* >>>>>>>>>>>>>> GO ahead an TRY. The counter-suit would ruin you.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.The source code has always proved that HHH does correctly >>>>>>>>>>>>>>>>> emulate itself emulating DDD.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,
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
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.
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. >>>>>>>>>>> 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.
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.
whether or not HHH returns a value would seem to be a good
incompetence defense to defamation.
whether it is, in fact, a decider.
My point HERE AND NOW is that DDD emulated by every HHH that canYes, it depends on HHH. HHH cannot simulate DDD to its termination.
possibly exist cannot possibly reach its own return instruction NO
MATTER WHAT HHH DOES.
That is the same as saying that people are limited
in their ability to calculate the diameter of a square.
People who can only use rational numbers are. People who can use
irrational numbers are not.
Squares do not have diameters making it impossible
for anyone or anything to calculate the diameter or
a square.
| Sysop: | Keyop |
|---|---|
| Location: | Huddersfield, West Yorkshire, UK |
| Users: | 546 |
| Nodes: | 16 (2 / 14) |
| Uptime: | 42:31:46 |
| Calls: | 10,392 |
| Files: | 14,064 |
| Messages: | 6,417,214 |