# Tag Archives: yahoo!

## How to Build the Best Fantasy Football Team, Part 2

UPDATE on 10/5/2015: Explained how to model a requirement of baseball leagues (Requirement 4).

UPDATE on 10/8/2015: Explained how to model a different objective function (Requirement 5).

Yesterday, I wrote a post describing an optimization model for picking a set of players for a fantasy football team that maximizes the teams’ point projection, while respecting a given budget and team composition constraints. In this post I’ll assume you’re familiar with that model. (If you are not, please spend a few minutes reading this first.)

Fellow O.R. blogger and Analytics expert Matthew Galati pointed out that my model did not include all of the team-building constraints that appear on popular fantasy football web sites. Therefore, I’m writing this follow-up post to address this issue. (Thanks, Matthew!) My MBA student Kevin Bustillo was kind enough to compile a list of rules from three sites for me. (Thanks, Kevin!) After looking at them, it seems my previous model fails to deal with three kinds of requirements:

1. Rosters must include players from at least $N_1$ different NFL teams ($N_1=2$ for Draft Kings and $N_1=3$ for both Fan Duel and Yahoo!).
2. Rosters cannot have more than $N_2$ players from the same team ($N_2=4$ for Fan Duel and $N_2=6$ for Yahoo! Draft Kings does not seem to have this requirement).
3. Players in the roster must represent at least $N_3$ different football games (Only Draft Kings seems to have this requirement, with $N_3=2$).

Let’s see what the math would look like for each of the three requirements above. (Converting this math into Excel formulas shouldn’t be a problem if you follow the methodology I used in my previous post.) I’ll be using the same variables I had before (recall that binary variable $x_i$ indicates whether or not player $i$ is on the team).

Requirement 1

Last time I checked, the NFL had 32 teams, so let’s index them with the letter $j=1,2,\ldots,32$ and create 32 new binary variables called $y_j$, each of which is equal to 1 when at least one player from team $j$ is on our team, and equal to zero otherwise. The requirement that our team must include players from at least $N_1$ teams can be written as this constraint:

$\displaystyle \sum_{j=1}^{32} y_j \geq N_1$

The above constraint alone, however, won’t do anything unless the $y_j$ variables are connected with the $x_i$ variables via additional constraints. The behavior that we want to enforce is that a given $y_j$ can only be allowed to equal 1, if at least one of the players from team $j$ has its corresponding $x$ variable equal to 1. To make this happen, we add the constraint below for each team $j$:

$\displaystyle y_j \leq \sum_{\text{all players } i \text{ that belong to team } j} x_i$

For example, if the Miami Dolphins are team number 1 and their players are numbered from 1 to 20, this constraint would look like this: $y_1 \leq x_1 + x_2 + \cdots + x_{20}$

Requirement 2

Repeat the following constraint for every team $j$:

$\displaystyle \sum_{\text{all players } i \text{ that belong to team } j} x_i \leq N_2$

Assuming again that the first 2o players represent all the players from the Miami Dolphins, this constraint on Fan Duel would look like this: $x_1 + x_2 + \cdots + x_{20} \leq 4$

Requirement 3

My understanding of this requirement is that it applies to short-term leagues that get decided after a given collection of games takes place (it could even be a single-day league). This could be implemented in a way that’s very similar to what I did for requirement 1. Create one binary $z_g$ variable for each game $g$. It will be equal to 1 if your team includes at least one player who’s participating in game $g$, and equal to zero otherwise. Then, you need this constraint

$\displaystyle \sum_{\text{all games } g} z_g \geq N_3$

as well as the constraint below repeated for each game $g$:

$\displaystyle z_g \leq \sum_{\text{all players } i \text{ that participate in game } g} x_i$

Additional Requirements Submitted by Readers

I earlier claimed that this model can be adapted to fit fantasy leagues other than football. So here’s a question I received from one of my readers:

For fantasy baseball, some players can play multiple positions. E.g. Miguel Cabrera can play 1B or 3B. I currently use OpenSolver for DFS and haven’t found a good way to incorporate this into my model. Any ideas?

Let’s call this…

Requirement 4: What if some players can be added to the team at one of several positions?

Here’s how to take care of this. Given a player $i$, let the index $t=1,2,\ldots,T_i$ represent the different positions he/she can play. Instead of having a binary variable $x_i$ representing whether or not $i$ is on the team, we have binary variables $x_{it}$ (as many as there are possible values for $t$) representing whether or not player $i$ is on the team at position $t$. Because a player can either not be picked or picked to play one position, we need the following constraint for each of these multi-position players:

$\displaystyle \sum_{t=1}^{T_i} x_{it} \leq 1$

Because we have replaced $x_i$ with a collection of $x_{it}$‘s, we need to replace all occurrences of $x_i$ in our model with $(x_{i1} + x_{i2} + \cdots + x_{iT_i})$.

In the Miguel Cabrera example above, let’s say Cabrera’s player ID (the index $i$) is 3, and that $t=1$ represents the first-base position, and $t=2$ represents the third-base position. The constraint above would become

$x_{31} + x_{32} \leq 1$

And we would replace all occurrences of $x_3$ in our model with $(x_{31} + x_{32})$.

That’s it!

Reader rs181602 asked me the following question:

I was wondering, is there a way to add an additional constraint that maximizes the minimum rating of the chosen players, if each player has some rating score. I tried to think that out, but can’t seem to get it to be linear.

Let’s call this…

Requirement 5: What if I want to maximize the point projection of the worst player on the team? (In other words, how do I make my worst player as good as possible?)

It’s possible to write a linear model to accomplish this. Technically speaking, we would be changing the objective function from maximizing the total point projection of all players on the team to maximizing the point projection of the worst player on the team. (There’s a way to do both together (sort of). I’ll say a few words about that later on.)

Here we go. Because we don’t know what the projection of the worst player is, let’s create a variable to represent it and call it $z$. The objective then becomes:

$\max z$

You might have imagined, however, that this isn’t enough. We defined in words what we want $z$ to be, but we still need formulas to make $z$ behave the way we want. Let $M$ be the largest point projection among all players that could potentially be on our team. It should be clear to you that the constraint $z\leq M$ is a valid ceiling on the value of $z$. In fact, the value of $z$ will be limited above by 9 values/ceilings: the 9 point projections of the players on the team. We want the lowest of these ceilings to be as high as possible.

When a player $i$ is not on the team ($x_i=0$), his point projection $p_i$ should not interfere with the value of $z$. When player $i$ is on the team ($x_i=1$), we would like $p_i$ to become a ceiling for $z$, by enforcing $z\leq p_i$. The way to make this happen is to write a constraint that changes its behavior depending on the value of $x_i$, as follows:

$z \leq p_ix_i + M(1-x_i)$

We need one of these for each player. To see why the constraint above works, consider the two possibilities for $x_i$. When $x_i=0$ (player not on the team), the constraint reduces to $z\leq M$ (the obvious ceiling), and when $x_i=1$ (player on the team), the constraint reduces to $z\leq p_i$ (the ceiling we want to push up).

BONUS: What if I want, among all possible teams that have the maximum total point projection, the one team whose worst player is as good as possible? To do this, you solve two optimization problems. First solve the original model maximizing the total point projection. Then switch to this $\max z$ model and include a constraint saying that the total point projection of your team (the objective formula of the first model) should equal the total maximum value you found earlier.

That’s it!

And that does it, folks!

Does your league have other requirements I have not addressed here? If so, let me know in the comments. I’m sure most (if not all) of them can be incorporated.

Advertisements

24 Comments

Filed under Analytics, Applications, Integer Programming, Modeling, Motivation, Sports