Re: Who here is too stupid to know that DDD simulated by HHH cannot reach its own return?

On 8/7/24 3:02 PM, olcott wrote:

On 8/7/2024 1:25 PM, joes wrote:

Am Wed, 07 Aug 2024 08:40:31 -0500 schrieb olcott:

On 8/7/2024 2:22 AM, Mikko wrote:

On 2024-08-05 15:00:12 +0000, olcott said:

On 8/5/2024 2:44 AM, Mikko wrote:

On 2024-08-04 13:11:56 +0000, olcott said:

On 8/4/2024 1:26 AM, Fred. Zwarts wrote:

Op 03.aug.2024 om 17:20 schreef olcott:>>

>

In another message you have said that when HHH simulates itself
simulating DDD is does not simulate itself simulating itself
simulating DDD. You have not told whether it makes a cup of coffee.
Neither action can be seen in the traces you have shown.
>

HHH and HH and the original H have proved that they simulate
themselves simulating DDD, DD and P for three years now.

>
Your trace don't show siulation of exectuion differently from
simulation of simulation of execution.
>

It does but it is too difficult to dig it out of emulations of emulators
emulating inputs.

You could make it clearer by prefixing the simulation level.
>

 Maybe I can do this. it requires a static local, yet this
is only for reporting purposes and does not have an effect
on the computation.

Why? This is all supposedly the output of the top level decideer, which know what level it is at.
Or, are you admitting that you have been lying all the time about where the output comes from.

 None of this was every really required. We have complete
proof that the second HHH does emulated its DDD correctly
by simply compare the execution trace that it produce to
the x86 source code of DDD.

Only when you use the wrong definiton of emulating correctly, which means you don't actually get the results you need for your claims.

We have had this complete proof for HH/DD and H/P for three
years and everyone simply ignores it. This can only mean:
(a) dishonesty
(b) insufficient technical competence.

Yep, YOU have both of those problems.
Do you EVER intend to provide ANY of the "source" for any of your claims that you rely on?

 

As soon as the first HHH sees the second DDD about to invoke a third HHH
it aborts the emulation. At this point DDD, the second HHH and the
second DDD all immediately stop running and HHH returns 0 to main.

 

And HHH concludes that the second invocation of itself would somehow
not also abort but run forever, and then returns that itself wouldn't
halt, and halts. ???
>

 void DDD()
{
   HHH(DDD);
   return;
}
 Any expert in C can tell that DDD simulated by HHH cannot
possibly ever reach its own "return" instruction final halt
state.

No, The Program DDD which is simualte by HHH will return, if and only if the subroutine HHH returns. If HHH ACTUALY does a correct emualtion of its input, and thus never abort to it reaches an end, will not return.
But, YOUR HHH doesn't do that, because you claim that HHH is a decider, so it MUST answer, and thus can't be the correct emulation that you hypothocate, and thus you can't use the behavior of the DIFFERENT program DDD that uses a DIFFERENT program HHH as a subroutine for your analysis.

 Is it possible for someone to have a PhD in computer science
and not have any clue about something as simple as this?
 

Since you base your claims on the deceptive lies of changinge definitions, YOU are the stupid one.