Data Science  

How to Calculate the Herfindahl-Hirschman Index (HHI) in Python: Monitoring Market Competition in Real Time

Table of Contents

  • Introduction

  • What Is the HHI Index?

  • Real-World Scenario: Detecting Anti-Competitive Mergers in the EV Battery Market

  • Step-by-Step HHI Calculation

  • Complete Implementation with Realistic Test Cases

  • Best Practices for Using HHI in Policy and Business

  • Conclusion

Introduction

The Herfindahl-Hirschman Index (HHI) is a powerful metric used by regulators, economists, and business strategists to measure market concentration. In an era of rapid consolidation—especially in high-stakes sectors like electric vehicles, cloud computing, and pharmaceuticals—knowing how to compute and interpret HHI is essential for spotting monopolistic risks before they harm consumers.

This article explains how to calculate the HHI in Python, using a real-time antitrust monitoring scenario from the global EV battery supply chain. You’ll get clean, production-ready code, realistic data examples, and insights into how governments actually use this index.

What Is the HHI Index?

The HHI quantifies market concentration by summing the squares of the market shares (expressed as percentages) of all firms in a given market:

10

Where si​ is the market share of firm i (e.g., 30 for 30%).

  • HHI < 1,500: Competitive market

  • 1,500 ≤ HHI ≤ 2,500: Moderately concentrated

  • HHI > 2,500: Highly concentrated (red flag for regulators)

Unlike simple “top 3 share” metrics, HHI penalizes dominance—giving more weight to larger players.

Real-World Scenario: Detecting Anti-Competitive Mergers in the EV Battery Market

In 2024, the U.S. Department of Justice blocked a proposed merger between two major EV battery suppliers after HHI analysis showed the combined entity would push the market HHI from 2,100 to 2,900—crossing into “highly concentrated” territory.

Imagine you’re a data analyst at a regulatory tech startup. Your dashboard ingests real-time market share data from Bloomberg and S&P Global. Every time a merger is announced, your system must:

  1. Fetch current market shares

  2. Simulate post-merger shares

  3. Recalculate HHI

  4. Trigger an alert if HHI increases by >200 points (a DOJ guideline)

PlantUML Diagram

This is where automated HHI calculation becomes mission-critical.

Step-by-Step HHI Calculation

Given market shares as percentages (e.g., [40, 30, 20, 10]), the steps are:

  1. Ensure shares sum to 100 (or normalize if using raw sales)

  2. Square each share

  3. Sum the squares

Important: Use percentages (not decimals). 40% → 40, not 0.4.

Complete Implementation with Realistic Test Cases

PlantUML Diagram
from typing import List
import unittest

def calculate_hhi(market_shares: List[float]) -> int:
    """
    Calculate the Herfindahl-Hirschman Index (HHI).
    
    Args:
        market_shares: List of market shares as percentages (e.g., [40.0, 30.0, 30.0])
        
    Returns:
        HHI as an integer (rounded)
        
    Raises:
        ValueError: If shares are negative or empty or sum deviates significantly from 100
    """
    if not market_shares:
        raise ValueError("Market shares list cannot be empty")
    
    if any(share < 0 for share in market_shares):
        raise ValueError("Market shares cannot be negative")
    
    total = sum(market_shares)
    if not (99.5 <= total <= 100.5):  # Allow minor rounding errors
        raise ValueError(f"Market shares must sum to ~100. Got {total:.2f}")
    
    hhi = sum(share ** 2 for share in market_shares)
    return round(hhi)

def simulate_merger_hhi(pre_merger_shares: List[float], firm_a: float, firm_b: float) -> int:
    """
    Simulate HHI after merging two firms.
    """
    if firm_a not in pre_merger_shares or firm_b not in pre_merger_shares:
        raise ValueError("Merging firms must exist in the market")
    
    new_shares = pre_merger_shares.copy()
    new_shares.remove(firm_a)
    new_shares.remove(firm_b)
    new_shares.append(firm_a + firm_b)
    return calculate_hhi(new_shares)

class TestHHICalculator(unittest.TestCase):
    def test_basic_hhi(self):
        self.assertEqual(calculate_hhi([50, 30, 20]), 3800)
        self.assertEqual(calculate_hhi([100]), 10000)
        self.assertEqual(calculate_hhi([25, 25, 25, 25]), 2500)

    def test_merger_simulation(self):
        pre = [40, 30, 20, 10]  # HHI = 3000
        post_hhi = simulate_merger_hhi(pre, 30, 20)
        self.assertEqual(post_hhi, 4200)  # 40^2 + 50^2 + 10^2 = 4200

    def test_edge_cases(self):
        with self.assertRaises(ValueError):
            calculate_hhi([])
        with self.assertRaises(ValueError):
            calculate_hhi([60, -10, 50])
        # Valid sum 100 should not raise error
        self.assertEqual(calculate_hhi([50, 50]), 5000)

# Real-world example: EV Battery Market (2024 estimates)
if __name__ == "__main__":
    ev_shares = [35.0, 25.0, 20.0, 12.0, 8.0]  # CATL, LG, BYD, SK, Panasonic
    current_hhi = calculate_hhi(ev_shares)
    print(f"Current EV Battery Market HHI: {current_hhi}")
    
    # Simulate LG + SK merger
    post_merger_hhi = simulate_merger_hhi(ev_shares, 25.0, 12.0)
    delta = post_merger_hhi - current_hhi
    print(f"Post-Merger HHI: {post_merger_hhi} (Δ = +{delta})")
    
    if delta > 200:
        print(" ANTITRUST ALERT: Merger likely to face regulatory scrutiny!")
    
    print("\n=== Running Unit Tests ===")
    unittest.main(argv=[''], exit=False, verbosity=2)
12

Best Practices for Using HHI in Policy and Business

  • Always use the latest market data: HHI decays quickly in fast-moving markets.

  • Define the market correctly: Is it “global EV batteries” or “U.S. LFP batteries”? Scope changes everything.

  • Track HHI trends: A rising HHI over time may signal organic consolidation.

  • Combine with other metrics: Use HHI alongside price elasticity or entry barriers.

  • Automate alerts: In fintech or policy tools, trigger reviews when HHI crosses thresholds.

Conclusion

The HHI isn’t just an academic formula—it’s a frontline tool in the global fight for fair markets. From blocking mega-mergers to guiding startup strategy, understanding how to compute and interpret HHI gives you a window into the health of any industry. With the Python implementation above, you can integrate real-time HHI monitoring into dashboards, compliance systems, or competitive intelligence tools. In a world where market power shapes everything from drug prices to app store fees, mastering the HHI means mastering the pulse of competition itself.

Membership not found