Upload folder using huggingface_hub

squid_game.py

@@ -1,5 +1,9 @@
 import gradio as gr
-from squid_game_core import parse_tier_map, get_expected_value, next_squid_gain_for_nonzero, hypothetical_next_round_gain
+from squid_game_core import (
+    parse_tier_map,
+    get_expected_value,
+    compute_ev_win_lose_two_extremes,
+)
 from typing import List, Tuple
 
 def validate_distribution(dist_str: str) -> Tuple[bool, str, List[int]]:
@@ -21,7 +25,6 @@ def validate_tier_map(tier_str: str) -> Tuple[bool, str]:
                 return False, "Each line must contain a colon (e.g., '1-2:1.5')"
             range_part, mult_part = line.split(':')
             float(mult_part.strip())  # Check multiplier is a valid number
-            
             if '-' in range_part:
                 low_str, high_str = range_part.split('-')
                 int(low_str), int(high_str)
@@ -37,12 +40,12 @@ def solve_game(distribution: str, total_squids: int, tier_map_str: str) -> str:
     valid_dist, error_msg, dist = validate_distribution(distribution)
     if not valid_dist:
         return error_msg
-    
+
     # Validate tier map
     valid_tier, error_msg = validate_tier_map(tier_map_str)
     if not valid_tier:
         return error_msg
-    
+
     # Validate total squids
     try:
         X = int(total_squids)
@@ -56,54 +59,41 @@ def solve_game(distribution: str, total_squids: int, tier_map_str: str) -> str:
     # Parse tier map and convert to tuple for caching
     try:
         tier_map = parse_tier_map(tier_map_str)
-        tier_map_tuple = tuple((a,b,c) for a,b,c in tier_map)
-        
-        # Calculate remaining squids
+        tier_map_tuple = tuple((a, b, c) for a, b, c in tier_map)
+
+        # Calculate remaining squids to distribute
         remaining = X - sum(dist)
-        
-        # Get expected values
+
+        # Get unforced expected values (full random assignment)
         get_expected_value.cache_clear()
-        expected_values = get_expected_value(tuple(dist), remaining, tier_map_tuple)
-        
-        # Format results
-        result = "Expected Values:\n"
-        for i, ev in enumerate(expected_values):
+        unforced_ev = get_expected_value(tuple(dist), remaining, tier_map_tuple)
+
+        result = "Unforced Expected Values:\n"
+        for i, ev in enumerate(unforced_ev):
             result += f"Player {i+1}: {ev:.3f}\n"
-        
-        # 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 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
+
+        # Compute each player's forced win/lose EV extremes:
+        win_lose_results = compute_ev_win_lose_two_extremes(tuple(dist), remaining, tier_map_tuple)
+
+        result += "\nForced Win/Lose Results:\n"
+        for r in win_lose_results:
+            result += (f"Player {r['player']+1}: forcedWinEV = {r['forcedWinEV']:.3f}, "
+                       f"forcedLoseEV = {r['forcedLoseEV']:.3f}, Diff = {r['difference']:.3f}\n")
+
+        # Add a human-friendly interpretation of the tier map
         result += "\nTier Map Interpretation:\n"
         for low, high, mult in tier_map:
             if low == high:
                 result += f"• {low} squid(s): multiplier = {mult:.1f}\n"
             else:
                 result += f"• {low}-{high} squids: multiplier = {mult:.1f}\n"
-                
+
         return result
-    
+
     except Exception as e:
         return f"Error occurred: {str(e)}"
 
-# Define a default tier map that's commonly used
+# Default value for tier map used in interface
 DEFAULT_TIER_MAP = """0-0:0
 1-2:1
 3-4:2
@@ -121,16 +111,16 @@ iface = gr.Interface(
             placeholder="0,0",
             value="0,0",
             info="""Enter each player's current squids, separated by commas.
-Example: '1,0,1,2,0' means:
-- Player 1 has 1 squid
-- Player 2 has 0 squids
-- Player 3 has 1 squid
-- Player 4 has 2 squids
-- Player 5 has 0 squids"""
+Example: '1,0,1,2,0' represents:
+  - Player 1 has 1 squid
+  - Player 2 has 0 squids
+  - Player 3 has 1 squid
+  - Player 4 has 2 squids
+  - Player 5 has 0 squids"""
         ),
         gr.Number(
             label="Total Squids in Game",
-            value=2,
+            value=9,
             minimum=0,
             step=1,
             precision=0,
@@ -140,41 +130,35 @@ Example: '1,0,1,2,0' means:
             label="Squid Value Tiers",
             placeholder=DEFAULT_TIER_MAP,
             value=DEFAULT_TIER_MAP,
-            lines=6,
-            info="""Define how squids are valued at different quantities.
-Format: range:multiplier (one rule per line)
-
-Examples:
-0-0:0     → 0 squids = 0 points
-1-2:1     → 1,2 squid = 1× points (total = 1)
-3-4:2     → 3,4 squids = 2× points each (total = 4)
-5-6:4     → 5,6 squids = 4× points each
-7-7:8     → 7 squids = 8 points
-8-8:16    → 8 squids = 16 points
-9-9:32    → 9 squids = 32 points
-10-100:64 → 10+ squids = 64× points each
-
-Edit these values to match your game rules."""
+            lines=8,
+            info="""Define the value tiers for squids.
+Format: range:multiplier (one per line)
+Example:
+0-0:0
+1-2:1
+3-4:2
+5-6:4
+7-7:8
+8-8:16
+9-9:32
+10-100:64"""
         )
     ],
-    outputs=gr.Textbox(label="Results", lines=10),
+    outputs=gr.Textbox(label="Results", lines=15),
     title="Squid Game Expected Value Calculator",
     description="""
     Calculate the expected payoff for each player in the Squid Game.
-    
-    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, 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
+
+    Rules:
+    1. Players take turns collecting squids randomly.
+    2. The game ends when either:
+       - Exactly one player has 0 squids, OR
+       - There are no squids left to distribute.
     """,
     examples=[
-        # Common scenarios with descriptive labels
-        ["0,0", 2, DEFAULT_TIER_MAP],      # Basic 2-player game
-        ["1,0,1", 4, DEFAULT_TIER_MAP],    # 3 players, some squids distributed
-        ["2,0,2,0", 6, DEFAULT_TIER_MAP],  # 4 players, mixed distribution
+        ["0,0", 9, DEFAULT_TIER_MAP],
+        ["1,0,1", 12, DEFAULT_TIER_MAP],
+        ["2,0,2,0", 14, DEFAULT_TIER_MAP],
     ]
 )
 

squid_game_core.py

@@ -112,49 +112,95 @@ def get_expected_value(distribution, remaining, tier_map_tuple):
         accumulated[i] /= n
     return tuple(accumulated)
 
-def next_squid_gain_for_nonzero(distribution, tier_map):
+def get_expected_value_forced_win(
+    i, 
+    distribution, 
+    leftover, 
+    tier_map_tuple
+):
     """
-    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.
+    假设下一只乌贼 100% 给玩家 i。
+    则先把 distribution[i] += 1, leftover -=1,
+    然后对 (distribution', leftover') 做完全随机的 get_expected_value(...)。
+    返回：一个长度 N 的 tuple，表示每个玩家在这种强制赢前提下的期望最终收益。
     """
-    results = {}
-    for i, s in enumerate(distribution):
-        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
+    if leftover <= 0:
+        # 没乌贼剩了，也可能是某些奇怪边界，直接算终局：
+        return get_expected_value(distribution, leftover, tier_map_tuple)
+
+    dist_forced = list(distribution)
+    dist_forced[i] += 1
+    new_dist = tuple(dist_forced)
+    return get_expected_value(new_dist, leftover - 1, tier_map_tuple)
+
+
+def get_expected_value_forced_lose(
+    i, 
+    distribution, 
+    leftover, 
+    tier_map_tuple
+):
+    """
+    假设下一只乌贼 100% 不会给玩家 i，
+    即本轮发乌贼只在其余 (n-1) 人中随机选 winner，
+    然后后续 (leftover-1) 轮恢复正常 n 人随机。
 
-def hypothetical_next_round_gain(distribution, tier_map, penalty):
+    做法：遍历所有 winner != i (prob=1/(n-1))，发给那个 winner，
+    然后 leftover-1 的状态再用 get_expected_value 完全随机。
+
+    返回：一个长度 N 的 tuple (每个玩家最终EV)
     """
-    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.
+    n = len(distribution)
+    if leftover <= 0:
+        return get_expected_value(distribution, leftover, tier_map_tuple)
+
+    # 如果 n=1，那就无可比了……(此处不太可能)
+    # 一般 n>=2, leftover>=1
     
-    - 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)
+    # 假设我们这里显式地做一次 "下一只的发放" 的平均
+    # winner只能在 [0..n-1] - {i} 之中。
+    # Probability = 1/(n-1)
+
+    accumulated = [0.0]*n
+    valid_winners = [w for w in range(n) if w != i]
+
+    for w in valid_winners:
+        dist_next = list(distribution)
+        dist_next[w] += 1
+        sub_ev = get_expected_value(tuple(dist_next), leftover-1, tier_map_tuple)
+        for p in range(n):
+            accumulated[p] += sub_ev[p]
+
+    # 做平均
+    for p in range(n):
+        accumulated[p] /= len(valid_winners)  # == (n-1)
+
+    return tuple(accumulated)
+
+def compute_ev_win_lose_two_extremes(distribution, leftover, tier_map_tuple):
+    """
+    返回一个数据结构,记录每个玩家 i 在:
+      - forced_win    时的期望收益
+      - forced_lose   时的期望收益
+      - difference    = forced_win - forced_lose
     """
     n = len(distribution)
-    gains = [0.0]*n
+    results = []
 
-    zero_count = sum(1 for x in distribution if x==0)
+    for i in range(n):
+        forced_win_vec = get_expected_value_forced_win(i, distribution, leftover, tier_map_tuple)
+        forced_lose_vec = get_expected_value_forced_lose(i, distribution, leftover, tier_map_tuple)
 
-    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
+        # 我们可能只关心玩家 i 本人的比较, 也可以把全部人都算,
+        # 这里演示只关心 i
+        forced_win_i = forced_win_vec[i]
+        forced_lose_i = forced_lose_vec[i]
+        diff_i = forced_win_i - forced_lose_i
+
+        results.append({
+            'player': i,
+            'forcedWinEV': forced_win_i,
+            'forcedLoseEV': forced_lose_i,
+            'difference': diff_i
+        })
+    return results