Re: HHH maps its input to the behavior specified by it --- key error in all the proofs --- Mike

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.

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.

--
Am Sat, 20 Jul 2024 12:35:31 +0000 schrieb WM in sci.math:
It is not guaranteed that n+1 exists for every n.