Re: HHH maps its input to the behavior specified by it --- key error in all the proofs --- fakers or liars?

On 8/12/24 6:46 PM, olcott wrote:

On 8/12/2024 5:31 PM, joes wrote:

Am Mon, 12 Aug 2024 16:23:30 -0500 schrieb olcott:

On 8/12/2024 4:13 PM, Richard Damon wrote:

On 8/12/24 2:25 PM, olcott wrote:

On 8/12/2024 1:16 PM, Richard Damon wrote:

On 8/12/24 1:32 PM, olcott wrote:

On 8/12/2024 12:12 PM, Richard Damon wrote:

>

It has clearlly changed over time without notice, you said you added
highlighting, but it also has had content changes.
It really needs to be date-stamped and version controlled. I can not
say if the copy I look at today is the same as I looked at the other
day.

Absolutely.
>

Second, it is NOT the trace you keep on claiming but is the trace that
x86UTM makes of running main, with the trace that the levels of HHH do
inserted (WITHOUT COMMENT) into the listing, making the trace that HHH
generats hard to find.

If you can colourcode it, you can do so right in the source.
>

The length of the wrong trace starts on page 38, so there are only
about 160 pages of trace (the rest is an assembly listing of the
program, useful to understand the trace, but not part of the trace
itself) and there are only 1 to 2 lines from HHH per page, so a trace
of just what HHH does would be only about 200-300 LINES long, not 200
pages, and not beyond what many people can handle, especially when you
remove the cruft of having to wade through all the other junk that
isn't the trace that HHH makes.

Yes, one only needs the one level.
>

One thing I do note is that the trace sees conditional jump
instructions in the trace, but your "rule" is that there can be no
conditional instructions see in the full loop, so something is wrong.
Page 79, simulated the JNZ 00001335 at address 000012f8 Why wasn't this
counted as a conditional instruction in the trace? (That means the
recursion isn't unconditional)
So, mybe it is a correct partial emulation, but just ignores some of
the meaning, so that conditional recursion is incorrectly considered to
be infinite recursion. Perhaps you just failed to test you code to see
that it correctly detects conditional jump instructions.

Ah, but we know that HHH is correct! Haha.
>

Note, examining your code, your code also VIOLATES your requirement to
be a pure functikon.
First, in Init_Halts_HH you detect if you are the "root" decider by
look to see it the stack is at the initial prefilled value, and if so
make yourself the "root" and setup a trace buffer, and record that we
are the "Root"
Then in Decides_Halting_HH you test that Root flag, and only the "Root"
decider actually does halt deciding, thus the copy of HHH that DDD
calls performs a DIFFERENT set of actions to the ones that the one
called by main does.
Thus, You are proven to be a liar that you code ACTUALLY acts as a pure
function. The static memory isn't just a way for the lower emulator to
have its results seen by the higher emulator, but the emulators
actually change from Halt Deciders to pure emulators when they are nes

 

This is where I lose track. HHH is not simulating itself.
>

 https://github.com/plolcott/x86utm/blob/master/Halt7.c
Anyone that is a c expert and understands operating systems
design can easily tell that HHH emulates DDD which calls
HHH(DDD) such that the directly executed HHH does emulate
itself emulating DDD.

Anyone can see that HHH *CONDITIONALLY* emulates its input, and that means that it can (and in fact will) abort its simulation to return, and thus doesn't create an infinite simulation loop.

 It looks like not a single person here in the last four years
has ever had that level technical competence.

No, it seems you don't have the technical competence to get the program right, as some how it seem to ignore the CONDITIONAL jumps that it simulated along the path

 Anyone with a modicum of expertise in the x86 language can
determine this same thing from the half-page execution trace
of the two emulations of DDD.

But that hides the CONDITIONAL jumps inside the HHH that DDD uses.
Which, of course, is why you try to pass that off, even that it totally violates the criteria you claim to be following.
Of course, following requirements seems not to be one of your criteria.

 It looks like everyone here for the last two years is
trying to get away with the pure bluster of faking this
competence.

Nope, YOU have been trying to pass of LIES that you have working code.
Did you test it on loops that were finite because they were conditional?
Why can't you get it to generate the results of the actual simulation of the input, rather than that becoming only a couple percent of the output, as it traces HOW that decider builds that trace instead of just the trace itself.

 

that it doesn't simulate what happens in HHH after the jmp 000015e7
instruction, and thus you claim is still a LIE.
>

That is counter factual.

>
Maybe it is recording but not looking at those instructions. Why else
is it ignoring the conditional instructions?
>

I proved that your statements were counter-factual.

Above I see only your claim. What is simulated after that jump?
>

Instead of admitting whoops I goofed you are trying to get away with
changing the subject.

Nah, you are evading questions.
>

I am about to forever give up on you.
I finally found a group of tens of thousands of people that totally
understand what I am saying.

Please tell where they are.
>