[Top][All Lists]

[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index]

[Bug-gnubg] Live cube take points - error in gnubg cubeful code ?

From: Massimiliano Maini
Subject: [Bug-gnubg] Live cube take points - error in gnubg cubeful code ?
Date: Tue, 10 Mar 2009 16:42:06 +0100

Hi all,

I'm not really familiar with all the theory and even less with gnubg internal code, hence
I may well be wrong, but there's something that looks wrong to me.

In gnubg.pdf, paragraph "Live cube equities", there's the following:

        For match play there is no simple formula, since redoubles can only occur a limited number of times.
        The live cube take point is generally calculated as

          TP(live, n Cube)=TP(dead, n cube) * (1 - TP(live, 2n cube)

(missing closed bracket on last line, minor).

I was wondering how this relation is deduced, since I can't obtain it from Janowski paper
(which seems to be the basis for cubeful evaluation).

Looking at Janowski's paper, in paragraph 2 of appendix 5 (Finite Model — Constant gammon
and backgammon-rates), it seems he gets a different recursive _expression_ for the take point
in the finite model.

From my understanding, gnubg does this:

        Live_CP_playerB(n Cube) = 1 - Live_CP_playerA(2n Cube) * Dead_TP_playerA(n Cube)

This is in GetPoints (matchequity.c), lines 598- ... :

        /* Doubled cube is alive */

        /* redouble, pass */
        rRDP =

        /* double, pass */
        rDP =

        /* double, take win */

        rDTW =
          ( 1.0f - arG[ k ] - arBG[ k ] ) *
                  + arG[ k ] * aarMETResults[k][DTWG]
                  + arBG[ k ] * aarMETResults[k][DTWB];

        arCPLive[ k ][ n ] =
          1.0f - arCPLive[ ! k ][ n + 1] * ( rDP - rDTW ) / ( rRDP - rDTW );

I think that the code does exactly what is written in gnubg.doc.
(Note: why rRDP, commented ad "redouble pass", is associated to the tag DTL,
which is for Double/Take and Lose ? rRDP should probably be rDTL and the comment
should be /* double, take and lose */).

In Janowski's paper however, the relation is (pages 27-28):

        Live_CP_playerB(n Cube) = 1 - Live_CP_playerA(2n Cube) * Effective_TP_playerA(n Cube)

The difference in the recursive relation is between multiplying by the dead take point
(as gunbg does) and the effective take point (as Janowski does). In Janowski formula,
only the last term of the recursive relation has the dead take point, all the intermediate
ones have the effective take points. I think Janowski formula is the right one.

The dead take point is:

        TP_dead = (Eq(Pass) - Eq(Take and Lose)) / (Eq(Take and Win) - Eq (Take and Lose))

This is the term in gnubg code ( rDP - rDTW ) / ( rRDP - rDTW ), once you realise that
in gnubg code the equities are seen from player k point of view.

For money, this is the well known (L-1/2)/(W+L)

The effective take point is:

        TP_eff  = (Eq(Pass) - Eq(Take and Lose)) / (Eq(Take and Cash) - Eq (Take and Lose))

For money this is (L-1/2)/(L+1).

In the dead take point, you can't cash. In the effective one you can.

Can a more knowledgeable one have a look and let me know ?

reply via email to

[Prev in Thread] Current Thread [Next in Thread]