On 10/7/2024 6:02 AM, Richard Damon wrote:
On 10/6/24 10:05 PM, olcott wrote:
On 10/6/2024 8:29 PM, Richard Damon wrote:
On 10/6/24 8:05 PM, olcott wrote:
On 10/6/2024 5:36 PM, Richard Damon wrote:
On 10/6/24 3:05 PM, olcott wrote:
On 10/6/2024 1:52 PM, Richard Damon wrote:
On 10/6/24 2:32 PM, olcott wrote:
On 10/6/2024 1:13 PM, Richard Damon wrote:
On 10/6/24 2:03 PM, olcott wrote:
On 10/6/2024 12:29 PM, Richard Damon wrote:
On 10/6/24 1:07 PM, olcott wrote:
On 10/6/2024 11:59 AM, Richard Damon wrote:
On 10/6/24 8:39 AM, olcott wrote:
DDD emulated by each corresponding HHH that can possibly >>>>>>>>>>>>>>> exist never returns. Each of these HHH emulators that does >>>>>>>>>>>>>>> return 0 correctly reports the above non-halting behavior. >>>>>>>>>>>>>>>
No, the DDD return (if the HHH(DDD) gives an answer), just >>>>>>>>>>>>>> after the HHH that emulated them gave up.
DDD emulated by each corresponding HHH that can possibly >>>>>>>>>>>>> exist never returns.
DDD emulated by each corresponding HHH
DDD emulated by each corresponding HHH
DDD emulated by each corresponding HHH
DDD emulated by each corresponding HHH
Which, as you have been told but seems to be above your head >>>>>>>>>>>> means that the execution of DDD,
gets to ignore the fact that DDD was defined to
have a pathological relationship with HHH that
HHH cannot ignore.
No, that isn't ignoring it, but taking into account that since >>>>>>>>>> HHH is defined to be a specific program, it has specific
behavior.
The behavior of the executed DDD after the emulated
DDD has already been aborted is different than the
behavior of the emulated DDD that must be aborted.
Nope, it is the exact same code on the exact same data, and thus >>>>>>>> does the exact same behavior.
The execution trace proves that the executed DDD has
different behavior that need not be aborted because
emulated DDD must be an is aborted.
Nope, whst instruction ACTUALLY EMULATE showed a different
behavior than the executed DDD?
All you do is look at a DIFFERENT INPUT which is just a lie, since >>>>>> that isn't the DDD that HHH was given (since the PROGRAM DDD
includes the all the exact code of the HHH that it calls, thus you >>>>>> can't change it to hypothosze a diffferent non-aborting HHH)
No one can be stupid enough to think that:
MUST BE ABORTED
is exactly the same as
NEED NOT BE ABORTED
Who said otherwise.
The directly executed DDD need not be aborted.
DDD emulated by HHH must be aborted, thus
proving that their behavior IS NOT THE SAME.
No, the design of HHH does abort its emulation, because if you had a
DIFFERENT HHH, which would be given a DIFFERENT DDD (since DDD
includes the HHH that it is calling) it would fail worse at the task
at the meta- level by not answering.
That you are not addressing my points seems to be over your head.
No, the fact that I *AM* adddressing your points and pointing out your
error just proves that you are nothing but a stupid idiot.
That you don't even try to point out an error in what I say, proves
that you don't actually care about what is right, but that you just
want to blindly hold on to your position. The fact that you
consistantly snip out much of the arguement shows that you know you
are defeated, but still insist on your WRONG position.
Halting is a property of PROGRAMS.
void DDD()
{
HHH(DDD);
return;
}
Terminating is a property of finite string machine descriptions.
One cannot simply ignore the actual behavior specified by the
finite string such that
DDD emulated by each corresponding HHH that can possibly
exist never returns.
Thus each of these HHH emulators that does return 0 correctly
reports the above non-terminating behavior.
*Fully operational software*
https://github.com/plolcott/x86utm *x86utm operating system*
On 10/7/2024 5:39 PM, Richard Damon wrote:
On 10/7/24 8:08 AM, olcott wrote:
On 10/7/2024 6:02 AM, Richard Damon wrote:
On 10/6/24 10:05 PM, olcott wrote:
On 10/6/2024 8:29 PM, Richard Damon wrote:
On 10/6/24 8:05 PM, olcott wrote:
On 10/6/2024 5:36 PM, Richard Damon wrote:
On 10/6/24 3:05 PM, olcott wrote:
On 10/6/2024 1:52 PM, Richard Damon wrote:
On 10/6/24 2:32 PM, olcott wrote:
On 10/6/2024 1:13 PM, Richard Damon wrote:
On 10/6/24 2:03 PM, olcott wrote:
On 10/6/2024 12:29 PM, Richard Damon wrote:
On 10/6/24 1:07 PM, olcott wrote:
On 10/6/2024 11:59 AM, Richard Damon wrote:
On 10/6/24 8:39 AM, olcott wrote:
DDD emulated by each corresponding HHH that can possibly >>>>>>>>>>>>>>>>> exist never returns. Each of these HHH emulators that does >>>>>>>>>>>>>>>>> return 0 correctly reports the above non-halting behavior. >>>>>>>>>>>>>>>>>
No, the DDD return (if the HHH(DDD) gives an answer), >>>>>>>>>>>>>>>> just after the HHH that emulated them gave up. >>>>>>>>>>>>>>>>
DDD emulated by each corresponding HHH that can possibly >>>>>>>>>>>>>>> exist never returns.
DDD emulated by each corresponding HHH
DDD emulated by each corresponding HHH
DDD emulated by each corresponding HHH
DDD emulated by each corresponding HHH
Which, as you have been told but seems to be above your >>>>>>>>>>>>>> head means that the execution of DDD,
gets to ignore the fact that DDD was defined to
have a pathological relationship with HHH that
HHH cannot ignore.
No, that isn't ignoring it, but taking into account that >>>>>>>>>>>> since HHH is defined to be a specific program, it has
specific behavior.
The behavior of the executed DDD after the emulated
DDD has already been aborted is different than the
behavior of the emulated DDD that must be aborted.
Nope, it is the exact same code on the exact same data, and >>>>>>>>>> thus does the exact same behavior.
The execution trace proves that the executed DDD has
different behavior that need not be aborted because
emulated DDD must be an is aborted.
Nope, whst instruction ACTUALLY EMULATE showed a different
behavior than the executed DDD?
All you do is look at a DIFFERENT INPUT which is just a lie,
since that isn't the DDD that HHH was given (since the PROGRAM >>>>>>>> DDD includes the all the exact code of the HHH that it calls,
thus you can't change it to hypothosze a diffferent non-aborting >>>>>>>> HHH)
No one can be stupid enough to think that:
MUST BE ABORTED
is exactly the same as
NEED NOT BE ABORTED
Who said otherwise.
The directly executed DDD need not be aborted.
DDD emulated by HHH must be aborted, thus
proving that their behavior IS NOT THE SAME.
No, the design of HHH does abort its emulation, because if you had >>>>>> a DIFFERENT HHH, which would be given a DIFFERENT DDD (since DDD
includes the HHH that it is calling) it would fail worse at the
task at the meta- level by not answering.
That you are not addressing my points seems to be over your head.
No, the fact that I *AM* adddressing your points and pointing out
your error just proves that you are nothing but a stupid idiot.
That you don't even try to point out an error in what I say, proves
that you don't actually care about what is right, but that you just
want to blindly hold on to your position. The fact that you
consistantly snip out much of the arguement shows that you know you
are defeated, but still insist on your WRONG position.
Halting is a property of PROGRAMS.
void DDD()
{
HHH(DDD);
return;
}
Terminating is a property of finite string machine descriptions.
And, for the PROGRAM DDD, must include the FULL decription of the HHH
that it calls.
It does and the source-code specifies that it does
yet this is simply over-your-head.
https://github.com/plolcott/x86utm/blob/master/Halt7.c
On 10/7/2024 6:04 PM, Richard Damon wrote:
On 10/7/24 6:57 PM, olcott wrote:
On 10/7/2024 5:39 PM, Richard Damon wrote:
On 10/7/24 8:08 AM, olcott wrote:
On 10/7/2024 6:02 AM, Richard Damon wrote:
On 10/6/24 10:05 PM, olcott wrote:
On 10/6/2024 8:29 PM, Richard Damon wrote:
On 10/6/24 8:05 PM, olcott wrote:
On 10/6/2024 5:36 PM, Richard Damon wrote:
On 10/6/24 3:05 PM, olcott wrote:
On 10/6/2024 1:52 PM, Richard Damon wrote:
On 10/6/24 2:32 PM, olcott wrote:
On 10/6/2024 1:13 PM, Richard Damon wrote:
On 10/6/24 2:03 PM, olcott wrote:
On 10/6/2024 12:29 PM, Richard Damon wrote:
On 10/6/24 1:07 PM, olcott wrote:
On 10/6/2024 11:59 AM, Richard Damon wrote: >>>>>>>>>>>>>>>>>> On 10/6/24 8:39 AM, olcott wrote:
DDD emulated by each corresponding HHH that can possibly >>>>>>>>>>>>>>>>>>> exist never returns. Each of these HHH emulators that >>>>>>>>>>>>>>>>>>> does
return 0 correctly reports the above non-halting >>>>>>>>>>>>>>>>>>> behavior.
No, the DDD return (if the HHH(DDD) gives an answer), >>>>>>>>>>>>>>>>>> just after the HHH that emulated them gave up. >>>>>>>>>>>>>>>>>>
DDD emulated by each corresponding HHH that can possibly >>>>>>>>>>>>>>>>> exist never returns.
DDD emulated by each corresponding HHH
DDD emulated by each corresponding HHH
DDD emulated by each corresponding HHH
DDD emulated by each corresponding HHH
Which, as you have been told but seems to be above your >>>>>>>>>>>>>>>> head means that the execution of DDD,
gets to ignore the fact that DDD was defined to
have a pathological relationship with HHH that
HHH cannot ignore.
No, that isn't ignoring it, but taking into account that >>>>>>>>>>>>>> since HHH is defined to be a specific program, it has >>>>>>>>>>>>>> specific behavior.
The behavior of the executed DDD after the emulated
DDD has already been aborted is different than the
behavior of the emulated DDD that must be aborted.
Nope, it is the exact same code on the exact same data, and >>>>>>>>>>>> thus does the exact same behavior.
The execution trace proves that the executed DDD has
different behavior that need not be aborted because
emulated DDD must be an is aborted.
Nope, whst instruction ACTUALLY EMULATE showed a different >>>>>>>>>> behavior than the executed DDD?
All you do is look at a DIFFERENT INPUT which is just a lie, >>>>>>>>>> since that isn't the DDD that HHH was given (since the PROGRAM >>>>>>>>>> DDD includes the all the exact code of the HHH that it calls, >>>>>>>>>> thus you can't change it to hypothosze a diffferent non-
aborting HHH)
No one can be stupid enough to think that:
MUST BE ABORTED
is exactly the same as
NEED NOT BE ABORTED
Who said otherwise.
The directly executed DDD need not be aborted.
DDD emulated by HHH must be aborted, thus
proving that their behavior IS NOT THE SAME.
No, the design of HHH does abort its emulation, because if you >>>>>>>> had a DIFFERENT HHH, which would be given a DIFFERENT DDD (since >>>>>>>> DDD includes the HHH that it is calling) it would fail worse at >>>>>>>> the task at the meta- level by not answering.
That you are not addressing my points seems to be over your head. >>>>>>>
No, the fact that I *AM* adddressing your points and pointing out
your error just proves that you are nothing but a stupid idiot.
That you don't even try to point out an error in what I say,
proves that you don't actually care about what is right, but that
you just want to blindly hold on to your position. The fact that
you consistantly snip out much of the arguement shows that you
know you are defeated, but still insist on your WRONG position.
Halting is a property of PROGRAMS.
void DDD()
{
HHH(DDD);
return;
}
Terminating is a property of finite string machine descriptions.
And, for the PROGRAM DDD, must include the FULL decription of the
HHH that it calls.
It does and the source-code specifies that it does
yet this is simply over-your-head.
https://github.com/plolcott/x86utm/blob/master/Halt7.c
But that isn't the finite string you are claiming above.
When you include the code of HHH in DDD, then when you hypotosize HHH
not aborting, that hypothetical HHH is still given the DDD that calls
the HHH that DOES, and your hypothetical HHH proves that this HHH is
wrong.
No it continues to be you fail to pay complete attention
to every detail of every words that I said.
*THE FOLLOWING REMAINS TRUE NO MATTER WHAT HHH DOES*
DDD emulated by each corresponding HHH that can possibly
exist never returns.
On 10/7/2024 7:48 PM, Richard Damon wrote:
On 10/7/24 7:36 PM, olcott wrote:
On 10/7/2024 6:04 PM, Richard Damon wrote:
On 10/7/24 6:57 PM, olcott wrote:
On 10/7/2024 5:39 PM, Richard Damon wrote:
On 10/7/24 8:08 AM, olcott wrote:
On 10/7/2024 6:02 AM, Richard Damon wrote:
On 10/6/24 10:05 PM, olcott wrote:
On 10/6/2024 8:29 PM, Richard Damon wrote:
On 10/6/24 8:05 PM, olcott wrote:
On 10/6/2024 5:36 PM, Richard Damon wrote:
On 10/6/24 3:05 PM, olcott wrote:
On 10/6/2024 1:52 PM, Richard Damon wrote:
On 10/6/24 2:32 PM, olcott wrote:
On 10/6/2024 1:13 PM, Richard Damon wrote:Nope, it is the exact same code on the exact same data, >>>>>>>>>>>>>> and thus does the exact same behavior.
On 10/6/24 2:03 PM, olcott wrote:
On 10/6/2024 12:29 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>> On 10/6/24 1:07 PM, olcott wrote:
On 10/6/2024 11:59 AM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>> On 10/6/24 8:39 AM, olcott wrote:
DDD emulated by each corresponding HHH that can >>>>>>>>>>>>>>>>>>>>> possibly
exist never returns. Each of these HHH emulators >>>>>>>>>>>>>>>>>>>>> that does
return 0 correctly reports the above non-halting >>>>>>>>>>>>>>>>>>>>> behavior.
No, the DDD return (if the HHH(DDD) gives an >>>>>>>>>>>>>>>>>>>> answer), just after the HHH that emulated them gave up. >>>>>>>>>>>>>>>>>>>>
DDD emulated by each corresponding HHH that can possibly >>>>>>>>>>>>>>>>>>> exist never returns.
DDD emulated by each corresponding HHH
DDD emulated by each corresponding HHH
DDD emulated by each corresponding HHH
DDD emulated by each corresponding HHH
Which, as you have been told but seems to be above >>>>>>>>>>>>>>>>>> your head means that the execution of DDD,
gets to ignore the fact that DDD was defined to >>>>>>>>>>>>>>>>> have a pathological relationship with HHH that >>>>>>>>>>>>>>>>> HHH cannot ignore.
No, that isn't ignoring it, but taking into account that >>>>>>>>>>>>>>>> since HHH is defined to be a specific program, it has >>>>>>>>>>>>>>>> specific behavior.
The behavior of the executed DDD after the emulated >>>>>>>>>>>>>>> DDD has already been aborted is different than the >>>>>>>>>>>>>>> behavior of the emulated DDD that must be aborted. >>>>>>>>>>>>>>
The execution trace proves that the executed DDD has >>>>>>>>>>>>> different behavior that need not be aborted because
emulated DDD must be an is aborted.
Nope, whst instruction ACTUALLY EMULATE showed a different >>>>>>>>>>>> behavior than the executed DDD?
All you do is look at a DIFFERENT INPUT which is just a lie, >>>>>>>>>>>> since that isn't the DDD that HHH was given (since the >>>>>>>>>>>> PROGRAM DDD includes the all the exact code of the HHH that >>>>>>>>>>>> it calls, thus you can't change it to hypothosze a
diffferent non- aborting HHH)
No one can be stupid enough to think that:
MUST BE ABORTED
is exactly the same as
NEED NOT BE ABORTED
Who said otherwise.
The directly executed DDD need not be aborted.
DDD emulated by HHH must be aborted, thus
proving that their behavior IS NOT THE SAME.
No, the design of HHH does abort its emulation, because if you >>>>>>>>>> had a DIFFERENT HHH, which would be given a DIFFERENT DDD
(since DDD includes the HHH that it is calling) it would fail >>>>>>>>>> worse at the task at the meta- level by not answering.
That you are not addressing my points seems to be over your head. >>>>>>>>>
No, the fact that I *AM* adddressing your points and pointing
out your error just proves that you are nothing but a stupid idiot. >>>>>>>>
That you don't even try to point out an error in what I say,
proves that you don't actually care about what is right, but
that you just want to blindly hold on to your position. The fact >>>>>>>> that you consistantly snip out much of the arguement shows that >>>>>>>> you know you are defeated, but still insist on your WRONG position. >>>>>>>>
Halting is a property of PROGRAMS.
void DDD()
{
HHH(DDD);
return;
}
Terminating is a property of finite string machine descriptions. >>>>>>>
And, for the PROGRAM DDD, must include the FULL decription of the >>>>>> HHH that it calls.
It does and the source-code specifies that it does
yet this is simply over-your-head.
https://github.com/plolcott/x86utm/blob/master/Halt7.c
But that isn't the finite string you are claiming above.
When you include the code of HHH in DDD, then when you hypotosize
HHH not aborting, that hypothetical HHH is still given the DDD that
calls the HHH that DOES, and your hypothetical HHH proves that this
HHH is wrong.
No it continues to be you fail to pay complete attention
to every detail of every words that I said.
*THE FOLLOWING REMAINS TRUE NO MATTER WHAT HHH DOES*
DDD emulated by each corresponding HHH that can possibly
exist never returns.
No, because *DDD*, the one that was emulated by each of the HHH, will
HALT if that HHH(DDD) returns 0, just after its HHH aborted its
emulaiton.
PLEASE PLAY 100% COMPLETE ATTENTION TO THESE EXACT WORDS
DDD emulated by each corresponding HHH
that can possibly exist never returns.
Your incorrect paraphrase of my words proves that
you are either clueless or deliberately deceptive.
I am going with clueless.
On 10/7/2024 8:11 PM, Richard Damon wrote:
On 10/7/24 8:58 PM, olcott wrote:
On 10/7/2024 7:48 PM, Richard Damon wrote:
On 10/7/24 7:36 PM, olcott wrote:
On 10/7/2024 6:04 PM, Richard Damon wrote:
On 10/7/24 6:57 PM, olcott wrote:
On 10/7/2024 5:39 PM, Richard Damon wrote:
On 10/7/24 8:08 AM, olcott wrote:
On 10/7/2024 6:02 AM, Richard Damon wrote:
On 10/6/24 10:05 PM, olcott wrote:
On 10/6/2024 8:29 PM, Richard Damon wrote:
On 10/6/24 8:05 PM, olcott wrote:
On 10/6/2024 5:36 PM, Richard Damon wrote:
On 10/6/24 3:05 PM, olcott wrote:
On 10/6/2024 1:52 PM, Richard Damon wrote:
On 10/6/24 2:32 PM, olcott wrote:
On 10/6/2024 1:13 PM, Richard Damon wrote:Nope, it is the exact same code on the exact same data, >>>>>>>>>>>>>>>> and thus does the exact same behavior.
On 10/6/24 2:03 PM, olcott wrote:
On 10/6/2024 12:29 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>> On 10/6/24 1:07 PM, olcott wrote:
gets to ignore the fact that DDD was defined to >>>>>>>>>>>>>>>>>>> have a pathological relationship with HHH that >>>>>>>>>>>>>>>>>>> HHH cannot ignore.On 10/6/2024 11:59 AM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>> On 10/6/24 8:39 AM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>Which, as you have been told but seems to be above >>>>>>>>>>>>>>>>>>>> your head means that the execution of DDD, >>>>>>>>>>>>>>>>>>>
DDD emulated by each corresponding HHH that can >>>>>>>>>>>>>>>>>>>>>>> possibly
exist never returns. Each of these HHH emulators >>>>>>>>>>>>>>>>>>>>>>> that does
return 0 correctly reports the above non-halting >>>>>>>>>>>>>>>>>>>>>>> behavior.
No, the DDD return (if the HHH(DDD) gives an >>>>>>>>>>>>>>>>>>>>>> answer), just after the HHH that emulated them >>>>>>>>>>>>>>>>>>>>>> gave up.
DDD emulated by each corresponding HHH that can >>>>>>>>>>>>>>>>>>>>> possibly
exist never returns.
DDD emulated by each corresponding HHH >>>>>>>>>>>>>>>>>>>>> DDD emulated by each corresponding HHH >>>>>>>>>>>>>>>>>>>>> DDD emulated by each corresponding HHH >>>>>>>>>>>>>>>>>>>>> DDD emulated by each corresponding HHH >>>>>>>>>>>>>>>>>>>>
No, that isn't ignoring it, but taking into account >>>>>>>>>>>>>>>>>> that since HHH is defined to be a specific program, it >>>>>>>>>>>>>>>>>> has specific behavior.
The behavior of the executed DDD after the emulated >>>>>>>>>>>>>>>>> DDD has already been aborted is different than the >>>>>>>>>>>>>>>>> behavior of the emulated DDD that must be aborted. >>>>>>>>>>>>>>>>
The execution trace proves that the executed DDD has >>>>>>>>>>>>>>> different behavior that need not be aborted because >>>>>>>>>>>>>>> emulated DDD must be an is aborted.
Nope, whst instruction ACTUALLY EMULATE showed a different >>>>>>>>>>>>>> behavior than the executed DDD?
All you do is look at a DIFFERENT INPUT which is just a >>>>>>>>>>>>>> lie, since that isn't the DDD that HHH was given (since >>>>>>>>>>>>>> the PROGRAM DDD includes the all the exact code of the HHH >>>>>>>>>>>>>> that it calls, thus you can't change it to hypothosze a >>>>>>>>>>>>>> diffferent non- aborting HHH)
No one can be stupid enough to think that:
MUST BE ABORTED
is exactly the same as
NEED NOT BE ABORTED
Who said otherwise.
The directly executed DDD need not be aborted.
DDD emulated by HHH must be aborted, thus
proving that their behavior IS NOT THE SAME.
No, the design of HHH does abort its emulation, because if >>>>>>>>>>>> you had a DIFFERENT HHH, which would be given a DIFFERENT >>>>>>>>>>>> DDD (since DDD includes the HHH that it is calling) it would >>>>>>>>>>>> fail worse at the task at the meta- level by not answering. >>>>>>>>>>>>
That you are not addressing my points seems to be over your >>>>>>>>>>> head.
No, the fact that I *AM* adddressing your points and pointing >>>>>>>>>> out your error just proves that you are nothing but a stupid >>>>>>>>>> idiot.
That you don't even try to point out an error in what I say, >>>>>>>>>> proves that you don't actually care about what is right, but >>>>>>>>>> that you just want to blindly hold on to your position. The >>>>>>>>>> fact that you consistantly snip out much of the arguement
shows that you know you are defeated, but still insist on your >>>>>>>>>> WRONG position.
Halting is a property of PROGRAMS.
void DDD()
{
HHH(DDD);
return;
}
Terminating is a property of finite string machine descriptions. >>>>>>>>>
And, for the PROGRAM DDD, must include the FULL decription of >>>>>>>> the HHH that it calls.
It does and the source-code specifies that it does
yet this is simply over-your-head.
https://github.com/plolcott/x86utm/blob/master/Halt7.c
But that isn't the finite string you are claiming above.
When you include the code of HHH in DDD, then when you hypotosize
HHH not aborting, that hypothetical HHH is still given the DDD
that calls the HHH that DOES, and your hypothetical HHH proves
that this HHH is wrong.
No it continues to be you fail to pay complete attention
to every detail of every words that I said.
*THE FOLLOWING REMAINS TRUE NO MATTER WHAT HHH DOES*
DDD emulated by each corresponding HHH that can possibly
exist never returns.
No, because *DDD*, the one that was emulated by each of the HHH,
will HALT if that HHH(DDD) returns 0, just after its HHH aborted its
emulaiton.
PLEASE PLAY 100% COMPLETE ATTENTION TO THESE EXACT WORDS
DDD emulated by each corresponding HHH
that can possibly exist never returns.
Your incorrect paraphrase of my words proves that
you are either clueless or deliberately deceptive.
I am going with clueless.
No, and please *PAY* 100% complete attention to these exact words.
DDD emulated by HHH is NOT the same thing as the emulation of DDD by HHH.
DDD emulated by HHH, is the full behavior of the full program DDD,
which one we are talking about. That behavior does not "stop" just
becuase the HHH that was emulating it stopped its emulation.
I didn't "paraphrase" your words, I looked that the exact words you
said, and looked at the grammatical construction. If you disagree with
my analysys, point out the error.
Every executed HHH that returns 0 correctly reports that
no DDD emulated by its corresponding HHH ever returns.
You paraphrased this as some kind of "vacuous truth".
On 10/8/2024 6:51 AM, Richard Damon wrote:
On 10/7/24 9:28 PM, olcott wrote:
On 10/7/2024 8:11 PM, Richard Damon wrote:
On 10/7/24 8:58 PM, olcott wrote:
On 10/7/2024 7:48 PM, Richard Damon wrote:
On 10/7/24 7:36 PM, olcott wrote:
On 10/7/2024 6:04 PM, Richard Damon wrote:
On 10/7/24 6:57 PM, olcott wrote:
On 10/7/2024 5:39 PM, Richard Damon wrote:
On 10/7/24 8:08 AM, olcott wrote:
On 10/7/2024 6:02 AM, Richard Damon wrote:
On 10/6/24 10:05 PM, olcott wrote:
On 10/6/2024 8:29 PM, Richard Damon wrote:
On 10/6/24 8:05 PM, olcott wrote:
On 10/6/2024 5:36 PM, Richard Damon wrote:
On 10/6/24 3:05 PM, olcott wrote:
On 10/6/2024 1:52 PM, Richard Damon wrote:
On 10/6/24 2:32 PM, olcott wrote:
On 10/6/2024 1:13 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>> On 10/6/24 2:03 PM, olcott wrote:Nope, it is the exact same code on the exact same >>>>>>>>>>>>>>>>>> data, and thus does the exact same behavior. >>>>>>>>>>>>>>>>>>
On 10/6/2024 12:29 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>> On 10/6/24 1:07 PM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>> On 10/6/2024 11:59 AM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>> On 10/6/24 8:39 AM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>
gets to ignore the fact that DDD was defined to >>>>>>>>>>>>>>>>>>>>> have a pathological relationship with HHH that >>>>>>>>>>>>>>>>>>>>> HHH cannot ignore.Which, as you have been told but seems to be above >>>>>>>>>>>>>>>>>>>>>> your head means that the execution of DDD, >>>>>>>>>>>>>>>>>>>>>DDD emulated by each corresponding HHH that can >>>>>>>>>>>>>>>>>>>>>>>>> possibly
exist never returns. Each of these HHH >>>>>>>>>>>>>>>>>>>>>>>>> emulators that does
return 0 correctly reports the above non- >>>>>>>>>>>>>>>>>>>>>>>>> halting behavior.
No, the DDD return (if the HHH(DDD) gives an >>>>>>>>>>>>>>>>>>>>>>>> answer), just after the HHH that emulated them >>>>>>>>>>>>>>>>>>>>>>>> gave up.
DDD emulated by each corresponding HHH that can >>>>>>>>>>>>>>>>>>>>>>> possibly
exist never returns.
DDD emulated by each corresponding HHH >>>>>>>>>>>>>>>>>>>>>>> DDD emulated by each corresponding HHH >>>>>>>>>>>>>>>>>>>>>>> DDD emulated by each corresponding HHH >>>>>>>>>>>>>>>>>>>>>>> DDD emulated by each corresponding HHH >>>>>>>>>>>>>>>>>>>>>>
No, that isn't ignoring it, but taking into account >>>>>>>>>>>>>>>>>>>> that since HHH is defined to be a specific program, >>>>>>>>>>>>>>>>>>>> it has specific behavior.
The behavior of the executed DDD after the emulated >>>>>>>>>>>>>>>>>>> DDD has already been aborted is different than the >>>>>>>>>>>>>>>>>>> behavior of the emulated DDD that must be aborted. >>>>>>>>>>>>>>>>>>
The execution trace proves that the executed DDD has >>>>>>>>>>>>>>>>> different behavior that need not be aborted because >>>>>>>>>>>>>>>>> emulated DDD must be an is aborted.
Nope, whst instruction ACTUALLY EMULATE showed a >>>>>>>>>>>>>>>> different behavior than the executed DDD?
All you do is look at a DIFFERENT INPUT which is just a >>>>>>>>>>>>>>>> lie, since that isn't the DDD that HHH was given (since >>>>>>>>>>>>>>>> the PROGRAM DDD includes the all the exact code of the >>>>>>>>>>>>>>>> HHH that it calls, thus you can't change it to >>>>>>>>>>>>>>>> hypothosze a diffferent non- aborting HHH)
No one can be stupid enough to think that:
MUST BE ABORTED
is exactly the same as
NEED NOT BE ABORTED
Who said otherwise.
The directly executed DDD need not be aborted.
DDD emulated by HHH must be aborted, thus
proving that their behavior IS NOT THE SAME.
No, the design of HHH does abort its emulation, because if >>>>>>>>>>>>>> you had a DIFFERENT HHH, which would be given a DIFFERENT >>>>>>>>>>>>>> DDD (since DDD includes the HHH that it is calling) it >>>>>>>>>>>>>> would fail worse at the task at the meta- level by not >>>>>>>>>>>>>> answering.
That you are not addressing my points seems to be over your >>>>>>>>>>>>> head.
No, the fact that I *AM* adddressing your points and
pointing out your error just proves that you are nothing but >>>>>>>>>>>> a stupid idiot.
That you don't even try to point out an error in what I say, >>>>>>>>>>>> proves that you don't actually care about what is right, but >>>>>>>>>>>> that you just want to blindly hold on to your position. The >>>>>>>>>>>> fact that you consistantly snip out much of the arguement >>>>>>>>>>>> shows that you know you are defeated, but still insist on >>>>>>>>>>>> your WRONG position.
Halting is a property of PROGRAMS.
void DDD()
{
HHH(DDD);
return;
}
Terminating is a property of finite string machine descriptions. >>>>>>>>>>>
And, for the PROGRAM DDD, must include the FULL decription of >>>>>>>>>> the HHH that it calls.
It does and the source-code specifies that it does
yet this is simply over-your-head.
https://github.com/plolcott/x86utm/blob/master/Halt7.c
But that isn't the finite string you are claiming above.
When you include the code of HHH in DDD, then when you
hypotosize HHH not aborting, that hypothetical HHH is still
given the DDD that calls the HHH that DOES, and your
hypothetical HHH proves that this HHH is wrong.
No it continues to be you fail to pay complete attention
to every detail of every words that I said.
*THE FOLLOWING REMAINS TRUE NO MATTER WHAT HHH DOES*
DDD emulated by each corresponding HHH that can possibly
exist never returns.
No, because *DDD*, the one that was emulated by each of the HHH,
will HALT if that HHH(DDD) returns 0, just after its HHH aborted
its emulaiton.
PLEASE PLAY 100% COMPLETE ATTENTION TO THESE EXACT WORDS
DDD emulated by each corresponding HHH
that can possibly exist never returns.
Your incorrect paraphrase of my words proves that
you are either clueless or deliberately deceptive.
I am going with clueless.
No, and please *PAY* 100% complete attention to these exact words.
DDD emulated by HHH is NOT the same thing as the emulation of DDD by
HHH.
DDD emulated by HHH, is the full behavior of the full program DDD,
which one we are talking about. That behavior does not "stop" just
becuase the HHH that was emulating it stopped its emulation.
I didn't "paraphrase" your words, I looked that the exact words you
said, and looked at the grammatical construction. If you disagree
with my analysys, point out the error.
Every executed HHH that returns 0 correctly reports that
no DDD emulated by its corresponding HHH ever returns.
You paraphrased this as some kind of "vacuous truth".
I didn't paraphrase you, I showed you what the words mean, but
apparently you are too stupid to understand.
How can those HHH be correct when there answer is wrong.
There answer is wrong because for EVERY HHH that returned 0, the DDD
that the emulated WILL return,
"the DDD that the emulated WILL return"
Seems like gibberish nonsense.
Here is not non-gibberish way to say it:
No DDD emulated by its corresponding HHH ever returns.
it just that return happens after the point that HHH aborted its
emulation.
Also gibberish nonsense.
Once a process is killed this process does nothing.
https://www.linuxfoundation.org/blog/blog/classic-sysadmin-how-to-kill- a-process-from-the-command-line
On 10/8/2024 8:21 AM, Richard Damon wrote:
On 10/8/24 8:44 AM, olcott wrote:
On 10/8/2024 6:51 AM, Richard Damon wrote:
On 10/7/24 9:28 PM, olcott wrote:
On 10/7/2024 8:11 PM, Richard Damon wrote:
On 10/7/24 8:58 PM, olcott wrote:
On 10/7/2024 7:48 PM, Richard Damon wrote:
On 10/7/24 7:36 PM, olcott wrote:
On 10/7/2024 6:04 PM, Richard Damon wrote:
On 10/7/24 6:57 PM, olcott wrote:
On 10/7/2024 5:39 PM, Richard Damon wrote:
On 10/7/24 8:08 AM, olcott wrote:
On 10/7/2024 6:02 AM, Richard Damon wrote:
On 10/6/24 10:05 PM, olcott wrote:
On 10/6/2024 8:29 PM, Richard Damon wrote:
On 10/6/24 8:05 PM, olcott wrote:
On 10/6/2024 5:36 PM, Richard Damon wrote:
On 10/6/24 3:05 PM, olcott wrote:
On 10/6/2024 1:52 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>> On 10/6/24 2:32 PM, olcott wrote:
On 10/6/2024 1:13 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>> On 10/6/24 2:03 PM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>> On 10/6/2024 12:29 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>> On 10/6/24 1:07 PM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>> On 10/6/2024 11:59 AM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>>>> On 10/6/24 8:39 AM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>Nope, it is the exact same code on the exact same >>>>>>>>>>>>>>>>>>>> data, and thus does the exact same behavior. >>>>>>>>>>>>>>>>>>>>
gets to ignore the fact that DDD was defined to >>>>>>>>>>>>>>>>>>>>>>> have a pathological relationship with HHH that >>>>>>>>>>>>>>>>>>>>>>> HHH cannot ignore.Which, as you have been told but seems to be >>>>>>>>>>>>>>>>>>>>>>>> above your head means that the execution of DDD, >>>>>>>>>>>>>>>>>>>>>>>DDD emulated by each corresponding HHH that >>>>>>>>>>>>>>>>>>>>>>>>>>> can possibly
exist never returns. Each of these HHH >>>>>>>>>>>>>>>>>>>>>>>>>>> emulators that does
return 0 correctly reports the above non- >>>>>>>>>>>>>>>>>>>>>>>>>>> halting behavior.
No, the DDD return (if the HHH(DDD) gives an >>>>>>>>>>>>>>>>>>>>>>>>>> answer), just after the HHH that emulated them >>>>>>>>>>>>>>>>>>>>>>>>>> gave up.
DDD emulated by each corresponding HHH that can >>>>>>>>>>>>>>>>>>>>>>>>> possibly
exist never returns.
DDD emulated by each corresponding HHH >>>>>>>>>>>>>>>>>>>>>>>>> DDD emulated by each corresponding HHH >>>>>>>>>>>>>>>>>>>>>>>>> DDD emulated by each corresponding HHH >>>>>>>>>>>>>>>>>>>>>>>>> DDD emulated by each corresponding HHH >>>>>>>>>>>>>>>>>>>>>>>>
No, that isn't ignoring it, but taking into >>>>>>>>>>>>>>>>>>>>>> account that since HHH is defined to be a specific >>>>>>>>>>>>>>>>>>>>>> program, it has specific behavior. >>>>>>>>>>>>>>>>>>>>>>
The behavior of the executed DDD after the emulated >>>>>>>>>>>>>>>>>>>>> DDD has already been aborted is different than the >>>>>>>>>>>>>>>>>>>>> behavior of the emulated DDD that must be aborted. >>>>>>>>>>>>>>>>>>>>
The execution trace proves that the executed DDD has >>>>>>>>>>>>>>>>>>> different behavior that need not be aborted because >>>>>>>>>>>>>>>>>>> emulated DDD must be an is aborted.
Nope, whst instruction ACTUALLY EMULATE showed a >>>>>>>>>>>>>>>>>> different behavior than the executed DDD?
All you do is look at a DIFFERENT INPUT which is just >>>>>>>>>>>>>>>>>> a lie, since that isn't the DDD that HHH was given >>>>>>>>>>>>>>>>>> (since the PROGRAM DDD includes the all the exact code >>>>>>>>>>>>>>>>>> of the HHH that it calls, thus you can't change it to >>>>>>>>>>>>>>>>>> hypothosze a diffferent non- aborting HHH) >>>>>>>>>>>>>>>>>>
No one can be stupid enough to think that: >>>>>>>>>>>>>>>>>>> MUST BE ABORTED
is exactly the same as
NEED NOT BE ABORTED
Who said otherwise.
The directly executed DDD need not be aborted. >>>>>>>>>>>>>>>>> DDD emulated by HHH must be aborted, thus
proving that their behavior IS NOT THE SAME. >>>>>>>>>>>>>>>>>
No, the design of HHH does abort its emulation, because >>>>>>>>>>>>>>>> if you had a DIFFERENT HHH, which would be given a >>>>>>>>>>>>>>>> DIFFERENT DDD (since DDD includes the HHH that it is >>>>>>>>>>>>>>>> calling) it would fail worse at the task at the meta- >>>>>>>>>>>>>>>> level by not answering.
That you are not addressing my points seems to be over >>>>>>>>>>>>>>> your head.
No, the fact that I *AM* adddressing your points and >>>>>>>>>>>>>> pointing out your error just proves that you are nothing >>>>>>>>>>>>>> but a stupid idiot.
That you don't even try to point out an error in what I >>>>>>>>>>>>>> say, proves that you don't actually care about what is >>>>>>>>>>>>>> right, but that you just want to blindly hold on to your >>>>>>>>>>>>>> position. The fact that you consistantly snip out much of >>>>>>>>>>>>>> the arguement shows that you know you are defeated, but >>>>>>>>>>>>>> still insist on your WRONG position.
Halting is a property of PROGRAMS.
void DDD()
{
HHH(DDD);
return;
}
Terminating is a property of finite string machine
descriptions.
And, for the PROGRAM DDD, must include the FULL decription >>>>>>>>>>>> of the HHH that it calls.
It does and the source-code specifies that it does
yet this is simply over-your-head.
https://github.com/plolcott/x86utm/blob/master/Halt7.c
But that isn't the finite string you are claiming above.
When you include the code of HHH in DDD, then when you
hypotosize HHH not aborting, that hypothetical HHH is still >>>>>>>>>> given the DDD that calls the HHH that DOES, and your
hypothetical HHH proves that this HHH is wrong.
No it continues to be you fail to pay complete attention
to every detail of every words that I said.
*THE FOLLOWING REMAINS TRUE NO MATTER WHAT HHH DOES*
DDD emulated by each corresponding HHH that can possibly
exist never returns.
No, because *DDD*, the one that was emulated by each of the HHH, >>>>>>>> will HALT if that HHH(DDD) returns 0, just after its HHH aborted >>>>>>>> its emulaiton.
PLEASE PLAY 100% COMPLETE ATTENTION TO THESE EXACT WORDS
DDD emulated by each corresponding HHH
that can possibly exist never returns.
Your incorrect paraphrase of my words proves that
you are either clueless or deliberately deceptive.
I am going with clueless.
No, and please *PAY* 100% complete attention to these exact words. >>>>>>
DDD emulated by HHH is NOT the same thing as the emulation of DDD
by HHH.
DDD emulated by HHH, is the full behavior of the full program DDD, >>>>>> which one we are talking about. That behavior does not "stop" just >>>>>> becuase the HHH that was emulating it stopped its emulation.
I didn't "paraphrase" your words, I looked that the exact words
you said, and looked at the grammatical construction. If you
disagree with my analysys, point out the error.
Every executed HHH that returns 0 correctly reports that
no DDD emulated by its corresponding HHH ever returns.
You paraphrased this as some kind of "vacuous truth".
I didn't paraphrase you, I showed you what the words mean, but
apparently you are too stupid to understand.
How can those HHH be correct when there answer is wrong.
There answer is wrong because for EVERY HHH that returned 0, the DDD
that the emulated WILL return,
"the DDD that the emulated WILL return"
Seems like gibberish nonsense.
type, the DDD that was emullated WILL return
counter-factual
On 10/8/2024 9:10 AM, Richard Damon wrote:
On 10/8/24 10:03 AM, olcott wrote:
On 10/8/2024 8:21 AM, Richard Damon wrote:
On 10/8/24 8:44 AM, olcott wrote:
On 10/8/2024 6:51 AM, Richard Damon wrote:
On 10/7/24 9:28 PM, olcott wrote:
On 10/7/2024 8:11 PM, Richard Damon wrote:
On 10/7/24 8:58 PM, olcott wrote:
On 10/7/2024 7:48 PM, Richard Damon wrote:
On 10/7/24 7:36 PM, olcott wrote:
On 10/7/2024 6:04 PM, Richard Damon wrote:
On 10/7/24 6:57 PM, olcott wrote:
On 10/7/2024 5:39 PM, Richard Damon wrote:
On 10/7/24 8:08 AM, olcott wrote:
On 10/7/2024 6:02 AM, Richard Damon wrote:
On 10/6/24 10:05 PM, olcott wrote:
On 10/6/2024 8:29 PM, Richard Damon wrote:
On 10/6/24 8:05 PM, olcott wrote:
On 10/6/2024 5:36 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>> On 10/6/24 3:05 PM, olcott wrote:
On 10/6/2024 1:52 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>> On 10/6/24 2:32 PM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>> On 10/6/2024 1:13 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>> On 10/6/24 2:03 PM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>> On 10/6/2024 12:29 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>>>> On 10/6/24 1:07 PM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>> On 10/6/2024 11:59 AM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>> On 10/6/24 8:39 AM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>
Nope, it is the exact same code on the exact same >>>>>>>>>>>>>>>>>>>>>> data, and thus does the exact same behavior. >>>>>>>>>>>>>>>>>>>>>>gets to ignore the fact that DDD was defined to >>>>>>>>>>>>>>>>>>>>>>>>> have a pathological relationship with HHH that >>>>>>>>>>>>>>>>>>>>>>>>> HHH cannot ignore.Which, as you have been told but seems to be >>>>>>>>>>>>>>>>>>>>>>>>>> above your head means that the execution of DDD, >>>>>>>>>>>>>>>>>>>>>>>>>DDD emulated by each corresponding HHH that >>>>>>>>>>>>>>>>>>>>>>>>>>>>> can possibly
exist never returns. Each of these HHH >>>>>>>>>>>>>>>>>>>>>>>>>>>>> emulators that does
return 0 correctly reports the above non- >>>>>>>>>>>>>>>>>>>>>>>>>>>>> halting behavior.
No, the DDD return (if the HHH(DDD) gives an >>>>>>>>>>>>>>>>>>>>>>>>>>>> answer), just after the HHH that emulated >>>>>>>>>>>>>>>>>>>>>>>>>>>> them gave up.
DDD emulated by each corresponding HHH that >>>>>>>>>>>>>>>>>>>>>>>>>>> can possibly
exist never returns.
DDD emulated by each corresponding HHH >>>>>>>>>>>>>>>>>>>>>>>>>>> DDD emulated by each corresponding HHH >>>>>>>>>>>>>>>>>>>>>>>>>>> DDD emulated by each corresponding HHH >>>>>>>>>>>>>>>>>>>>>>>>>>> DDD emulated by each corresponding HHH >>>>>>>>>>>>>>>>>>>>>>>>>>
No, that isn't ignoring it, but taking into >>>>>>>>>>>>>>>>>>>>>>>> account that since HHH is defined to be a >>>>>>>>>>>>>>>>>>>>>>>> specific program, it has specific behavior. >>>>>>>>>>>>>>>>>>>>>>>>
The behavior of the executed DDD after the emulated >>>>>>>>>>>>>>>>>>>>>>> DDD has already been aborted is different than the >>>>>>>>>>>>>>>>>>>>>>> behavior of the emulated DDD that must be aborted. >>>>>>>>>>>>>>>>>>>>>>
The execution trace proves that the executed DDD has >>>>>>>>>>>>>>>>>>>>> different behavior that need not be aborted because >>>>>>>>>>>>>>>>>>>>> emulated DDD must be an is aborted.
Nope, whst instruction ACTUALLY EMULATE showed a >>>>>>>>>>>>>>>>>>>> different behavior than the executed DDD? >>>>>>>>>>>>>>>>>>>>
All you do is look at a DIFFERENT INPUT which is >>>>>>>>>>>>>>>>>>>> just a lie, since that isn't the DDD that HHH was >>>>>>>>>>>>>>>>>>>> given (since the PROGRAM DDD includes the all the >>>>>>>>>>>>>>>>>>>> exact code of the HHH that it calls, thus you can't >>>>>>>>>>>>>>>>>>>> change it to hypothosze a diffferent non- aborting HHH) >>>>>>>>>>>>>>>>>>>>
No one can be stupid enough to think that: >>>>>>>>>>>>>>>>>>>>> MUST BE ABORTED
is exactly the same as
NEED NOT BE ABORTED
Who said otherwise.
The directly executed DDD need not be aborted. >>>>>>>>>>>>>>>>>>> DDD emulated by HHH must be aborted, thus >>>>>>>>>>>>>>>>>>> proving that their behavior IS NOT THE SAME. >>>>>>>>>>>>>>>>>>>
No, the design of HHH does abort its emulation, >>>>>>>>>>>>>>>>>> because if you had a DIFFERENT HHH, which would be >>>>>>>>>>>>>>>>>> given a DIFFERENT DDD (since DDD includes the HHH that >>>>>>>>>>>>>>>>>> it is calling) it would fail worse at the task at the >>>>>>>>>>>>>>>>>> meta- level by not answering.
That you are not addressing my points seems to be over >>>>>>>>>>>>>>>>> your head.
No, the fact that I *AM* adddressing your points and >>>>>>>>>>>>>>>> pointing out your error just proves that you are nothing >>>>>>>>>>>>>>>> but a stupid idiot.
That you don't even try to point out an error in what I >>>>>>>>>>>>>>>> say, proves that you don't actually care about what is >>>>>>>>>>>>>>>> right, but that you just want to blindly hold on to your >>>>>>>>>>>>>>>> position. The fact that you consistantly snip out much >>>>>>>>>>>>>>>> of the arguement shows that you know you are defeated, >>>>>>>>>>>>>>>> but still insist on your WRONG position.
Halting is a property of PROGRAMS.
void DDD()
{
HHH(DDD);
return;
}
Terminating is a property of finite string machine >>>>>>>>>>>>>>> descriptions.
And, for the PROGRAM DDD, must include the FULL decription >>>>>>>>>>>>>> of the HHH that it calls.
It does and the source-code specifies that it does
yet this is simply over-your-head.
https://github.com/plolcott/x86utm/blob/master/Halt7.c >>>>>>>>>>>>>
But that isn't the finite string you are claiming above. >>>>>>>>>>>>
When you include the code of HHH in DDD, then when you >>>>>>>>>>>> hypotosize HHH not aborting, that hypothetical HHH is still >>>>>>>>>>>> given the DDD that calls the HHH that DOES, and your
hypothetical HHH proves that this HHH is wrong.
No it continues to be you fail to pay complete attention >>>>>>>>>>> to every detail of every words that I said.
*THE FOLLOWING REMAINS TRUE NO MATTER WHAT HHH DOES*
DDD emulated by each corresponding HHH that can possibly >>>>>>>>>>> exist never returns.
No, because *DDD*, the one that was emulated by each of the >>>>>>>>>> HHH, will HALT if that HHH(DDD) returns 0, just after its HHH >>>>>>>>>> aborted its emulaiton.
PLEASE PLAY 100% COMPLETE ATTENTION TO THESE EXACT WORDS
DDD emulated by each corresponding HHH
that can possibly exist never returns.
Your incorrect paraphrase of my words proves that
you are either clueless or deliberately deceptive.
I am going with clueless.
No, and please *PAY* 100% complete attention to these exact words. >>>>>>>>
DDD emulated by HHH is NOT the same thing as the emulation of
DDD by HHH.
DDD emulated by HHH, is the full behavior of the full program
DDD, which one we are talking about. That behavior does not
"stop" just becuase the HHH that was emulating it stopped its
emulation.
I didn't "paraphrase" your words, I looked that the exact words >>>>>>>> you said, and looked at the grammatical construction. If you
disagree with my analysys, point out the error.
Every executed HHH that returns 0 correctly reports that
no DDD emulated by its corresponding HHH ever returns.
You paraphrased this as some kind of "vacuous truth".
I didn't paraphrase you, I showed you what the words mean, but
apparently you are too stupid to understand.
How can those HHH be correct when there answer is wrong.
There answer is wrong because for EVERY HHH that returned 0, the
DDD that the emulated WILL return,
"the DDD that the emulated WILL return"
Seems like gibberish nonsense.
type, the DDD that was emullated WILL return
counter-factual
Proven by your own traces.
01 void DDD()
02 {
03 HHH(DDD);
04 return;
05 }
Every executed HHH emulates 01,02,03 of DDD
then either endlessly emulates itself emulating lines 01,02,03
of DDD never reaching line 04 of DDD or aborts the emulation
before ever reaching line 04 of DDD and returns some value.
Every executed HHH that returns 0 correctly reports that DDD
emulated by HHH cannot possibly reach its own line 04 no matter
what this HHH does.
On 10/8/2024 12:51 PM, Richard Damon wrote:
On 10/8/24 10:41 AM, olcott wrote:
On 10/8/2024 9:10 AM, Richard Damon wrote:
On 10/8/24 10:03 AM, olcott wrote:
On 10/8/2024 8:21 AM, Richard Damon wrote:
On 10/8/24 8:44 AM, olcott wrote:
On 10/8/2024 6:51 AM, Richard Damon wrote:
On 10/7/24 9:28 PM, olcott wrote:
On 10/7/2024 8:11 PM, Richard Damon wrote:
On 10/7/24 8:58 PM, olcott wrote:
On 10/7/2024 7:48 PM, Richard Damon wrote:
On 10/7/24 7:36 PM, olcott wrote:
On 10/7/2024 6:04 PM, Richard Damon wrote:
On 10/7/24 6:57 PM, olcott wrote:
On 10/7/2024 5:39 PM, Richard Damon wrote:
On 10/7/24 8:08 AM, olcott wrote:
On 10/7/2024 6:02 AM, Richard Damon wrote:
On 10/6/24 10:05 PM, olcott wrote:
On 10/6/2024 8:29 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>> On 10/6/24 8:05 PM, olcott wrote:
On 10/6/2024 5:36 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>> On 10/6/24 3:05 PM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>> On 10/6/2024 1:52 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>> On 10/6/24 2:32 PM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>> On 10/6/2024 1:13 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>>>> On 10/6/24 2:03 PM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>> On 10/6/2024 12:29 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>> On 10/6/24 1:07 PM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 10/6/2024 11:59 AM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 10/6/24 8:39 AM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
Nope, whst instruction ACTUALLY EMULATE showed a >>>>>>>>>>>>>>>>>>>>>> different behavior than the executed DDD? >>>>>>>>>>>>>>>>>>>>>>Nope, it is the exact same code on the exact >>>>>>>>>>>>>>>>>>>>>>>> same data, and thus does the exact same behavior. >>>>>>>>>>>>>>>>>>>>>>>>Which, as you have been told but seems to be >>>>>>>>>>>>>>>>>>>>>>>>>>>> above your head means that the execution of >>>>>>>>>>>>>>>>>>>>>>>>>>>> DDD,DDD emulated by each corresponding HHH >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that can possibly >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> exist never returns. Each of these HHH >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> emulators that does >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> return 0 correctly reports the above non- >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> halting behavior. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
No, the DDD return (if the HHH(DDD) gives >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> an answer), just after the HHH that >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> emulated them gave up. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
DDD emulated by each corresponding HHH that >>>>>>>>>>>>>>>>>>>>>>>>>>>>> can possibly
exist never returns. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>
DDD emulated by each corresponding HHH >>>>>>>>>>>>>>>>>>>>>>>>>>>>> DDD emulated by each corresponding HHH >>>>>>>>>>>>>>>>>>>>>>>>>>>>> DDD emulated by each corresponding HHH >>>>>>>>>>>>>>>>>>>>>>>>>>>>> DDD emulated by each corresponding HHH >>>>>>>>>>>>>>>>>>>>>>>>>>>>
gets to ignore the fact that DDD was defined to >>>>>>>>>>>>>>>>>>>>>>>>>>> have a pathological relationship with HHH that >>>>>>>>>>>>>>>>>>>>>>>>>>> HHH cannot ignore.
No, that isn't ignoring it, but taking into >>>>>>>>>>>>>>>>>>>>>>>>>> account that since HHH is defined to be a >>>>>>>>>>>>>>>>>>>>>>>>>> specific program, it has specific behavior. >>>>>>>>>>>>>>>>>>>>>>>>>>
The behavior of the executed DDD after the >>>>>>>>>>>>>>>>>>>>>>>>> emulated
DDD has already been aborted is different than the >>>>>>>>>>>>>>>>>>>>>>>>> behavior of the emulated DDD that must be aborted. >>>>>>>>>>>>>>>>>>>>>>>>
The execution trace proves that the executed DDD has >>>>>>>>>>>>>>>>>>>>>>> different behavior that need not be aborted because >>>>>>>>>>>>>>>>>>>>>>> emulated DDD must be an is aborted. >>>>>>>>>>>>>>>>>>>>>>
All you do is look at a DIFFERENT INPUT which is >>>>>>>>>>>>>>>>>>>>>> just a lie, since that isn't the DDD that HHH was >>>>>>>>>>>>>>>>>>>>>> given (since the PROGRAM DDD includes the all the >>>>>>>>>>>>>>>>>>>>>> exact code of the HHH that it calls, thus you >>>>>>>>>>>>>>>>>>>>>> can't change it to hypothosze a diffferent non- >>>>>>>>>>>>>>>>>>>>>> aborting HHH)
No one can be stupid enough to think that: >>>>>>>>>>>>>>>>>>>>>>> MUST BE ABORTED
is exactly the same as
NEED NOT BE ABORTED
Who said otherwise.
The directly executed DDD need not be aborted. >>>>>>>>>>>>>>>>>>>>> DDD emulated by HHH must be aborted, thus >>>>>>>>>>>>>>>>>>>>> proving that their behavior IS NOT THE SAME. >>>>>>>>>>>>>>>>>>>>>
No, the design of HHH does abort its emulation, >>>>>>>>>>>>>>>>>>>> because if you had a DIFFERENT HHH, which would be >>>>>>>>>>>>>>>>>>>> given a DIFFERENT DDD (since DDD includes the HHH >>>>>>>>>>>>>>>>>>>> that it is calling) it would fail worse at the task >>>>>>>>>>>>>>>>>>>> at the meta- level by not answering.
That you are not addressing my points seems to be >>>>>>>>>>>>>>>>>>> over your head.
No, the fact that I *AM* adddressing your points and >>>>>>>>>>>>>>>>>> pointing out your error just proves that you are >>>>>>>>>>>>>>>>>> nothing but a stupid idiot.
That you don't even try to point out an error in what >>>>>>>>>>>>>>>>>> I say, proves that you don't actually care about what >>>>>>>>>>>>>>>>>> is right, but that you just want to blindly hold on to >>>>>>>>>>>>>>>>>> your position. The fact that you consistantly snip out >>>>>>>>>>>>>>>>>> much of the arguement shows that you know you are >>>>>>>>>>>>>>>>>> defeated, but still insist on your WRONG position. >>>>>>>>>>>>>>>>>>
Halting is a property of PROGRAMS.
void DDD()
{
HHH(DDD);
return;
}
Terminating is a property of finite string machine >>>>>>>>>>>>>>>>> descriptions.
And, for the PROGRAM DDD, must include the FULL >>>>>>>>>>>>>>>> decription of the HHH that it calls.
It does and the source-code specifies that it does >>>>>>>>>>>>>>> yet this is simply over-your-head.
https://github.com/plolcott/x86utm/blob/master/Halt7.c >>>>>>>>>>>>>>>
But that isn't the finite string you are claiming above. >>>>>>>>>>>>>>
When you include the code of HHH in DDD, then when you >>>>>>>>>>>>>> hypotosize HHH not aborting, that hypothetical HHH is >>>>>>>>>>>>>> still given the DDD that calls the HHH that DOES, and your >>>>>>>>>>>>>> hypothetical HHH proves that this HHH is wrong.
No it continues to be you fail to pay complete attention >>>>>>>>>>>>> to every detail of every words that I said.
*THE FOLLOWING REMAINS TRUE NO MATTER WHAT HHH DOES* >>>>>>>>>>>>> DDD emulated by each corresponding HHH that can possibly >>>>>>>>>>>>> exist never returns.
No, because *DDD*, the one that was emulated by each of the >>>>>>>>>>>> HHH, will HALT if that HHH(DDD) returns 0, just after its >>>>>>>>>>>> HHH aborted its emulaiton.
PLEASE PLAY 100% COMPLETE ATTENTION TO THESE EXACT WORDS >>>>>>>>>>>
DDD emulated by each corresponding HHH
that can possibly exist never returns.
Your incorrect paraphrase of my words proves that
you are either clueless or deliberately deceptive.
I am going with clueless.
No, and please *PAY* 100% complete attention to these exact >>>>>>>>>> words.
DDD emulated by HHH is NOT the same thing as the emulation of >>>>>>>>>> DDD by HHH.
DDD emulated by HHH, is the full behavior of the full program >>>>>>>>>> DDD, which one we are talking about. That behavior does not >>>>>>>>>> "stop" just becuase the HHH that was emulating it stopped its >>>>>>>>>> emulation.
I didn't "paraphrase" your words, I looked that the exact
words you said, and looked at the grammatical construction. If >>>>>>>>>> you disagree with my analysys, point out the error.
Every executed HHH that returns 0 correctly reports that
no DDD emulated by its corresponding HHH ever returns.
You paraphrased this as some kind of "vacuous truth".
I didn't paraphrase you, I showed you what the words mean, but >>>>>>>> apparently you are too stupid to understand.
How can those HHH be correct when there answer is wrong.
There answer is wrong because for EVERY HHH that returned 0, the >>>>>>>> DDD that the emulated WILL return,
"the DDD that the emulated WILL return"
Seems like gibberish nonsense.
type, the DDD that was emullated WILL return
counter-factual
Proven by your own traces.
01 void DDD()
02 {
03 HHH(DDD);
04 return;
05 }
Every executed HHH emulates 01,02,03 of DDD
then either endlessly emulates itself emulating lines 01,02,03
of DDD never reaching line 04 of DDD or aborts the emulation
before ever reaching line 04 of DDD and returns some value.
So, you are not ADMITTING that the above is not a proper "finite-
string" represention of the program DDD, as it doesn't define what DDD
actually does as it depend on which of the choices HHH does.
This may all be your unintentional inability
to pay close enough attention.
DDD emulated by each corresponding HHH
that can possibly exist never returns
NO MATTER WTF THAT ITS EXECUTED HHH DOES.
On 10/8/2024 3:48 PM, Richard Damon wrote:
On 10/8/24 3:11 PM, olcott wrote:
On 10/8/2024 12:51 PM, Richard Damon wrote:
On 10/8/24 10:41 AM, olcott wrote:
On 10/8/2024 9:10 AM, Richard Damon wrote:
On 10/8/24 10:03 AM, olcott wrote:
On 10/8/2024 8:21 AM, Richard Damon wrote:
On 10/8/24 8:44 AM, olcott wrote:
On 10/8/2024 6:51 AM, Richard Damon wrote:
On 10/7/24 9:28 PM, olcott wrote:
On 10/7/2024 8:11 PM, Richard Damon wrote:
On 10/7/24 8:58 PM, olcott wrote:
On 10/7/2024 7:48 PM, Richard Damon wrote:
On 10/7/24 7:36 PM, olcott wrote:
On 10/7/2024 6:04 PM, Richard Damon wrote:
On 10/7/24 6:57 PM, olcott wrote:
On 10/7/2024 5:39 PM, Richard Damon wrote:
On 10/7/24 8:08 AM, olcott wrote:
On 10/7/2024 6:02 AM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>> On 10/6/24 10:05 PM, olcott wrote:
On 10/6/2024 8:29 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>> On 10/6/24 8:05 PM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>> On 10/6/2024 5:36 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>> On 10/6/24 3:05 PM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>> On 10/6/2024 1:52 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>>>> On 10/6/24 2:32 PM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>> On 10/6/2024 1:13 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>> On 10/6/24 2:03 PM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 10/6/2024 12:29 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 10/6/24 1:07 PM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 10/6/2024 11:59 AM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 10/6/24 8:39 AM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
Nope, whst instruction ACTUALLY EMULATE showed a >>>>>>>>>>>>>>>>>>>>>>>> different behavior than the executed DDD? >>>>>>>>>>>>>>>>>>>>>>>>Which, as you have been told but seems to >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> be above your head means that the >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> execution of DDD,DDD emulated by each corresponding HHH >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that can possibly >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> exist never returns. Each of these HHH >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> emulators that does >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> return 0 correctly reports the above >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> non- halting behavior. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
No, the DDD return (if the HHH(DDD) >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> gives an answer), just after the HHH >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that emulated them gave up. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
DDD emulated by each corresponding HHH >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that can possibly >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> exist never returns. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
DDD emulated by each corresponding HHH >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> DDD emulated by each corresponding HHH >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> DDD emulated by each corresponding HHH >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> DDD emulated by each corresponding HHH >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
gets to ignore the fact that DDD was >>>>>>>>>>>>>>>>>>>>>>>>>>>>> defined to
have a pathological relationship with HHH that >>>>>>>>>>>>>>>>>>>>>>>>>>>>> HHH cannot ignore.
No, that isn't ignoring it, but taking into >>>>>>>>>>>>>>>>>>>>>>>>>>>> account that since HHH is defined to be a >>>>>>>>>>>>>>>>>>>>>>>>>>>> specific program, it has specific behavior. >>>>>>>>>>>>>>>>>>>>>>>>>>>>
The behavior of the executed DDD after the >>>>>>>>>>>>>>>>>>>>>>>>>>> emulated
DDD has already been aborted is different >>>>>>>>>>>>>>>>>>>>>>>>>>> than the
behavior of the emulated DDD that must be >>>>>>>>>>>>>>>>>>>>>>>>>>> aborted.
Nope, it is the exact same code on the exact >>>>>>>>>>>>>>>>>>>>>>>>>> same data, and thus does the exact same behavior. >>>>>>>>>>>>>>>>>>>>>>>>>>
The execution trace proves that the executed >>>>>>>>>>>>>>>>>>>>>>>>> DDD has
different behavior that need not be aborted >>>>>>>>>>>>>>>>>>>>>>>>> because
emulated DDD must be an is aborted. >>>>>>>>>>>>>>>>>>>>>>>>
All you do is look at a DIFFERENT INPUT which is >>>>>>>>>>>>>>>>>>>>>>>> just a lie, since that isn't the DDD that HHH >>>>>>>>>>>>>>>>>>>>>>>> was given (since the PROGRAM DDD includes the >>>>>>>>>>>>>>>>>>>>>>>> all the exact code of the HHH that it calls, >>>>>>>>>>>>>>>>>>>>>>>> thus you can't change it to hypothosze a >>>>>>>>>>>>>>>>>>>>>>>> diffferent non- aborting HHH)
No one can be stupid enough to think that: >>>>>>>>>>>>>>>>>>>>>>>>> MUST BE ABORTED
is exactly the same as
NEED NOT BE ABORTED
Who said otherwise.
The directly executed DDD need not be aborted. >>>>>>>>>>>>>>>>>>>>>>> DDD emulated by HHH must be aborted, thus >>>>>>>>>>>>>>>>>>>>>>> proving that their behavior IS NOT THE SAME. >>>>>>>>>>>>>>>>>>>>>>>
No, the design of HHH does abort its emulation, >>>>>>>>>>>>>>>>>>>>>> because if you had a DIFFERENT HHH, which would be >>>>>>>>>>>>>>>>>>>>>> given a DIFFERENT DDD (since DDD includes the HHH >>>>>>>>>>>>>>>>>>>>>> that it is calling) it would fail worse at the >>>>>>>>>>>>>>>>>>>>>> task at the meta- level by not answering. >>>>>>>>>>>>>>>>>>>>>>
That you are not addressing my points seems to be >>>>>>>>>>>>>>>>>>>>> over your head.
No, the fact that I *AM* adddressing your points and >>>>>>>>>>>>>>>>>>>> pointing out your error just proves that you are >>>>>>>>>>>>>>>>>>>> nothing but a stupid idiot.
That you don't even try to point out an error in >>>>>>>>>>>>>>>>>>>> what I say, proves that you don't actually care >>>>>>>>>>>>>>>>>>>> about what is right, but that you just want to >>>>>>>>>>>>>>>>>>>> blindly hold on to your position. The fact that you >>>>>>>>>>>>>>>>>>>> consistantly snip out much of the arguement shows >>>>>>>>>>>>>>>>>>>> that you know you are defeated, but still insist on >>>>>>>>>>>>>>>>>>>> your WRONG position.
Halting is a property of PROGRAMS.
void DDD()
{
HHH(DDD);
return;
}
Terminating is a property of finite string machine >>>>>>>>>>>>>>>>>>> descriptions.
And, for the PROGRAM DDD, must include the FULL >>>>>>>>>>>>>>>>>> decription of the HHH that it calls.
It does and the source-code specifies that it does >>>>>>>>>>>>>>>>> yet this is simply over-your-head.
https://github.com/plolcott/x86utm/blob/master/Halt7.c >>>>>>>>>>>>>>>>>
But that isn't the finite string you are claiming above. >>>>>>>>>>>>>>>>
When you include the code of HHH in DDD, then when you >>>>>>>>>>>>>>>> hypotosize HHH not aborting, that hypothetical HHH is >>>>>>>>>>>>>>>> still given the DDD that calls the HHH that DOES, and >>>>>>>>>>>>>>>> your hypothetical HHH proves that this HHH is wrong. >>>>>>>>>>>>>>>>
No it continues to be you fail to pay complete attention >>>>>>>>>>>>>>> to every detail of every words that I said.
*THE FOLLOWING REMAINS TRUE NO MATTER WHAT HHH DOES* >>>>>>>>>>>>>>> DDD emulated by each corresponding HHH that can possibly >>>>>>>>>>>>>>> exist never returns.
No, because *DDD*, the one that was emulated by each of >>>>>>>>>>>>>> the HHH, will HALT if that HHH(DDD) returns 0, just after >>>>>>>>>>>>>> its HHH aborted its emulaiton.
PLEASE PLAY 100% COMPLETE ATTENTION TO THESE EXACT WORDS >>>>>>>>>>>>>
DDD emulated by each corresponding HHH
that can possibly exist never returns.
Your incorrect paraphrase of my words proves that
you are either clueless or deliberately deceptive.
I am going with clueless.
No, and please *PAY* 100% complete attention to these exact >>>>>>>>>>>> words.
DDD emulated by HHH is NOT the same thing as the emulation >>>>>>>>>>>> of DDD by HHH.
DDD emulated by HHH, is the full behavior of the full
program DDD, which one we are talking about. That behavior >>>>>>>>>>>> does not "stop" just becuase the HHH that was emulating it >>>>>>>>>>>> stopped its emulation.
I didn't "paraphrase" your words, I looked that the exact >>>>>>>>>>>> words you said, and looked at the grammatical construction. >>>>>>>>>>>> If you disagree with my analysys, point out the error. >>>>>>>>>>>>
Every executed HHH that returns 0 correctly reports that >>>>>>>>>>> no DDD emulated by its corresponding HHH ever returns.
You paraphrased this as some kind of "vacuous truth".
I didn't paraphrase you, I showed you what the words mean, but >>>>>>>>>> apparently you are too stupid to understand.
How can those HHH be correct when there answer is wrong.
There answer is wrong because for EVERY HHH that returned 0, >>>>>>>>>> the DDD that the emulated WILL return,
"the DDD that the emulated WILL return"
Seems like gibberish nonsense.
type, the DDD that was emullated WILL return
counter-factual
Proven by your own traces.
01 void DDD()
02 {
03 HHH(DDD);
04 return;
05 }
Every executed HHH emulates 01,02,03 of DDD
then either endlessly emulates itself emulating lines 01,02,03
of DDD never reaching line 04 of DDD or aborts the emulation
before ever reaching line 04 of DDD and returns some value.
So, you are not ADMITTING that the above is not a proper "finite-
string" represention of the program DDD, as it doesn't define what
DDD actually does as it depend on which of the choices HHH does.
This may all be your unintentional inability
to pay close enough attention.
No, it is you not understanding English, and it seems INTENTIONAL
DECEPTIVE just showing your pathological lying.
DDD emulated by each corresponding HHH
that can possibly exist never returns
NO MATTER WTF THAT ITS EXECUTED HHH DOES.
No, if HHH(DDD) returns 0 when it is directly executed, then it will
return 0 to DDD when DDD is directly exectuted
Changing the subject counts as a strawman deception rebuttal.
Terminating is a property of finite string machine descriptions.
or correctly (and completely emulaitod, something that HHH can't do),
and thus DDD halts.
DDD cannot be completely emulated by HHH for the same sort
of logical impossible reason that squares cannot be round.
My above paragraph is factually correct and your
paraphrase of this paragraph is factually incorrect.
On 10/8/2024 4:27 PM, Richard Damon wrote:
On 10/8/24 5:10 PM, olcott wrote:
On 10/8/2024 3:48 PM, Richard Damon wrote:
On 10/8/24 3:11 PM, olcott wrote:
On 10/8/2024 12:51 PM, Richard Damon wrote:
On 10/8/24 10:41 AM, olcott wrote:
On 10/8/2024 9:10 AM, Richard Damon wrote:
On 10/8/24 10:03 AM, olcott wrote:
On 10/8/2024 8:21 AM, Richard Damon wrote:
On 10/8/24 8:44 AM, olcott wrote:
On 10/8/2024 6:51 AM, Richard Damon wrote:
On 10/7/24 9:28 PM, olcott wrote:
On 10/7/2024 8:11 PM, Richard Damon wrote:
On 10/7/24 8:58 PM, olcott wrote:
On 10/7/2024 7:48 PM, Richard Damon wrote:
On 10/7/24 7:36 PM, olcott wrote:
On 10/7/2024 6:04 PM, Richard Damon wrote:
On 10/7/24 6:57 PM, olcott wrote:
On 10/7/2024 5:39 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>> On 10/7/24 8:08 AM, olcott wrote:
On 10/7/2024 6:02 AM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>> On 10/6/24 10:05 PM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>> On 10/6/2024 8:29 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>> On 10/6/24 8:05 PM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>> On 10/6/2024 5:36 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>>>> On 10/6/24 3:05 PM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>> On 10/6/2024 1:52 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>> On 10/6/24 2:32 PM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 10/6/2024 1:13 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 10/6/24 2:03 PM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 10/6/2024 12:29 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 10/6/24 1:07 PM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 10/6/2024 11:59 AM, Richard Damon >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wrote:
Nope, whst instruction ACTUALLY EMULATE showed >>>>>>>>>>>>>>>>>>>>>>>>>> a different behavior than the executed DDD? >>>>>>>>>>>>>>>>>>>>>>>>>>gets to ignore the fact that DDD was >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> defined toWhich, as you have been told but seems >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> to be above your head means that the >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> execution of DDD, >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>On 10/6/24 8:39 AM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
DDD emulated by each corresponding >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> HHH that can possibly >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> exist never returns. Each of these >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> HHH emulators that does >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> return 0 correctly reports the above >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> non- halting behavior. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
No, the DDD return (if the HHH(DDD) >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> gives an answer), just after the HHH >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that emulated them gave up. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
DDD emulated by each corresponding HHH >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that can possibly >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> exist never returns. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
DDD emulated by each corresponding HHH >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> DDD emulated by each corresponding HHH >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> DDD emulated by each corresponding HHH >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> DDD emulated by each corresponding HHH >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
have a pathological relationship with HHH >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that
HHH cannot ignore. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
No, that isn't ignoring it, but taking >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> into account that since HHH is defined to >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> be a specific program, it has specific >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> behavior.
The behavior of the executed DDD after the >>>>>>>>>>>>>>>>>>>>>>>>>>>>> emulated
DDD has already been aborted is different >>>>>>>>>>>>>>>>>>>>>>>>>>>>> than the
behavior of the emulated DDD that must be >>>>>>>>>>>>>>>>>>>>>>>>>>>>> aborted.
Nope, it is the exact same code on the exact >>>>>>>>>>>>>>>>>>>>>>>>>>>> same data, and thus does the exact same >>>>>>>>>>>>>>>>>>>>>>>>>>>> behavior.
The execution trace proves that the executed >>>>>>>>>>>>>>>>>>>>>>>>>>> DDD has
different behavior that need not be aborted >>>>>>>>>>>>>>>>>>>>>>>>>>> because
emulated DDD must be an is aborted. >>>>>>>>>>>>>>>>>>>>>>>>>>
All you do is look at a DIFFERENT INPUT which >>>>>>>>>>>>>>>>>>>>>>>>>> is just a lie, since that isn't the DDD that >>>>>>>>>>>>>>>>>>>>>>>>>> HHH was given (since the PROGRAM DDD includes >>>>>>>>>>>>>>>>>>>>>>>>>> the all the exact code of the HHH that it >>>>>>>>>>>>>>>>>>>>>>>>>> calls, thus you can't change it to hypothosze >>>>>>>>>>>>>>>>>>>>>>>>>> a diffferent non- aborting HHH) >>>>>>>>>>>>>>>>>>>>>>>>>>
No one can be stupid enough to think that: >>>>>>>>>>>>>>>>>>>>>>>>>>> MUST BE ABORTED
is exactly the same as >>>>>>>>>>>>>>>>>>>>>>>>>>> NEED NOT BE ABORTED
Who said otherwise.
The directly executed DDD need not be aborted. >>>>>>>>>>>>>>>>>>>>>>>>> DDD emulated by HHH must be aborted, thus >>>>>>>>>>>>>>>>>>>>>>>>> proving that their behavior IS NOT THE SAME. >>>>>>>>>>>>>>>>>>>>>>>>>
No, the design of HHH does abort its emulation, >>>>>>>>>>>>>>>>>>>>>>>> because if you had a DIFFERENT HHH, which would >>>>>>>>>>>>>>>>>>>>>>>> be given a DIFFERENT DDD (since DDD includes the >>>>>>>>>>>>>>>>>>>>>>>> HHH that it is calling) it would fail worse at >>>>>>>>>>>>>>>>>>>>>>>> the task at the meta- level by not answering. >>>>>>>>>>>>>>>>>>>>>>>>
That you are not addressing my points seems to be >>>>>>>>>>>>>>>>>>>>>>> over your head.
No, the fact that I *AM* adddressing your points >>>>>>>>>>>>>>>>>>>>>> and pointing out your error just proves that you >>>>>>>>>>>>>>>>>>>>>> are nothing but a stupid idiot.
That you don't even try to point out an error in >>>>>>>>>>>>>>>>>>>>>> what I say, proves that you don't actually care >>>>>>>>>>>>>>>>>>>>>> about what is right, but that you just want to >>>>>>>>>>>>>>>>>>>>>> blindly hold on to your position. The fact that >>>>>>>>>>>>>>>>>>>>>> you consistantly snip out much of the arguement >>>>>>>>>>>>>>>>>>>>>> shows that you know you are defeated, but still >>>>>>>>>>>>>>>>>>>>>> insist on your WRONG position.
Halting is a property of PROGRAMS.
void DDD()
{
HHH(DDD);
return;
}
Terminating is a property of finite string machine >>>>>>>>>>>>>>>>>>>>> descriptions.
And, for the PROGRAM DDD, must include the FULL >>>>>>>>>>>>>>>>>>>> decription of the HHH that it calls.
It does and the source-code specifies that it does >>>>>>>>>>>>>>>>>>> yet this is simply over-your-head.
https://github.com/plolcott/x86utm/blob/master/Halt7.c >>>>>>>>>>>>>>>>>>>
But that isn't the finite string you are claiming above. >>>>>>>>>>>>>>>>>>
When you include the code of HHH in DDD, then when you >>>>>>>>>>>>>>>>>> hypotosize HHH not aborting, that hypothetical HHH is >>>>>>>>>>>>>>>>>> still given the DDD that calls the HHH that DOES, and >>>>>>>>>>>>>>>>>> your hypothetical HHH proves that this HHH is wrong. >>>>>>>>>>>>>>>>>>
No it continues to be you fail to pay complete attention >>>>>>>>>>>>>>>>> to every detail of every words that I said.
*THE FOLLOWING REMAINS TRUE NO MATTER WHAT HHH DOES* >>>>>>>>>>>>>>>>> DDD emulated by each corresponding HHH that can possibly >>>>>>>>>>>>>>>>> exist never returns.
No, because *DDD*, the one that was emulated by each of >>>>>>>>>>>>>>>> the HHH, will HALT if that HHH(DDD) returns 0, just >>>>>>>>>>>>>>>> after its HHH aborted its emulaiton.
PLEASE PLAY 100% COMPLETE ATTENTION TO THESE EXACT WORDS >>>>>>>>>>>>>>>
DDD emulated by each corresponding HHH
that can possibly exist never returns.
Your incorrect paraphrase of my words proves that >>>>>>>>>>>>>>> you are either clueless or deliberately deceptive. >>>>>>>>>>>>>>> I am going with clueless.
No, and please *PAY* 100% complete attention to these >>>>>>>>>>>>>> exact words.
DDD emulated by HHH is NOT the same thing as the emulation >>>>>>>>>>>>>> of DDD by HHH.
DDD emulated by HHH, is the full behavior of the full >>>>>>>>>>>>>> program DDD, which one we are talking about. That behavior >>>>>>>>>>>>>> does not "stop" just becuase the HHH that was emulating it >>>>>>>>>>>>>> stopped its emulation.
I didn't "paraphrase" your words, I looked that the exact >>>>>>>>>>>>>> words you said, and looked at the grammatical
construction. If you disagree with my analysys, point out >>>>>>>>>>>>>> the error.
Every executed HHH that returns 0 correctly reports that >>>>>>>>>>>>> no DDD emulated by its corresponding HHH ever returns. >>>>>>>>>>>>>
You paraphrased this as some kind of "vacuous truth". >>>>>>>>>>>>>
I didn't paraphrase you, I showed you what the words mean, >>>>>>>>>>>> but apparently you are too stupid to understand.
How can those HHH be correct when there answer is wrong. >>>>>>>>>>>>
There answer is wrong because for EVERY HHH that returned 0, >>>>>>>>>>>> the DDD that the emulated WILL return,
"the DDD that the emulated WILL return"
Seems like gibberish nonsense.
type, the DDD that was emullated WILL return
counter-factual
Proven by your own traces.
01 void DDD()
02 {
03 HHH(DDD);
04 return;
05 }
Every executed HHH emulates 01,02,03 of DDD
then either endlessly emulates itself emulating lines 01,02,03
of DDD never reaching line 04 of DDD or aborts the emulation
before ever reaching line 04 of DDD and returns some value.
So, you are not ADMITTING that the above is not a proper "finite-
string" represention of the program DDD, as it doesn't define what >>>>>> DDD actually does as it depend on which of the choices HHH does.
This may all be your unintentional inability
to pay close enough attention.
No, it is you not understanding English, and it seems INTENTIONAL
DECEPTIVE just showing your pathological lying.
DDD emulated by each corresponding HHH
that can possibly exist never returns
NO MATTER WTF THAT ITS EXECUTED HHH DOES.
No, if HHH(DDD) returns 0 when it is directly executed, then it will
return 0 to DDD when DDD is directly exectuted
Changing the subject counts as a strawman deception rebuttal.
Terminating is a property of finite string machine descriptions.
So, you are admitting that your work is just rubbish.
Terminationg is a property of a Machine/Program
Remember the definition, a Machine halts when it reachs a final state.
And a non-halting machine is a machine the NEVER reaches a final
state, even after an unlimited number of steps.
Finite-Strings are just ways we encode data to give to machines as a
representation for things they can not directly process.
I guess you failed CS 101.
or correctly (and completely emulaitod, something that HHH can't
do), and thus DDD halts.
DDD cannot be completely emulated by HHH for the same sort
of logical impossible reason that squares cannot be round.
Right, and since HHH can not completely emulate DDD, even when it is a
halting program, HHH can't use its only emulation as the defining
characterist of the input.
You just agreeing that your whole premise is just a strawman, and that
you have wasted the last decades of your life on your own errors.
My above paragraph is factually correct and your
paraphrase of this paragraph is factually incorrect.
Your paragraph has factually correct statements in it that proves that
you conclusion is just incorrect.
The fact that you can't point out the errors in what I say, says that
you accept my explaination and are admitting that you are just a liar.
You are just showing that
PPPP EEEEE TTTTT EEEEE RRRR
P P E T E R R
P P E T E R R
PPPP EEEEE T EEEEE RRRR
P E T E R R
P E T E R R
P EEEEE T EEEEE R R
OOO L CCC OOO TTTTT TTTTT
O O L C C O O T T
O O L C O O T T
O O L C O O T T
O O L C O O T T
O O L C C O O T T
OOO LLLLL CCC OOO T T
L IIIII EEEEE SSS
L I E S S
L I E S
L I EEEEE SSS
L I E S
L I E S S
LLLLL IIIII EEEEE SSS
AND THINKS THAT IS JUST OK.
DDD emulated by each corresponding HHH
that can possibly exist never returns
NO MATTER WTF THAT ITS EXECUTED HHH DOES.
On 10/8/2024 8:50 PM, Richard Damon wrote:
On 10/8/24 7:10 PM, olcott wrote:
On 10/8/2024 4:27 PM, Richard Damon wrote:
On 10/8/24 5:10 PM, olcott wrote:
On 10/8/2024 3:48 PM, Richard Damon wrote:
On 10/8/24 3:11 PM, olcott wrote:
On 10/8/2024 12:51 PM, Richard Damon wrote:
On 10/8/24 10:41 AM, olcott wrote:
On 10/8/2024 9:10 AM, Richard Damon wrote:
On 10/8/24 10:03 AM, olcott wrote:
On 10/8/2024 8:21 AM, Richard Damon wrote:
On 10/8/24 8:44 AM, olcott wrote:
On 10/8/2024 6:51 AM, Richard Damon wrote:
On 10/7/24 9:28 PM, olcott wrote:
On 10/7/2024 8:11 PM, Richard Damon wrote:
On 10/7/24 8:58 PM, olcott wrote:
On 10/7/2024 7:48 PM, Richard Damon wrote:
On 10/7/24 7:36 PM, olcott wrote:
On 10/7/2024 6:04 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>> On 10/7/24 6:57 PM, olcott wrote:
On 10/7/2024 5:39 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>> On 10/7/24 8:08 AM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>> On 10/7/2024 6:02 AM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>> On 10/6/24 10:05 PM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>> On 10/6/2024 8:29 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>>>> On 10/6/24 8:05 PM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>> On 10/6/2024 5:36 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>> On 10/6/24 3:05 PM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 10/6/2024 1:52 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 10/6/24 2:32 PM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 10/6/2024 1:13 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 10/6/24 2:03 PM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 10/6/2024 12:29 PM, Richard Damon >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wrote:
void DDD()Nope, whst instruction ACTUALLY EMULATE >>>>>>>>>>>>>>>>>>>>>>>>>>>> showed a different behavior than the >>>>>>>>>>>>>>>>>>>>>>>>>>>> executed DDD?On 10/6/24 1:07 PM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 10/6/2024 11:59 AM, Richard Damon >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wrote:gets to ignore the fact that DDD was >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> defined to
Which, as you have been told but seems >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> to be above your head means that the >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> execution of DDD, >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>On 10/6/24 8:39 AM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
DDD emulated by each corresponding >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> HHH that can possibly >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> exist never returns. Each of these >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> HHH emulators that does >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> return 0 correctly reports the >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> above non- halting behavior. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
No, the DDD return (if the HHH(DDD) >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> gives an answer), just after the HHH >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that emulated them gave up. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
DDD emulated by each corresponding >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> HHH that can possibly >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> exist never returns. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
DDD emulated by each corresponding HHH >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> DDD emulated by each corresponding HHH >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> DDD emulated by each corresponding HHH >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> DDD emulated by each corresponding HHH >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
have a pathological relationship with >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> HHH that
HHH cannot ignore. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
No, that isn't ignoring it, but taking >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> into account that since HHH is defined >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> to be a specific program, it has >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> specific behavior. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
The behavior of the executed DDD after >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the emulated
DDD has already been aborted is different >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> than the
behavior of the emulated DDD that must be >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> aborted.
Nope, it is the exact same code on the >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> exact same data, and thus does the exact >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> same behavior.
The execution trace proves that the >>>>>>>>>>>>>>>>>>>>>>>>>>>>> executed DDD has
different behavior that need not be aborted >>>>>>>>>>>>>>>>>>>>>>>>>>>>> because
emulated DDD must be an is aborted. >>>>>>>>>>>>>>>>>>>>>>>>>>>>
All you do is look at a DIFFERENT INPUT >>>>>>>>>>>>>>>>>>>>>>>>>>>> which is just a lie, since that isn't the >>>>>>>>>>>>>>>>>>>>>>>>>>>> DDD that HHH was given (since the PROGRAM >>>>>>>>>>>>>>>>>>>>>>>>>>>> DDD includes the all the exact code of the >>>>>>>>>>>>>>>>>>>>>>>>>>>> HHH that it calls, thus you can't change it >>>>>>>>>>>>>>>>>>>>>>>>>>>> to hypothosze a diffferent non- aborting HHH) >>>>>>>>>>>>>>>>>>>>>>>>>>>>
No one can be stupid enough to think that: >>>>>>>>>>>>>>>>>>>>>>>>>>>>> MUST BE ABORTED
is exactly the same as >>>>>>>>>>>>>>>>>>>>>>>>>>>>> NEED NOT BE ABORTED
Who said otherwise.
The directly executed DDD need not be aborted. >>>>>>>>>>>>>>>>>>>>>>>>>>> DDD emulated by HHH must be aborted, thus >>>>>>>>>>>>>>>>>>>>>>>>>>> proving that their behavior IS NOT THE SAME. >>>>>>>>>>>>>>>>>>>>>>>>>>>
No, the design of HHH does abort its >>>>>>>>>>>>>>>>>>>>>>>>>> emulation, because if you had a DIFFERENT HHH, >>>>>>>>>>>>>>>>>>>>>>>>>> which would be given a DIFFERENT DDD (since >>>>>>>>>>>>>>>>>>>>>>>>>> DDD includes the HHH that it is calling) it >>>>>>>>>>>>>>>>>>>>>>>>>> would fail worse at the task at the meta- >>>>>>>>>>>>>>>>>>>>>>>>>> level by not answering.
That you are not addressing my points seems to >>>>>>>>>>>>>>>>>>>>>>>>> be over your head.
No, the fact that I *AM* adddressing your points >>>>>>>>>>>>>>>>>>>>>>>> and pointing out your error just proves that you >>>>>>>>>>>>>>>>>>>>>>>> are nothing but a stupid idiot. >>>>>>>>>>>>>>>>>>>>>>>>
That you don't even try to point out an error in >>>>>>>>>>>>>>>>>>>>>>>> what I say, proves that you don't actually care >>>>>>>>>>>>>>>>>>>>>>>> about what is right, but that you just want to >>>>>>>>>>>>>>>>>>>>>>>> blindly hold on to your position. The fact that >>>>>>>>>>>>>>>>>>>>>>>> you consistantly snip out much of the arguement >>>>>>>>>>>>>>>>>>>>>>>> shows that you know you are defeated, but still >>>>>>>>>>>>>>>>>>>>>>>> insist on your WRONG position. >>>>>>>>>>>>>>>>>>>>>>>>
Halting is a property of PROGRAMS. >>>>>>>>>>>>>>>>>>>>>>>
{
HHH(DDD);
return;
}
Terminating is a property of finite string >>>>>>>>>>>>>>>>>>>>>>> machine descriptions.
And, for the PROGRAM DDD, must include the FULL >>>>>>>>>>>>>>>>>>>>>> decription of the HHH that it calls. >>>>>>>>>>>>>>>>>>>>>>
It does and the source-code specifies that it does >>>>>>>>>>>>>>>>>>>>> yet this is simply over-your-head.
https://github.com/plolcott/x86utm/blob/master/Halt7.c >>>>>>>>>>>>>>>>>>>>>
But that isn't the finite string you are claiming >>>>>>>>>>>>>>>>>>>> above.
When you include the code of HHH in DDD, then when >>>>>>>>>>>>>>>>>>>> you hypotosize HHH not aborting, that hypothetical >>>>>>>>>>>>>>>>>>>> HHH is still given the DDD that calls the HHH that >>>>>>>>>>>>>>>>>>>> DOES, and your hypothetical HHH proves that this HHH >>>>>>>>>>>>>>>>>>>> is wrong.
No it continues to be you fail to pay complete attention >>>>>>>>>>>>>>>>>>> to every detail of every words that I said. >>>>>>>>>>>>>>>>>>>
*THE FOLLOWING REMAINS TRUE NO MATTER WHAT HHH DOES* >>>>>>>>>>>>>>>>>>> DDD emulated by each corresponding HHH that can possibly >>>>>>>>>>>>>>>>>>> exist never returns.
No, because *DDD*, the one that was emulated by each >>>>>>>>>>>>>>>>>> of the HHH, will HALT if that HHH(DDD) returns 0, just >>>>>>>>>>>>>>>>>> after its HHH aborted its emulaiton.
PLEASE PLAY 100% COMPLETE ATTENTION TO THESE EXACT WORDS >>>>>>>>>>>>>>>>>
DDD emulated by each corresponding HHH
that can possibly exist never returns.
Your incorrect paraphrase of my words proves that >>>>>>>>>>>>>>>>> you are either clueless or deliberately deceptive. >>>>>>>>>>>>>>>>> I am going with clueless.
No, and please *PAY* 100% complete attention to these >>>>>>>>>>>>>>>> exact words.
DDD emulated by HHH is NOT the same thing as the >>>>>>>>>>>>>>>> emulation of DDD by HHH.
DDD emulated by HHH, is the full behavior of the full >>>>>>>>>>>>>>>> program DDD, which one we are talking about. That >>>>>>>>>>>>>>>> behavior does not "stop" just becuase the HHH that was >>>>>>>>>>>>>>>> emulating it stopped its emulation.
I didn't "paraphrase" your words, I looked that the >>>>>>>>>>>>>>>> exact words you said, and looked at the grammatical >>>>>>>>>>>>>>>> construction. If you disagree with my analysys, point >>>>>>>>>>>>>>>> out the error.
Every executed HHH that returns 0 correctly reports that >>>>>>>>>>>>>>> no DDD emulated by its corresponding HHH ever returns. >>>>>>>>>>>>>>>
You paraphrased this as some kind of "vacuous truth". >>>>>>>>>>>>>>>
I didn't paraphrase you, I showed you what the words mean, >>>>>>>>>>>>>> but apparently you are too stupid to understand.
How can those HHH be correct when there answer is wrong. >>>>>>>>>>>>>>
There answer is wrong because for EVERY HHH that returned >>>>>>>>>>>>>> 0, the DDD that the emulated WILL return,
"the DDD that the emulated WILL return"
Seems like gibberish nonsense.
type, the DDD that was emullated WILL return
counter-factual
Proven by your own traces.
01 void DDD()
02 {
03 HHH(DDD);
04 return;
05 }
Every executed HHH emulates 01,02,03 of DDD
then either endlessly emulates itself emulating lines 01,02,03 >>>>>>>>> of DDD never reaching line 04 of DDD or aborts the emulation >>>>>>>>> before ever reaching line 04 of DDD and returns some value.
So, you are not ADMITTING that the above is not a proper
"finite- string" represention of the program DDD, as it doesn't >>>>>>>> define what DDD actually does as it depend on which of the
choices HHH does.
This may all be your unintentional inability
to pay close enough attention.
No, it is you not understanding English, and it seems INTENTIONAL
DECEPTIVE just showing your pathological lying.
DDD emulated by each corresponding HHH
that can possibly exist never returns
NO MATTER WTF THAT ITS EXECUTED HHH DOES.
No, if HHH(DDD) returns 0 when it is directly executed, then it
will return 0 to DDD when DDD is directly exectuted
Changing the subject counts as a strawman deception rebuttal.
Terminating is a property of finite string machine descriptions.
So, you are admitting that your work is just rubbish.
Terminationg is a property of a Machine/Program
Remember the definition, a Machine halts when it reachs a final
state. And a non-halting machine is a machine the NEVER reaches a
final state, even after an unlimited number of steps.
Finite-Strings are just ways we encode data to give to machines as a
representation for things they can not directly process.
I guess you failed CS 101.
or correctly (and completely emulaitod, something that HHH can't
do), and thus DDD halts.
DDD cannot be completely emulated by HHH for the same sort
of logical impossible reason that squares cannot be round.
Right, and since HHH can not completely emulate DDD, even when it is
a halting program, HHH can't use its only emulation as the defining
characterist of the input.
You just agreeing that your whole premise is just a strawman, and
that you have wasted the last decades of your life on your own errors. >>>>
My above paragraph is factually correct and your
paraphrase of this paragraph is factually incorrect.
Your paragraph has factually correct statements in it that proves
that you conclusion is just incorrect.
The fact that you can't point out the errors in what I say, says
that you accept my explaination and are admitting that you are just
a liar.
You are just showing that
PPPP EEEEE TTTTT EEEEE RRRR
P P E T E R R
P P E T E R R
PPPP EEEEE T EEEEE RRRR
P E T E R R
P E T E R R
P EEEEE T EEEEE R R
OOO L CCC OOO TTTTT TTTTT
O O L C C O O T T
O O L C O O T T
O O L C O O T T
O O L C O O T T
O O L C C O O T T
OOO LLLLL CCC OOO T T
L IIIII EEEEE SSS
L I E S S
L I E S
L I EEEEE SSS
L I E S
L I E S S
LLLLL IIIII EEEEE SSS
AND THINKS THAT IS JUST OK.
DDD emulated by each corresponding HHH
that can possibly exist never returns
NO MATTER WTF THAT ITS EXECUTED HHH DOES.
Just more of your lying eqivocation.
The direct exectuion or complete emulation of DDD, which is what you
statement actually refers to have been proven BY YOU to halt when it
is simulated.
This is what the term "DDD emulated by ... never returns" refers to.
PERIOD.
Any other meaning means you are just admitting to be lying about
working on the Halting Problem for the last two decaded.
Yes, the emulation of DDD by HHH doesn't reach that point, but that is
NOT what you statement means, except by trying to invoke an
equivocation of the words.
Thus it is shown that
PPPP EEEEE TTTTT EEEEE RRRR
P P E T E R R
P P E T E R R
PPPP EEEEE T EEEEE RRRR
P E T E R R
P E T E R R
P EEEEE T EEEEE R R
OOO L CCC OOO TTTTT TTTTT
O O L C C O O T T
O O L C O O T T
O O L C O O T T
O O L C O O T T
O O L C C O O T T
OOO LLLLL CCC OOO T T
L IIIII EEEEE SSS
L I E S S
L I E S
L I EEEEE SSS
L I E S
L I E S S
LLLLL IIIII EEEEE SSS
AND THINKS THAT IS JUST OK.
Sorry, you are just showing that you just don't care about what is
true, but only that you want to push your false claims. This just
shows that you are nothing but a pathological liar. The fact that you
then at times claim that you have never lied, just proves that you
have destroyed your own ability to reason about the truth, just
showing that you are the poster child example of the seared conscious
that happens when a person just continues to lie and not be bothered
by it.
This just seals your fate to end up in the fire of Gehenna that you
like to quote at people to try to make them be afraid that they might
be lying, not understanding that you are just heaping curses upon
yourself.
Sorry, it seems you at some point just sold yourself to the devil, and
he is in the process of claiming you now.
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/8/2024 7:49 AM, Andy Walker wrote:
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.
| Sysop: | Keyop |
|---|---|
| Location: | Huddersfield, West Yorkshire, UK |
| Users: | 493 |
| Nodes: | 16 (2 / 14) |
| Uptime: | 180:43:26 |
| Calls: | 9,705 |
| Files: | 13,737 |
| Messages: | 6,179,422 |