Math People Only!: Changes to how much ratings change...

Noting your link there and the earlier one

http://math.bu.edu/people/mg/research/gdescrip.pdf

These are different but equivalent formulae, one using p, K and f, the other using q,d and g. That you refer to p,q and K in the OP of the thread suggests you are using both sets of formulae rather than just one, which would seem to increase the risk of an error.

I agree with not forcing K>=16, and I agree with trying a lower c.

     I'm still leaning towards my idea of raising t and lowering c, with the result
being the RD will lower as a result (I think).
     Jay, why don't you create your own system, it would be interesting?

This might not be math worthy but, you could ask the user to choose his/her rating when starting out. Perhaps also have option "beginner, average, advanced... etc" to determine their starting rating. When the user in question plays someone at around that same level, the ratings might not fluctuate as much.

If someone takes a month off from playing here at chess.com, their deviation balloons.  A person taking a month off shouldn't have to start over with their ratings as if their hundreds of games before never existed.  I am not gifted enough to give a valid idea on how to change the formula correctly.  But, I'll leave it up to you intelligent people to figure something out. Erik is not going to be able to appease everyone's wishes, so maybe just do what's best collectively, instead of tackling personal complaints.  Good luck! 

Since a lot of people have suggested that maybe the code or my implementation of the formulas is wrong, here is the php code for anyone whose ambitious enough to proof it :)

      $intPlayer1Rating = $objPlayer1Rating->Rating;
      $fltPlayer1Rd = $objPlayer1Rating->Rd;
      $intPlayer2Rating = $objPlayer2Rating->Rating;
      $fltPlayer2Rd = $objPlayer2Rating->Rd;

      $objPlayer1LastGame = Game::GetLastRatedGameByUserId($intPlayer1UserId, 'email_chess', null, $strGameTypeCode);
      $objPlayer2LastGame = Game::GetLastRatedGameByUserId($intPlayer2UserId, 'email_chess', null, $strGameTypeCode);

      if($objPlayer1LastGame) {
        $intMinutes = intval((time() - $objPlayer1LastGame->GameEndTime->Timestamp) / 60);

        $fltPlayer1RdPrime = sqrt(pow($fltPlayer1Rd,2) + (UserGameRating::$fltCValue * $intMinutes));
      } else {
        $fltPlayer1RdPrime = $fltPlayer1Rd;
      }

      if($objPlayer2LastGame) {
        $intMinutes = intval((time() - $objPlayer2LastGame->GameEndTime->Timestamp) / 60);

        $fltPlayer2RdPrime = sqrt(pow($fltPlayer2Rd,2) + (UserGameRating::$fltCValue * $intMinutes));
      } else {
        $fltPlayer2RdPrime = $fltPlayer2Rd;
      }

      $fltPlayer1AFactor = 1 / sqrt(1 + (UserGameRating::$fltPValue * pow($fltPlayer2RdPrime,2)));
      $fltPlayer2AFactor = 1 / sqrt(1 + (UserGameRating::$fltPValue * pow($fltPlayer1RdPrime,2)));

      $fltPlayer1EValue = 1 / (1 + pow(10,-(($intPlayer1Rating - $intPlayer2Rating) * $fltPlayer1AFactor / 400)));
      $fltPlayer2EValue = 1 / (1 + pow(10,-(($intPlayer2Rating - $intPlayer1Rating) * $fltPlayer2AFactor / 400)));

      $fltPlayer1KValue = (UserGameRating::$fltQValue * $fltPlayer1AFactor) / ((1 / pow($fltPlayer1RdPrime,2)) + (pow(UserGameRating::$fltQValue,2) * pow($fltPlayer1AFactor,2) * $fltPlayer1EValue * (1 - $fltPlayer1EValue)));
      $fltPlayer2KValue = (UserGameRating::$fltQValue * $fltPlayer2AFactor) / ((1 / pow($fltPlayer2RdPrime,2)) + (pow(UserGameRating::$fltQValue,2) * pow($fltPlayer2AFactor,2) * $fltPlayer2EValue * (1 - $fltPlayer2EValue)));

      $resultList = array(
        1 => array(
                  'w' => round($fltPlayer1KValue * (1 - $fltPlayer1EValue)),
                  'd' => round($fltPlayer1KValue * (.5 - $fltPlayer1EValue)),
                  'l' => round($fltPlayer1KValue * (0 - $fltPlayer1EValue)),
                  'rd' => round(1 / (sqrt( (1 / pow($fltPlayer1RdPrime,2)) + (pow(UserGameRating::$fltQValue,2) * pow($fltPlayer1AFactor,2) * $fltPlayer1EValue * (1 - $fltPlayer1EValue)))),2)
             ),
        2 => array(
                  'w' => round($fltPlayer2KValue * (1 - $fltPlayer2EValue)),
                  'd' => round($fltPlayer2KValue * (.5 - $fltPlayer2EValue)),
                  'l' => round($fltPlayer2KValue * (0 - $fltPlayer2EValue)),
                  'rd' => round(1 / (sqrt( (1 / pow($fltPlayer2RdPrime,2)) + (pow(UserGameRating::$fltQValue,2) * pow($fltPlayer2AFactor,2) * $fltPlayer2EValue * (1 - $fltPlayer2EValue)))),2)
             )
      );

Ok, I'll admit, I'm entirely confused and lost at this point having re-read these pages a dozen times. Notice how my RD' is NOT the new RD, but is used in further formulas. Is RD' and "new RD" synonymous? In my formulas, it is not.

RD' = sqrt(pow($fltPlayer1Rd,2) + (UserGameRating::$fltCValue * $intMinutes));

and new RD = round(1 / (sqrt( (1 / pow($fltPlayer1RdPrime,2)) + (pow(UserGameRating::$fltQValue,2) * pow($fltPlayer1AFactor,2) * $fltPlayer1EValue * (1 - $fltPlayer1EValue)))),2)

If it IS synonymous and I should remove the RD' calculation, then where in the formulas do I input the # of minutes passed since their last game? Back to the documentation....argh...

By the way, this is where I got my idea of RD' NOT being the same as new RD:

http://www.freechess.org/Help/HelpFiles/glicko.html

"

If no RD yet, initial RD assumed to be 350 if you have no games, or 70
       if your rating is carried over from ICC. Otherwise, calculate new RD,
       based on the RD that was obtained after the most recent game played,
       and on the amount of time (t) that has passed since that game, as
       follows:
       RD' = Sqrt(RD^2 + ct)
       where c is a numerical constant chosen so that predictions made
       according to the ratings from this system will be approximately"
       optimal.

In the same url I posted above, it says:

6. Your new RD is calculated as

           RD' =                     1
                   -------------------------------------------------
                   Sqrt(    1/(RD)^2   +   q^2 * f^2 * E * (1-E)   )  . 

But my code says:

               'rd' => round(1 / (sqrt( (1 /
pow($fltPlayer1RdPrime,2)) + (pow(UserGameRating::$fltQValue,2) *
pow($fltPlayer1AFactor,2) * $fltPlayer1EValue * (1 -$fltPlayer1EValue)))),2)

Notice how my new RD is calculated using the RD' value, not just old RD as their formula suggests.

Maybe thats the problem?

 That's the RD change based on the time since your last game, not the RD change based on the results of the game.

     Jay, is it possible to run a couple of experiments with "test groups?"  Have
Group A use a higher t and a lower c, Group B something similar, and so forth.
     Then you could compare the data on an empirical basis and see what the
results look like.  You could put the results in a forum so we could all debate
it.  That would be fun, like my old college days (go UVA and CNU) when I
studied Psychology and Mathematics.

I suspect a large part of the problem is caused by the length of time a player can take to complete a game. Both Elo and Glicko rating systems were designed for situations where a player completes a game at one sitting and has one game going at a time. On this type of website a player might have many games going at one time and might take many days to complete even one move. That has to make a mess of the RD calculation. This is just the opinion of an applied mathematician, feel free to ignore it if you want.

lol- good suggestion, but I don't know why you went "emo" on the last sentence.

Hey Jay,

My brief and vague understanding of glicko system is that the new RD and current RD are not synonymous.

New RD is calculated after the game has been completed, while RD is used to determine the change in rating from said game. However, the RD should not be fixed at the beginning of the game and allowed to fluxuate through out the course of the game. What this will allow for is if a player as the game continues ends up completeing more games then his RD - New RD; New RD based on previous game.

I.e.

New RD is a function call to describe RD.

For example you would have something like.

RD = NewRD(Parameters);

However, there is no real problem with your maths mate. I believe the problem maybe your assumption of how many time periods it requires before a players rating becomes as accurate as that of an unrated player.

[COMMENT DELETED]

 emo? You mean the "ignore me if you don't like my opinion bit"? My experience of this kind of forum is that anyone with anything approaching a reasonable idea had best be wearing asbestos underwear.

Jay, the first of those two formulae implements the increase in RD since the previous game result. The second one implements the decrease due to the new game result. So they both need to be applied one after the other.

hey extraBold what you said is exactly right. The New RD is simply a formula to calculate the real RD of a specific object. Which in this case is a player/computer. ;)

um i think your understanding is a little bit lacking here mate. You will get the increment in RD if you have no current games in process. As for ultering the time based on players strength and level of play ( Completely Subjective by the way) is simply pupostuous. As for Poisson distribution well that is interesting, i have to ask what event would you be measuring the probabillity off? What that a game concludes? That a player within 200 points wins? What exactly. I am sure Mark would have considered this option when he was devising his system.

paul, it is a model for predicting the probability of a result, not how many games are played in an interval. So what is the relevance of the Poisson distribution?

Cool. extraBold you could use it if you wanted to determine the frequency in which an individual who is +- 200 points wins and then uses that as a basis for the change in k value. But seems like a lot of work and as you know all mathematicians are lazy. :D