1. Trade Evaluation Framework

Multi-Dimensional Assessment

Effective trade evaluation requires analyzing proposals across several key dimensions:

Trade Evaluation Process

2. Key Metrics for Trade Analysis

Wins Above Replacement (WAR)

WAR estimates a player's total contribution in wins compared to a replacement-level player. It's crucial for comparing players of different positions and roles.

Contract Value Analysis

Evaluate the relationship between player performance and compensation:

Draft Pick Valuation

Draft picks must be converted to expected value for trade analysis:

Advanced Impact Metrics

3. Python Code for Trade Analysis

Trade Evaluation System

This Python implementation provides a comprehensive framework for analyzing NBA trades:

import pandas as pd
import numpy as np
from typing import Dict, List, Tuple
from dataclasses import dataclass
from datetime import datetime

@dataclass
class Player:
    """Represents a player in a trade analysis."""
    name: str
    salary: float
    contract_years: int
    age: int
    war: float
    position: str
    injury_risk: float  # 0-1 scale

@dataclass
class DraftPick:
    """Represents a draft pick in a trade."""
    year: int
    round: int
    protection: str  # e.g., "Top 10 protected"
    estimated_value: float  # Expected WAR

class TradeAnalyzer:
    """Comprehensive NBA trade analysis system."""

    def __init__(self, luxury_tax_threshold: float = 170.814e6):
        self.luxury_tax_threshold = luxury_tax_threshold
        self.war_value_per_million = 10_000_000  # $10M per WAR

    def calculate_player_value(self, player: Player) -> Dict[str, float]:
        """Calculate comprehensive player value metrics."""
        # Expected WAR value in dollars
        war_value = player.war * self.war_value_per_million

        # Value over contract
        annual_value = war_value - player.salary
        total_contract_value = annual_value * player.contract_years

        # Age adjustment (players peak around 27-28)
        age_factor = 1.0 - abs(player.age - 27) * 0.02
        age_factor = max(0.5, min(1.2, age_factor))

        # Injury risk adjustment
        risk_adjusted_value = annual_value * (1 - player.injury_risk * 0.3)

        return {
            'war_value': war_value,
            'annual_voc': annual_value,
            'total_voc': total_contract_value,
            'age_adjusted_value': annual_value * age_factor,
            'risk_adjusted_value': risk_adjusted_value
        }

    def evaluate_draft_pick(self, pick: DraftPick,
                          current_year: int = 2024) -> float:
        """Evaluate draft pick value with temporal discounting."""
        # Base value from expected WAR
        base_value = pick.estimated_value * self.war_value_per_million

        # Discount for future years (10% per year)
        years_away = pick.year - current_year
        time_discount = 0.9 ** years_away

        # Protection discount
        protection_discount = 1.0
        if 'protected' in pick.protection.lower():
            protection_discount = 0.75  # 25% discount for protection

        # Round discount
        round_discount = 1.0 if pick.round == 1 else 0.3

        return base_value * time_discount * protection_discount * round_discount

    def calculate_trade_balance(self,
                               team_a_players: List[Player],
                               team_a_picks: List[DraftPick],
                               team_b_players: List[Player],
                               team_b_picks: List[DraftPick]) -> Dict[str, float]:
        """Calculate value balance for a proposed trade."""
        # Team A receives (Team B gives up)
        team_a_receives_value = sum(
            self.calculate_player_value(p)['risk_adjusted_value']
            for p in team_b_players
        ) + sum(
            self.evaluate_draft_pick(pick)
            for pick in team_b_picks
        )

        # Team B receives (Team A gives up)
        team_b_receives_value = sum(
            self.calculate_player_value(p)['risk_adjusted_value']
            for p in team_a_players
        ) + sum(
            self.evaluate_draft_pick(pick)
            for pick in team_a_picks
        )

        # Calculate balance
        team_a_net = team_a_receives_value - team_b_receives_value

        return {
            'team_a_receives': team_a_receives_value,
            'team_b_receives': team_b_receives_value,
            'team_a_net_value': team_a_net,
            'team_b_net_value': -team_a_net,
            'value_ratio': team_a_receives_value / team_b_receives_value
                          if team_b_receives_value > 0 else float('inf')
        }

    def check_salary_matching(self,
                             team_a_outgoing: float,
                             team_b_outgoing: float,
                             team_a_over_cap: bool = True,
                             team_b_over_cap: bool = True) -> Dict[str, bool]:
        """Verify trade meets NBA salary matching rules."""
        results = {
            'team_a_legal': False,
            'team_b_legal': False,
            'trade_legal': False
        }

        # Team A salary matching
        if team_a_over_cap:
            if team_a_outgoing <= 7.5e6:
                results['team_a_legal'] = team_b_outgoing <= team_a_outgoing + 5e6
            elif team_a_outgoing <= 29e6:
                results['team_a_legal'] = team_b_outgoing <= team_a_outgoing * 2 + 250_000
            else:
                results['team_a_legal'] = team_b_outgoing <= team_a_outgoing * 1.25 + 250_000
        else:
            results['team_a_legal'] = True  # Under cap teams have more flexibility

        # Team B salary matching
        if team_b_over_cap:
            if team_b_outgoing <= 7.5e6:
                results['team_b_legal'] = team_a_outgoing <= team_b_outgoing + 5e6
            elif team_b_outgoing <= 29e6:
                results['team_b_legal'] = team_a_outgoing <= team_b_outgoing * 2 + 250_000
            else:
                results['team_b_legal'] = team_a_outgoing * 1.25 + 250_000
        else:
            results['team_b_legal'] = True

        results['trade_legal'] = results['team_a_legal'] and results['team_b_legal']

        return results

    def calculate_tax_implications(self,
                                  current_payroll: float,
                                  incoming_salary: float,
                                  outgoing_salary: float) -> Dict[str, float]:
        """Calculate luxury tax implications of a trade."""
        old_payroll = current_payroll
        new_payroll = current_payroll + incoming_salary - outgoing_salary

        def calculate_tax(payroll: float) -> float:
            """Calculate total luxury tax bill."""
            if payroll <= self.luxury_tax_threshold:
                return 0

            excess = payroll - self.luxury_tax_threshold
            tax = 0

            # Incremental tax rates
            if excess > 0:
                tax += min(excess, 5e6) * 1.50
            if excess > 5e6:
                tax += min(excess - 5e6, 5e6) * 1.75
            if excess > 10e6:
                tax += min(excess - 10e6, 5e6) * 2.50
            if excess > 15e6:
                tax += min(excess - 15e6, 5e6) * 3.25
            if excess > 20e6:
                tax += (excess - 20e6) * 4.25  # Escalating further

            return tax

        old_tax = calculate_tax(old_payroll)
        new_tax = calculate_tax(new_payroll)

        return {
            'old_payroll': old_payroll,
            'new_payroll': new_payroll,
            'payroll_change': new_payroll - old_payroll,
            'old_tax': old_tax,
            'new_tax': new_tax,
            'tax_change': new_tax - old_tax,
            'total_cost_change': (new_payroll + new_tax) - (old_payroll + old_tax)
        }

    def generate_trade_report(self,
                            trade_name: str,
                            team_a_name: str,
                            team_a_players_out: List[Player],
                            team_a_picks_out: List[DraftPick],
                            team_a_players_in: List[Player],
                            team_a_picks_in: List[DraftPick],
                            team_a_payroll: float) -> str:
        """Generate comprehensive trade analysis report."""

        # Calculate value balance
        balance = self.calculate_trade_balance(
            team_a_players_out, team_a_picks_out,
            team_a_players_in, team_a_picks_in
        )

        # Salary matching
        outgoing_salary = sum(p.salary for p in team_a_players_out)
        incoming_salary = sum(p.salary for p in team_a_players_in)

        matching = self.check_salary_matching(outgoing_salary, incoming_salary)

        # Tax implications
        tax = self.calculate_tax_implications(
            team_a_payroll, incoming_salary, outgoing_salary
        )

        # Generate report
        report = f"""
{'='*80}
TRADE ANALYSIS REPORT: {trade_name}
Team: {team_a_name}
Generated: {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}
{'='*80}

PLAYERS OUT:
{chr(10).join(f"  - {p.name}: ${p.salary:,.0f}, {p.contract_years}y, {p.war:.1f} WAR"
              for p in team_a_players_out)}

PLAYERS IN:
{chr(10).join(f"  + {p.name}: ${p.salary:,.0f}, {p.contract_years}y, {p.war:.1f} WAR"
              for p in team_a_players_in)}

PICKS OUT:
{chr(10).join(f"  - {p.year} Round {p.round} ({p.protection})"
              for p in team_a_picks_out) or "  None"}

PICKS IN:
{chr(10).join(f"  + {p.year} Round {p.round} ({p.protection})"
              for p in team_a_picks_in) or "  None"}

{'='*80}
VALUE ANALYSIS:
{'='*80}
Value Received:      ${balance['team_a_receives']:,.0f}
Value Surrendered:   ${balance['team_b_receives']:,.0f}
Net Value:           ${balance['team_a_net_value']:,.0f}
Value Ratio:         {balance['value_ratio']:.2f}

Assessment: {'FAVORABLE' if balance['team_a_net_value'] > 0 else 'UNFAVORABLE'}

{'='*80}
SALARY & CAP IMPACT:
{'='*80}
Outgoing Salary:     ${outgoing_salary:,.0f}
Incoming Salary:     ${incoming_salary:,.0f}
Net Change:          ${incoming_salary - outgoing_salary:+,.0f}

Salary Matching:     {'LEGAL' if matching['trade_legal'] else 'ILLEGAL'}

Old Payroll:         ${tax['old_payroll']:,.0f}
New Payroll:         ${tax['new_payroll']:,.0f}

Old Tax Bill:        ${tax['old_tax']:,.0f}
New Tax Bill:        ${tax['new_tax']:,.0f}
Tax Change:          ${tax['tax_change']:+,.0f}

Total Cost Impact:   ${tax['total_cost_change']:+,.0f}

{'='*80}
"""
        return report


# Example Usage
if __name__ == "__main__":
    analyzer = TradeAnalyzer()

    # Example trade scenario
    # Team A trades aging star for younger player + picks

    team_a_gives = [
        Player("Damian Lillard", 45.64e6, 2, 33, 5.2, "PG", 0.3)
    ]

    team_a_receives = [
        Player("Tyler Herro", 27e6, 3, 24, 3.8, "SG", 0.2),
        Player("Duncan Robinson", 18.2e6, 3, 29, 1.5, "SF", 0.1)
    ]

    team_a_picks_out = []

    team_a_picks_in = [
        DraftPick(2025, 1, "Top 10 protected", 3.5),
        DraftPick(2027, 1, "Unprotected", 4.0)
    ]

    report = analyzer.generate_trade_report(
        "Lillard to Miami",
        "Milwaukee Bucks",
        team_a_gives,
        team_a_picks_out,
        team_a_receives,
        team_a_picks_in,
        165e6  # Current payroll
    )

    print(report)

4. R Code for Value Modeling

Statistical Trade Value Models

R provides powerful statistical modeling capabilities for trade analysis:

library(tidyverse)
library(ggplot2)
library(broom)
library(modelr)

# Trade Value Prediction Model
# Predicts future player value based on historical patterns

# Load historical player data
# Assuming data with: player_id, season, age, war, salary, usage, etc.

create_value_projection <- function(player_data) {
  # Fit age curve model for performance projection
  age_curve_model <- player_data %>%
    group_by(player_id) %>%
    filter(n() >= 3) %>%  # Players with 3+ seasons
    ungroup() %>%
    lm(war ~ age + I(age^2) + position + usage_rate, data = .)

  return(age_curve_model)
}

# Project future WAR for a player
project_war <- function(model, age, position, usage_rate, years = 3) {
  future_ages <- age + 1:years

  predictions <- tibble(
    age = future_ages,
    position = position,
    usage_rate = usage_rate
  ) %>%
    add_predictions(model, var = "projected_war") %>%
    mutate(
      season = 2024 + row_number(),
      confidence_decay = 0.9 ^ row_number()  # Uncertainty increases
    )

  return(predictions)
}

# Contract value analysis
analyze_contract_value <- function(player_war, salary, years_remaining) {
  # Market value per WAR (updated annually)
  market_value_per_war <- 10e6

  # Calculate value metrics
  analysis <- tibble(
    season = 1:years_remaining,
    salary = salary,
    expected_war = player_war * (0.95 ^ (season - 1)),  # Slight decline
    market_value = expected_war * market_value_per_war,
    surplus_value = market_value - salary,
    cumulative_surplus = cumsum(surplus_value)
  )

  return(analysis)
}

# Trade impact simulation using Monte Carlo
simulate_trade_outcomes <- function(player_in, player_out,
                                   n_simulations = 10000) {
  # Simulate performance uncertainty
  simulations <- tibble(
    sim = 1:n_simulations,

    # Player incoming (with uncertainty)
    war_in = rnorm(n_simulations,
                   mean = player_in$expected_war,
                   sd = player_in$war_sd),

    # Player outgoing (with uncertainty)
    war_out = rnorm(n_simulations,
                    mean = player_out$expected_war,
                    sd = player_out$war_sd),

    # Calculate net WAR impact
    net_war = war_in - war_out,

    # Value impact
    value_in = war_in * 10e6 - player_in$salary,
    value_out = war_out * 10e6 - player_out$salary,
    net_value = value_in - value_out
  )

  # Summary statistics
  summary <- simulations %>%
    summarise(
      mean_net_war = mean(net_war),
      median_net_war = median(net_war),
      sd_net_war = sd(net_war),
      prob_positive = mean(net_war > 0),
      percentile_10 = quantile(net_war, 0.10),
      percentile_90 = quantile(net_war, 0.90),
      mean_net_value = mean(net_value),
      value_at_risk = quantile(net_value, 0.05)
    )

  return(list(
    simulations = simulations,
    summary = summary
  ))
}

# Visualization of trade value distribution
plot_trade_distribution <- function(simulation_results) {
  p <- ggplot(simulation_results$simulations, aes(x = net_war)) +
    geom_histogram(bins = 50, fill = "steelblue", alpha = 0.7) +
    geom_vline(xintercept = 0, linetype = "dashed", color = "red", size = 1) +
    geom_vline(aes(xintercept = mean(net_war)),
               linetype = "solid", color = "darkgreen", size = 1) +
    labs(
      title = "Trade Value Distribution (Monte Carlo Simulation)",
      subtitle = sprintf("Mean: %.2f WAR | P(Positive): %.1f%%",
                        mean(simulation_results$simulations$net_war),
                        mean(simulation_results$simulations$net_war > 0) * 100),
      x = "Net WAR Impact",
      y = "Frequency"
    ) +
    theme_minimal() +
    theme(
      plot.title = element_text(face = "bold", size = 14),
      plot.subtitle = element_text(size = 11)
    )

  return(p)
}

# Multi-year trade impact model
model_multiyear_impact <- function(trade_details, team_payroll, years = 4) {
  # Create year-by-year projection
  projections <- tibble(
    year = 1:years,

    # Players in
    war_in = trade_details$incoming_war * (0.94 ^ (year - 1)),
    salary_in = trade_details$incoming_salary,

    # Players out
    war_out = trade_details$outgoing_war * (0.94 ^ (year - 1)),
    salary_out = trade_details$outgoing_salary,

    # Net impact
    net_war = war_in - war_out,
    net_salary = salary_in - salary_out,

    # Team context
    team_payroll = team_payroll + net_salary,

    # Luxury tax calculation
    tax_threshold = 170.814e6 * (1.03 ^ (year - 1)),  # ~3% annual increase
    over_tax = pmax(0, team_payroll - tax_threshold),

    # Progressive tax rates
    tax_bill = case_when(
      over_tax == 0 ~ 0,
      over_tax <= 5e6 ~ over_tax * 1.50,
      over_tax <= 10e6 ~ 5e6 * 1.50 + (over_tax - 5e6) * 1.75,
      over_tax <= 15e6 ~ 5e6 * 1.50 + 5e6 * 1.75 + (over_tax - 10e6) * 2.50,
      over_tax <= 20e6 ~ 5e6 * 1.50 + 5e6 * 1.75 + 5e6 * 2.50 +
                         (over_tax - 15e6) * 3.25,
      TRUE ~ 5e6 * 1.50 + 5e6 * 1.75 + 5e6 * 2.50 + 5e6 * 3.25 +
             (over_tax - 20e6) * 4.25
    ),

    # Total annual cost
    total_cost = salary_in + tax_bill,

    # Cost per WAR
    cost_per_war = if_else(war_in > 0, total_cost / war_in, NA_real_),

    # Cumulative value
    cumulative_war = cumsum(net_war),
    cumulative_cost = cumsum(net_salary + tax_bill)
  )

  return(projections)
}

# Risk-adjusted trade value
calculate_risk_adjusted_value <- function(player_stats) {
  # Factors that affect risk
  risk_factors <- player_stats %>%
    mutate(
      # Age risk (peak 25-29)
      age_risk = case_when(
        age < 23 ~ 0.3,  # Development uncertainty
        age >= 23 & age <= 29 ~ 0.1,  # Prime years
        age >= 30 & age <= 32 ~ 0.2,  # Early decline
        age > 32 ~ 0.4  # Significant decline risk
      ),

      # Injury risk (based on games missed)
      injury_risk = pmin(0.5, games_missed_last_2y / 164),

      # Performance volatility
      performance_risk = sd_war_last_3y / mean_war_last_3y,
      performance_risk = pmin(0.4, performance_risk),

      # Contract risk
      contract_risk = if_else(years_remaining == 1, 0.3, 0.1),

      # Combined risk score (0-1)
      total_risk = (age_risk + injury_risk + performance_risk + contract_risk) / 4,

      # Risk-adjusted expected value
      risk_discount = 1 - total_risk,
      adjusted_war = expected_war * risk_discount,
      adjusted_value = adjusted_war * 10e6 - salary
    )

  return(risk_factors)
}

# Example usage
set.seed(42)

# Define trade scenario
player_incoming <- list(
  name = "Tyler Herro",
  expected_war = 3.8,
  war_sd = 1.2,
  salary = 27e6,
  age = 24
)

player_outgoing <- list(
  name = "Damian Lillard",
  expected_war = 5.2,
  war_sd = 1.5,
  salary = 45.64e6,
  age = 33
)

# Run simulation
sim_results <- simulate_trade_outcomes(player_incoming, player_outgoing)

# Print summary
print(sim_results$summary)

# Create visualization
trade_plot <- plot_trade_distribution(sim_results)
print(trade_plot)

# Multi-year projection
trade_details <- list(
  incoming_war = 3.8,
  incoming_salary = 27e6,
  outgoing_war = 5.2,
  outgoing_salary = 45.64e6
)

multiyear <- model_multiyear_impact(trade_details, team_payroll = 165e6)
print(multiyear)

# Visualize multi-year impact
ggplot(multiyear, aes(x = year)) +
  geom_line(aes(y = cumulative_war, color = "Cumulative WAR"), size = 1.2) +
  geom_line(aes(y = cumulative_cost / 50e6, color = "Cumulative Cost"),
            size = 1.2) +
  geom_hline(yintercept = 0, linetype = "dashed", alpha = 0.5) +
  scale_color_manual(values = c("Cumulative WAR" = "darkgreen",
                                "Cumulative Cost" = "darkred")) +
  labs(
    title = "Multi-Year Trade Impact Projection",
    x = "Years After Trade",
    y = "Cumulative Value",
    color = "Metric"
  ) +
  theme_minimal()

5. Historical Trade Analysis Case Studies

Case Study 1: James Harden to Brooklyn (2021)

Case Study 2: Kristaps Porzingis to Washington (2023)

Case Study 3: Rudy Gobert to Minnesota (2022)

Framework Lessons from Case Studies

6. Salary Matching and Cap Considerations

NBA Salary Matching Rules

Understanding salary matching is critical for trade legality:

Luxury Tax Calculations

The luxury tax system creates significant financial constraints:

Apron Restrictions (New CBA)

Trade Exception Strategy

Poison Pill Provision

7. Best Practices for Front Offices

Trade Evaluation Process

Common Pitfalls to Avoid

Advanced Trade Strategies

Negotiation Best Practices

Post-Trade Analysis

Ethical Considerations

Conclusion

Effective trade analysis requires integrating quantitative modeling, qualitative assessment, financial sophistication, and strategic thinking. Modern NBA front offices must combine:

• Data-driven evaluation using advanced metrics and statistical modeling
• Financial acumen to navigate complex CBA rules and cap management
• Strategic vision to align trades with organizational timeline
• Risk management to account for uncertainty and downside scenarios
• Market intelligence to identify inefficiencies and arbitrage opportunities
• Negotiation skills to extract maximum value in discussions

By implementing robust analytical frameworks, maintaining disciplined processes, and learning from historical precedent, front offices can make more informed trade decisions that improve their teams while managing risk and preserving long-term flexibility.