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.
HHH recognizes this pattern when HHH emulates itself emulating DDD
void DDD()
{
HHH(DDD);
return;
}
One cannot simply ignore the actual behavior specified by the
finite string x86 machine language of DDD such that
DDD emulated by each corresponding HHH that can possibly
exist never returns
thus each of the directly executed HHH emulators that does
return 0 correctly reports the above non-terminating behavior.
https://github.com/plolcott/x86utm x86utm operating system
Every executed HHH that returns 0 correctly reports that
DDD emulated by its corresponding HHH never returns.
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*
DDD emulated by each corresponding HHH that can possibly
exist never returns
thus each of the directly executed HHH emulators that does
return 0 correctly reports the above non-terminating behavior.
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.
THAT IS NOT WHAT I 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.
THAT IS NOT WHAT I SAID !!!
On 10/9/2024 9:20 PM, Richard Damon wrote:
On 10/9/24 8:15 PM, olcott wrote:
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.
THAT IS NOT WHAT I SAID !!!
So, you are admitting you don't know what your words mean? Since that
*IS* what they mean. Your failure to even attempt to refute my grammer
analysis shows you accept my logic, or at least can't fight it.
You are not talking about the behavior of DDD emulated by HHH.
On 10/10/2024 6:17 AM, Richard Damon wrote:
On 10/9/24 11:17 PM, olcott wrote:
On 10/9/2024 9:20 PM, Richard Damon wrote:
On 10/9/24 8:15 PM, olcott wrote:You are not talking about the behavior of DDD emulated by HHH.
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.
THAT IS NOT WHAT I SAID !!!
So, you are admitting you don't know what your words mean? Since
that *IS* what they mean. Your failure to even attempt to refute my
grammer analysis shows you accept my logic, or at least can't fight it. >>>
But that was what your previous sentence was talking about,
counter-factual.
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.
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.
Instead you seemed to have said that:
the behavior of DDD emulated by HHH
is the behavior of DDD when directly executed.
Is this what you mean?
On 10/11/2024 6:04 AM, Richard Damon wrote:
On 10/10/24 9:55 PM, olcott wrote:
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.
No, (the behavior of ddd) [that was] emulated by HHH is a different
sentence then
the behavior (of DDD) [by] emulation by HHH
That merely seem grammatically incorrect.
In any case I am only taking about the behavior of DDD
emulated by HHH.
Instead you seemed to have said that:
the behavior of DDD emulated by HHH
is the behavior of DDD when directly executed.
(The behavior of DDD) is the behavior of DDD directly executed.
I am only talking about the behavior of DDD emulated by HHH.
That <is> the premise to my deduction.
When you change the premise to my deduction as the basis of
your rebuttal that <is> the strawman error.
A straw man fallacy (sometimes written as strawman) is the
informal fallacy of refuting an argument different from the
one actually under discussion, while not recognizing or
acknowledging the distinction.
https://en.wikipedia.org/wiki/Straw_man
The emulated by HHH, just specifies WHICH DDD was look at.
The sentence, in the context of Computation Theory and the Halting
Problem, does not allow the "emulation" to modify behavior (which
wasn't in your original sentence to begin with) as which behavior is
defined by the technical definiitions of the field, something you have
CHOSEN to no learn, thus leading you into self-inflicted stupidity.
No matter what anyone anywhere says
THIS IS A VERIFIED FACT.
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.
You can legitimately say that is not that way that this
is typically done in the theory of computation.
Is this what you mean?
You are just proving you are trying to use an equivocation.
I am not using equivocation. You are changing the premise
to my reasoning and then applying the strawman fallacy.
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.
The x86 machine code of DDD and HHH provides the single correct
way to interpret DDD emulated by HHH.
_DDD()
[00002172] 55 push ebp ; housekeeping
[00002173] 8bec mov ebp,esp ; housekeeping
[00002175] 6872210000 push 00002172 ; push DDD
[0000217a] e853f4ffff call 000015d2 ; call HHH(DDD)
[0000217f] 83c404 add esp,+04
[00002182] 5d pop ebp
[00002183] c3 ret
Size in bytes:(0018) [00002183]
Fully operational code is here. https://github.com/plolcott/x86utm/blob/master/Halt7.c
By the usual rules
"emulated by HHH" is an attribute of DDD with the intent to prevent
cofusion with some other function that happens to have the same name.
But it could also be an attribute of "the behaviour" with the intent
to prevent confision with the true behaviour of DDD if the behaviour
emulated by HHH is different from the behaviour specified by the input
to HHH.
| Sysop: | Keyop |
|---|---|
| Location: | Huddersfield, West Yorkshire, UK |
| Users: | 546 |
| Nodes: | 16 (2 / 14) |
| Uptime: | 10:42:19 |
| Calls: | 10,387 |
| Calls today: | 2 |
| Files: | 14,060 |
| Messages: | 6,416,691 |