XPost: sci.logic
On 7/12/24 8:28 AM, olcott wrote:
On 7/12/2024 6:15 AM, Richard Damon wrote:
On 7/11/24 11:30 PM, olcott wrote:
On 7/11/2024 10:18 PM, Richard Damon wrote:
On 7/11/24 10:28 PM, olcott wrote:
We stipulate that the only measure of a correct emulation
is the semantics of the x86 programming language. By this
measure when 1 to ∞ steps of DDD are correctly emulated
by each pure function x86 emulator HHH (of the infinite
set of every HHH that can possibly exist) then DDD cannot
possibly reach its own machine address of 00002174 and halt.
You CAN'T atipulate "Correct", only what definition you are using
But using x86 sematics is a correct definition, and means that partial emulations are NOT correct, as part of the definition of every
non-terminal x86 instruction is that the next instruction at the
resulting PC address WILL be run.
Thus, if HHH actually DOES such an emulation, you have shown that it
will never be able to give a result.
And, if HHH doesn't do the ACTUAL correct emulation, but only a partial emulation and then return, then the FULLY CORRECT emulation of that
input will see after HHH aborts it partial emulation the continuation of
a HHH emulating its input, aborting its emulation and returning to DDD
and DDD returning, thus getting to the point you LIED about it not
getting to.
Your problem is you confuse the TRUTH about the behavior of DDD with the partial observation by its partial emulation done by HHH.
DDD DOES reach that point.
The PARTIAL emulation by HHH of DDD doesn't, but being partial doesn't
let HHH know about that behavior, but HHH's not knowing doesn't mean it
doesn't happen.
_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 1,2,3... ∞ steps of DDD are correctly emulated by
HHH it is a lie to say that this many instructions were
not correctly emulated and you know it.
But only N instructions "correctly emulated" is NOT a CORRECT
emulaition of the instructions of DDD/HHH
I didn't limit it to N. Is this your ADD? I say 1 to infinity steps !!!
I didn't limit it to N. Is this your ADD? I say 1 to infinity steps !!!
I didn't limit it to N. Is this your ADD? I say 1 to infinity steps !!!
I didn't limit it to N. Is this your ADD? I say 1 to infinity steps !!!
I didn't limit it to N. Is this your ADD? I say 1 to infinity steps !!!
So, I guess NONE of them ever stop before reaching the end, if none of
them stop before that.
1,2,3... ∞ steps of DDD are correctly emulated is every
HHH/DDD pair that can possibly exist when HHH is a pure
function x86 emulator.
No more dishonest shell game ruse
https://jorynjenkins.com/hiding-the-pea/
That wastes weeks and weeks talking in circles.
So, the finite emulations that return answers, are wrong as explained above.
The HHH the never abor tdo create DDD that never halt, but also those
HHH never repreot that behaivor, so also fail to be a decider.
For each element of this infinite set of HHH/DDD pairs
DDD never halts. For every finite N number of emulated
steps HHH halts.
Nope, as explained above, EVERY element of that set with an HHH that
only does a finite emulation, WILL return, and thus those HHH are wrong.
Yes, the DDD based on an HHH that never aborts its emulation will be non-halting, but such an HHH can never actually "report" that behavior,
so it is also wrong.
This means that every HHH of this set that aborts its
emulation of DDD is correct to reject its DDD as non
halting.
Nope, every one is WRONG (or failed to report).
You are just proving yourself to be a LIAR.
--- SoupGate-Win32 v1.05
* Origin: fsxNet Usenet Gateway (21:1/5)