How Can One Arbitrage in Football Betting? (Part 3)

How Can One Arbitrage in Football Betting? (Part 3)

In the previous article, we built the payout matrix. This article continues the next step: once every bet type under every score can be written as a vector, how do we calculate stake ratios and judge whether a group of markets is actually arbitrage?

Q: How does a payout matrix become stake amounts?

First, write all possible match outcomes as a set:

\[ S={s_1,s_2,\ldots,s_m} \]

In the simplified example from the previous article, we only looked at the 9 scores from 0:0 to 2:2. In the real strategy, I use:

\[ {0,1,2,3,4,5,99}\times{0,1,2,3,4,5,99} \]

That is 49 score states. Here 99 is not an actual score. It is a high-score bucket, which can be understood as a compressed expression for 6 goals or more. The purpose is not to predict the score, but to express betting rules completely inside a finite score space.

Then write the current candidate legs as:

\[ L={L_1,L_2,\ldots,L_n} \]

Each leg \(L_i\) has decimal odds \(O_i\). For every score state \(s_j\), this leg has a settlement code:

The return multiplier includes stake. For example, if the odds are 2.10 and the leg fully wins, the return multiplier is 2.10. If it half wins, half the stake settles at 2.10 and the other half is returned:

\[ \frac{2.10+1}{2}=1.55 \]

So for every score state \(s_j\), we get one row of real return multipliers:

\[ p_j=(p_{j1},p_{j2},\ldots,p_{jn}) \]

Putting all score states together gives a return matrix:

\[ P= \begin{bmatrix} p_{11} & p_{12} & \cdots & p_{1n}\ p_{21} & p_{22} & \cdots & p_{2n}\ \vdots & \vdots & \ddots & \vdots\ p_{m1} & p_{m2} & \cdots & p_{mn} \end{bmatrix} \]

What we solve is not the absolute money amount of each leg, but each leg's ratio of total stake:

\[ x=(x_1,x_2,\ldots,x_n) \]

with:

\[ x_i\ge 0,\quad \sum_{i=1}^{n}x_i=1 \]

If total bankroll is 1000, the real stake on leg \(i\) is:

\[ \text{amount}_i=1000\times x_i \]

For any score state \(s_j\), the group's total return multiplier is:

\[ R_j=p_j\cdot x=\sum_{i=1}^{n}p_{ji}x_i \]

The core arbitrage condition is:

\[ \min_j R_j>1 \]

That means: no matter which score state happens, the final return is greater than the total stake.

Q: Why solve linear equations?

The ideal arbitrage combination does not use equal stakes. It makes returns under different outcomes as equal as possible. If some outcomes return a lot and others return very little, the low-return outcome is the real risk.

So the strategy solves for stake ratios that approximately equalize returns. Take the first effective return state as the base, and require other return states to equal it:

\[ (p_j-p_1)\cdot x=0,\quad j=2,\ldots,m \]

Then add:

\[ \sum_i x_i=1 \]

Together:

\[ \begin{cases} (p_2-p_1)\cdot x=0\ (p_3-p_1)\cdot x=0\ \cdots\ \sum_i x_i=1 \end{cases} \]

After solving \(x\), calculate:

\[ R=p_1\cdot x \]

If \(R>1\), this group can cover stake and leave profit under all effective return states.

In implementation, completely identical return rows are deduplicated first. For example, many scores for over/under 2.5 only have two forms: greater than 2.5 goals, or not greater than 2.5 goals. Although the score space has 49 states, the return matrix may only have 2 unique rows. This greatly reduces solving size.

Example: Two-leg arbitrage in over/under markets

Suppose one match has the following two markets:

For any score, these two markets only have two settlement states:

Let the stake ratio of Over 2.5 be \(x_1\), and Under 2.5 be \(x_2\). We want the two outcome returns to be equal:

\[ 2.05x_1=1.98x_2 \]

and:

\[ x_1+x_2=1 \]

Then:

\[ x_1=\frac{1.98}{2.05+1.98}=0.4913 \]

\[ x_2=\frac{2.05}{2.05+1.98}=0.5087 \]

The unified return multiplier is:

\[ R=2.05\times0.4913=1.007 \]

If total stake is 1000, the amounts are:

No matter whether total goals are greater than 2.5, the return is about 1007. Net profit is about:

\[ 1000\times(1.007-1)=7 \]

This is the simplest two-leg linear combination.

Q: How do half win and half loss enter the same model?

Asian handicap is complex because it is not only win or loss. For example, handicap \(-0.25\) can produce full win, half loss, or full loss. Handicap \(+0.25\) can produce full win, half win, or full loss. But in the payout matrix, these are not special. They are just different return multipliers.

Suppose there are two legs:

Group the result by home-team result:

The return matrix is:

\[ P= \begin{bmatrix} 1.95 & 0\ 0.5 & 1.525\ 0 & 2.05 \end{bmatrix} \]

This cannot be judged by the simple "sum of odds reciprocals less than 1" rule. In the draw state, one leg half loses and the other half wins. It is a linear combination, not a pure win/loss pair.

More generally, football arbitrage should not only look at market names. It should look at the payout vector formed by each market under all score states. If those payout vectors can be added together with nonnegative ratios so that every score state returns more than the stake, then there is an arbitrage structure.

Q: Why does the script first search for coverage combinations?

If all markets in one match are directly thrown into a solver as pairs, triples, and quadruples, computation can be large. The strategy first applies a rule filter: a group of markets must cover all score states before it is worth entering stake solving.

In matrix language, if a leg's return code under a score state is greater than 0, this state is considered covered. The coverage set of a group is the union of all leg coverage sets:

\[ C(L_1,\ldots,L_n)=C(L_1)\cup C(L_2)\cup\cdots\cup C(L_n) \]

Only when:

\[ C(L_1,\ldots,L_n)=S \]

does this group enter the next step.

The production strategy only enumerates 2- to 4-leg combinations. This is not a mathematical limit. It is a trading compromise: the more legs there are, the more vulnerable the group becomes to odds movement, limits, and order delay. Two, three, and four legs are more realistic execution ranges.

This forms the full decision chain:

1. Write each market as a payout vector over score states.
2. Find 2- to 4-leg combinations that cover all score states.
3. Convert settlement codes into return multipliers using real odds.
4. Solve nonnegative stake ratios \(x\).
5. Check whether the worst-result return is greater than stake.

At this point, arbitrage has moved from "looking at odds by experience" into a clear linear algebra problem. The next article continues with how this model lands inside a real-time strategy script: how data enters, how combinations are filtered faster, how rebates enter EV, and how results are finally written to the output table.