# How many rounds should a swiss tournament have?

There are many different pairing methods. While it would not surprise me in the least to learn that Swiss pairing on OGS was an inexplicable black box that should be improved, not all reasonable Swiss pairing methods have “pair people with the same score together if possible” as the top priority. For example, Amalfi Pairing is my favorite: in an R-round tournament with each round `n` numbered in `[1, R]`, for each round perform the following pairing algorithm:

``````if the number of players remaining (not disqualified or dropped out) is odd {
award a bye to a player who has not had a bye yet
(if all remaining players have had a bye, award it to a player who has not had 2 byes, and so on)

if multiple players have not yet had a bye, award it to the one lowest in the current standings
(use tiebreaks as needed)

the player receiving the bye scores 1 point and sits out the round
}

sort the list of players left to pair (after removing the player with a bye, if any) by current standings
(use tiebreaks as needed)

let players-left-to-pair[] be an array in descending order of standings
(so players-left-to-pair[0] is the player currently in the lead)
(use tiebreaks as needed to sort)
(don't include disqualified or dropped out players, or a player with a bye this round)

while players-left-to-pair is not empty {
pair players-left-to-pair[0] with players-left-to-pair[(R + 1) - n]
remove both newly-paired players from players-left-to-pair
}
``````

The goal here is to save the closest matches for the last rounds, to make it more exciting

Another fun one is King of the Hill pairing, where the top player is always paired with the 2nd player, 3rd with 4th, 5th with 6th, &c., no matter how many rematches this results in (Amalfi pairing doesn’t explicitly avoid rematches, but it does tend to give a variety of opponents), but King of the Hill pairing does try to pair players of the same score with eachother and while fun from a certain perspective, is probably not the best for a serious tournament

Sure, it may be nice to discuss other reasonable pairing methods once we have at least one such implemented. We should not say ‘there are differnt reasonable options, hence we should happily live with the nonsense cirrently implemented’. (I am not claiming you said anything like that. )

FYI here is what I was told about the pairing algorithm:

I don’t believe the part about ignoring points, though it’s possible the algorithm might be split-brained about that, leading to weird results.

EDIT: your tournament is set to “random” pairing so I don’t think you should expect too much predictability!

Sure, it’s just that THERE IS NO WAY to define a pairing method that takes the points into account.

I’ve done a couple of things to help resolve what’s easy to resolve in the short term:

• Posted a frontend PR to show number of rounds after a Swiss tournament starts
• Posted a backend PR to use the `ceil(log2(P) * 1.4)` formula

Not sure if either will land right away… fortunately, they don’t depend on each other.

I don’t think I’ll be able to contribute much in the next few months, but happy to look at improving pairing in the autumn sometime. Feel free to file a bug on GitHub and ping me there (or on the forum) in September-ish.

From the quick reading I’ve done, it seems like @richyfourtytwo is correct, and that the default Swiss pairing (or maybe all Swiss pairings) should prioritize a playoff between the participants with the most points until `log2(P)` rounds (i.e, until they have all met). In other words, it seems like Swiss is supposed to have a superset of the matchups that a single elimination tournament would have (assuming no draws).

Maybe there’s a way to implement that without getting too deep into pairing algorithms: (1) find all players with the top point total; (2) run the pairing algorithm on them, ensuring no rematches (anyone that can’t be matched is left for step 3); (3) run pairing algorithm on players not matched up in step 2. (Kind of seems like Swiss choices for “subsequent round” pairing algorithm should be limited to those that ensure no rematches. Not sure if that’s already done? (Or maybe that was impossible while using the Mr. Model formula?))

1 Like

I don’t understand, why don’t you think all the other methods use points? Especially “strength”.

Because I’ve seen plenty of proof of that in McMahon tournaments. Yes, admittedly the assumption that it’s the same in swiss is not guaranteed to be true, but I’d be willing to bet on it.

‘Strength’ in McMahon uses the rating, not the points.

1 Like

I checked the code in the backend. The “strength” pairing takes into account, in this order:

• Avoid rematch
• Tournament points
• Rank difference
• Colour reuse

Tournament points is weighted higher than rank difference, but not by much. I’ve just sent a backend patch that increases the weight of tournament points by 100-fold so that it dominates rank difference and colour reuse (also increases the weight of avoid rematch so that it continues to dominate tournament points).

4 Likes

Also filed public issues so you can track if/when the backend fixes land:

(They’ll probably be closed when the fix is “merged” but before it’s actually deployed, but usually the delay between that is only a few days.)

3 Likes