Upload folder using huggingface_hub

.gitignore

@@ -0,0 +1,69 @@
+# Python
+__pycache__/
+*.py[cod]
+*$py.class
+*.so
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+
+# Virtual Environment
+venv/
+env/
+ENV/
+.env
+.venv
+env.bak/
+venv.bak/
+
+# IDE - PyCharm
+.idea/
+*.iml
+*.iws
+.idea_modules/
+
+# IDE - VSCode
+.vscode/
+*.code-workspace
+.history/
+
+# IDE - Jupyter Notebook
+.ipynb_checkpoints
+*.ipynb
+
+# Testing
+.pytest_cache/
+.coverage
+htmlcov/
+.tox/
+.nox/
+coverage.xml
+*.cover
+*.py,cover
+.hypothesis/
+
+# Misc
+.DS_Store
+*.log
+*.swp
+*.swo
+.env.local
+.env.development.local
+.env.test.local
+.env.production.local 
+
+
+.gradio/*

squid_game.py

@@ -1,5 +1,5 @@
 import gradio as gr
-from squid_game_core import parse_tier_map, get_expected_value
+from squid_game_core import parse_tier_map, get_expected_value, next_squid_gain_for_nonzero, hypothetical_next_round_gain
 from typing import List, Tuple
 
 def validate_distribution(dist_str: str) -> Tuple[bool, str, List[int]]:
@@ -70,6 +70,13 @@ def solve_game(distribution: str, total_squids: int, tier_map_str: str) -> str:
         for i, ev in enumerate(expected_values):
             result += f"Player {i+1}: {ev:.3f}\n"
         
+        # Add next squid gains information
+        gains = next_squid_gain_for_nonzero(dist, tier_map)
+        if gains:
+            result += "\nPotential Gains from Next Squid:\n"
+            for player_idx, gain in gains.items():
+                result += f"Player {player_idx+1}: +{gain:.1f} \n"
+        
         # Add tier map interpretation
         result += "\nTier Map Interpretation:\n"
         for low, high, mult in tier_map:
@@ -139,8 +146,10 @@ Edit these values to match your game rules."""
     Game Rules:
     1. Players take turns collecting squids randomly
     2. Game ends when either:
-       - Exactly one player has 0 squids (they pay the total value of others' squids), OR
-       - No squids remain to distribute (if multiple players have 0, they share the payment; if no one has 0, no payment)
+       - Exactly one player has 0 squids (they pay the total value of others' squids, winners keep their squids), OR
+       - No squids remain to distribute:
+         * If multiple players have 0, each pays the total value and winners get multiplied payouts
+         * If no one has 0, no payment occurs
     """,
     examples=[
         # Common scenarios with descriptive labels

squid_game_core.py

@@ -4,11 +4,11 @@ from functools import lru_cache
 
 def parse_tier_map(tier_str: str):
     """
-    Parses lines like "2-4:2" => for players with 2..4 squids,
-    each squid is worth multiplier=2. So if a player has 2 squids,
-    total = 2 * 2 = 4. If a player has 4 squids, total = 4 * 2 = 8.
-    
-    Returns a list of (min_k, max_k, per_squid_mult).
+    Example tier_str:
+      \"1-4:1\n5-6:3\"
+    means:
+      if a player has 1..4 squids => each worth x1 => total = k*1
+      if a player has 5..6 squids => each worth x3 => total = k*3
     """
     lines = tier_str.strip().splitlines()
     tier_map = []
@@ -16,42 +16,33 @@ def parse_tier_map(tier_str: str):
         range_part, mult_part = line.split(":")
         per_squid_mult = float(mult_part.strip())
 
-        if '-' in range_part:
-            low_str, high_str = range_part.split('-')
+        if "-" in range_part:
+            low_str, high_str = range_part.split("-")
             low, high = int(low_str), int(high_str)
         else:
             low = high = int(range_part.strip())
 
         tier_map.append((low, high, per_squid_mult))
-
     tier_map.sort(key=lambda x: x[0])
     return tier_map
 
 def tierValue(k: int, tier_map) -> float:
     """
-    Given k squids, find which tier bracket (low, high, mult) it falls into.
-    Returns: k * per_squid_mult for that bracket.
-    If k is larger than any bracket's high value, use the last bracket's multiplier.
+    For k squids, find bracket => return k * bracket_multiplier.
+    If k <= 0 => 0.
     """
     if k <= 0:
         return 0.0
-    
-    # Find matching bracket
     for (low, high, mult) in tier_map:
         if low <= k <= high:
             return k * mult
-            
-    # If k is larger than any bracket, use last bracket's multiplier
     if tier_map and k > tier_map[-1][1]:
         return k * tier_map[-1][2]
-        
-    return 0.0
+    return 0.0  # fallback if no bracket matches
 
 def is_terminal(distribution, remaining) -> bool:
     """
-    Checks if the game should end:
-      1) Exactly one player has 0 squids, OR
-      2) No squids remain (remaining == 0).
+    Game ends if exactly one zero-squid player or no squids remain.
     """
     zero_count = sum(1 for x in distribution if x == 0)
     if zero_count == 1:
@@ -62,89 +53,121 @@ def is_terminal(distribution, remaining) -> bool:
 
 def compute_final_payout(distribution, tier_map):
     """
-    Computes final payouts when game ends.
+    distribution: e.g. (0,0,4)
     
-    Rules:
-    - If exactly one player has 0 squids: they pay sum of all other players' tier values
-    - If multiple players have 0 squids: they share the total cost equally
-    - If no players have 0 squids: everyone gets 0 payout
-    
-    Args:
-        distribution: tuple of squids per player
-        tier_map: list of (low, high, multiplier) brackets
-        
-    Returns:
-        List of payouts (positive = receive, negative = pay)
+    NEW RULES:
+      - If exactly 1 zero-squid => that one pays sum_of_winners_tier
+      - If multiple zeros => each zero-squid pays sum_of_winners_tier individually
+        => each winner gets (number_of_zero_squids * winner_tier_value).
     """
     n = len(distribution)
     zero_indices = [i for i, x in enumerate(distribution) if x == 0]
-    m = len(zero_indices)
-
-    # Calculate total value from non-zero players
-    total_cost = sum(tierValue(x, tier_map) for x in distribution if x > 0)
+    m = len(zero_indices)  # number of zero-squid players
+    winner_indices = [i for i, x in enumerate(distribution) if x > 0]
 
-    payouts = [0.0] * n
+    # sum of each winner's bracketed total
+    winner_values = [tierValue(distribution[w], tier_map) for w in winner_indices]
+    sum_winner_values = sum(winner_values)
 
+    payoffs = [0.0]*n
     if m == 0:
-        return payouts  # No zeros = no payments
+        # No zeros => no payment => everyone gets 0
+        return payoffs
     elif m == 1:
-        payouts[zero_indices[0]] = -total_cost  # Single zero pays all
+        # Exactly one zero-squid => that player pays the entire sum
+        z = zero_indices[0]
+        payoffs[z] = -sum_winner_values
+        # each winner receives exactly their own tierValue
+        # so we set payoffs[winner] = winner_values[i]
+        for i, w in enumerate(winner_indices):
+            payoffs[w] = winner_values[i]
+        return payoffs
     else:
-        cost_per_player = total_cost / m
-        for i in zero_indices:
-            payouts[i] = -cost_per_player  # Multiple zeros share cost
-
-    return payouts
+        # multiple zeros => each zero pays sum_winner_values
+        # => each winner receives m * (their own tierValue)
+        for z in zero_indices:
+            payoffs[z] = -sum_winner_values
+        for i, w in enumerate(winner_indices):
+            payoffs[w] = m * winner_values[i]
+        return payoffs
+
+def format_state(distribution, remaining):
+    """Format a game state for display"""
+    return f"({','.join(map(str, distribution))}, {remaining})"
 
 @lru_cache(None)
 def get_expected_value(distribution, remaining, tier_map_tuple):
     """
-    Returns an N-tuple of expected payoffs for each player in the partial state.
-    
-    Args:
-        distribution: tuple of ints representing squids per player, e.g. (1,0,2)
-        remaining: how many squids left to deal
-        tier_map_tuple: tuple of (low, high, multiplier) brackets
-        
-    Special cases:
-    - For 2 players with 2 remaining squids, uses exact probabilities:
-      - (2,0) and (0,2) each have 25% chance
-      - (1,1) has 50% chance
-    Otherwise averages over all possible next-squid distributions.
+    Memoized DP: returns an N-tuple of payoffs from state=(distribution, remaining).
+    distribution: tuple of ints
+    remaining: int (squids left)
+    tier_map_tuple: bracket info (like ( (1,4,1.0), (5,6,3.0) ))
     """
-    distribution = tuple(distribution)
-
-    # 1. Terminal?
     if is_terminal(distribution, remaining):
-        final_payout = compute_final_payout(distribution, tier_map_tuple)
-        return tuple(final_payout)
-
-    # 2. Otherwise, average over all possible ways to distribute the remaining squids
-    n = len(distribution)
+        final_pay = compute_final_payout(distribution, tier_map_tuple)
+        return tuple(final_pay)
     
-    # Special case: 2 players, 2 remaining squids
-    if remaining == 2 and n == 2:
-        payout_2_0 = compute_final_payout((distribution[0]+2, distribution[1]), tier_map_tuple)
-        payout_0_2 = compute_final_payout((distribution[0], distribution[1]+2), tier_map_tuple)
-        payout_1_1 = compute_final_payout((distribution[0]+1, distribution[1]+1), tier_map_tuple)
-        
-        return tuple(
-            0.25 * payout_2_0[i] + 0.25 * payout_0_2[i] + 0.5 * payout_1_1[i]
-            for i in range(n)
-        )
-
-    # Original logic for other cases
-    accumulated_ev = [0.0]*n
+    n = len(distribution)
+    accumulated = [0.0]*n
     for winner in range(n):
         new_dist = list(distribution)
         new_dist[winner] += 1
-        new_dist = tuple(new_dist)
-        sub_ev = get_expected_value(new_dist, remaining - 1, tier_map_tuple)
+        sub_ev = get_expected_value(tuple(new_dist), remaining-1, tier_map_tuple)
         for i in range(n):
-            accumulated_ev[i] += sub_ev[i]
-
-    # Probability = 1/n for each winner
+            accumulated[i] += sub_ev[i]
+    # average
     for i in range(n):
-        accumulated_ev[i] /= n
+        accumulated[i] /= n
+    return tuple(accumulated)
 
-    return tuple(accumulated_ev)
+def next_squid_gain_for_nonzero(distribution, tier_map):
+    """
+    Returns a dict: {player_index: gain in tierValue if that player goes from s_i to s_i+1}.
+    Only for players who currently hold > 0 squids.
+    
+    Example:
+      if distribution=(4,0,2) with "1-4:1,5-6:3":
+        - Player0 has 4 => tierValue(4)=4 => tierValue(5)=15 => gain=11
+        - Player1 has 0 => skip
+        - Player2 has 2 => tierValue(2)=2*1=2 => tierValue(3)=3 => gain=1
+    """
+    results = {}
+    for i, s in enumerate(distribution):
+        curr_val = tierValue(s, tier_map)
+        next_val = tierValue(s+1, tier_map)
+        results[i] = next_val - curr_val
+    return results
+
+def hypothetical_next_round_gain(distribution, tier_map, penalty=24):
+    """
+    Returns a list (or dict) of length N, indicating how much "extra" reward 
+    each player would get if they, individually, are the *sole* winner next round.
+    
+    - If s[i] > 0: 
+         gain[i] = tierValue(s[i]+1) - tierValue(s[i])
+    - If s[i] == 0:
+         gain[i] = tierValue(1) + (1/zero_count)*penalty
+           (assuming your simplified logic that 1/zero_count is 
+            the chance of "dodging" the final cost of 24 by winning a squid)
+    """
+    n = len(distribution)
+    gains = [0.0]*n
+
+    zero_count = sum(1 for x in distribution if x==0)
+
+    for i, s_i in enumerate(distribution):
+        if s_i > 0:
+            current_val = tierValue(s_i, tier_map)
+            next_val = tierValue(s_i + 1, tier_map)
+            gains[i] = next_val - current_val
+        else:
+            # s_i=0
+            val_if_win = tierValue(1, tier_map)  # from 0 => 1
+            # plus the "avoid paying 24" portion *if you assume 
+            # it is equally likely you'd be the one stuck paying if you remain at 0
+            if zero_count > 0:
+                gains[i] = val_if_win + (penalty / zero_count)
+            else:
+                # edge case: if zero_count=0? not possible if s_i=0. 
+                gains[i] = val_if_win
+    return gains

test_squid_game.py

@@ -4,165 +4,141 @@ import pytest
 from math import isclose
 from functools import lru_cache
 
-# Import from our main solver
-from squid_game import get_expected_value
+# Import from our main module
+from squid_game_core import (
+    parse_tier_map,
+    tierValue,
+    is_terminal,
+    compute_final_payout,
+    get_expected_value,
+    next_squid_gain_for_nonzero
+)
+
+def nearly_equal(a, b, tol=1e-9):
+    return isclose(a, b, abs_tol=tol)
 
 @pytest.fixture
-def corrected_tier_map():
+def tier_map_example():
     """
-    A simple bracket-based tier for test:
-       0-0:0  => 0 squids => total=0
-       1-1:1  => 1 squid => total=1
-       2-2:2  => 2 squids => total=4
-       3-100:2 => 3 or more => total=k*2
+    We'll define a bracket:
+      1-4:1 => if you have 1..4 squids => total = k * 1
+      5-6:3 => if you have 5..6 squids => total = k * 3
+    0 => always 0
     """
+    # We'll store it as a tuple for use in DP
+    # parse_tier_map would do the same, but let's define it directly
     return (
         (0,0,0.0),
-        (1,1,1.0),
-        (2,2,2.0),
-        (3,100,2.0)
+        (1,4,1.0),
+        (5,6,3.0)
     )
 
-def nearly_equal(a, b, tol=1e-9):
-    return isclose(a, b, abs_tol=tol)
+def test_multiple_losers_pay_individually(tier_map_example):
+    """
+    Scenario: 3 players => final distribution=(0,0,4).
+    According to bracket (1-4:1 => 4=>4*1=4).
+    - 2 losers => each pays 4 => each has payoff=-4
+    - 1 winner => receives 2 * 4=8.
+    """
+    dist = (0,0,4)
+    payoffs = compute_final_payout(dist, tier_map_example)
+    # payoffs => [ -4, -4, 8 ]
+    assert nearly_equal(payoffs[0], -4)
+    assert nearly_equal(payoffs[1], -4)
+    assert nearly_equal(payoffs[2],  8)
 
-def test_caseA(corrected_tier_map):
+def test_single_loser(tier_map_example):
     """
-    N=2, X=1, dist=(0,0)
-    -> EV=(-0.5, -0.5)
-    Explanation:
-      - 1 squid left, 50% P1 gets => payoff=(0, -1)
-      - 50% P2 gets => payoff=(-1, 0)
-    => each player => -0.5
+    Scenario: 2 players => final distribution=(1,0).
+    => 1 zero => that zero pays sum_of_winners= tierValue(1)=1 => payoff=(0, -1).
     """
-    dist = (0,0)
-    X = 1
-    r = X - sum(dist)
-    get_expected_value.cache_clear()
-    ev = get_expected_value(dist, r, tier_map_tuple=corrected_tier_map)
-    assert nearly_equal(ev[0], -0.5)
-    assert nearly_equal(ev[1], -0.5)
+    dist = (1,0)
+    payoffs = compute_final_payout(dist, tier_map_example)
+    assert nearly_equal(payoffs[0],  0)
+    assert nearly_equal(payoffs[1], -1)
 
-def test_caseB(corrected_tier_map):
-    """
-    N=2, X=2, dist=(0,0)
-    Possible final distributions:
-      (2,0) => zero pays tierValue(2)=4 => payoff=(0,-4)
-      (0,2) => payoff=(-4,0)
-      (1,1) => payoff=(0,0)
-    Prob(2,0)=Prob(0,2)=0.25, Prob(1,1)=0.5 => EV=(-1, -1)
-    """
-    dist = (0,0)
-    X = 2
-    r = X - sum(dist)
-    get_expected_value.cache_clear()
-    ev = get_expected_value(dist, r, tier_map_tuple=corrected_tier_map)
-    assert nearly_equal(ev[0], -1.0)
-    assert nearly_equal(ev[1], -1.0)
+def test_no_losers(tier_map_example):
+    """
+    Scenario: 2 players => final distribution=(2,3).
+    => no zero => no payment => payoff=(0,0).
+    """
+    dist = (2,3)
+    payoffs = compute_final_payout(dist, tier_map_example)
+    # 2 => bracket(1..4 => *1)=>2
+    # 3 => bracket(1..4 => *1)=>3
+    # but since no zero => payoff=(0,0).
+    assert nearly_equal(payoffs[0], 0)
+    assert nearly_equal(payoffs[1], 0)
 
-def test_caseC(corrected_tier_map):
-    """
-    N=2, X=2, dist=(1,0)
-    => Exactly one zero => immediate terminal => zero pays tierValue(1)=1 => payoff=(0, -1).
-    """
-    dist = (1,0)
-    X = 2
-    r = X - sum(dist)
-    get_expected_value.cache_clear()
-    ev = get_expected_value(dist, r, tier_map_tuple=corrected_tier_map)
-    assert nearly_equal(ev[0],  0.0)
-    assert nearly_equal(ev[1], -1.0)
+def test_next_squid_gain_for_nonzero(tier_map_example):
+    """
+    distribution=(4,0,2) => 
+      - Player0=4 => tierValue(4)=4 => tierValue(5)=15 => gain=11
+        (since 5 squids => bracket => 5*3=15)
+      - Player1=0 => skip
+      - Player2=2 => tierValue(2)=2 => tierValue(3)=3 => gain=1
+    """
+    dist = (4,0,2)
+    gains = next_squid_gain_for_nonzero(dist, tier_map_example)
+    assert 0 in gains
+    assert gains[0] == 11  # 15-4
+    assert 2 in gains
+    assert gains[2] == 1   # 3-2
+    assert 1 not in gains  # because that player has 0
 
-def test_caseD(corrected_tier_map):
-    """
-    N=3, X=3, dist=(0,0,3)
-    => sum=3 => no squids remain => multiple zeros share cost= tierValue(3)=3*2=6 => each pays 3 => payoff=(-3, -3, 0)
+def test_ev_with_leftover_multiple_losers(tier_map_example):
     """
-    dist = (0,0,3)
-    X = 3
-    r = X - sum(dist)
-    get_expected_value.cache_clear()
-    ev = get_expected_value(dist, r, tier_map_tuple=corrected_tier_map)
-    assert nearly_equal(ev[0], -3.0)
-    assert nearly_equal(ev[1], -3.0)
-    assert nearly_equal(ev[2],  0.0)
+    We'll test a DP scenario:
+      N=3, X=4 total squids
+      Current distribution=(0,1,1)
+      => sum=2 => leftover=2 => not terminal.
 
-def test_caseE(corrected_tier_map):
-    """
-    N=3, X=2, dist=(0,1,1)
-    => sum=2 => no squids remain => exactly one zero => cost= tierValue(1)+ tierValue(1)=1+1=2
-    => payoff=(-2, 0, 0)
+    Let's see possible final states:
+      - They could keep awarding 2 more squids in 2 rounds.
+      - It's possible we end with multiple zeros if the 2 additional squids both go to the same non-zero player, 
+        or exactly one zero, etc.
+
+    We'll just check the computed EV matches a hand-run or at least we confirm no errors.
     """
     dist = (0,1,1)
-    X = 2
-    r = X - sum(dist)
-    get_expected_value.cache_clear()
-    ev = get_expected_value(dist, r, tier_map_tuple=corrected_tier_map)
-    assert nearly_equal(ev[0], -2.0)
-    assert nearly_equal(ev[1],  0.0)
-    assert nearly_equal(ev[2],  0.0)
+    X = 4
+    r = X - sum(dist)  # 4-2=2
 
-def test_caseF(corrected_tier_map):
-    """
-    N=3, X=2, dist=(1,0,1)
-    => sum=2 => no squids => exactly one zero => cost=1+1=2 => payoff=(0, -2, 0)
-    """
-    dist = (1,0,1)
-    X = 2
-    r = X - sum(dist)
+    # We'll do a quick partial analysis by enumerating the 2 leftover squids:
+    # Round 1 => three possibilities: P0, P1, P2
+    # But let's just rely on the solver to give us a final result, 
+    # and we'll assert that we get a numeric 3-tuple and 
+    # the sum of payoffs is near 0 (since it's a zero-sum game).
+    
+    from squid_game import get_expected_value
     get_expected_value.cache_clear()
-    ev = get_expected_value(dist, r, tier_map_tuple=corrected_tier_map)
-    assert nearly_equal(ev[0],  0.0)
-    assert nearly_equal(ev[1], -2.0)
-    assert nearly_equal(ev[2],  0.0)
+    ev = get_expected_value(dist, r, tier_map_example)
+    assert len(ev) == 3
+    # Because it's zero-sum, the sum of EVs should be very close to 0:
+    total_ev = sum(ev)
+    assert nearly_equal(total_ev, 0.0), f"Sum of EVs is not near 0, got {total_ev}"
 
-def test_caseG(corrected_tier_map):
-    """
-    N=2, X=3, dist=(1,1)
-    => sum=2 => 1 leftover => final => (2,1) or (1,2) => no zero => payoff=(0,0) => EV=(0,0)
-    """
-    dist = (1,1)
-    X = 3
-    r = X - sum(dist)
-    get_expected_value.cache_clear()
-    ev = get_expected_value(dist, r, tier_map_tuple=corrected_tier_map)
-    assert nearly_equal(ev[0], 0.0)
-    assert nearly_equal(ev[1], 0.0)
+    # We won't do a full hand enumeration here, 
+    # but we at least confirm the DP runs and yields a plausible sum=0 result.
 
-def test_caseH(corrected_tier_map):
+def test_ev_multiple_losers_specific(tier_map_example):
     """
-    Demonstrates a scenario with a currently NON-zero player
-    AND the game is NOT terminal. Specifically:
-    
-    N=3, X=3, dist=(0,0,2)
-    => sum=2 => leftover=1 => zero_count=2 => not terminal (must continue).
-    
-    Next round (1 leftover) goes to:
-      - P1 => final (1,0,2) => sum=3 => leftover=0 => EXACTLY ONE zero => that zero pays:
-           cost = tierValue(1)+ tierValue(2)= 1 + 4= 5 => payoff=(0, -5, 0).
-      - P2 => final (0,1,2) => sum=3 => leftover=0 => EXACTLY ONE zero => that zero pays:
-           cost = tierValue(1)+ tierValue(2)= 5 => payoff=(-5, 0, 0).
-      - P3 => final (0,0,3) => sum=3 => leftover=0 => MULTIPLE zeros => cost= tierValue(3)=3*2=6 => each zero pays -3 => payoff=(-3, -3, 0).
-    Each outcome has probability 1/3.
-    
-    So final EV:
-      Player1 => 1/3(0) + 1/3(-5) + 1/3(-3) = -8/3 = approx -2.6667
-      Player2 => 1/3(-5) + 1/3(0) + 1/3(-3) = -8/3 = approx -2.6667
-      Player3 => 1/3(0) + 1/3(0) + 1/3(0)   = 0
-    
-    This confirms the code gives EVs for both zero and non-zero players.
+    A more direct test for multiple losers via DP:
+      N=3, X=2, distribution=(0,0,2)
+      => sum=2 => leftover=0 => terminal => multiple zero => each zero pays tierValue(2)=2 => payoff=(-2,-2,4)
+
+    Then we check that the DP logic returns the same final payoff if is_terminal is triggered.
     """
     dist = (0,0,2)
-    X = 3
-    r = X - sum(dist)
-    # Zero_count=2 => not terminal => must see who wins the final squid
-    # We can compute expected payoffs by hand => see docstring above.
-    
+    X = 2
+    r = X - sum(dist)  # leftover=0 => terminal immediately
+    from squid_game import get_expected_value
     get_expected_value.cache_clear()
-    ev = get_expected_value(dist, r, tier_map_tuple=corrected_tier_map)
-    assert len(ev) == 3
-    
-    # Compare to the exact values: ( -2.666..., -2.666..., 0 )
-    assert nearly_equal(ev[0], -8.0/3.0, 1e-7)
-    assert nearly_equal(ev[1], -8.0/3.0, 1e-7)
-    assert nearly_equal(ev[2],  0.0)
+    ev = get_expected_value(dist, r, tier_map_example)
+    # With bracket => 2 => 2*1=2 => each zero pays 2 => 2 losers => winner gets 2*2=4
+    # payoff=( -2, -2, 4 )
+    assert nearly_equal(ev[0], -2)
+    assert nearly_equal(ev[1], -2)
+    assert nearly_equal(ev[2],  4)
+    # sum = 0
+    assert nearly_equal(sum(ev), 0.0)