Re: DDD emulated by HHH --- (does not refer to prior posts)

On 8/28/24 12:21 PM, olcott wrote:

On 8/28/2024 11:11 AM, Fred. Zwarts wrote:

Op 28.aug.2024 om 17:13 schreef olcott:

On 8/28/2024 9:57 AM, Fred. Zwarts wrote:

Op 28.aug.2024 om 14:59 schreef olcott:

On 8/28/2024 7:46 AM, Fred. Zwarts wrote:

Op 28.aug.2024 om 14:12 schreef olcott:

On 8/28/2024 4:09 AM, Fred. Zwarts wrote:

Op 27.aug.2024 om 14:44 schreef olcott:

On 8/27/2024 3:38 AM, Fred. Zwarts wrote:

Op 27.aug.2024 om 04:33 schreef olcott:

This is intended to be a stand-alone post that does not
reference anything else mentioned in any other posts.
>
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]
>
When we assume that:
(a) HHH is an x86 emulator that is in the same memory space as DDD.
(b) HHH emulates DDD according to the semantics of the x86 language.
>
then we can see that DDD emulated by HHH cannot possibly get past
its own machine address 0000217a.
>

>
>
Yes, we see. In fact DDD is not needed at all.

>
A straw man fallacy (sometimes written as strawman) is the informal fallacy of refuting an argument different from the one actually under discussion...
https://en.wikipedia.org/wiki/Straw_man

>
Apparently you do not even understand the English that is used to describe the straw man fallacy.
Or are trying to distract the attention from the fact that DDD is not needed is a simple truism, a tautology in your terms?
>

>
When 100% of the whole point is for HHH to correctly determine
whether or not DDD would stop running if not aborted
*IT IS RIDICULOUSLY STUPID TO SAY THAT DDD IS NOT NEEDED*
>
Acting ridiculously stupid when on is not stupid at all
cannot be reasonably construed as anything besides a sadistic
head game.
>

When without DDD it is clear as crystal that HHH cannot possibly simulate itself correctly:

>
>
Damned Liar !!!

>
I will ignore this, because I know how difficult it is for you to accept the truth.
>

I have told you too many times that correct simulation
is simply obeying the semantics of the 86 language for
whatever the x86 input finite string specifies.

>
You may repeat it many more times, but HHH violated the semantics of the x86 language by skipping the last few instructions of a halting program. This finite string, when given for direct execution, shows a halting behaviour. This is the proof what the semantics of the x86 language means for this finite string: a halting program.
>

>
If the x86 string tells the computer to catch on fire and
the computer catches on fire then this proves that the
emulation was correct.

>
And when the x86 string tells the computer that there is a halting program and the simulator decides that there is a non-halting program, this proves that the simulation is incorrect.
Clear as crystal: the semantics of the x86 string is proved by its direct execution.
This is shown in the example below, where the direct execution of HHH halts, but HHH decides that it does not halt.
>

>
By this same reasoning that fact that you are no longer hungry
AFTER you have eaten proves that you never needed to eat.

>
No, again, you do not understand what It said.
>

>
The behavior of DDD before HHH aborts its simulation
(before it has eaten) it not the same behavior after
DDD has been aborted (after it has eaten).
>

>
If hungry stands for fear for infinite recursion

 hungry stands for will not stop running unless aborted
just like
will remain hungry until eating is always true whenever hungry

And thus the error of your analogy is exposed.
Eating removes the state of hunger.
Aborting a simulation does nor remove the need for that programs simulation to need to be aborted, ALL copies of it will still need to be aborted.
You seem to have a funny-mental problem aobut programs, not understanding that they are not volitialional entities, but are just deterministic algorithms that do exactly as they are programmed.

 

and eating stands for aborting, then both the simulating HHH and the simulated HHH are hungry and both are coded to eat. But the simulating HHH kills the simulated HHH before the simulated HHH could eat, which does not prove that it would not have eaten if not killed.
There was no need to kill the simulated HHH, because it also knows how to eat.
>
You seem to think that if the simulated HHH was not killed, it would have eaten. But it knows how to eat, because that is how it is coded.