void DDD()
{
HHH(DDD);
return;
}
_DDD()
[00002172] 55 push ebp ; housekeeping
[00002173] 8bec mov ebp,esp ; housekeeping
[00002175] 6872210000 push 00002172 ; push DDD
[0000217a] e853f4ffff call 000015d2 ; call HHH(DDD)
[0000217f] 83c404 add esp,+04
[00002182] 5d pop ebp
[00002183] c3 ret
Size in bytes:(0018) [00002183]
A simulation of N instructions of DDD by HHH according to
the semantics of the x86 language is necessarily correct.
A correct simulation of N instructions of DDD by HHH is
sufficient to correctly predict the behavior of an unlimited
simulation.
Termination analyzers / halt deciders are only required
to correctly predict the behavior of their inputs.
Termination analyzers / halt deciders are only required
to correctly predict the behavior of their inputs, thus
the behavior of non-inputs is outside of their domain.
On 8/13/2024 9:29 PM, Richard Damon wrote:
On 8/13/24 8:52 PM, olcott wrote:
void DDD()
{
HHH(DDD);
return;
}
_DDD()
[00002172] 55 push ebp ; housekeeping
[00002173] 8bec mov ebp,esp ; housekeeping
[00002175] 6872210000 push 00002172 ; push DDD
[0000217a] e853f4ffff call 000015d2 ; call HHH(DDD)
[0000217f] 83c404 add esp,+04
[00002182] 5d pop ebp
[00002183] c3 ret
Size in bytes:(0018) [00002183]
A simulation of N instructions of DDD by HHH according to
the semantics of the x86 language is necessarily correct.
Nope, it is just the correct PARTIAL emulation of the first N
instructions of DDD, and not of all of DDD,
That is what I said dufuss.
A correct simulation of N instructions of DDD by HHH is
sufficient to correctly predict the behavior of an unlimited
simulation.
Nope, if a HHH returns to its caller,
*Try to show exactly how DDD emulated by HHH returns to its caller*
(the first one doesn't even have a caller)
Use the above machine language instructions to show this.
On 8/13/2024 10:21 PM, Richard Damon wrote:
On 8/13/24 10:38 PM, olcott wrote:
On 8/13/2024 9:29 PM, Richard Damon wrote:
On 8/13/24 8:52 PM, olcott wrote:
void DDD()
{
HHH(DDD);
return;
}
_DDD()
[00002172] 55 push ebp ; housekeeping
[00002173] 8bec mov ebp,esp ; housekeeping
[00002175] 6872210000 push 00002172 ; push DDD
[0000217a] e853f4ffff call 000015d2 ; call HHH(DDD)
[0000217f] 83c404 add esp,+04
[00002182] 5d pop ebp
[00002183] c3 ret
Size in bytes:(0018) [00002183]
A simulation of N instructions of DDD by HHH according to
the semantics of the x86 language is necessarily correct.
Nope, it is just the correct PARTIAL emulation of the first N
instructions of DDD, and not of all of DDD,
That is what I said dufuss.
Nope. You didn't. I added clairifying words, pointing out why you
claim is incorrect.
For an emulation to be "correct" it must be complete, as partial
emulations are only partially correct, so without the partial
modifier, they are not correct.
A complete emulation of one instruction is
a complete emulation of one instruction
A correct simulation of N instructions of DDD by HHH is
sufficient to correctly predict the behavior of an unlimited
simulation.
Nope, if a HHH returns to its caller,
*Try to show exactly how DDD emulated by HHH returns to its caller*
(the first one doesn't even have a caller)
Use the above machine language instructions to show this.
Remember how English works:
When you ask "How DDD emulated by HHH returns to its callers".
Show the exact machine code trace of how DDD emulated
by HHH (according to the semantics of the x86 language)
reaches its own machine address 00002183
_DDD()
[00002172] 55 push ebp ; housekeeping
[00002173] 8bec mov ebp,esp ; housekeeping
[00002175] 6872210000 push 00002172 ; push DDD
[0000217a] e853f4ffff call 000015d2 ; call HHH(DDD)
[0000217f] 83c404 add esp,+04
[00002182] 5d pop ebp
[00002183] c3 ret
Size in bytes:(0018) [00002183]
When DDD is emulated by HHH
HHH emulates the lines of DDD in this order:
[00002172]
[00002173]
[00002175]
[0000217a] calls HHH(DDD)
which emulates the lines of DDD in this order
HHH emulates the lines of DDD in this order:
[00002172]
[00002173]
[00002175]
[0000217a]
with 200 pages of HHH emulating itself emulating
DDD inbetween.
On 8/13/2024 9:29 PM, Richard Damon wrote:You were trying to label an incomplete/partial/aborted simulation
On 8/13/24 8:52 PM, olcott wrote:
That is what I said dufuss.A simulation of N instructions of DDD by HHH according to theNope, it is just the correct PARTIAL emulation of the first N
semantics of the x86 language is necessarily correct.
instructions of DDD, and not of all of DDD,
how *HHH* returns*Try to show exactly how DDD emulated by HHH returns to its caller*A correct simulation of N instructions of DDD by HHH is sufficient toNope, if a HHH returns to its caller,
correctly predict the behavior of an unlimited simulation.
(the first one doesn't even have a caller)HHH simulates DDD enter the matrix
Use the above machine language instructions to show this.
void DDD()
{
HHH(DDD);
return;
}
_DDD()
[00002172] 55 push ebp ; housekeeping
[00002173] 8bec mov ebp,esp ; housekeeping
[00002175] 6872210000 push 00002172 ; push DDD
[0000217a] e853f4ffff call 000015d2 ; call HHH(DDD)
[0000217f] 83c404 add esp,+04
[00002182] 5d pop ebp
[00002183] c3 ret
Size in bytes:(0018) [00002183]
A simulation of N instructions of DDD by HHH according to
the semantics of the x86 language is necessarily correct.
A correct simulation of N instructions of DDD by HHH is
sufficient to correctly predict the behavior of an unlimited
simulation.
Termination analyzers / halt deciders are only required
to correctly predict the behavior of their inputs.
Termination analyzers / halt deciders are only required
to correctly predict the behavior of their inputs, thus
the behavior of non-inputs is outside of their domain.
void DDD()
{
HHH(DDD);
return;
}
On 8/13/2024 11:04 PM, Richard Damon wrote:
On 8/13/24 11:48 PM, olcott wrote:
On 8/13/2024 10:21 PM, Richard Damon wrote:
On 8/13/24 10:38 PM, olcott wrote:
On 8/13/2024 9:29 PM, Richard Damon wrote:
On 8/13/24 8:52 PM, olcott wrote:
void DDD()
{
HHH(DDD);
return;
}
_DDD()
[00002172] 55 push ebp ; housekeeping
[00002173] 8bec mov ebp,esp ; housekeeping
[00002175] 6872210000 push 00002172 ; push DDD
[0000217a] e853f4ffff call 000015d2 ; call HHH(DDD)
[0000217f] 83c404 add esp,+04
[00002182] 5d pop ebp
[00002183] c3 ret
Size in bytes:(0018) [00002183]
A simulation of N instructions of DDD by HHH according to
the semantics of the x86 language is necessarily correct.
Nope, it is just the correct PARTIAL emulation of the first N
instructions of DDD, and not of all of DDD,
That is what I said dufuss.
Nope. You didn't. I added clairifying words, pointing out why you
claim is incorrect.
For an emulation to be "correct" it must be complete, as partial
emulations are only partially correct, so without the partial
modifier, they are not correct.
A complete emulation of one instruction is
a complete emulation of one instruction
A correct simulation of N instructions of DDD by HHH is
sufficient to correctly predict the behavior of an unlimited
simulation.
Nope, if a HHH returns to its caller,
*Try to show exactly how DDD emulated by HHH returns to its caller*
(the first one doesn't even have a caller)
Use the above machine language instructions to show this.
Remember how English works:
When you ask "How DDD emulated by HHH returns to its callers".
Show the exact machine code trace of how DDD emulated
by HHH (according to the semantics of the x86 language)
reaches its own machine address 00002183
No. The trace is to long,
Show the Trace of DDD emulated by HHH
and show the trace of DDD emulated by HHH
emulated by the executed HHH
Just show the DDD code traces.
On 8/14/2024 2:43 AM, joes wrote:Only one, so not all.
Am Tue, 13 Aug 2024 21:38:07 -0500 schrieb olcott:When one instruction of DDD is correctly emulated then one instruction
On 8/13/2024 9:29 PM, Richard Damon wrote:You were trying to label an incomplete/partial/aborted simulation as
On 8/13/24 8:52 PM, olcott wrote:
That is what I said dufuss.A simulation of N instructions of DDD by HHH according to theNope, it is just the correct PARTIAL emulation of the first N
semantics of the x86 language is necessarily correct.
instructions of DDD, and not of all of DDD,
correct.
was correctly emulated.
Richard was talking about HHH returning.Changing the question is the strawman error or reasoning.how *HHH* returns*Try to show exactly how DDD emulated by HHH returns to its caller*A correct simulation of N instructions of DDD by HHH is sufficientNope, if a HHH returns to its caller,
to correctly predict the behavior of an unlimited simulation.
This is not a misrepresentation of your position, this is mine.That is the strawman error of reasoning.(the first one doesn't even have a caller)HHH simulates DDD enter the matrix
Use the above machine language instructions to show this.
DDD calls HHH(DDD) Fred: could be eliminated
HHH simulates DDD second level
DDD calls HHH(DDD) recursion detected
HHH aborts, returns outside interference
DDD halts voila
HHH halts
DDD correctly emulated by HHH never reaches its own "return"See above. Show the error.
instruction. Show how it does or admit that I am correct.
On 8/14/2024 3:17 AM, Mikko wrote:What is wrong about that?
On 2024-08-14 00:52:36 +0000, olcott said:
void DDD()In order to prove that the above specifies a non-halting behavour you
{
HHH(DDD);
return;
}
must prove that HHH(DDD) does not terminate.
That is the strawman error of reasoning.Not at all. A strawman is a wrong presentation of opposing arguments.
The focus of the post was to show that DDD emulated by HHH according toYes, and that was a direct reply. As Fred said, DDD could be replaced
the semantics of the x86 language cannot possibly reach its own "return" instruction.
By changing the subject you cheat.You are avoiding questions.
On 8/14/2024 3:17 AM, Mikko wrote:How can DDD not halt if HHH does?
On 2024-08-14 00:52:36 +0000, olcott said:Wrong.
void DDD()In order to prove that the above specifies a non-halting behavour you
{
HHH(DDD);
return;
}
must prove that HHH(DDD) does not terminate.
On 8/14/2024 3:17 AM, Mikko wrote:A simulation that fails to reach the end is never correct.
On 2024-08-14 00:52:36 +0000, olcott said:
void DDD()
{
HHH(DDD);
return;
}
In order to prove that the above specifies a non-halting behavour
you must prove that HHH(DDD) does not terminate.
That is the strawman error of reasoning.
The focus of the post was to show that DDD emulated by HHH
according to the semantics of the x86 language cannot possibly
reach its own "return" instruction.
On 8/14/2024 4:09 AM, Fred. Zwarts wrote:
Op 14.aug.2024 om 02:52 schreef olcott:
void DDD()
{
HHH(DDD);
return;
}
_DDD()
[00002172] 55 push ebp ; housekeeping
[00002173] 8bec mov ebp,esp ; housekeeping
[00002175] 6872210000 push 00002172 ; push DDD
[0000217a] e853f4ffff call 000015d2 ; call HHH(DDD)
[0000217f] 83c404 add esp,+04
[00002182] 5d pop ebp
[00002183] c3 ret
Size in bytes:(0018) [00002183]
Again the same joke? It seems you are short of memory.
A simulation of N instructions of DDD by HHH according to
the semantics of the x86 language is necessarily correct.
It is only a correct start of an incomplete simulation.
When one instruction is emulated completely then this
is a complete emulation of one instruction.
A correct simulation of N instructions of DDD by HHH is
sufficient to correctly predict the behavior of an unlimited
simulation.
It is not,
When one instruction is emulated completely then this
is a complete emulation of one instruction.
Until you agree with that we are dead in the water.
On 8/14/2024 2:43 AM, joes wrote:
Am Tue, 13 Aug 2024 21:38:07 -0500 schrieb olcott:
On 8/13/2024 9:29 PM, Richard Damon wrote:You were trying to label an incomplete/partial/aborted simulation
On 8/13/24 8:52 PM, olcott wrote:
That is what I said dufuss.A simulation of N instructions of DDD by HHH according to theNope, it is just the correct PARTIAL emulation of the first N
semantics of the x86 language is necessarily correct.
instructions of DDD, and not of all of DDD,
as correct.
When one instruction of DDD is correctly emulated then one
instruction was correctly emulated.
how *HHH* returns*Try to show exactly how DDD emulated by HHH returns to its caller*A correct simulation of N instructions of DDD by HHH is sufficient to >>>>> correctly predict the behavior of an unlimited simulation.Nope, if a HHH returns to its caller,
Changing the question is the strawman error or reasoning.
(the first one doesn't even have a caller)HHH simulates DDD enter the matrix
Use the above machine language instructions to show this.
DDD calls HHH(DDD) Fred: could be eliminated
HHH simulates DDD second level
DDD calls HHH(DDD) recursion detected
HHH aborts, returns outside interference
DDD halts voila
HHH halts
That is the strawman error of reasoning.
DDD correctly emulated by HHH never reaches its own "return"
instruction. Show how it does or admit that I am correct.
Am Tue, 13 Aug 2024 21:38:07 -0500 schrieb olcott:
On 8/13/2024 9:29 PM, Richard Damon wrote:
On 8/13/24 8:52 PM, olcott wrote:
You were trying to label an incomplete/partial/aborted simulationThat is what I said dufuss.A simulation of N instructions of DDD by HHH according to theNope, it is just the correct PARTIAL emulation of the first N
semantics of the x86 language is necessarily correct.
instructions of DDD, and not of all of DDD,
as correct.
how *HHH* returns*Try to show exactly how DDD emulated by HHH returns to its caller*A correct simulation of N instructions of DDD by HHH is sufficient toNope, if a HHH returns to its caller,
correctly predict the behavior of an unlimited simulation.
(the first one doesn't even have a caller)HHH simulates DDD enter the matrix
Use the above machine language instructions to show this.
DDD calls HHH(DDD) Fred: could be eliminated
HHH simulates DDD second level
DDD calls HHH(DDD) recursion detected
HHH aborts, returns outside interference
DDD halts voila
HHH halts
On 8/14/2024 4:09 AM, Fred. Zwarts wrote:And not an emulation of all instructions.
Op 14.aug.2024 om 02:52 schreef olcott:
When one instruction is emulated completely then this is a completeA simulation of N instructions of DDD by HHH according to theIt is only a correct start of an incomplete simulation.
semantics of the x86 language is necessarily correct.
emulation of one instruction.
That's on you.When one instruction is emulated completely then this is a completeA correct simulation of N instructions of DDD by HHH is sufficient toIt is not,
correctly predict the behavior of an unlimited simulation.
emulation of one instruction.
Until you agree with that we are dead in the water.
Termination analyzers / halt deciders are only required to correctlyExactly. And this is the same input that, when used in direct
predict the behavior of their inputs.
execution, halts.
Termination analyzers / halt deciders are only required to correctlyIndeed, so your dreams of a HHH that does not abort and does not halt,
predict the behavior of their inputs, thus the behavior of non-inputs
is outside of their domain.
is a non-input and is outside the domain.
On 14/08/2024 08:43, joes wrote:DDD
Am Tue, 13 Aug 2024 21:38:07 -0500 schrieb olcott:
On 8/13/2024 9:29 PM, Richard Damon wrote:You were trying to label an incomplete/partial/aborted simulation as
On 8/13/24 8:52 PM, olcott wrote:
That is what I said dufuss.A simulation of N instructions of DDD by HHH according to theNope, it is just the correct PARTIAL emulation of the first N
semantics of the x86 language is necessarily correct.
instructions of DDD, and not of all of DDD,
correct.
how *HHH* returns*Try to show exactly how DDD emulated by HHH returns to its caller*A correct simulation of N instructions of DDD by HHH is sufficientNope, if a HHH returns to its caller,
to correctly predict the behavior of an unlimited simulation.
HHH simulates DDD enter the matrix
DDD calls HHH(DDD) Fred: could be eliminated HHH simulates
voilasecond level
DDD calls HHH(DDD) recursion detected
HHH aborts, returns outside interference DDD halts
Of course. I made it only to illustrate one step in the paradoxicalHHH halts
You're misunderstanding the scenario? If your simulated HHH aborts its simulation [line 5 above],
then the outer level H would have aborted its identical simulation
earlier. You know that, right?
So your trace is impossible...Just like all the others are wrong.
On 8/13/24 11:48 PM, olcott wrote:
On 8/13/2024 10:21 PM, Richard Damon wrote:
On 8/13/24 10:38 PM, olcott wrote:
On 8/13/2024 9:29 PM, Richard Damon wrote:
On 8/13/24 8:52 PM, olcott wrote:
void DDD()
{
HHH(DDD);
return;
}
_DDD()
[00002172] 55 push ebp ; housekeeping
[00002173] 8bec mov ebp,esp ; housekeeping
[00002175] 6872210000 push 00002172 ; push DDD
[0000217a] e853f4ffff call 000015d2 ; call HHH(DDD)
[0000217f] 83c404 add esp,+04
[00002182] 5d pop ebp
[00002183] c3 ret
Size in bytes:(0018) [00002183]
A simulation of N instructions of DDD by HHH according to
the semantics of the x86 language is necessarily correct.
Nope, it is just the correct PARTIAL emulation of the first N
instructions of DDD, and not of all of DDD,
That is what I said dufuss.
Nope. You didn't. I added clairifying words, pointing out why you claim
is incorrect.
For an emulation to be "correct" it must be complete, as partial
emulations are only partially correct, so without the partial modifier,
they are not correct.
A complete emulation of one instruction is
a complete emulation of one instruction
A correct simulation of N instructions of DDD by HHH is
sufficient to correctly predict the behavior of an unlimited
simulation.
Nope, if a HHH returns to its caller,
*Try to show exactly how DDD emulated by HHH returns to its caller*
(the first one doesn't even have a caller)
Use the above machine language instructions to show this.
Remember how English works:
When you ask "How DDD emulated by HHH returns to its callers".
Show the exact machine code trace of how DDD emulated
by HHH (according to the semantics of the x86 language)
reaches its own machine address 00002183
No. The trace is to long, and since you HHH doesn't meet your
requirements (since it isn't a pure function) you can't give me a
compldte input to trace.
On 8/14/2024 3:17 AM, Mikko wrote:
On 2024-08-14 00:52:36 +0000, olcott said:
void DDD()
{
HHH(DDD);
return;
}
In order to prove that the above specifies a non-halting behavour
you must prove that HHH(DDD) does not terminate.
That is the strawman error of reasoning.
The focus of the post was to show that DDD emulated by HHH
according to the semantics of the x86 language cannot possibly
reach its own "return" instruction.
By changing the subject you cheat.
On 8/14/2024 3:17 AM, Mikko wrote:
On 2024-08-14 00:52:36 +0000, olcott said:
void DDD()
{
HHH(DDD);
return;
}
In order to prove that the above specifies a non-halting behavour
you must prove that HHH(DDD) does not terminate.
Wrong.
Am Wed, 14 Aug 2024 16:07:43 +0100 schrieb Mike Terry:
On 14/08/2024 08:43, joes wrote:
Am Tue, 13 Aug 2024 21:38:07 -0500 schrieb olcott:
On 8/13/2024 9:29 PM, Richard Damon wrote:You were trying to label an incomplete/partial/aborted simulation as
On 8/13/24 8:52 PM, olcott wrote:
That is what I said dufuss.A simulation of N instructions of DDD by HHH according to theNope, it is just the correct PARTIAL emulation of the first N
semantics of the x86 language is necessarily correct.
instructions of DDD, and not of all of DDD,
correct.
how *HHH* returns*Try to show exactly how DDD emulated by HHH returns to its caller*A correct simulation of N instructions of DDD by HHH is sufficient >>>>>> to correctly predict the behavior of an unlimited simulation.Nope, if a HHH returns to its caller,
DDDHHH simulates DDD enter the matrix
DDD calls HHH(DDD) Fred: could be eliminated HHH simulates
voilasecond level
DDD calls HHH(DDD) recursion detected
HHH aborts, returns outside interference DDD halts
Of course. I made it only to illustrate one step in the paradoxical reasoning, as long as we're calling programs that do or don't abortHHH halts
You're misunderstanding the scenario? If your simulated HHH aborts its
simulation [line 5 above],
then the outer level H would have aborted its identical simulation
earlier. You know that, right?
the same.
On 8/15/2024 3:19 AM, Mikko wrote:
On 2024-08-14 04:04:23 +0000, Richard Damon said:
On 8/13/24 11:48 PM, olcott wrote:
On 8/13/2024 10:21 PM, Richard Damon wrote:
On 8/13/24 10:38 PM, olcott wrote:
On 8/13/2024 9:29 PM, Richard Damon wrote:
On 8/13/24 8:52 PM, olcott wrote:
void DDD()
{
HHH(DDD);
return;
}
_DDD()
[00002172] 55 push ebp ; housekeeping >>>>>>>> [00002173] 8bec mov ebp,esp ; housekeeping
[00002175] 6872210000 push 00002172 ; push DDD
[0000217a] e853f4ffff call 000015d2 ; call HHH(DDD)
[0000217f] 83c404 add esp,+04
[00002182] 5d pop ebp
[00002183] c3 ret
Size in bytes:(0018) [00002183]
A simulation of N instructions of DDD by HHH according to
the semantics of the x86 language is necessarily correct.
Nope, it is just the correct PARTIAL emulation of the first N
instructions of DDD, and not of all of DDD,
That is what I said dufuss.
Nope. You didn't. I added clairifying words, pointing out why you
claim is incorrect.
For an emulation to be "correct" it must be complete, as partial
emulations are only partially correct, so without the partial
modifier, they are not correct.
A complete emulation of one instruction is
a complete emulation of one instruction
A correct simulation of N instructions of DDD by HHH is
sufficient to correctly predict the behavior of an unlimited
simulation.
Nope, if a HHH returns to its caller,
*Try to show exactly how DDD emulated by HHH returns to its caller* >>>>>> (the first one doesn't even have a caller)
Use the above machine language instructions to show this.
Remember how English works:
When you ask "How DDD emulated by HHH returns to its callers".
Show the exact machine code trace of how DDD emulated
by HHH (according to the semantics of the x86 language)
reaches its own machine address 00002183
No. The trace is to long, and since you HHH doesn't meet your
requirements (since it isn't a pure function) you can't give me a
compldte input to trace.
The trace is regular enough that we could define a formal language for
the trace and construct an analyzer program to detect deviations from
x86 semnatics and hidden inputs.
There are no deviations. The x86utm operating system is
built from libx86emu that has had decades of development
effort. HHH really does emulate itself emulating DDD.
*This source-code proves it* https://github.com/plolcott/x86utm/blob/master/Halt7.c
Mike seems to have the best understanding of that source-code.
He might not yet understand that HHH does emulate itself
emulating DDD. He could find out how HHH does this.
HHH calls the x86utm operating system to create a new
process context to emulate DDD. HHH emulates itself in
the same process context. Its emulated self calls x86utm
to create another process context to emulate its own
DDD instance.
On 8/15/2024 8:57 PM, Richard Damon wrote:
On 8/15/24 10:58 AM, olcott wrote:
On 8/15/2024 3:19 AM, Mikko wrote:
On 2024-08-14 04:04:23 +0000, Richard Damon said:
On 8/13/24 11:48 PM, olcott wrote:
On 8/13/2024 10:21 PM, Richard Damon wrote:
On 8/13/24 10:38 PM, olcott wrote:
On 8/13/2024 9:29 PM, Richard Damon wrote:
On 8/13/24 8:52 PM, olcott wrote:
void DDD()
{
HHH(DDD);
return;
}
_DDD()
[00002172] 55 push ebp ; housekeeping >>>>>>>>>> [00002173] 8bec mov ebp,esp ; housekeeping >>>>>>>>>> [00002175] 6872210000 push 00002172 ; push DDD
[0000217a] e853f4ffff call 000015d2 ; call HHH(DDD)
[0000217f] 83c404 add esp,+04
[00002182] 5d pop ebp
[00002183] c3 ret
Size in bytes:(0018) [00002183]
A simulation of N instructions of DDD by HHH according to
the semantics of the x86 language is necessarily correct.
Nope, it is just the correct PARTIAL emulation of the first N >>>>>>>>> instructions of DDD, and not of all of DDD,
That is what I said dufuss.
Nope. You didn't. I added clairifying words, pointing out why you >>>>>>> claim is incorrect.
For an emulation to be "correct" it must be complete, as partial >>>>>>> emulations are only partially correct, so without the partial
modifier, they are not correct.
A complete emulation of one instruction is
a complete emulation of one instruction
A correct simulation of N instructions of DDD by HHH is
sufficient to correctly predict the behavior of an unlimited >>>>>>>>>> simulation.
Nope, if a HHH returns to its caller,
*Try to show exactly how DDD emulated by HHH returns to its caller* >>>>>>>> (the first one doesn't even have a caller)
Use the above machine language instructions to show this.
Remember how English works:
When you ask "How DDD emulated by HHH returns to its callers".
Show the exact machine code trace of how DDD emulated
by HHH (according to the semantics of the x86 language)
reaches its own machine address 00002183
No. The trace is to long, and since you HHH doesn't meet your
requirements (since it isn't a pure function) you can't give me a
compldte input to trace.
The trace is regular enough that we could define a formal language for >>>> the trace and construct an analyzer program to detect deviations from
x86 semnatics and hidden inputs.
There are no deviations. The x86utm operating system is
built from libx86emu that has had decades of development
effort. HHH really does emulate itself emulating DDD.
And then ignores that emulation,
counter-factual but you don't care.
On 8/15/2024 11:02 PM, Richard Damon wrote:Only that is not possible here, because HHH is part of DDD by design.
On 8/15/24 10:26 PM, olcott wrote:
On 8/15/2024 8:57 PM, Richard Damon wrote:
On 8/15/24 10:58 AM, olcott wrote:
On 8/15/2024 3:19 AM, Mikko wrote:
On 2024-08-14 04:04:23 +0000, Richard Damon said:
On 8/13/24 11:48 PM, olcott wrote:
On 8/13/2024 10:21 PM, Richard Damon wrote:
On 8/13/24 10:38 PM, olcott wrote:
On 8/13/2024 9:29 PM, Richard Damon wrote:
On 8/13/24 8:52 PM, olcott wrote:
Never heard of dividing the program under test from the test program?Then why does it say there were no conditional branches in theAnd then ignores that emulation,There are no deviations. The x86utm operating system is built fromNo. The trace is too long, and since you HHH doesn't meet your
requirements (since it isn't a pure function) you can't give me a >>>>>>> compldte input to trace.
The trace is regular enough that we could define a formal language >>>>>> for the trace and construct an analyzer program to detect
deviations from x86 semnatics and hidden inputs.
libx86emu that has had decades of development effort. HHH really
does emulate itself emulating DDD.
counter-factual but you don't care.
simulation of the code of the program "DDD" where there were in the
simulation of the HHH that was called by DDD and thus part of the
program DDD.
HHH is reporting on the behavior of DDD.
On 8/14/2024 3:17 AM, Mikko wrote:
On 2024-08-14 00:52:36 +0000, olcott said:
void DDD()
{
HHH(DDD);
return;
}
In order to prove that the above specifies a non-halting behavour
you must prove that HHH(DDD) does not terminate.
That is the strawman error of reasoning.
On 8/15/2024 5:22 AM, Mikko wrote:
On 2024-08-14 13:06:27 +0000, olcott said:
On 8/14/2024 3:17 AM, Mikko wrote:
On 2024-08-14 00:52:36 +0000, olcott said:
void DDD()
{
HHH(DDD);
return;
}
In order to prove that the above specifies a non-halting behavour
you must prove that HHH(DDD) does not terminate.
Wrong.
At least the proof that DDD does not terminate also proves as an
intermedate result or an obvious corollary that HHH does not halt.
Non-halting means that an infinite number of instructions can be
executed without halting. That means that at least one instruction
is executed infinitely many times as there are only finitely many
instructions. But not instrunctions of DDD outside HHH is executed
infinitely many times.
Wrong. Non-halting only means that when DDD is emulated
according to the semantics of the x86 language and this
emulation is unlimited that DDD would never reach its
own "return" instruction.
On 8/15/2024 5:26 AM, Mikko wrote:
On 2024-08-14 13:38:51 +0000, olcott said:
On 8/14/2024 3:17 AM, Mikko wrote:
On 2024-08-14 00:52:36 +0000, olcott said:
void DDD()
{
HHH(DDD);
return;
}
In order to prove that the above specifies a non-halting behavour
you must prove that HHH(DDD) does not terminate.
That is the strawman error of reasoning.
No, the word "strawman" means someting else.
The focus of the post was to show that DDD emulated by HHH
according to the semantics of the x86 language cannot possibly
reach its own "return" instruction.
By changing the subject you cheat.
That is false. Everything you say is a valid topic for a reply.
The focus of the post was to show that DDD emulated by HHH
according to the semantics of the x86 language cannot possibly
reach its own "return" instruction.
Whatever you say that does not directly address these exact
words is construed as a dishonest dodge away from the point.
On 8/15/2024 11:02 PM, Richard Damon wrote:
On 8/15/24 10:26 PM, olcott wrote:
On 8/15/2024 8:57 PM, Richard Damon wrote:
On 8/15/24 10:58 AM, olcott wrote:
On 8/15/2024 3:19 AM, Mikko wrote:
On 2024-08-14 04:04:23 +0000, Richard Damon said:
On 8/13/24 11:48 PM, olcott wrote:
On 8/13/2024 10:21 PM, Richard Damon wrote:
On 8/13/24 10:38 PM, olcott wrote:
On 8/13/2024 9:29 PM, Richard Damon wrote:
On 8/13/24 8:52 PM, olcott wrote:
void DDD()
{
HHH(DDD);
return;
}
_DDD()
[00002172] 55 push ebp ; housekeeping >>>>>>>>>>>> [00002173] 8bec mov ebp,esp ; housekeeping >>>>>>>>>>>> [00002175] 6872210000 push 00002172 ; push DDD
[0000217a] e853f4ffff call 000015d2 ; call HHH(DDD)
[0000217f] 83c404 add esp,+04
[00002182] 5d pop ebp
[00002183] c3 ret
Size in bytes:(0018) [00002183]
A simulation of N instructions of DDD by HHH according to >>>>>>>>>>>> the semantics of the x86 language is necessarily correct. >>>>>>>>>>>>
Nope, it is just the correct PARTIAL emulation of the first N >>>>>>>>>>> instructions of DDD, and not of all of DDD,
That is what I said dufuss.
Nope. You didn't. I added clairifying words, pointing out why you claim
is incorrect.
For an emulation to be "correct" it must be complete, as partial >>>>>>>>> emulations are only partially correct, so without the partial modifier,
they are not correct.
A complete emulation of one instruction is
a complete emulation of one instruction
Show the exact machine code trace of how DDD emulated
A correct simulation of N instructions of DDD by HHH is >>>>>>>>>>>> sufficient to correctly predict the behavior of an unlimited >>>>>>>>>>>> simulation.
Nope, if a HHH returns to its caller,
*Try to show exactly how DDD emulated by HHH returns to its caller* >>>>>>>>>> (the first one doesn't even have a caller)
Use the above machine language instructions to show this.
Remember how English works:
When you ask "How DDD emulated by HHH returns to its callers". >>>>>>>>
by HHH (according to the semantics of the x86 language)
reaches its own machine address 00002183
No. The trace is to long, and since you HHH doesn't meet your
requirements (since it isn't a pure function) you can't give me a >>>>>>> compldte input to trace.
The trace is regular enough that we could define a formal language for >>>>>> the trace and construct an analyzer program to detect deviations from >>>>>> x86 semnatics and hidden inputs.
There are no deviations. The x86utm operating system is
built from libx86emu that has had decades of development
effort. HHH really does emulate itself emulating DDD.
And then ignores that emulation,
counter-factual but you don't care.
Then why does it say there were no conditional branches in the
simulation of the code of the program "DDD" where there were in the
simulation of the HHH that was called by DDD and thus part of the
program DDD.
Never heard of dividing the program under test from the test program?
HHH is reporting on the behavior of DDD.
On 8/16/2024 3:53 AM, Mikko wrote:It's kind of amazing to see you quote unrelated stuff.
On 2024-08-15 15:25:07 +0000, olcott said:
On 8/15/2024 5:22 AM, Mikko wrote:
On 2024-08-14 13:06:27 +0000, olcott said:
On 8/14/2024 3:17 AM, Mikko wrote:
On 2024-08-14 00:52:36 +0000, olcott said:
*You are getting the computer science incorrectly*Wrong. Non-halting only means that when DDD is emulated according toAt least the proof that DDD does not terminate also proves as anIn order to prove that the above specifies a non-halting behavour
you must prove that HHH(DDD) does not terminate.
intermedate result or an obvious corollary that HHH does not halt.
Non-halting means that an infinite number of instructions can be
executed without halting. That means that at least one instruction is
executed infinitely many times as there are only finitely many
instructions. But not instrunctions of DDD outside HHH is executed
infinitely many times.
the semantics of the x86 language and this emulation is unlimited that
DDD would never reach its own "return" instruction.
If what I said is wrong then what you said is wrong, too,
as you say what I said.
On 8/2/2024 11:32 PM, Jeff Barnett wrote:
...In some formulations, there are specific statesThe "return" instruction is the halt state of DDD.
defined as "halting states" and the machine only halts if either
the start state is a halt state...
...these and many other definitions all have
equivalent computing prowess...
On 8/16/2024 3:53 AM, Mikko wrote:
On 2024-08-15 15:25:07 +0000, olcott said:
On 8/15/2024 5:22 AM, Mikko wrote:
On 2024-08-14 13:06:27 +0000, olcott said:
On 8/14/2024 3:17 AM, Mikko wrote:
On 2024-08-14 00:52:36 +0000, olcott said:
void DDD()
{
HHH(DDD);
return;
}
In order to prove that the above specifies a non-halting behavour
you must prove that HHH(DDD) does not terminate.
Wrong.
At least the proof that DDD does not terminate also proves as an
intermedate result or an obvious corollary that HHH does not halt.
Non-halting means that an infinite number of instructions can be
executed without halting. That means that at least one instruction
is executed infinitely many times as there are only finitely many
instructions. But not instrunctions of DDD outside HHH is executed
infinitely many times.
Wrong. Non-halting only means that when DDD is emulated
according to the semantics of the x86 language and this
emulation is unlimited that DDD would never reach its
own "return" instruction.
If what I said is wrong then what you said is wrong, too,
as you say what I said.
*You are getting the computer science incorrectly*
On 8/2/2024 11:32 PM, Jeff Barnett wrote:
...In some formulations, there are specific states
defined as "halting states" and the machine only
halts if either the start state is a halt state...
...these and many other definitions all have
equivalent computing prowess...
The "return" instruction is the halt state of DDD.
On 8/16/2024 3:53 AM, Mikko wrote:
On 2024-08-15 15:25:07 +0000, olcott said:
On 8/15/2024 5:22 AM, Mikko wrote:
On 2024-08-14 13:06:27 +0000, olcott said:
On 8/14/2024 3:17 AM, Mikko wrote:
On 2024-08-14 00:52:36 +0000, olcott said:
void DDD()
{
HHH(DDD);
return;
}
In order to prove that the above specifies a non-halting behavour
you must prove that HHH(DDD) does not terminate.
Wrong.
At least the proof that DDD does not terminate also proves as an
intermedate result or an obvious corollary that HHH does not halt.
Non-halting means that an infinite number of instructions can be
executed without halting. That means that at least one instruction
is executed infinitely many times as there are only finitely many
instructions. But not instrunctions of DDD outside HHH is executed
infinitely many times.
Wrong. Non-halting only means that when DDD is emulated
according to the semantics of the x86 language and this
emulation is unlimited that DDD would never reach its
own "return" instruction.
If what I said is wrong then what you said is wrong, too,
as you say what I said.
*You are getting the computer science incorrectly*
On 8/2/2024 11:32 PM, Jeff Barnett wrote:
...In some formulations, there are specific states
defined as "halting states" and the machine only
halts if either the start state is a halt state...
Sysop: | Keyop |
---|---|
Location: | Huddersfield, West Yorkshire, UK |
Users: | 497 |
Nodes: | 16 (2 / 14) |
Uptime: | 23:17:16 |
Calls: | 9,789 |
Calls today: | 8 |
Files: | 13,749 |
Messages: | 6,188,006 |