Re: The philosophy of computation reformulates existing ideas on a new basis ---

On 10/28/24 11:08 PM, olcott wrote:

On 10/28/2024 9:56 PM, Richard Damon wrote:

On 10/28/24 9:09 PM, olcott wrote:

On 10/28/2024 6:56 PM, Richard Damon wrote:

>
It is IMPOSSIBLE to emulate DDD per the x86 semantics without the code for HHH, so it needs to be part of the input.
>

>
*You seemed to be a totally Jackass here*
You are not that stupid
You are not that ignorant
and this is not your ADD
>
_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]
>
At machine address 0000217a HHH emulates itself emulating
DDD without knowing that it is emulating itself.
>

>
Then how did it convert the call HHH into an emulation of DDD again?
>

 When HHH (unknowingly) emulates itself emulating DDD this
emulated HHH is going to freaking emulate DDD.
 Did you think it was going to play poker?
 

Which is what it would do, get stuck and fail to be a decider. It might figure out that it is emulating an emulating decider, at which point it knows that the decider might choose to abort its conditional emulation to return, so it needs to emulate further.
Only by recognizing itself, does it have grounds to say that if I don't abort, it never will, and thus I am stuck, so I need to abort.
The problem is that it also needs to be smarter than you have been, and realize this means that that original call to HHHG *WILL* return, and return with what ever answer it gives, and at the moment, it doesn't know what that program will do with that answer, which it will need to know to give the right answer.
So, your logic is wrong, and a LIE, as you said as your premise here that HHH never know it was emulating itself, so, how then did it convert the concept of the call HHH to being an emulator without recognizing itself?
Note, if it JUST decides that it is an "emulator", it made an error, as it is a CONDITIONAL emulator, that may (and if this HHH aborts, WILL) stop its emulation and return an answer.
To think of it as an unconditional emulator is to make an error and presume the input given wasn't the actual input that was given.
So, your problem is that you logic just forgets about some of the details it doesn't want to think about. Which shows that you idea of "interrupting conditions" like if you ever conclude P and not P for some P, you need to abort that step and weren't allowed to use that otherwise "valid" inference rule, just doesn't work.
Sorry, you are just proving yourself wrong.