computer-go: transpositions (less unclear?)

[met@xxxxxxxxxxxxxx]

I was a bit unclear in my previous posting. I will try to make
things less unclear.

First some facts about my tsumego program. My program:
- detects and handles ko
- detects and handles superko
- uses the Zorbrist hashing
- uses a hashed transposition table
- store and retrieve evaluations of nodes in the search tree

Then some facts about search trees in (tsume)go:

When one create a hashcode for a go position one have to have
a way to include which moves that are illegal by the ko-rule
into the hashcode.

When one is using the "*non* super-ko rule" only one point can
be illegal. A crude way to find this point is to try every move
and check if the position is recreated. For the "*non* super-ko
rule" one can easily find smarter ways find the illegal move.
(hashing go position under the "*non* super-ko rule" is quite
straight forward)

When using the super-ko rule more than one point can be illegal
in each position. One can still use the crude way to find these
illegal points. Every illegal point have to included into the
hashcode. The crude way to find illegal points is time consuming
(and quite unnecessary specially when the position can be retrieved
from the transposition table)

What I'm trying to say is that it is mush harder to implement a
transposition table under the super-ko rule then under the "*non*
super-ko rule".

(I will in an additional posting show a search tree which (I think)
 shows that it is *very* hard to have an correct and efficient hash
 coding of go-positions under the super-ko rule.)

(In 1995 someone wrote an excellent posting in the computer-go
 mailing list about problems when hashing go-positions. Unfortunately
 I did not save that post.)

I have browsed through the GnuGo source for hashing but as far as
I understand GnuGo does not create hash codes usable under the
super-ko rule.

My questions to this list:

Does your program create correct hash coding under the super-ko rule?
(My program uses for the moment the super-ko rule and the crude way
to find illegal moves. It works but I don't think it's correct enough)

As finding illegal moves under the super-ko rule is inefficient one
would like to avoid using the super-ko rule. On the other hand the
super-ko rule is quite efficient way to avoid useless eternal loops.
Is there some other way to prevent the program from running into
useless eternal loops? Other than detecting recreation of positions.
Probably not!

Please tell me your thougts about hash coding under the super-ko rule.

Thanks for your time.

Regards,
Mikael Thulin