League-Format Kuksu Title Tournament (Rules and Discussion)

The 9th cycle of Kuksu Main Title Tournament is ready for sign-up!

Here’s the current draft of the rules:

General Introduction
The Kuksu Title Tournament is a tournament in league format.

Rule 1: Hierarchy
The hierarchy of the league is in the exponential function with base 2. Typically, we have:
Tier 1: League A
Tier 2: League B1, League B2
Tier 3: League C1, League C2, League C3, League C4

Tier n: League (A+n-1)1, …, League (A+n-1)2^(n-1)

Rule 2: Promotion & Demotion
Each league is a round-robin tournament consisting of 5 to 10 players. Every player plays one game against every other player in that league. Generally speaking,
(2.1) the player winning the top league, League A, will challenge the previous Kuksu title holder in the best-of-five title match to determine the new title holder. The loser of the title match will be placed in League A of the next cycle.
(2.2) the 2nd place in league A stays in league A for the next cycle. Other than League A, players who finish 1st or 2nd in their league will advance and compete in the next highest league in the next cycle;
(2.3) players who finish 3rd, 4th, or 5th compete at the same tier in the next cycle;
(2.4) players who come in 6th place or lower, will compete in next lowest league in the next cycle;
(2.5) if there are many players dropping off in the next cycle without enough new players with high rating, the players might be placed in a higher (but never lower) league than the default tier decided in (2.2)-(2.4);

Rule 3: Tie breaker
There are two kinds of tie breaker:
(3.1) System tie breaker:
The top three players in each league will automatically get the trophy from the system. (Disqualified players could not get the trophy)
(3.2) League tie breaker:
The tie among players with the same points will be broken first by the sum of defeated opponent’s scores (SODOS), then the league tier in the last cycle, then the league ranking in the last cycle, and lastly by overall rank. Players disqualified by timeout will not be considered disqualified since we only have one round. However, if you timeout too many games, you’re likely to be demoted using either tie breaker. This tie breaker will be applied in all cases except the trophy determination.

Rule 4: Drop-out
(4.1) Every player (old or new) must register for the new cycle in the sign-up page created about 1~2 months prior to the new cycle, in order to be considered in the league arrangement.
(4.2) When the registration period ends, invitations will be sent to the registered players and there will be a period of about 2 weeks for the players to accept the tournament invitation.
(4.3) As mentioned above, if you finish 1st or 2nd in your league you will compete in the next highest league in the next cycle. However, if you decide to skip and not play in the next cycle, you will probably not advance to the next highest league when do decide to resume the participation. Skipping a tournament results in “starting over again” if and when you ever do wish to resume.

Rule 5: First-time player
If you’re entering the league for the first time, the league you are seeded in initially is based upon both your rating and the needs of that particular tournament. For example, a player may be initially seeded in League B and yet have a higher rating than some of the players in League A. The reason is these players with the lower rating in League A may have earned their right to be there by placing high in League B in the previous cycle.

Rule 6: Match setting
Fischer: Clock starts with 1 week and increments by 1 day per move up to a maximum of 1 week.
No handicap, 6.5 komi, Japanese (or Korean) rules, conditional moves enabled.

Rule 7: Number of Tiers
Assume all the leagues are full (with 10 players), then Tier k could hold 10 * 2^(k-1) players, and Tier 1~k could hold up to 10 * (2^k - 1) players.
Therefore,
(1) if we have 5-10 players , k = 1, there will be only one tier (tier 1).
(2) if we have 11-30 players, k = 2, there will be 2 tiers.
(3) if we have 31-70 players, k = 3, there will be 3 tiers.
(4) if we have 71-150 players, k = 4, there will be 4 tiers.
(5) if we have 151-310 players, k = 5, there will be 5 tiers.
(6) if we have 311-630 players, k = 6, there will be 6 tiers.
(7) if we have > 630 players, that would be one of the largest go tournaments ever:)
Rule 8: Number of groups and players in the bottom tier
It’s quite possible that we do not have the exact number.

In general, assume we have n (10 * (2^k - 1) < n < 10 * (2^(k+1) - 1)) players, we’ll fill up the first k tiers with 10 * (2^k - 1) players and then, the remaining r = n - 10 * (2^k - 1) players will be divided into as many league groups as possible, while ensuring that the number of players in each group is between 5 and 10 and the total number of groups does not exceed 2^k.

If r >= 5 * 2^k, we could have all 2^k groups with at least 5 players, and the remaining (r - 5 * 2^k) players will be distributed to the 2^k groups as evenly as possible;

If r < 5 * 2^k, we could have at most Floor(r/5) groups with at least 5 players, and the remaining players will be distributed to these groups as evenly as possible.

Let’s say if we have 257 players, we’ll fill up the first 4 tiers with 150 players and then, the remaining 107 players will be divided into as many league groups as possible, while ensuring that the number of players in each group is between 5 and 10 and the total number of the groups does not exceed 2^4 = 16. In this case we have 107 >= 80 = 5 * 16, so we could have all 16 groups with at least 5 players, and the remaining 27 = 16 * 1 + 11 players could be distributed to the groups as evenly as possible, resulting in 11 groups with 7 players and 5 groups with 6 players.

In case the number of remaining players is 1~4 (e.g. if we have 314 players), we might exclude some players that are in the timeout status and show no evidence of returning, or invite some more players to make the grouping possible.

Rule 9: Equivalence of rating when comparing between the old player and the new player:
(9.1) We’ll describe it with an example: if one player drops out of the league from League A and we only have 9 players by default, one player from League B (including the demoted player from League A in the last cycle) or the new players (the players from lower leagues are also considered as the new players in this case) might be drawn to fill up League A. The 3rd to 5th place from League B will be awarded 300, 200 and 100 ELO ratings, and the 6th to 8th place from previous League A will be awarded 300, 200 and 100 ratings, when compared with the new players. The same process will happen sequentially from higher tiers to lower tiers.
(9.2) If you were in the disqualification status (due to e.g. timeout) in the last cycle, there will be no awarding points even if you are placed in the positions described in (9.1) using the League tie-breaker described in (3.2).

Rule 10: Seeding Method
Once the players in each tier are decided, they will be placed using the snake seeding method according to their overall ELO rating.

Grouping Algorithm Overview:
-Input: Names of registered players with the current overall ratings, the tournament result (including the player name, league tier, league rank) from the last cycle.
-Output: The arrangement of the new league.

This system will be too complicated if it’s done manually. @Leira and I will try to make the system run automatically using the API.

This is the first draft of the system and any helpers, suggestions and comments are welcome:)

8 Likes

Brilliant!! Thanks for figuring out how to resurrect Kuksu! The protocol designed for promotions and demotions looks rational and fair, and the ELO additions to compare old players and newcomers is nice :slight_smile:

I have one question though: so you don’t consider kicking out players due to timeout? I mean, it is fine that their matches are accounted for, as this is a league, but shouldn’t they at least be forced to request re-entrance for the next cycle? Otherwise the lower leagues would get crowded with time-outers after a few cycles.

Thanks for your work!

1 Like

Thank you ygramul! :slight_smile:

For your question, while there’s no disqualification due to timeout, everyone has to sign up in each new cycle, so in this sense everybody is forced to request entrance (or confirm participation) for the new cycle. I’ve updated the Rule (4.1) to get it explicitly stated:)

This was my favorite tournament format fro the old OGS.

I am very happy to see it return.

Thanks for your efforts.

Clark

2 Likes

Good ol’ OGS Kuksu (may I say the “first” OGS League? sorry, I don’t mean to antagonize, moving on…)

I must say, @gamesorry, that you will be my beta tester, though I’ll try to have a working model soon enough (it works in my head :stuck_out_tongue_closed_eyes: ). There are perhaps one or two rules that I may not want to implement, but that’s a topic for a later post.

By the way, you said that you were toying with the API as well. Out of curiosity, what language were you using? Tell me you were also using Python and you’ll be my hero hehe.

Anyway, thanks for posting the rules; into it and off I go.

1 Like

Thank you @Traveller and @Leira, I think this league system is to “forge the future with the past” :wink:

As this is the first draft, there must be some imperfections so feel free to discuss on any specific rules :smile:

I have only gone through the introduction of the APIs. I have used Python to crawl information from another website, and have been studying node.js with REST API in another project, so I haven’t decided which language to use. If you are using Python, I guess we can work together to make the system work in Python!

(Well, in fact even C++ could be used for the logic once we obtain the input, i.e., names of registered players with the current overall ratings, the tournament result (including the player name, league level, league rank) from the last cycle, from the API - just kidding ;-))

Python 3, by the way, just to be sure (a lot of folks still seem to be using 2.7 so…).

The input part is done: it takes me just a very simple function call. I had already peeked how the Kuksu was stored in the server, and all games were mixed up, with no reference to the groups.

So, unless you wanted to make about 800 game info retrievals to the server I thought it was better to just do partitions: a played game would link two players together in the same group, and so you deconstruct the round robins. This is all very simple, it’s just I digress a lot doing stuff perhaps I’m not supposed to.

I do not discard integrating code in other languages, but not for this pre-alpha version :laughing: (and disregarding the fact that I’d have to learn how to do so).

Will you take into account the results of the last cycle?

Suggestion: make an announcement at L19.

Comment: if you want to be formal then (2.3) should also say that the 2nd place in league A stays in league A for the next cycle.

As I understood new players can enter higher leagues only if someone drops from the tournament. This can be a problem. May be it will be better to demote the 6th places too. Than the free spots can be filled according to your modified rating algorithm.

From a support view, targeting Python 3 makes sense.

There are many options. All can work. Existing code usually wins. Unless there is a string argument against, we should stay with Python 3. My new work is in Python 3 or Go. I use whatever is in place for the existing projects.

I’ll be happy to help with the coding or history research effort.

@Leira @Traveller Sure, Python 3 looks reasonable (I actually have both versions installed and they sometimes mix up ;-))

@Leira That sounds great! So are you able to obtain the list of players from the registration page as well? (Because I could not find such API on http://docs.ogs.apiary.io/)

For retrieval of the past tournament, the 9th cycle would be the only exception since it’s depending on the 8th cycle which mixes up the tiers a lot. For validation, the tier/group information could also be achieved through the web archive https://web.archive.org/web/20130821091711/http://online-go.com/tournaments/main_viewround.php?tID=26&cID=1 by the way. In the worst case, a one-time 3-hour manual work might solve the problem. In the successive cycles, an automatic mechanism is definitely required.

Yes, otherwise I would call it the “first” OGS League instead of the 9th Kuksu :wink:

Yes that’s a good suggestion. I planned to do it in the next month, since I’m afraid that making the announcement too early will attract some first-time players who have never played on OGS and forget to come back after two months, which could increase the timeout rate. (That’s also why I always make the announcement in the group only 10 days before a title tournament starts, and I can see the timeout rate has been obviously lowered down through this strategy, while the active players could still sign up early) However, posting the rules there for discussion might be a good idea now :smile:

Good catch! I’ve updated it in rule (2.2).

Another good observation! I thought that due to the long gap between the 8th and the 9th cycle, more than 50% of players would drop out from the league so there will be plenty of spots for the new players. But another factor is that the branching factor was four instead of two, and in the future cycles the dropout rate would be much lower, so it makes sense to always keep one spot available for the potential new players in each league. I’ve updated rule (2.3) and rule 9 to account for that.

Don’t worry @gamesorry, I’ve got it covered. In fact, my only concern is one of design; you see, I don’t want to make a program for that single purpose, but a program flexible enough to work out any league you wanted (including Sunjang).

Also I must admit that I have burned away part of my time on ascii arts for the console :sweat_smile:

1 Like

That’s really nice! Take your time writing the general-purpose program! If you need some specific functions that does not require the API, maybe I or @Traveller could help on it. Here are some simple examples I can think of:

function: get_equivalent_rating
input: tier_id, player_rating, previous_tier_id, previous_rank
return: equivalent_rating

function: snake_seeding
input: tier_id, number_of_groups, player_list, player_equivalent_rating_list
return: group_list

function: output_groups_in_ascii
input: group_list
return: ascii_arts :wink::wink:

function: output_groups_in_html
input: group_list
return: html_text

I would be interested in helping with development if you would like. I haven’t done any work with OGS but I am Python savvy.

@rsk Thank you for your interest! We’ll see if there’s a need on the development :smile:

In the final implementation, Rule 10 has been updated (I cannot edit the original post now, so I reply here):

Old:

Rule 10: Seeding Method
Once the players in each tier are decided, they will be placed using the snake seeding method according to their equivalent ELO rating.

New:

Rule 10: Seeding Method
Once the players in each tier are decided, they will be placed using the snake seeding method according to their overall ELO rating.

@gamesorry, [quote=“gamesorry, post:16, topic:5191”]
I cannot edit the original post now, so I reply here[/quote]

any mod can edit your post to change rule #10 if you want.

Thank you!:smile:

Apparently @Fairgo just went ahead and did it, thankfully :slight_smile: I myself was a little too shy and wanted to wait to get your “OK” for that.

I thought I registered and I was definitely IN for a while… now i don’t see the tournament??