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

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

In the previous section, I summarized the problem of standardizing team names. I admit this is not a perfect method, because football data will always keep producing new leagues, new teams, new cup names, and different translations for the same team across different websites.

So in a real system, I do not think there is a once-and-for-all solution to team-name normalization. The more realistic answer is: first build stable standardization rules, then keep running normalization scripts, and keep revising the special cases that appear later. Football data standardization is not a one-time project. It is infrastructure that needs long-term maintenance.

This article starts after team names have already been unified. In other words, we can already confirm that "Argentina VS Cape Verde" in different data sources points to the same match. The next problem is: under the same match, how do we judge whether different bet types, lines, and bookmakers can form an arbitrage structure?

After standardization, the data roughly looks like this:

id,starttime,league,event,dealer,lay,bettype,handicap,odd_home,odd_draw,odd_away,currency,Max_amount,Min_amount,other,timeStamp
15889684,2023-09-28 08:30,自由杯,弗鲁米嫩 VS 巴西国际,no,360,over,2,1.8,0.0,0.0,cny,0,0,,2023-09-27 13:53
15889685,2023-09-28 08:30,自由杯,弗鲁米嫩 VS 巴西国际,no,360,under,2,0.0,0.0,2.05,cny,0,0,,2023-09-27 13:53

Each row is one market quote under the same match. It tells us who is playing whom, which dealer the data comes from, what the bet type is, what the line is, and what the odds are for home/draw/away or over/under directions.

But at this point, we still cannot calculate arbitrage directly. One row is only one quote. By itself, it does not know what rule relationship it has with another quote. We first need to build betting rule mapping.

Q: Why must football betting rules be mapped first?

The core of arbitrage is not "the odds look high." The core is "no matter what the match result is, some part of the betting group can cover that result."

For example, moneyline has three results: home win, draw, and away win. If I can get high enough odds for home win, draw, and away win from different bookmakers, then these three legs can cover all 90-minute outcomes.

But football betting is not only moneyline. Common markets include:

These markets are not always in the same dimension. A full-time moneyline cannot be mixed with a first-half over/under market, because their settlement scopes are different. A 90-minute result, a 45-minute first-half result, and an extra-time result should be treated as different dimensions.

So the first principle is: only markets under the same match dimension can enter the same arbitrage model.

Regular football markets are usually settled by the 90-minute result, including stoppage time, but excluding extra time and penalty shootouts. For example, suppose a match is 1:1 after 90 minutes and becomes 3:2 after extra time. For the full-time moneyline, Asian handicap, and over/under markets discussed here, settlement is still based on the 90-minute 1:1, not the 3:2 after extra time.

This looks simple, but it is extremely important. If settlement scopes differ across data sources or markets, then even if the formula appears to show arbitrage, in real execution it may not be the same risk space.

Q: Why is moneyline arbitrage the easiest to understand?

Moneyline is the most intuitive example. It divides the 90-minute football result into three categories:

1. Home team wins.
2. Draw.
3. Away team wins.

If we bet separately on these three results, and adjust stake sizes according to odds, it may be possible to make the return greater than total stake under all three outcomes.

Suppose different bookmakers offer the following odds:

Start with the basic reciprocal test:

\[ \frac{1}{2.30}+\frac{1}{3.70}+\frac{1}{4.20}=0.9428<1 \]

Because the sum of reciprocals is less than 1, there is theoretical arbitrage space.

If the total bankroll is 1000, the stake is not split equally. It is allocated by reciprocal odds:

Final returns:

This is the most basic three-way arbitrage. The core principle is: arbitrage does not make every stake equal. It adjusts stake ratios by odds so that returns under different results are as close as possible.

Moneyline is easy to understand because it only has three mutually exclusive results, and each leg either fully wins or fully loses. But the real complexity in football betting is that many markets are not simple win/loss markets.

Q: Why can't all arbitrage be judged only by odds reciprocals?

Because Asian handicap and over/under markets have push, half win, and half loss.

For example, over/under 2.0:

Another example is Asian handicap -0.25:

These markets cannot simply use the moneyline reciprocal formula. Under some score states, a leg may not be a full win or full loss. It may be half win, half loss, or returned stake.

So every bet type must be converted into a more general expression:

What is its settlement result under every possible score?

Q: How can a script calculate combinations that cover all outcomes?

My method is to build a multidimensional model based on exhaustive score states.

For illustration, first limit each team's goals to 0, 1, and 2. Then there are 9 possible scores:

In these 9 scores, moneyline_home wins under:

1:0, 2:0, 2:1

moneyline_draw wins under:

0:0, 1:1, 2:2

moneyline_away wins under:

0:1, 0:2, 1:2

To put moneyline, Asian handicap, and over/under into the same model, I unify settlement results into five codes:

Moneyline only has full win and full loss, so its payout matrix can be written as:

This table is the rule mapping. It is not an odds table. It is the settlement table for each bet type under each score.

If ML Home has code 200 under one score, it means the home-win leg fully wins under that score. If the code is 0, it fully loses under that score.

Q: How does the payout matrix expand to more bet types?

The same method can extend to Asian handicap, over/under, both teams to score, correct score, and other markets.

For example, under the same 9 score states, after adding some common markets, the matrix can be:

The meaning of this table is that every market has become a payout vector.

For example:

\[ MLHome=(0,0,0,200,0,0,200,200,0) \]

\[ U2.5=(200,200,200,200,200,0,200,0,0) \]

If the payout vectors of several legs add together and cover every score state, they may form an arbitrage combination.

Q: What problem does this matrix solve?

It solves three problems.

First, it puts different bet types into the same coordinate system. Whether the market is moneyline, Asian handicap, over/under, or correct score, it eventually becomes "what code does it return under each score."

Second, it lets the script automatically judge coverage. If all legs are 0 under some score state, that group does not cover all outcomes and cannot be safe arbitrage.

Third, it prepares the next step of stake solving. The matrix values 200, 150, 100, 50, and 0 are not final money amounts, but they can be converted into return multipliers using real odds. For example, full win code 200 becomes odds \(O\), half win code 150 becomes \((O+1)/2\), and push code 100 becomes 1.

From this point on, arbitrage is no longer just an odds reciprocal problem. It becomes a linear combination problem over payout vectors.

The next article continues: after we already have the payout matrix, how do we plug in real odds, solve how much stake each leg should receive, and check whether the worst score still remains profitable?