Cap Management Strategy

Strategic Cap Space Management

Successful teams maximize value from their salary cap by balancing star players, cost-controlled young talent, and strategic depth signings. Advanced planning and scenario modeling help teams remain competitive while maintaining cap flexibility.

import pandas as pd
import numpy as np
import matplotlib.pyplot as plt

# Load multi-year contract data
contracts = pd.read_csv('team_contracts_multi_year.csv')

# Salary cap projections (estimated growth)
def project_salary_cap(current_cap, years, annual_growth=0.025):
    """Project future salary cap with estimated growth"""
    cap_by_year = {}
    for year in range(years + 1):
        cap_by_year[2024 + year] = current_cap * ((1 + annual_growth) ** year)
    return cap_by_year

CURRENT_CAP = 83_500_000
cap_projections = project_salary_cap(CURRENT_CAP, years=5)

# Multi-year cap analysis
def analyze_multi_year_cap(contracts_df, cap_projections):
    """Analyze cap situation over multiple years"""

    results = {}

    for year, cap_limit in cap_projections.items():
        # Filter active contracts for this year
        year_contracts = contracts_df[
            (contracts_df['contract_start'] <= year) &
            (contracts_df['contract_end'] >= year)
        ]

        total_committed = year_contracts['aav'].sum()
        cap_space = cap_limit - total_committed

        # Count contract expiries this year
        expiring = contracts_df[contracts_df['contract_end'] == year]

        results[year] = {
            'cap_limit': cap_limit,
            'committed': total_committed,
            'cap_space': cap_space,
            'cap_space_pct': (cap_space / cap_limit) * 100,
            'contracts_active': len(year_contracts),
            'contracts_expiring': len(expiring),
            'cap_expiring': expiring['aav'].sum()
        }

    return pd.DataFrame(results).T

multi_year_outlook = analyze_multi_year_cap(contracts, cap_projections)
print("=== Multi-Year Cap Outlook ===")
print(multi_year_outlook)

# Identify cap crunches (years with <5% cap space)
cap_crunches = multi_year_outlook[multi_year_outlook['cap_space_pct'] < 5]
if len(cap_crunches) > 0:
    print("\n⚠ WARNING: Cap Crunch Years")
    print(cap_crunches)

# Entry-level contract (ELC) management
def analyze_elc_value(contracts_df):
    """Analyze value from entry-level contracts"""

    elcs = contracts_df[contracts_df['contract_type'] == 'ELC']

    # ELC cap hit vs replacement cost
    elc_cap_hit = elcs['aav'].sum()
    elc_count = len(elcs)

    # Estimated replacement cost (market value)
    avg_market_replacement = 2_500_000  # Average for similar production
    estimated_market_cost = elc_count * avg_market_replacement

    cap_savings = estimated_market_cost - elc_cap_hit

    return {
        'elc_players': elc_count,
        'elc_cap_hit': elc_cap_hit,
        'estimated_market_cost': estimated_market_cost,
        'cap_savings': cap_savings,
        'avg_elc_hit': elc_cap_hit / elc_count if elc_count > 0 else 0
    }

elc_analysis = analyze_elc_value(contracts)
print("\n=== Entry-Level Contract Analysis ===")
print(f"ELC Players: {elc_analysis['elc_players']}")
print(f"ELC Cap Hit: ${elc_analysis['elc_cap_hit']:,.0f}")
print(f"Estimated Market Cost: ${elc_analysis['estimated_market_cost']:,.0f}")
print(f"Cap Savings from ELCs: ${elc_analysis['cap_savings']:,.0f}")

# Trade deadline cap accrual
def calculate_deadline_cap_space(cap_space, days_remaining=40):
    """Calculate trade deadline cap space from daily accrual"""

    SEASON_DAYS = 186  # Approximate NHL season length
    days_elapsed = SEASON_DAYS - days_remaining

    # Cap space accrues daily
    total_season_cap_space = cap_space * (SEASON_DAYS / days_elapsed)

    # Available space for deadline acquisition
    deadline_cap_space = cap_space + (total_season_cap_space - cap_space)

    return {
        'current_cap_space': cap_space,
        'total_accrued_space': total_season_cap_space,
        'effective_deadline_space': deadline_cap_space,
        'days_remaining': days_remaining
    }

# Example: Team with $2M cap space at deadline
current_space = 2_000_000
deadline_calc = calculate_deadline_cap_space(current_space, days_remaining=40)

print("\n=== Trade Deadline Cap Calculation ===")
print(f"Current Cap Space: ${deadline_calc['current_cap_space']:,.0f}")
print(f"Effective Deadline Space: ${deadline_calc['effective_deadline_space']:,.0f}")
print(f"Can acquire player with AAV up to: ${deadline_calc['effective_deadline_space']:,.0f}")

# Retention trade analysis
def retention_trade_impact(player_aav, retention_pct, years_remaining):
    """Calculate impact of salary retention in trade"""

    retained_hit = player_aav * (retention_pct / 100)
    traded_hit = player_aav - retained_hit

    total_retention_cost = retained_hit * years_remaining

    return {
        'original_aav': player_aav,
        'retained_hit': retained_hit,
        'traded_hit': traded_hit,
        'retention_pct': retention_pct,
        'years_remaining': years_remaining,
        'total_retention_cost': total_retention_cost
    }

# Example: Retain 50% on $6M player with 2 years left
retention = retention_trade_impact(
    player_aav=6_000_000,
    retention_pct=50,
    years_remaining=2
)

print("\n=== Retention Trade Analysis ===")
print(f"Original AAV: ${retention['original_aav']:,.0f}")
print(f"Retained Hit: ${retention['retained_hit']:,.0f} ({retention['retention_pct']}%)")
print(f"Traded Hit (to receiving team): ${retention['traded_hit']:,.0f}")
print(f"Total Retention Cost: ${retention['total_retention_cost']:,.0f} over {retention['years_remaining']} years")

# Cap optimization strategy
def optimize_roster_construction(cap_limit, star_players=3, depth_players=17):
    """Optimize cap allocation across roster"""

    # Recommended allocation
    star_cap_pct = 0.50  # 50% to star players
    depth_cap_pct = 0.35  # 35% to depth
    reserve_pct = 0.15    # 15% for flexibility/callups

    star_total = cap_limit * star_cap_pct
    depth_total = cap_limit * depth_cap_pct
    reserve = cap_limit * reserve_pct

    avg_star_cap = star_total / star_players
    avg_depth_cap = depth_total / depth_players

    return {
        'cap_limit': cap_limit,
        'star_allocation': star_total,
        'avg_star_cap': avg_star_cap,
        'depth_allocation': depth_total,
        'avg_depth_cap': avg_depth_cap,
        'reserve_space': reserve,
        'star_players': star_players,
        'depth_players': depth_players
    }

optimal_roster = optimize_roster_construction(CURRENT_CAP)

print("\n=== Optimal Cap Allocation Strategy ===")
print(f"Star Players ({optimal_roster['star_players']}): ${optimal_roster['star_allocation']:,.0f}")
print(f"  Avg per star: ${optimal_roster['avg_star_cap']:,.0f}")
print(f"Depth Players ({optimal_roster['depth_players']}): ${optimal_roster['depth_allocation']:,.0f}")
print(f"  Avg per depth: ${optimal_roster['avg_depth_cap']:,.0f}")
print(f"Reserve/Flexibility: ${optimal_roster['reserve_space']:,.0f}")

# Scenario modeling: What if we sign a star?
def scenario_analysis(current_cap_space, new_contract_aav, years):
    """Model impact of new contract signing"""

    scenarios = {
        'Best Case': {'war_per_year': 4.0, 'injury_risk': 0.05},
        'Expected': {'war_per_year': 2.5, 'injury_risk': 0.15},
        'Worst Case': {'war_per_year': 1.0, 'injury_risk': 0.30}
    }

    results = {}

    for scenario, params in scenarios.items():
        total_war = params['war_per_year'] * years
        total_cost = new_contract_aav * years
        cost_per_war = total_cost / total_war if total_war > 0 else float('inf')

        # Adjust for injury risk
        expected_war = total_war * (1 - params['injury_risk'])
        risk_adjusted_cost_per_war = total_cost / expected_war if expected_war > 0 else float('inf')

        results[scenario] = {
            'total_war': total_war,
            'expected_war': expected_war,
            'total_cost': total_cost,
            'cost_per_war': cost_per_war,
            'risk_adj_cost_per_war': risk_adjusted_cost_per_war
        }

    return pd.DataFrame(results).T

# Example: 7-year, $10M AAV contract
new_signing_scenarios = scenario_analysis(
    current_cap_space=5_000_000,
    new_contract_aav=10_000_000,
    years=7
)

print("\n=== Contract Signing Scenario Analysis ===")
print("7-year, $10M AAV contract:")
print(new_signing_scenarios)

library(tidyverse)
library(scales)

# Load contracts
contracts <- read_csv("team_contracts_multi_year.csv")

CURRENT_CAP <- 83500000

# Project salary cap
project_salary_cap <- function(current_cap, years, annual_growth = 0.025) {
  tibble(
    year = 2024:(2024 + years),
    cap_limit = current_cap * ((1 + annual_growth) ^ (0:years))
  )
}

cap_projections <- project_salary_cap(CURRENT_CAP, years = 5)

# Multi-year cap analysis
analyze_multi_year_cap <- function(contracts_data, cap_proj) {
  cap_proj %>%
    rowwise() %>%
    mutate(
      committed = sum(contracts_data$aav[
        contracts_data$contract_start <= year &
        contracts_data$contract_end >= year
      ]),
      cap_space = cap_limit - committed,
      cap_space_pct = (cap_space / cap_limit) * 100,
      contracts_expiring = sum(contracts_data$contract_end == year),
      cap_expiring = sum(contracts_data$aav[contracts_data$contract_end == year])
    ) %>%
    ungroup()
}

multi_year_outlook <- analyze_multi_year_cap(contracts, cap_projections)

cat("=== Multi-Year Cap Outlook ===\n")
print(multi_year_outlook)

# Visualize multi-year cap situation
ggplot(multi_year_outlook, aes(x = year)) +
  geom_col(aes(y = committed, fill = "Committed"), alpha = 0.7) +
  geom_line(aes(y = cap_limit, color = "Cap Limit"), size = 1.5) +
  geom_area(aes(y = cap_space, fill = "Available"), alpha = 0.3) +
  scale_y_continuous(labels = dollar_format(scale = 1e-6, suffix = "M")) +
  scale_fill_manual(values = c("Committed" = "red", "Available" = "green")) +
  scale_color_manual(values = c("Cap Limit" = "black")) +
  labs(title = "Multi-Year Cap Projection",
       subtitle = "Committed cap space vs available space",
       x = "Year", y = "Cap ($)",
       fill = "", color = "") +
  theme_minimal()

# Entry-level contract value
analyze_elc_value <- function(contracts_data) {
  elcs <- contracts_data %>% filter(contract_type == "ELC")

  elc_cap_hit <- sum(elcs$aav)
  elc_count <- nrow(elcs)

  avg_market_replacement <- 2500000
  estimated_market_cost <- elc_count * avg_market_replacement
  cap_savings <- estimated_market_cost - elc_cap_hit

  list(
    elc_players = elc_count,
    elc_cap_hit = elc_cap_hit,
    estimated_market_cost = estimated_market_cost,
    cap_savings = cap_savings
  )
}

elc_analysis <- analyze_elc_value(contracts)

cat("\n=== Entry-Level Contract Analysis ===\n")
cat(sprintf("ELC Players: %d\n", elc_analysis$elc_players))
cat(sprintf("ELC Cap Hit: $%s\n", format(elc_analysis$elc_cap_hit, big.mark = ",")))
cat(sprintf("Cap Savings: $%s\n", format(elc_analysis$cap_savings, big.mark = ",")))

# Trade deadline cap calculation
calculate_deadline_cap_space <- function(cap_space, days_remaining = 40) {
  SEASON_DAYS <- 186
  days_elapsed <- SEASON_DAYS - days_remaining

  total_season_cap_space <- cap_space * (SEASON_DAYS / days_elapsed)
  deadline_cap_space <- cap_space + (total_season_cap_space - cap_space)

  list(
    current_cap_space = cap_space,
    effective_deadline_space = deadline_cap_space,
    days_remaining = days_remaining
  )
}

deadline_calc <- calculate_deadline_cap_space(2000000, days_remaining = 40)

cat("\n=== Trade Deadline Cap Calculation ===\n")
cat(sprintf("Current Space: $%s\n",
    format(deadline_calc$current_cap_space, big.mark = ",")))
cat(sprintf("Effective Deadline Space: $%s\n",
    format(deadline_calc$effective_deadline_space, big.mark = ",")))

# Optimal roster construction
optimize_roster_construction <- function(cap_limit, star_players = 3,
                                        depth_players = 17) {
  star_cap_pct <- 0.50
  depth_cap_pct <- 0.35
  reserve_pct <- 0.15

  tibble(
    category = c("Stars", "Depth", "Reserve"),
    allocation = c(cap_limit * star_cap_pct,
                   cap_limit * depth_cap_pct,
                   cap_limit * reserve_pct),
    players = c(star_players, depth_players, NA),
    avg_per_player = c(
      cap_limit * star_cap_pct / star_players,
      cap_limit * depth_cap_pct / depth_players,
      NA
    )
  )
}

optimal_roster <- optimize_roster_construction(CURRENT_CAP)

cat("\n=== Optimal Cap Allocation Strategy ===\n")
print(optimal_roster)

# Visualize optimal allocation
ggplot(optimal_roster %>% filter(!is.na(players)),
       aes(x = category, y = allocation, fill = category)) +
  geom_col() +
  geom_text(aes(label = dollar(allocation, scale = 1e-6, suffix = "M")),
            vjust = -0.5) +
  scale_y_continuous(labels = dollar_format(scale = 1e-6, suffix = "M")) +
  labs(title = "Optimal Cap Allocation Strategy",
       x = "Player Category", y = "Cap Allocation",
       fill = "Category") +
  theme_minimal() +
  theme(legend.position = "none")

Bridge Contracts vs Long-Term Deals

Teams must decide between bridge contracts (short-term deals that defer commitment) and long-term extensions (securing players but with higher risk). The optimal choice depends on player age, cap situation, and organizational timeline.