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

On 10/31/24 8:11 AM, olcott wrote:

On 10/30/2024 10:18 PM, Richard Damon wrote:

On 10/30/24 10:28 PM, olcott wrote:

On 10/30/2024 6:35 PM, Richard Damon wrote:

On 10/30/24 8:28 AM, olcott wrote:

On 10/30/2024 6:19 AM, Richard Damon wrote:

On 10/29/24 9:41 PM, olcott wrote:

On 10/29/2024 8:17 PM, Richard Damon wrote:

On 10/29/24 10:41 AM, olcott wrote:

On 10/29/2024 5:50 AM, Richard Damon wrote:

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.
>

>
Counter-factual. This algorithm has no ability to its own code.
https://github.com/plolcott/x86utm/blob/master/Halt7.c // page 801
>
*That people fail to agree with this and also fail to*
*correctly point out any error seems to indicate dishonestly*
*or lack of technical competence*
>
DDD emulated by HHH according to the semantics of the x86
language cannot possibly reach its own "return" instruction
whether or not any HHH ever aborts its emulation of DDD.
>

>
No, it knows its own code because it rule for "No conditional branches" excludes that code.
>

>
Are you really so stupid that you think this will help
DDD reach its own return instruction?

>
DDD doesn't need any help to reach its own return instruction, as the HHH that it calls DOES abort and return to it.
>

>
Are you really so stupid that you think you can keep getting
away with the strawman deception by changing the subject away
from DDD emulated by HHH?
>

>
>
What strawman?
>
I am just going to the defintions of the problem you claim to be solving.
>

>
Do I have to repeat this a few hundred times in every post
so that you can remember from one post to the next?
>
*AT THIS POINT HHH IS NOT A HALT DECIDER OR A TERMINATION ANALYZER*
*AT THIS POINT HHH IS NOT A HALT DECIDER OR A TERMINATION ANALYZER*
*AT THIS POINT HHH IS NOT A HALT DECIDER OR A TERMINATION ANALYZER*

>
But, you haven't removed yourself from the topic, so the definitions still apply.
>

>
HHH is each element of the set of x86 emulators that emulates zero
to infinity steps of DDD including zero to infinity emulations of
itself emulating DDD.

>
No, it isn't, because your published HHH is not a "set of programs".
>
It is *A* progrtam.
>

>
DDD emulated by HHH according to the semantics of the x86
language cannot possibly reach its own "return" instruction
whether or not any HHH ever aborts its emulation of DDD.
>
>

>
Which means HHH can't abort its emulaiton, or it fails to meet its requrements.
>
And thus the ONLY HHH that meets yor requrements is a different one than presented, and that one returns to NOBODY.
>
You can't try to redefine the terms until you clearly and public announce that you are leaving Computation Theory behind, and nothing you talk about can be broght back in.
>

 EVERYTHING NOT EXPRESSLY STATED IS EXPRESSLY EXCLUDED
UNLESS ENTAILED BY THE SEMANTICS OF THE X86 LANGUAGE
 _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]
 DDD emulated by any HHH according to the semantics of the x86
language cannot possibly reach its own "return" instruction
whether or not any HHH ever aborts its emulation of DDD.
 

No, That DDD can not be "emulated by any HHH according to the semantics of the x8t6 language", as it doesn't define, PER THE x86 LANGUAGE, what is as 000015d2.
You can't use your "emulation" definition, as the semantics x86 language doesn't talk about "emulation", only execution, so since you EXPRESSLY EXCLUDED things not entailed by the SEMANTICS OF THE x86 LANGUAGE, description HHH as an emulaiton is out of bounds.
And then that description is INCORRECT, as you HHH will abort its emulation to return, and that breaks the semantics of the x86 language, so you can only use that for a different version then the HHH you have previously provided that never aborts its emulation, and you need to give it the code of the HHH that DDD calls.
So, to make your claim you need to fix some things.
First, if you change your HHH to never abort, then the equivocation of your wording goes away, and yes, when we correctly emulate the code of a DDD that calls an HHH that never aborts its emulation and passes it the code of itself, including the code of HHH, then it will never reach that end state, but again, that is *ONLY* for the case where HHH is defined to actually DO that correct emulation that is NEVER aborted.
Now, if you want to use the HHH that you have previously defined, you run into a problem.
First, that emulation doesn't meet your requrements above, as the only semantics of the x86 langugage that exists would yeild an emulation that doesn't abort, as part of the definition of every insturction we meet is that it *IS* followed by the execution of the next instruction as specified by that instruction. Thus we hit the equivocation problem.
the *behavior* of "DDD emulated by any HHH" needs to be clarified as if you actually mean the behavior of DDD, or the behavior of the emulation of DDD by that HHH.
The first, would be the results of an unaborted emulation (or direct exection) of DDD, and not the partial emulation done by HHH, as the x86 language only defines behavior in that context. If that HHH that it calls includes an abort that happens when HHH emulated this DDD then that behavior will be that it DOES reach the final return, and your claim is just false.
If, on the other hand, you want to talk about the Emulation of DDD by HHH, then you run into the problem that *ANY* emulation that is aborted, is *NOT* according to the semantics of the x86 language, and thuis your claim is shown to be irrelevent as it is based on a terms that are not defined.
So, you need to clairfy which of these cases you are claiming, or just prove that you are nothing but a fraud that can't define what he is doing.