On 7/12/2024 5:56 PM, Richard Damon wrote:
On 7/12/24 10:56 AM, olcott wrote:
We stipulate that the only measure of a correct emulation is the
semantics of the x86 programming language.
Which means the only "correct emulation" that tells the behavior of
the program at the input is a non-aborted one.
_DDD()
[00002163] 55 push ebp ; housekeeping
[00002164] 8bec mov ebp,esp ; housekeeping
[00002166] 6863210000 push 00002163 ; push DDD
[0000216b] e853f4ffff call 000015c3 ; call HHH(DDD)
[00002170] 83c404 add esp,+04
[00002173] 5d pop ebp
[00002174] c3 ret
Size in bytes:(0018) [00002174]
When N steps of DDD are emulated by HHH according to the
semantics of the x86 language then N steps are emulated correctly.
And thus HHH that do that know only the first N steps of the behavior
of DDD, which continues per the definition of the x86 instruction set
until the COMPLETE emulation (or direct execution) reaches a terminal
instruction.
When we examine the infinite set of every HHH/DDD pair such that:
HHH₁ one step of DDD is correctly emulated by HHH.
HHH₂ two steps of DDD are correctly emulated by HHH.
HHH₃ three steps of DDD are correctly emulated by HHH.
...
HHH∞ The emulation of DDD by HHH never stops running.
And thus, the subset that only did a finite number of steps and
aborted its emulation on a non-terminal instrucition only have partial
knowledge of the behavior of their DDD, and by returning to their
caller, they establish that behavior for ALL copies of that HHH, even
the one that DDD calls, which shows that DDD will be halting, even
though HHH stopped its observation of the input before it gets to that
point.
The above specifies the infinite set of every HHH/DDD pair
where 1 to infinity steps of DDD are correctly emulated by HHH.
No DDD instance of each HHH/DDD pair ever reaches past its
own machine address of 0000216b and halts.
Wrong. EVERY DDD of an HHH that simulated its input for only a finite
number of steps WILL halt becuase it will reach its final return.
The HHH that simulated it for only a finite number of steps, only
learned that finite number of steps of the behaivor, and in EVERY
case, when we look at the behavior past that point, which DOES occur
per the definition of the x86 instruction set, as we have not reached
a "termial" instruction that stops behavior, will see the HHH(DDD)
that DDD called continuing to simulate its input to the point that
this one was defined to stop, and then returns 0 to DDDD and then DDD
returning and ending the behavior.
You continue to stupidly confuse the PARTIAL observation that HHH does
of the behavior of DDD by its PARTIAL emulation with the ACTUAL FULL
behavior of DDD as defined by the full definition of the x86
insttuction set.
Thus each HHH element of the above infinite set of HHH/DDD
pairs is necessarily correct to reject its DDD as non-halting.
Nope.
NONE Of them CORRECTLY rejected itS DDD as non-halting and you are
shown to be ignorant of what you are talking about.
The HHH that did a partial emulation got the wrong answer, because
THEIR DDD will halt. and the HHH that doen't abort never get around to
rejecting its DDD as non-halting.
*Here is the gist of my proof it is irrefutable*
When no DDD of every HHH/DDD that can possibly exist
halts then each HHH that rejects its DDD as non-halting
is necessarily correct.
*No double-talk and weasel words can overcome that*
On 7/12/2024 6:41 PM, Richard Damon wrote:
On 7/12/24 7:19 PM, olcott wrote:
On 7/12/2024 5:56 PM, Richard Damon wrote:
On 7/12/24 10:56 AM, olcott wrote:
We stipulate that the only measure of a correct emulation is the
semantics of the x86 programming language.
Which means the only "correct emulation" that tells the behavior of
the program at the input is a non-aborted one.
_DDD()
[00002163] 55 push ebp ; housekeeping
[00002164] 8bec mov ebp,esp ; housekeeping
[00002166] 6863210000 push 00002163 ; push DDD
[0000216b] e853f4ffff call 000015c3 ; call HHH(DDD)
[00002170] 83c404 add esp,+04
[00002173] 5d pop ebp
[00002174] c3 ret
Size in bytes:(0018) [00002174]
When N steps of DDD are emulated by HHH according to the
semantics of the x86 language then N steps are emulated correctly.
And thus HHH that do that know only the first N steps of the
behavior of DDD, which continues per the definition of the x86
instruction set until the COMPLETE emulation (or direct execution)
reaches a terminal instruction.
When we examine the infinite set of every HHH/DDD pair such that:
HHH₁ one step of DDD is correctly emulated by HHH.
HHH₂ two steps of DDD are correctly emulated by HHH.
HHH₃ three steps of DDD are correctly emulated by HHH.
...
HHH∞ The emulation of DDD by HHH never stops running.
And thus, the subset that only did a finite number of steps and
aborted its emulation on a non-terminal instrucition only have
partial knowledge of the behavior of their DDD, and by returning to
their caller, they establish that behavior for ALL copies of that
HHH, even the one that DDD calls, which shows that DDD will be
halting, even though HHH stopped its observation of the input before
it gets to that point.
The above specifies the infinite set of every HHH/DDD pair
where 1 to infinity steps of DDD are correctly emulated by HHH.
No DDD instance of each HHH/DDD pair ever reaches past its
own machine address of 0000216b and halts.
Wrong. EVERY DDD of an HHH that simulated its input for only a
finite number of steps WILL halt becuase it will reach its final
return.
The HHH that simulated it for only a finite number of steps, only
learned that finite number of steps of the behaivor, and in EVERY
case, when we look at the behavior past that point, which DOES occur
per the definition of the x86 instruction set, as we have not
reached a "termial" instruction that stops behavior, will see the
HHH(DDD) that DDD called continuing to simulate its input to the
point that this one was defined to stop, and then returns 0 to DDDD
and then DDD returning and ending the behavior.
You continue to stupidly confuse the PARTIAL observation that HHH
does of the behavior of DDD by its PARTIAL emulation with the ACTUAL
FULL behavior of DDD as defined by the full definition of the x86
insttuction set.
Thus each HHH element of the above infinite set of HHH/DDD
pairs is necessarily correct to reject its DDD as non-halting.
Nope.
NONE Of them CORRECTLY rejected itS DDD as non-halting and you are
shown to be ignorant of what you are talking about.
The HHH that did a partial emulation got the wrong answer, because
THEIR DDD will halt. and the HHH that doen't abort never get around
to rejecting its DDD as non-halting.
*Here is the gist of my proof it is irrefutable*
When no DDD of every HHH/DDD that can possibly exist
halts then each HHH that rejects its DDD as non-halting
is necessarily correct.
*No double-talk and weasel words can overcome that*
Which is just your double-talk to try to redefine what halting means.
You try to cut my airtight proof up in little pieces and fail.
Every rebuttal that you make has disagreeing with the semantics
of the x86 language as its basis.
On 7/12/2024 5:56 PM, Richard Damon wrote:
On 7/12/24 10:56 AM, olcott wrote:
We stipulate that the only measure of a correct emulation is the
semantics of the x86 programming language.
Which means the only "correct emulation" that tells the behavior of
the program at the input is a non-aborted one.
_DDD()
[00002163] 55 push ebp ; housekeeping
[00002164] 8bec mov ebp,esp ; housekeeping
[00002166] 6863210000 push 00002163 ; push DDD
[0000216b] e853f4ffff call 000015c3 ; call HHH(DDD)
[00002170] 83c404 add esp,+04
[00002173] 5d pop ebp
[00002174] c3 ret
Size in bytes:(0018) [00002174]
When N steps of DDD are emulated by HHH according to the
semantics of the x86 language then N steps are emulated correctly.
And thus HHH that do that know only the first N steps of the behavior
of DDD, which continues per the definition of the x86 instruction set
until the COMPLETE emulation (or direct execution) reaches a terminal
instruction.
When we examine the infinite set of every HHH/DDD pair such that:
HHH₁ one step of DDD is correctly emulated by HHH.
HHH₂ two steps of DDD are correctly emulated by HHH.
HHH₃ three steps of DDD are correctly emulated by HHH.
...
HHH∞ The emulation of DDD by HHH never stops running.
And thus, the subset that only did a finite number of steps and
aborted its emulation on a non-terminal instrucition only have partial
knowledge of the behavior of their DDD, and by returning to their
caller, they establish that behavior for ALL copies of that HHH, even
the one that DDD calls, which shows that DDD will be halting, even
though HHH stopped its observation of the input before it gets to that
point.
The above specifies the infinite set of every HHH/DDD pair
where 1 to infinity steps of DDD are correctly emulated by HHH.
No DDD instance of each HHH/DDD pair ever reaches past its
own machine address of 0000216b and halts.
Wrong. EVERY DDD of an HHH that simulated its input for only a finite
number of steps WILL halt becuase it will reach its final return.
The HHH that simulated it for only a finite number of steps, only
learned that finite number of steps of the behaivor, and in EVERY
case, when we look at the behavior past that point, which DOES occur
per the definition of the x86 instruction set, as we have not reached
a "termial" instruction that stops behavior, will see the HHH(DDD)
that DDD called continuing to simulate its input to the point that
this one was defined to stop, and then returns 0 to DDDD and then DDD
returning and ending the behavior.
You continue to stupidly confuse the PARTIAL observation that HHH does
of the behavior of DDD by its PARTIAL emulation with the ACTUAL FULL
behavior of DDD as defined by the full definition of the x86
insttuction set.
Thus each HHH element of the above infinite set of HHH/DDD
pairs is necessarily correct to reject its DDD as non-halting.
Nope.
NONE Of them CORRECTLY rejected itS DDD as non-halting and you are
shown to be ignorant of what you are talking about.
The HHH that did a partial emulation got the wrong answer, because
THEIR DDD will halt. and the HHH that doen't abort never get around to
rejecting its DDD as non-halting.
*Here is the gist of my proof it is irrefutable*
When no DDD of every HHH/DDD that can possibly exist
halts then each HHH that rejects its DDD as non-halting
is necessarily correct.
*No double-talk and weasel words can overcome that*
On 7/13/2024 3:15 AM, Fred. Zwarts wrote:
Op 13.jul.2024 om 01:19 schreef olcott:
On 7/12/2024 5:56 PM, Richard Damon wrote:
On 7/12/24 10:56 AM, olcott wrote:
We stipulate that the only measure of a correct emulation is the
semantics of the x86 programming language.
Which means the only "correct emulation" that tells the behavior of
the program at the input is a non-aborted one.
_DDD()
[00002163] 55 push ebp ; housekeeping
[00002164] 8bec mov ebp,esp ; housekeeping
[00002166] 6863210000 push 00002163 ; push DDD
[0000216b] e853f4ffff call 000015c3 ; call HHH(DDD)
[00002170] 83c404 add esp,+04
[00002173] 5d pop ebp
[00002174] c3 ret
Size in bytes:(0018) [00002174]
When N steps of DDD are emulated by HHH according to the
semantics of the x86 language then N steps are emulated correctly.
And thus HHH that do that know only the first N steps of the
behavior of DDD, which continues per the definition of the x86
instruction set until the COMPLETE emulation (or direct execution)
reaches a terminal instruction.
When we examine the infinite set of every HHH/DDD pair such that:
HHH₁ one step of DDD is correctly emulated by HHH.
HHH₂ two steps of DDD are correctly emulated by HHH.
HHH₃ three steps of DDD are correctly emulated by HHH.
...
HHH∞ The emulation of DDD by HHH never stops running.
And thus, the subset that only did a finite number of steps and
aborted its emulation on a non-terminal instrucition only have
partial knowledge of the behavior of their DDD, and by returning to
their caller, they establish that behavior for ALL copies of that
HHH, even the one that DDD calls, which shows that DDD will be
halting, even though HHH stopped its observation of the input before
it gets to that point.
The above specifies the infinite set of every HHH/DDD pair
where 1 to infinity steps of DDD are correctly emulated by HHH.
No DDD instance of each HHH/DDD pair ever reaches past its
own machine address of 0000216b and halts.
Wrong. EVERY DDD of an HHH that simulated its input for only a
finite number of steps WILL halt becuase it will reach its final
return.
The HHH that simulated it for only a finite number of steps, only
learned that finite number of steps of the behaivor, and in EVERY
case, when we look at the behavior past that point, which DOES occur
per the definition of the x86 instruction set, as we have not
reached a "termial" instruction that stops behavior, will see the
HHH(DDD) that DDD called continuing to simulate its input to the
point that this one was defined to stop, and then returns 0 to DDDD
and then DDD returning and ending the behavior.
You continue to stupidly confuse the PARTIAL observation that HHH
does of the behavior of DDD by its PARTIAL emulation with the ACTUAL
FULL behavior of DDD as defined by the full definition of the x86
insttuction set.
Thus each HHH element of the above infinite set of HHH/DDD
pairs is necessarily correct to reject its DDD as non-halting.
Nope.
NONE Of them CORRECTLY rejected itS DDD as non-halting and you are
shown to be ignorant of what you are talking about.
The HHH that did a partial emulation got the wrong answer, because
THEIR DDD will halt. and the HHH that doen't abort never get around
to rejecting its DDD as non-halting.
*Here is the gist of my proof it is irrefutable*
When no DDD of every HHH/DDD that can possibly exist
halts then each HHH that rejects its DDD as non-halting
is necessarily correct.
*No double-talk and weasel words can overcome that*
This is double talk, because no HHH can possibly exist that simulates
itself correctly.
Your definition of correct contradicts the semantics of
the x86 language making it wrong.
On 7/13/2024 10:25 AM, Richard Damon wrote:
On 7/13/24 11:15 AM, olcott wrote:
In other words when you are very hungry you have the
free will to decide that you are not hungry at all
and never eat anything ever again with no ill effects
to your health what-so-ever.
Just shows that though I have free will, I am also in a Universe with
a lot of determinism.
Try and use this free will to make a square circle.
Nope, just shows you don't know what you are talking about and need to
switch to Red Herring because you lost the argument.
Face it, all you have proved is that you are nothing but a pathetic
ignorant pathological lying idiot.
After HHH has already aborted its simulation of DDD
and returns to the DDD that called it is not the same
behavior as DDD simulated by HHH that must be aborted.
Right, and the question is about the behavior of DDD,
the input finite string not an external process that HHH
has no access to.
Right, but the program it represents, and the question is about IS.
HHH cannot be correctly required to report on the behavior
of an external process that it has no access to.
As soon as HHH correctly determines that it must abort the
simulation of its input to prevent its own infinite execution
HHH is necessarily correct to reject this finite string as
specifying non-halting behavior.
On 7/13/2024 11:05 AM, Richard Damon wrote:
On 7/13/24 11:34 AM, olcott wrote:
On 7/13/2024 10:25 AM, Richard Damon wrote:
On 7/13/24 11:15 AM, olcott wrote:
In other words when you are very hungry you have the
free will to decide that you are not hungry at all
and never eat anything ever again with no ill effects
to your health what-so-ever.
Just shows that though I have free will, I am also in a Universe
with a lot of determinism.
Try and use this free will to make a square circle.
Nope, just shows you don't know what you are talking about and need
to switch to Red Herring because you lost the argument.
Face it, all you have proved is that you are nothing but a pathetic
ignorant pathological lying idiot.
After HHH has already aborted its simulation of DDD
and returns to the DDD that called it is not the same
behavior as DDD simulated by HHH that must be aborted.
Right, and the question is about the behavior of DDD,
the input finite string not an external process that HHH
has no access to.
Right, but the program it represents, and the question is about IS.
HHH cannot be correctly required to report on the behavior
of an external process that it has no access to.
But it has access to the complete representation of it.
In other words you are still hungry AFTER you filled
yourself with food BECAUSE you are the same person
thus the change in process state DOES NOT MATTER.
Sysop: | Keyop |
---|---|
Location: | Huddersfield, West Yorkshire, UK |
Users: | 365 |
Nodes: | 16 (0 / 16) |
Uptime: | 11:09:52 |
Calls: | 7,758 |
Calls today: | 1 |
Files: | 12,897 |
Messages: | 5,744,534 |