Chapter 3 Exercises: Expected Value and the Bettor's Edge

Instructions: Complete all exercises in the parts assigned by your instructor. Show all work for calculation problems. For programming challenges, include comments explaining your logic and provide sample output. For analysis and research problems, cite your sources where applicable.

Part A: Conceptual Understanding

Each problem is worth 5 points. Answer in complete sentences unless otherwise directed.

Exercise A.1 — Defining Expected Value

Define expected value (EV) in your own words as it applies to sports betting. Your definition should address each of the following:

(a) The mathematical intuition behind EV: what does the number actually represent?

(b) Why EV is expressed as a per-bet average rather than a guarantee about any individual bet.

(c) How a bettor's EV differs from their actual realized profit or loss over a finite sample of bets.

Provide a non-betting analogy (e.g., insurance, business investment, poker) that illustrates the concept of EV to someone unfamiliar with gambling mathematics.

Exercise A.2 — Why Positive Expected Value Matters

A friend says: "I don't care about expected value. I just want to win tonight's bet." Construct a structured argument (at least four points) explaining why a focus on positive expected value (+EV) is the only mathematically sustainable approach to sports betting. In your answer, address:

(a) Why winning individual bets is not evidence of a sound strategy.

(b) Why a bettor who consistently makes -EV wagers is guaranteed to lose money over time.

(c) How the sportsbook's vig creates a default negative EV environment for all bettors.

(d) How identifying +EV opportunities is the bettor's only path to overcoming the vig.

Exercise A.3 — The Law of Large Numbers

The Law of Large Numbers (LLN) is one of the most important theorems underpinning the concept of expected value. Explain the LLN in the context of sports betting by answering the following:

(a) State the Law of Large Numbers informally in one to two sentences.

(b) Explain why a bettor who makes +EV bets at a 3% edge might still be losing money after 50 bets, but is overwhelmingly likely to be profitable after 5,000 bets.

(c) A sportsbook processes millions of bets per year. How does the LLN work in the sportsbook's favor, and how does this differ from the bettor's situation?

(d) Does the LLN guarantee that a +EV bettor will be profitable? What caveats or assumptions are necessary for the LLN to apply in practice?

Exercise A.4 — Variance vs. Expected Value

Explain the relationship between variance and expected value in sports betting. Your answer should address:

(a) Define variance (or standard deviation) in the context of a bettor's results. How does it differ from EV?

(b) Explain why a bettor with a positive edge can experience long losing streaks. How long can such streaks reasonably last?

(c) Two bettors both have a 3% edge. Bettor A makes 10 bets per week at -110 odds. Bettor B makes 2 bets per week on +500 underdogs. Who experiences more variance relative to their expected profit, and why?

(d) Why is understanding variance critical for bankroll management? What happens to a bettor who has a genuine +EV strategy but sizes their bets too aggressively relative to their variance?

Exercise A.5 — EV and the Vig

Explain the mathematical relationship between expected value and the vigorish (vig). Specifically:

(a) If a sportsbook offers -110 on both sides of a point spread, what is the implied probability for each side? What do these probabilities sum to, and why does the sum exceed 100%?

(b) If the true probability of each side winning is exactly 50%, calculate the EV of a $100 bet at -110 odds. Explain why this EV is negative.

(c) What true win probability would a bettor need to achieve to break even betting at -110 odds? Show your derivation.

(d) If a bettor identifies a wager where their true estimated probability exceeds the break-even threshold, what is the sign of their EV? How does the magnitude of this excess probability translate into edge?

Exercise A.6 — Edge and Yield

Distinguish between the concepts of edge and yield. Your answer should include:

(a) Define edge mathematically. How is it computed from a bettor's estimated probability and the implied probability from the odds?

(b) Define yield (also called return on investment or ROI) and explain how it is calculated from a bettor's historical results.

(c) Explain why a bettor's theoretical edge and their realized yield will almost always differ, especially over small samples. What causes this discrepancy?

(d) A bettor claims a 5% yield over 200 bets. Is this strong evidence of a 5% edge? What additional information would you need to assess whether this result is due to skill or luck?

Exercise A.7 — EV of Different Bet Types

Compare the expected value characteristics of the following bet types. For each, explain whether the vig is typically higher or lower than a standard -110/-110 spread bet, and why:

(a) Moneyline bets on heavy favorites (e.g., -300 or higher)

(b) Moneyline bets on large underdogs (e.g., +500 or higher)

(c) Two-leg parlays at standard -110 odds

(d) Player prop bets (e.g., "Player X scores over 22.5 points")

(e) Futures bets (e.g., "Team Y to win the championship")

For which bet types is the sportsbook's edge typically largest, and what structural reasons explain this?

Exercise A.8 — When EV Is Not Enough

Expected value is the single most important concept for evaluating bets, but it is not the only consideration. Describe at least four situations in which a rational bettor might decline a positive-EV wager or prefer one +EV wager over another. Your answer should address:

(a) Bankroll constraints and risk of ruin.

(b) The Kelly Criterion and how overbetting a positive-EV opportunity can still lead to bankruptcy.

(c) Liquidity and maximum bet limits at sportsbooks.

(d) Correlation between bets in a portfolio (e.g., betting the same team on the moneyline and the spread).

(e) Any other practical consideration you can identify (e.g., account restrictions, time value, opportunity cost).

Part B: Calculations

Each problem is worth 5 points. Show all work and round final answers to the indicated precision.

Exercise B.1 — Basic EV Computation

Calculate the expected value of each of the following bets. Assume a $100 stake for each.

(a) A moneyline bet at -150 odds on a team you estimate has a 62% true probability of winning.

(b) A moneyline bet at +200 odds on an underdog you estimate has a 38% true probability of winning.

(c) A point spread bet at -110 odds where you estimate your side covers with 54% probability.

(d) A totals (over/under) bet at -105 odds where you estimate the over hits with 50% probability.

(e) A player prop bet at +160 odds where you estimate the prop hits with 42% probability.

For each bet, state whether it is +EV, -EV, or break-even, and calculate the edge as a percentage.

Exercise B.2 — Edge Calculation

A bettor analyzes an NFL game and estimates the following true probabilities:

• Team A wins: 58%
• Team B wins: 42%

The sportsbook offers:

• Team A moneyline: -155
• Team B moneyline: +135

(a) Calculate the implied probability for each side from the sportsbook's odds.

(b) Calculate the bettor's edge on a Team A bet, defined as:

$$\text{Edge} = p_{\text{true}} - p_{\text{implied}}$$

(c) Calculate the bettor's edge on a Team B bet.

(d) Calculate the EV of a $200 bet on Team A and a $200 bet on Team B separately.

(e) Which bet (if any) offers positive expected value? Express the EV as both a dollar amount and a percentage of the stake.

Exercise B.3 — Parlay EV

A bettor constructs a three-leg parlay. For each leg, the sportsbook's odds and the bettor's estimated true probability are given:

(a) Convert each leg to decimal odds.

(b) Calculate the parlay decimal odds (product of the three decimal odds).

(c) Calculate the true probability of the parlay hitting (product of the three true probabilities).

(d) Calculate the EV of a $50 parlay bet using the formula:

$$\text{EV} = (\text{True Probability} \times \text{Net Profit if Win}) - ((1 - \text{True Probability}) \times \text{Stake})$$

(e) Compare the parlay EV to the sum of the individual EVs if the same $50 were split equally among the three legs as straight bets. Which approach has higher EV?

Exercise B.4 — Yield Computation

A bettor's records for a month of NFL betting show the following results:

(a) Calculate the gross profit or loss for each week. For wins at average odds of -108, the profit per winning bet is $100 / 1.08 = $92.59. Apply this logic to each week.

(b) Calculate the total profit or loss for the month.

(c) Calculate the yield (ROI) for the month, defined as:

$$\text{Yield} = \frac{\text{Total Profit/Loss}}{\text{Total Amount Staked}} \times 100\%$$

(d) Calculate the bettor's overall win rate (excluding pushes). Is this win rate above or below the break-even rate for their average odds?

(e) Based on only one month of data (34 bets), can you draw statistically meaningful conclusions about this bettor's edge? Explain why or why not.

Exercise B.5 — Variance and Standard Deviation

A bettor makes 100 bets, each at -110 odds with a $100 stake. Their true win probability per bet is 53%.

(a) Calculate the expected profit per bet.

$$E[\text{profit per bet}] = (p \times \text{win amount}) - ((1-p) \times \text{loss amount})$$

(b) Calculate the expected total profit over 100 bets.

(c) Calculate the variance of a single bet. For a bet that pays +$90.91 with probability $p$ and loses -$100 with probability $(1-p)$:

$$\text{Var}(X) = p \times (W - \mu)^2 + (1-p) \times (-L - \mu)^2$$

where $W = 90.91$, $L = 100$, and $\mu = E[\text{profit per bet}]$.

(d) Calculate the standard deviation of total profit over 100 bets. (Hint: for independent bets, the variance of the sum is the sum of the variances.)

(e) Construct a 95% confidence interval for the bettor's total profit after 100 bets. Is it possible that the bettor loses money despite having a positive edge? What is the approximate probability of a net loss?

Exercise B.6 — Comparing Edges Across Odds

Three bets are available. For each, the sportsbook's odds and your estimated true probability are given:

(a) Calculate the implied probability for each bet.

(b) Calculate the edge (true probability minus implied probability) for each bet.

(c) Calculate the EV per $100 wagered for each bet.

(d) Calculate the EV as a percentage of the stake (the "EV%") for each bet.

(e) Rank the three bets by EV%. Which bet offers the best return per dollar risked? Does the bet with the largest raw edge necessarily have the highest EV%?

Exercise B.7 — Break-Even and Required Win Rates

For each of the following odds, calculate the break-even win rate (the win rate at which EV = 0):

(a) Fill in the complete table, converting to decimal odds and computing break-even win rates.

(b) Plot (or sketch) the relationship between American odds and break-even win rate. Describe the shape of this curve.

(c) A bettor wins 54% of their -110 bets. What is their EV per $100 bet? What is their edge over the break-even rate?

(d) A bettor wins 35% of their +250 bets. What is their EV per $100 bet? What is their edge over the break-even rate?

(e) Which scenario (c or d) produces a higher EV per dollar wagered? What does this tell you about the relationship between win rate and profitability at different odds levels?

Part C: Programming Challenges

Each problem is worth 10 points. Write clean, well-documented Python code. Include docstrings, type hints, and at least three test cases per function.

Exercise C.1 — Expected Value Calculator

Write a Python module that computes the expected value of any bet given the odds and the bettor's estimated true probability:

def calculate_ev(
    stake: float,
    odds: int | float,
    true_probability: float,
    odds_format: str = "american"
) -> dict:
    """
    Calculate the expected value of a bet.

    Parameters:
        stake: Amount wagered (must be positive)
        odds: The sportsbook's odds
        true_probability: Bettor's estimated true probability of winning (0 to 1)
        odds_format: One of 'american', 'decimal', 'fractional'

    Returns:
        Dictionary with keys:
        - 'stake': the original stake
        - 'odds': the original odds
        - 'odds_format': the format used
        - 'decimal_odds': odds converted to decimal
        - 'implied_probability': probability implied by the odds
        - 'true_probability': the bettor's input probability
        - 'edge': true_probability - implied_probability
        - 'ev_dollar': expected value in dollars
        - 'ev_percent': expected value as percentage of stake
        - 'is_positive_ev': boolean
        - 'win_profit': profit if the bet wins
        - 'loss_amount': amount lost if the bet loses (negative)
        - 'breakeven_probability': win rate needed to break even at these odds
    """

def ev_summary(result: dict) -> str:
    """Return a formatted string summarizing the EV calculation."""

def batch_ev(bets: list[dict]) -> list[dict]:
    """
    Calculate EV for a list of bets.

    Each bet in the list should be a dictionary with keys:
    'stake', 'odds', 'true_probability', and optionally 'odds_format'.

    Returns a list of EV result dictionaries, plus an aggregate summary.
    """

Requirements:

• Handle American (positive and negative), decimal, and fractional odds formats.
• Validate all inputs: stake must be positive, true_probability must be between 0 and 1 exclusive, odds must be valid for the specified format.
• Raise ValueError with descriptive messages for invalid inputs.
• Include a __main__ block that demonstrates at least five different EV calculations with various odds and probabilities, printing the formatted results.

Exercise C.2 — Positive EV Scanner

Write a Python program that scans a dataset of betting lines and identifies all positive-EV opportunities given a set of true probability estimates:

from dataclasses import dataclass

@dataclass
class BettingLine:
    event: str
    market: str
    selection: str
    odds: int  # American odds
    sportsbook: str

@dataclass
class TrueProbability:
    event: str
    market: str
    selection: str
    probability: float  # 0 to 1

def scan_for_positive_ev(
    lines: list[BettingLine],
    probabilities: list[TrueProbability],
    min_edge: float = 0.0
) -> list[dict]:
    """
    Match betting lines with true probability estimates and identify +EV bets.

    Parameters:
        lines: Available betting lines from sportsbooks
        probabilities: True probability estimates from the bettor's model
        min_edge: Minimum edge threshold (e.g., 0.02 for 2% minimum edge)

    Returns:
        List of +EV opportunities sorted by edge (descending), each containing:
        - event, market, selection, sportsbook
        - odds, implied_probability, true_probability
        - edge, ev_per_100
    """

def generate_report(opportunities: list[dict]) -> str:
    """Generate a formatted report of +EV opportunities."""

Requirements:

• Match lines to probabilities using event, market, and selection fields.
• Calculate edge and EV for every matched pair.
• Filter to only +EV opportunities (or those above min_edge).
• Sort results by edge in descending order.
• The report function should output a well-formatted table (use the tabulate library or formatted strings).
• Include a demonstration with at least 10 hypothetical betting lines across 3-4 events and 2-3 sportsbooks, with true probability estimates for each.

Exercise C.3 — Monte Carlo Simulator for Bet Sequences

Write a Monte Carlo simulator that models the outcomes of a sequence of bets to visualize the distribution of possible results:

import numpy as np
import matplotlib.pyplot as plt

def simulate_bet_sequence(
    num_bets: int,
    win_probability: float,
    odds: int,
    stake: float,
    num_simulations: int = 10000,
    odds_format: str = "american"
) -> dict:
    """
    Simulate a sequence of bets using Monte Carlo methods.

    Parameters:
        num_bets: Number of bets in the sequence
        win_probability: True probability of winning each bet
        odds: The odds for each bet
        stake: Amount wagered per bet
        num_simulations: Number of Monte Carlo simulations to run
        odds_format: Format of the odds

    Returns:
        Dictionary with:
        - 'final_profits': array of final profit/loss for each simulation
        - 'mean_profit': average final profit across simulations
        - 'median_profit': median final profit
        - 'std_profit': standard deviation of final profits
        - 'prob_profitable': fraction of simulations that ended profitable
        - 'prob_loss': fraction that ended with a loss
        - 'worst_case': 5th percentile outcome
        - 'best_case': 95th percentile outcome
        - 'max_drawdown_avg': average maximum drawdown across simulations
        - 'theoretical_ev': analytical expected profit
        - 'paths': a sample of individual simulation paths (for plotting)
    """

def plot_simulation_results(results: dict, title: str = "Monte Carlo Simulation") -> None:
    """
    Create a multi-panel visualization:
    - Panel 1: Histogram of final profits with mean/median markers
    - Panel 2: Sample of 50 individual bankroll paths over time
    - Panel 3: Probability of profit vs. number of bets (cumulative)
    """

def compare_strategies(strategies: list[dict]) -> dict:
    """
    Run simulations for multiple strategies and compare results.

    Each strategy dict should contain: 'name', 'win_probability', 'odds',
    'stake', 'num_bets'.

    Returns comparison metrics for all strategies.
    """

Requirements:

• Use NumPy for efficient simulation (vectorize where possible).
• Track the full bankroll path for each simulation (not just the final result).
• Calculate maximum drawdown for each simulation path.
• The plotting function should produce publication-quality charts with labels, legends, and titles.
• Include a demonstration comparing at least three strategies:
• Strategy A: 53% win rate at -110 odds, $100 per bet, 500 bets
• Strategy B: 38% win rate at +200 odds, $100 per bet, 500 bets
• Strategy C: 25% win rate at +400 odds, $100 per bet, 500 bets
• Print a comparison table showing EV, variance, probability of profit, and worst/best cases for each strategy.

Exercise C.4 — Performance Tracker with Statistical Analysis

Build a comprehensive bet performance tracker that logs bets and computes detailed statistics:

from datetime import datetime
from typing import Optional
import statistics

class PerformanceTracker:
    def __init__(self, initial_bankroll: float):
        """Initialize the tracker with a starting bankroll."""
        self.initial_bankroll = initial_bankroll
        self.current_bankroll = initial_bankroll
        self.bets: list[dict] = []
        self.bet_counter = 0

    def log_bet(
        self,
        event: str,
        selection: str,
        odds: int,
        stake: float,
        result: str,
        true_probability: Optional[float] = None,
        sport: str = "Unknown",
        bet_type: str = "straight",
        date: Optional[datetime] = None,
        odds_format: str = "american"
    ) -> dict:
        """
        Log a settled bet with full metadata.

        Parameters:
            result: One of 'win', 'loss', 'push', 'half_win', 'half_loss'

        Returns:
            Dictionary with bet details and computed profit/loss.
        """

    def get_overall_stats(self) -> dict:
        """
        Compute overall performance statistics:
        - Total bets, wins, losses, pushes
        - Win rate, profit/loss, yield (ROI)
        - Average odds, average stake
        - Longest winning streak, longest losing streak
        - Current bankroll, peak bankroll, max drawdown
        - Profit factor (gross wins / gross losses)
        - Sharpe ratio analog (mean profit / std of profits)
        - CLV (closing line value) if true_probability is provided
        """

    def get_stats_by_sport(self) -> dict:
        """Break down performance by sport."""

    def get_stats_by_bet_type(self) -> dict:
        """Break down performance by bet type (straight, parlay, prop, etc.)."""

    def get_stats_by_odds_range(self) -> dict:
        """
        Break down performance by odds buckets:
        Heavy favorites (< -200), Moderate favorites (-200 to -110),
        Pick'em (-109 to +109), Moderate underdogs (+110 to +200),
        Large underdogs (> +200).
        """

    def get_monthly_breakdown(self) -> dict:
        """Return month-by-month performance summary."""

    def hypothesis_test(self, null_win_rate: Optional[float] = None) -> dict:
        """
        Test whether the bettor's results are statistically significant.

        Performs a one-sample proportion z-test against the null hypothesis
        that the bettor has no edge (wins at the break-even rate implied
        by their average odds, or at the specified null_win_rate).

        Returns:
        - z_score, p_value, is_significant_at_05, is_significant_at_01
        - confidence_interval_95 for the true win rate
        - minimum bets needed to detect the observed edge at 80% power
        """

    def print_report(self) -> None:
        """Print a comprehensive, formatted performance report."""

Requirements:

• Support all result types: win, loss, push, half-win, half-loss.
• Compute all statistics listed in the docstrings above.
• The hypothesis test should use proper statistical methods (z-test for proportions).
• Include a demonstration with at least 20 logged bets across multiple sports and bet types, followed by a full printed report.

Exercise C.5 — Confidence Interval Calculator for Betting Results

Write a Python tool that calculates confidence intervals for a bettor's true edge based on their observed results:

import numpy as np
from scipy import stats

def confidence_interval_for_edge(
    total_bets: int,
    wins: int,
    average_odds: int,
    confidence_level: float = 0.95,
    odds_format: str = "american"
) -> dict:
    """
    Calculate a confidence interval for the bettor's true win rate and edge.

    Parameters:
        total_bets: Number of resolved bets (excluding pushes)
        wins: Number of winning bets
        average_odds: Average odds across all bets
        confidence_level: Desired confidence level (e.g., 0.95, 0.99)
        odds_format: Format of the average odds

    Returns:
        Dictionary with:
        - 'observed_win_rate': wins / total_bets
        - 'breakeven_win_rate': win rate needed to break even at average_odds
        - 'ci_lower': lower bound of CI for true win rate
        - 'ci_upper': upper bound of CI for true win rate
        - 'observed_edge': observed_win_rate - breakeven_win_rate
        - 'ci_edge_lower': ci_lower - breakeven_win_rate
        - 'ci_edge_upper': ci_upper - breakeven_win_rate
        - 'is_significantly_positive': whether CI lower bound > breakeven
        - 'observed_yield': estimated yield at observed win rate
        - 'ci_yield_lower': yield at lower CI bound
        - 'ci_yield_upper': yield at upper CI bound
    """

def sample_size_calculator(
    target_edge: float,
    average_odds: int,
    confidence_level: float = 0.95,
    power: float = 0.80,
    odds_format: str = "american"
) -> dict:
    """
    Calculate the number of bets needed to detect a given edge with
    specified confidence and power.

    Returns:
        Dictionary with:
        - 'required_sample_size': minimum bets needed
        - 'target_edge': the edge we're trying to detect
        - 'target_win_rate': breakeven + target_edge
        - 'breakeven_win_rate': the null hypothesis win rate
        - 'confidence_level': the alpha level used
        - 'power': the statistical power
    """

def progressive_confidence(
    results: list[str],
    odds_per_bet: list[int],
    confidence_level: float = 0.95,
    odds_format: str = "american"
) -> list[dict]:
    """
    Calculate rolling confidence intervals as bets accumulate.

    Parameters:
        results: List of 'win' or 'loss' for each bet
        odds_per_bet: American odds for each bet

    Returns:
        List of CI snapshots after each bet (or every N bets for large samples),
        useful for plotting how confidence narrows over time.
    """

def plot_confidence_evolution(snapshots: list[dict], title: str = "") -> None:
    """
    Plot the evolution of the confidence interval over time.
    Shows observed win rate, CI bounds, and break-even line.
    """

Requirements:

• Use the Wilson score interval (preferred for small samples) or the Wald interval with continuity correction for the confidence interval computation.
• The sample size calculator should use proper power analysis formulas for a one-sided proportion test.
• The progressive confidence function should compute a rolling CI after each bet (or every 5-10 bets for efficiency).
• Include a demonstration showing:
• A bettor with 200 bets at 55% win rate on -110 odds: CI and significance test.
• A bettor with 50 bets at 58% win rate on -110 odds: CI and significance test.
• A comparison showing how many bets are needed to confirm edges of 1%, 2%, 3%, and 5%.
• A progressive confidence plot for a simulated 500-bet sequence.

Part D: Analysis & Interpretation

Each problem is worth 5 points. Provide structured, well-reasoned responses.

Exercise D.1 — Evaluating a Betting Record

A sports bettor shares the following summary of their last two seasons of NFL betting:

(a) Calculate the win rate for each season (excluding pushes). Compare each to the break-even win rate for the average odds.

(b) Compute a 95% confidence interval for the bettor's true win rate using the combined two-season data (200 wins, 181 losses out of 381 resolved bets at approximately -108.5 average odds).

(c) Based on the confidence interval, can you conclude with 95% confidence that this bettor has a genuine edge? Explain.

(d) What is the most likely explanation for the dramatic difference in results between Season 1 and Season 2? Consider variance, regression to the mean, and the possibility that the bettor's edge changed.

(e) What would you advise this bettor to do going forward? Should they continue, modify their approach, or stop? Justify your recommendation with reference to the statistical evidence.

Exercise D.2 — Identifying +EV Situations from Odds Data

The following table shows odds from four sportsbooks for the same NFL game, along with your model's estimated true probabilities:

Your model estimates: Team A true probability = 57%, Team B true probability = 43%.

(a) Calculate the implied probability and EV per $100 bet for a Team A wager at each sportsbook. Identify which books (if any) offer +EV on Team A.

(b) Calculate the implied probability and EV per $100 bet for a Team B wager at each sportsbook. Identify which books (if any) offer +EV on Team B.

(c) What is the best available odds for each side across all four books? Calculate the combined implied probability using the best odds for each side. Is there an arbitrage opportunity?

(d) If you could only bet at one sportsbook and had to pick one side, which bet at which book would you choose, and why?

(e) How sensitive are your +EV conclusions to your probability estimates? At what true probability for Team A do all four sportsbooks become -EV for a Team A bet?

Exercise D.3 — Comparing Betting Strategies

Three bettors follow different strategies over a full NFL season (approximately 270 games). All use flat $100 stakes.

(a) Calculate the yield (ROI) for each bettor.

(b) Calculate the win rate for each bettor and compare it to the break-even win rate at their average odds.

(c) Perform a rough significance test for each bettor: calculate a z-score testing whether their win rate is significantly above the break-even rate. Which bettor(s) have statistically significant results at the 5% level?

(d) Despite having the fewest bets and not the highest total profit, make an argument for why Carol's strategy might be the most impressive. Consider edge, selectivity, and statistical significance.

(e) What are the practical trade-offs between Alice's high-volume approach and Carol's selective approach? Under what circumstances might each be preferred?

Exercise D.4 — The Parlay Trap

A recreational bettor shows you their parlay betting history for the season:

(a) Calculate the yield for each parlay type and for the overall parlay portfolio.

(b) Calculate the implied hit rate for each parlay type based on the average parlay odds. Compare the bettor's actual hit rate to the implied hit rate.

(c) For the 2-leg parlays, the bettor hit 14 out of 45 (31.1%). If each leg independently has a 52.4% implied probability (standard -110 lines), what is the expected hit rate for a 2-leg parlay? How does the bettor's actual rate compare?

(d) Explain why longer parlays (4+ legs) are generally considered to have the worst expected value for bettors. Reference the compounding effect of the vig across legs.

(e) Under what specific circumstances, if any, might a parlay bet offer better expected value than the corresponding straight bets? Consider correlated outcomes and promotional odds boosts.

Exercise D.5 — Closing Line Value as a Predictor

A bettor tracks their bets along with the closing line (the final odds before the event starts). Here is a sample:

(a) For each bet, determine whether the bettor "beat the closing line" (got better odds than the market closed at). How many of the 8 bets beat the closing line?

(b) Explain why closing line value (CLV) is considered by many professional bettors to be the single best predictor of long-term profitability, even more predictive than a bettor's actual win-loss record.

(c) A bettor who consistently beats the closing line by an average of 3 cents (e.g., getting -110 when the line closes at -113) has a strong claim to being a skilled bettor, even if their recent results are poor. Explain why, using the concepts of EV and the Law of Large Numbers.

(d) Sportsbooks use CLV data to identify and restrict sharp bettors. From the sportsbook's perspective, why is a bettor who beats the closing line more threatening than a bettor who simply has a good win-loss record?

(e) Calculate the approximate implied edge for a bettor who averages -110 odds at time of bet placement and whose lines close at an average of -118. Express this edge in probability terms.

Part E: Research & Extension

Each problem is worth 5 points. These require independent research beyond Chapter 3. Cite all sources.

Exercise E.1 — Academic Research on Market Efficiency

Search for and summarize two academic papers that study the efficiency of sports betting markets. For each paper:

(a) Provide the full citation (authors, title, journal, year).

(b) Summarize the research question, methodology, and key findings in 150-200 words.

(c) Explain the paper's implications for bettors seeking positive expected value. Does the paper suggest that +EV opportunities exist, or that markets are too efficient to beat?

(d) Identify one limitation of the study and how it might affect the validity of the conclusions.

(e) Discuss how the paper's findings relate to the concepts of expected value, the Law of Large Numbers, and market efficiency as discussed in Chapter 3.

Suggested starting points: papers by Levitt (2004), Woodland and Woodland (1994), Gandar et al. (1988), Borghesi (2007), or Humphreys et al. (2013).

Exercise E.2 — Professional Bettor Returns Analysis

Research the publicly known track records of professional sports bettors or betting syndicates. Find at least two documented cases and for each:

(a) Identify the bettor or syndicate and their primary sport and bet types.

(b) Report their documented win rate, yield (ROI), and sample size (number of bets or seasons) where available.

(c) Compare their returns to what would be expected from random chance at their typical odds. Is there strong statistical evidence of genuine skill?

(d) Describe the key strategies or edges they reportedly exploited (e.g., model-based handicapping, steam chasing, closing line value, market inefficiency exploitation).

(e) Discuss what lessons a developing bettor can learn from these professionals about expected value, variance management, and the reality of professional gambling.

Suggested cases: Billy Walters, Haralabos Voulgaris, the Computer Group, ACCA, Pinnacle sharp bettors.

Exercise E.3 — The Kelly Criterion and Expected Value

Research the Kelly Criterion and its relationship to expected value. Write a detailed analysis (400-600 words) covering:

(a) The mathematical derivation of the Kelly Criterion for a simple two-outcome bet. State the formula and define all variables.

(b) Explain why Kelly bet sizing requires a positive expected value bet as a prerequisite. What does the Kelly formula output when EV is zero or negative?

(c) Demonstrate with a numerical example how full Kelly, half Kelly, and quarter Kelly sizing differ for a bet with a 55% win probability at -110 odds. Calculate the optimal stake as a percentage of bankroll for each.

(d) Discuss the concept of "fractional Kelly" and why most professional bettors use half-Kelly or less. Reference the trade-off between growth rate and volatility.

(e) Explain the relationship between Kelly Criterion and risk of ruin. How does Kelly sizing theoretically ensure that a bettor never goes bankrupt, and why does this break down in practice?

Cite at least three sources, including the original Kelly (1956) paper if possible.

Exercise E.4 — Expected Value Across Different Sports

Research and compare the typical expected value landscape across at least four different sports betting markets. For each sport, investigate:

(a) The typical vig charged by major sportsbooks for the most common bet type (e.g., NFL spreads, NBA moneylines, soccer match results, tennis match winner).

(b) The estimated efficiency of the market: how quickly do lines adjust to new information, and how accurately do closing lines predict outcomes?

(c) Whether academic or industry research has identified persistent +EV opportunities (e.g., specific biases, line stale periods, or undervalued bet types).

(d) The typical volume and liquidity of the market, and how this affects a bettor's ability to exploit any edge they find.

Synthesize your findings into a comparison table and a 200-300 word summary of which markets are most and least favorable for bettors seeking positive expected value.

Exercise E.5 — Behavioral Biases and Expected Value

Research the academic literature on behavioral biases in sports betting markets. Find and discuss at least three documented biases that create deviations from market efficiency:

(a) For each bias, provide its name, a definition, and a brief summary of the academic evidence supporting its existence.

(b) Explain the mechanism by which each bias can create +EV opportunities for informed bettors. Be specific: which side of which bet type benefits?

(c) Assess the current strength of each bias. Has it weakened over time as markets have become more efficient? Cite evidence.

(d) For each bias, propose a simple betting strategy that would exploit it and estimate the theoretical edge.

(e) Discuss whether exploiting behavioral biases is a sustainable source of expected value, or whether market forces will eventually eliminate these inefficiencies.

Suggested biases to investigate: favorite-longshot bias, home-underdog bias, recency bias, the hot-hand fallacy, and public money bias.

Scoring Guide

Grading Criteria

Part A (Conceptual): Full credit requires clear, accurate explanations that demonstrate understanding of expected value, edge, variance, and the Law of Large Numbers. Partial credit for incomplete but correct reasoning.

Part B (Calculations): Full credit requires correct final answers with all work shown. Partial credit for correct methodology with arithmetic errors. EV calculations must show both the dollar amount and the percentage.

Part C (Programming): Graded on correctness (40%), code quality and documentation (30%), and test coverage (30%). Code must execute without errors. Functions must handle edge cases gracefully.

Part D (Analysis): Graded on analytical depth, logical reasoning, and appropriate application of EV concepts. Answers must reference specific calculations and statistical reasoning. Multiple valid approaches may exist.

Part E (Research): Graded on research quality, source credibility, analytical depth, and clear writing. Minimum source requirements specified per problem. Sources must be properly cited.

Solutions: Complete worked solutions for all exercises are available in solutions/chapter-03-solutions.md. For programming challenges, reference implementations are provided in solutions/code/chapter_03/.