Upload folder using huggingface_hub

squid_game.py

@@ -70,12 +70,25 @@ 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)
+        # Calculate penalty from expected values of zero-squid players
+        zero_player_evs = [ev for i, ev in enumerate(expected_values) if dist[i] == 0]
+        if zero_player_evs:
+            # Verify all zero-squid players have same expected value
+            if not all(abs(ev - zero_player_evs[0]) < 1e-6 for ev in zero_player_evs):
+                return "Error: Zero-squid players have different expected values"
+            penalty = abs(zero_player_evs[0])
+        else:
+            penalty = 0
+        
+        # Calculate potential gains using hypothetical_next_round_gain with actual penalty
+        gains = hypothetical_next_round_gain(dist, tier_map, penalty=penalty)
         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"
+            for player_idx, gain in enumerate(gains):
+                result += f"Player {player_idx+1}: +{gain:.1f}"
+                if dist[player_idx] == 0:
+                    result += " (includes avoiding payment share)"
+                result += "\n"
         
         # Add tier map interpretation
         result += "\nTier Map Interpretation:\n"

squid_game_core.py

@@ -55,7 +55,7 @@ def compute_final_payout(distribution, tier_map):
     """
     distribution: e.g. (0,0,4)
     
-    NEW RULES:
+    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).
@@ -73,22 +73,14 @@ def compute_final_payout(distribution, tier_map):
     if m == 0:
         # No zeros => no payment => everyone gets 0
         return payoffs
-    elif m == 1:
-        # 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:
-        # multiple zeros => each zero pays sum_winner_values
-        # => each winner receives m * (their own tierValue)
+        # Each zero pays sum_winner_values
         for z in zero_indices:
             payoffs[z] = -sum_winner_values
+        # Each winner gets their tierValue (if single loser)
+        # or m * their tierValue (if multiple losers)
         for i, w in enumerate(winner_indices):
-            payoffs[w] = m * winner_values[i]
+            payoffs[w] = winner_values[i] if m == 1 else m * winner_values[i]
         return payoffs
 
 def format_state(distribution, remaining):
@@ -124,21 +116,16 @@ 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
+        if s > 0:  # Only include non-zero players
+            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):
+def hypothetical_next_round_gain(distribution, tier_map, penalty):
     """
     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.

test_squid_game.py

@@ -11,7 +11,8 @@ from squid_game_core import (
     is_terminal,
     compute_final_payout,
     get_expected_value,
-    next_squid_gain_for_nonzero
+    next_squid_gain_for_nonzero,
+    hypothetical_next_round_gain
 )
 
 def nearly_equal(a, b, tol=1e-9):
@@ -50,12 +51,15 @@ def test_multiple_losers_pay_individually(tier_map_example):
 def test_single_loser(tier_map_example):
     """
     Scenario: 2 players => final distribution=(1,0).
-    => 1 zero => that zero pays sum_of_winners= tierValue(1)=1 => payoff=(0, -1).
+    => 1 zero => that zero pays sum_of_winners= tierValue(1)=1
+    => payoff=(1, -1) because:
+    - Winner keeps their tierValue (1)
+    - Loser pays that amount (-1)
     """
     dist = (1,0)
     payoffs = compute_final_payout(dist, tier_map_example)
-    assert nearly_equal(payoffs[0],  0)
-    assert nearly_equal(payoffs[1], -1)
+    assert nearly_equal(payoffs[0], 1)  # Winner gets tierValue(1)=1
+    assert nearly_equal(payoffs[1], -1)  # Loser pays -1
 
 def test_no_losers(tier_map_example):
     """
@@ -142,3 +146,55 @@ def test_ev_multiple_losers_specific(tier_map_example):
     assert nearly_equal(ev[2],  4)
     # sum = 0
     assert nearly_equal(sum(ev), 0.0)
+
+def test_hypothetical_next_round_gain_with_penalty():
+    """
+    Test scenario: 3 players with distribution=(0,0,2)
+    Expected values would be (-2,-2,4) as shown in test_ev_multiple_losers_specific
+    So penalty should be 2 (abs of -2)
+    
+    For zero-squid players (0,1):
+    - Getting 1 squid = tierValue(1) = 1
+    - Avoiding penalty share = 2/2 = 1 (penalty/zero_count)
+    - Total gain = 2
+    
+    For player with 2 squids:
+    - Going from 2 to 3 = tierValue(3) - tierValue(2) = 3 - 2 = 1
+    """
+    tier_map = (
+        (0,0,0.0),
+        (1,4,1.0),
+        (5,6,3.0)
+    )
+    dist = (0,0,2)
+    penalty = 2  # abs of -2 from expected values
+    
+    gains = hypothetical_next_round_gain(dist, tier_map, penalty)
+    
+    # Check zero-squid players
+    assert nearly_equal(gains[0], 2.0), f"Expected gain 2.0 for player 1, got {gains[0]}"
+    assert nearly_equal(gains[1], 2.0), f"Expected gain 2.0 for player 2, got {gains[1]}"
+    
+    # Check non-zero player
+    assert nearly_equal(gains[2], 1.0), f"Expected gain 1.0 for player 3, got {gains[2]}"
+
+def test_hypothetical_next_round_gain_no_zeros():
+    """
+    Test scenario: 2 players with distribution=(1,2)
+    No zero-squid players, so penalty doesn't matter
+    
+    Player 1: going from 1 to 2 = tierValue(2) - tierValue(1) = 2 - 1 = 1
+    Player 2: going from 2 to 3 = tierValue(3) - tierValue(2) = 3 - 2 = 1
+    """
+    tier_map = (
+        (0,0,0.0),
+        (1,4,1.0),
+        (5,6,3.0)
+    )
+    dist = (1,2)
+    penalty = 0  # doesn't matter since no zero-squid players
+    
+    gains = hypothetical_next_round_gain(dist, tier_map, penalty)
+    
+    assert nearly_equal(gains[0], 1.0), f"Expected gain 1.0 for player 1, got {gains[0]}"
+    assert nearly_equal(gains[1], 1.0), f"Expected gain 1.0 for player 2, got {gains[1]}"