Re: Indirect Reference Changes the Behavior of DDD() relative to DDD emulated by HHH --- Deception

On 9/10/24 10:04 AM, olcott wrote:

On 9/10/2024 4:04 AM, Mikko wrote:

On 2024-09-09 18:15:26 +0000, olcott said:
>

On 9/8/2024 9:44 AM, Mikko wrote:

On 2024-09-08 13:58:32 +0000, olcott said:
>

On 9/8/2024 4:25 AM, Mikko wrote:

On 2024-09-07 14:00:19 +0000, olcott said:
>

On 9/7/2024 5:19 AM, Fred. Zwarts wrote:

Op 06.sep.2024 om 13:31 schreef olcott:

On 9/6/2024 4:36 AM, Fred. Zwarts wrote:

Op 05.sep.2024 om 15:48 schreef olcott:

>
HHH MUST ABORT AFTER SOME FIXED NUMBER OF RECURSIVE EMULATIONS
AND THE OUTERMOST HHH ALWAYS SEE ONE MORE THAN THE NEXT INNER ONE.

>
And the outer one, when aborting after two cycles , misses the behaviour of the inner one in the next cycle, where the inner one would see the 'special condition', abort, return to DDD, which would halt as well.
That HHH misses the last part of the behaviour of the program, does not change the fact that this is the behaviour that was coded in the program
>

>
If we have an infinite chain of people each waiting for
the next one down the line to do something then that thing
is never done.

>
The infinite chain exists only in your dream. In fact there are only two recursions, so never more that a chain of three HHH in the simulation.
HHH is incorrect in assuming the there is an infinite chain, but this incorrect assumption makes that it aborts and halts. This applies both to the simulating and the simulated HHH.

>
The way it is encoded now there are only two recursions.
>
If we encode it as you suggest the outermost directly
executed HHH would wait for the first emulated HHH which
would wait for the second which would wait for third
on and on...
>

>
What is olcott's problem with English?
If one way is incorrect, he thinks that it suggests that another way must be correct.
I never suggested to change HHH, because there is *no* correct way to do it. Every HHH that simulates itself is incorrect. No matter what clever code it includes.

>
You must be a brain dead moron.
As long as HHH emulates the sequence of instructions
it was provided then HHH is correct even if it catches
your computer on fire.

>
That is right. The error only occurs when HHH no longer emulates the
sequence of instructions it was provided.
>

>
<MIT Professor Sipser agreed to ONLY these verbatim words 10/13/2022>
     If simulating halt decider H correctly simulates its input D
     until H correctly determines that its simulated D would never
     stop running unless aborted then
>
     H can abort its simulation of D and correctly report that D
     specifies a non-halting sequence of configurations.
</MIT Professor Sipser agreed to ONLY these verbatim words 10/13/2022>
>
The above refers to determining that *its input D*
"specifies a non-halting sequence of configurations"
When people change this to a *non-input D* they are
trying to get away with deception.

>
We know except the only "people" that do so is you.
>

>
_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]
>
Try to show all of the details of how DDD emulated
by HHH ever reaches machine address  00002183

>
It is your emulator so you need to show what needs be shown.

 I am not making the false claim.
My claim in that 00002172, 00002173, 00002175, 0000217a
are emulated by the first executed emulator HHH then
HHH emulates itself emulating DDD and we get
00002172, 00002173, 00002175, 0000217a...

But that isn't what you are asked to do by the problem, or what you solution claims.
You are claiming to be doing a correct x86 emultion of the program given as the input, and thus you need to show HOW that second HHH did its emulation, not the results of the emulation.
You are just making a MAJOR category error, and making yourself in to a LIAR.

 I proved this claim by showing the execution trace
https://www.liarparadox.org/HHH(DDD).pdf

Which just proves that you aren't doing what you claim, perhaps becuase ypu are too stupid to know what it is that you are claiming to do.

 Disagreeing with verified facts seems to be a psychotic
break from reality to me. It is up to you to show otherwise.

No, the verified facts are that the ACTUAL correct emulation reaches the end.
It is just your lies and fabircations that show otherwise.

 

For others it is sufficient to determine what HHH returns and
whether DDD halts and compare the two.
>

 That is the fallacy of equivocation error.

No, YOU are making the equivocation error, and that is proving that you are nothing but a LIAR.

 The emulated HHH cannot possibly return and you
are trying to get away with lying about it by
changing to subject to a different HHH instance.

No, the emulated HHH most certainly returns, just only after the HHH that is emulating it gives up.
YOU make the "equivocation" error of confounding the actual behavior of the thing talked about (the program DDD or HHH) and the behavior of a partial emulation of it.
Sorry, you are just proved to be an idiot.

 

Sequences of machine addressed when DDD is emulated by HHH
00002172, 00002173, 00002175, 0000217a
which calls an emulated HHH(DDD).
>
What are the next instructions of DDD emulated by the emulated HHH ?

>
Here, too, it is your problem to show what needs be shown.
For the rest of us it is sufficient to note what you have not proven.
>

 When DDD calls HHH(DDD) do I need to say that DDD does not
make a milkshake? DDD does not dance the jig?

No, but you need to look at what DDD actually does, and that is more than what the emulation by HHH of it does, since your HHH DOES abort its emulation.

 Wouldn't someone that is not a liar say that when DDD calls
HHH(DDD) that HHH(DDD) would be invoked?
 

Yes, and *ALL* of HHH(DDD) and thus the emulation of that would show HOW HHH(DDD) does what it does, not the output that it produced.
Would you say the correct x86 emulation of:
void DDD() {
     print("Starting\n");
     HHH(DDD);
     print("Done\n");
}
could be:
Starting
Done
No, it needs to show the instructions done, not the results generated.
Sorry, you are just proving your utter stupidity.