:new: add stuff

squid_game.py

@@ -1,3 +1,5 @@
+--- START OF FILE squid_game (1).py ---
+
 import gradio as gr
 from squid_game_core import (
     parse_tier_map,
@@ -17,10 +19,24 @@ def validate_distribution(dist_str: str) -> Tuple[bool, str, List[int]]:
         dist = [int(x.strip()) for x in dist_str.split(',')]
         if any(x < 0 for x in dist):
             return False, "Distribution cannot contain negative numbers", []
+        if not dist:
+            return False, "Distribution cannot be empty.", []
         return True, "", dist
     except ValueError:
         return False, "Distribution must be comma-separated integers (e.g., '0,1,2')", []
 
+def validate_folded_players(folded_str: str, num_players: int) -> Tuple[bool, str, List[int]]:
+    """Validate the folded players string."""
+    try:
+        folded = [int(x.strip()) for x in folded_str.split(',')]
+        if len(folded) != num_players:
+            return False, f"Folded players list must have {num_players} entries, but it has {len(folded)}.", []
+        if any(x not in [0, 1] for x in folded):
+            return False, "Folded players list can only contain 0s and 1s.", []
+        return True, "", folded
+    except ValueError:
+        return False, "Folded players must be comma-separated integers (e.g., '0,0,1,0')", []
+
 def validate_tier_map(tier_str: str) -> Tuple[bool, str]:
     """Validate the tier map string format"""
     try:
@@ -39,13 +55,18 @@ def validate_tier_map(tier_str: str) -> Tuple[bool, str]:
     except ValueError:
         return False, "Invalid format. Example: '1:1.0\\n2-4:2.0\\n5-6:3.0'"
 
-def solve_game(distribution: str, total_squids: int, tier_map_str: str) -> str:
+def solve_game(distribution: str, folded_players_str: str, total_squids: int, tier_map_str: str) -> str:
     """Main function to solve the game and return formatted results"""
     # Validate distribution
     valid_dist, error_msg, dist = validate_distribution(distribution)
     if not valid_dist:
         return error_msg
 
+    # Validate folded players
+    valid_folded, error_msg, folded = validate_folded_players(folded_players_str, len(dist))
+    if not valid_folded:
+        return error_msg
+
     # Validate tier map
     valid_tier, error_msg = validate_tier_map(tier_map_str)
     if not valid_tier:
@@ -65,22 +86,25 @@ def solve_game(distribution: str, total_squids: int, tier_map_str: str) -> str:
     try:
         tier_map = parse_tier_map(tier_map_str)
         tier_map_tuple = tuple((a, b, c) for a, b, c in tier_map)
+        dist_tuple = tuple(dist)
+        folded_tuple = tuple(folded)
 
         # Calculate remaining squids to distribute
         remaining = X - sum(dist)
 
         # Get unforced expected values (full random assignment)
         get_expected_value.cache_clear()
-        unforced_ev = get_expected_value(tuple(dist), remaining, tier_map_tuple)
+        unforced_ev = get_expected_value(dist_tuple, remaining, tier_map_tuple, folded_tuple)
 
         result = "Unforced Expected Values:\n"
         for i, ev in enumerate(unforced_ev):
-            result += f"Player {i+1}: {ev:.3f}\n"
+            player_status = "(Folded)" if folded[i] == 1 else ""
+            result += f"Player {i+1}: {ev:.3f} {player_status}\n"
 
         # Compute each player's forced win/lose EV extremes:
-        win_lose_results = compute_ev_win_lose_two_extremes(tuple(dist), remaining, tier_map_tuple)
+        win_lose_results = compute_ev_win_lose_two_extremes(dist_tuple, remaining, tier_map_tuple, folded_tuple)
 
-        result += "\nForced Win/Lose Results:\n"
+        result += "\nForced Win/Lose Results (for non-folded players):\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")
@@ -98,13 +122,18 @@ def solve_game(distribution: str, total_squids: int, tier_map_str: str) -> str:
     except Exception as e:
         return f"Error occurred: {str(e)}"
 
-def solve_finite_game(distribution: str, total_squids: int) -> str:
+def solve_finite_game(distribution: str, folded_players_str: str, total_squids: int) -> str:
     """Calculate the Expected Value (EV) for each player in the finite variant using tuple-based state."""
     # Validate distribution
     valid_dist, error_msg, dist = validate_distribution(distribution)
     if not valid_dist:
         return error_msg
 
+    # Validate folded players
+    valid_folded, error_msg, folded = validate_folded_players(folded_players_str, len(dist))
+    if not valid_folded:
+        return error_msg
+
     # Validate finite variant rules
     if any(x > 1 for x in dist):
         return "Error: In the finite variant, players can only have 0 or 1 squid."
@@ -123,35 +152,34 @@ def solve_finite_game(distribution: str, total_squids: int) -> str:
         return "Total squids must be an integer."
 
     try:
-        # 清理新函数的缓存
         get_expected_value_finite.cache_clear()
         
         remaining = X - sum(dist)
-        dist_tuple = tuple(dist) # 使用元组作为状态
+        dist_tuple = tuple(dist)
+        folded_tuple = tuple(folded)
         
-        # 导入内部函数用于判断终局
         from squid_game_core import _is_terminal_finite, _compute_final_payout_finite_tuple
         
-        # 如果游戏已经结束，直接计算终局收益
-        if _is_terminal_finite(dist_tuple, remaining):
+        if _is_terminal_finite(dist_tuple, remaining, folded_tuple):
             final_payoffs = _compute_final_payout_finite_tuple(dist_tuple)
             result = "Finite Squid Game Final Payouts:\n(Game has ended or no squids left)\n\n"
             for i, payoff in enumerate(final_payoffs):
-                result += f"Player {i+1}: {payoff:.4f}\n"
+                player_status = "(Folded)" if folded[i] == 1 else ""
+                result += f"Player {i+1}: {payoff:.4f} {player_status}\n"
             return result
 
-        # 计算基础EV和Forced Win/Lose EV
-        base_ev, win_lose_results = compute_ev_win_lose_finite_tuple(dist_tuple, remaining)
+        base_ev, win_lose_results = compute_ev_win_lose_finite_tuple(dist_tuple, remaining, folded_tuple)
         
         result = "Finite Squid Game Expected Value (EV):\n"
         result += "(Payout Rule: Losers pay for all winners' squids)\n\n"
         
         result += "Baseline EV (fully random):\n"
         for i, ev in enumerate(base_ev):
-            result += f"Player {i+1}: {ev:.4f}\n"
+            player_status = "(Folded)" if folded[i] == 1 else ""
+            result += f"Player {i+1}: {ev:.4f} {player_status}\n"
 
         if win_lose_results:
-            result += "\nForced Win/Lose EV (for players without a squid):\n"
+            result += "\nForced Win/Lose EV (for players without a squid who haven't folded):\n"
             for r in win_lose_results:
                 result += (f"Player {r['player']+1}: forcedWinEV = {r['forcedWinEV']:.4f}, "
                            f"forcedLoseEV = {r['forcedLoseEV']:.4f}, Diff = {r['difference']:.4f}\n")
@@ -237,12 +265,14 @@ with gr.Blocks(title="Squid Game Calculator") as iface:
                 placeholder="0,0",
                 value="0,0",
                 info="""Enter each player's current squids, separated by commas.
-    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"""
+    Example: '1,0,1,2,0' represents 5 players."""
+            )
+            folded_players_input = gr.Textbox(
+                label="Folded Players (0 = Playing, 1 = Folded)",
+                placeholder="0,0",
+                value="0,0",
+                info="""Enter 0 for playing, 1 for folded. Must match the number of players.
+    Example: '0,0,1,0,0' means Player 3 has folded and won't receive any more squids."""
             )
             total_squids_input = gr.Number(
                 label="Total Squids in Game (Classic & Finite Variants Only)",
@@ -258,20 +288,11 @@ with gr.Blocks(title="Squid Game Calculator") as iface:
                 value=DEFAULT_TIER_MAP,
                 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"""
+    Format: range:multiplier (one per line)"""
             )
         
         with gr.Column():
-            results_output = gr.Textbox(label="Results", lines=15)
+            results_output = gr.Textbox(label="Results", lines=20)
             
             with gr.Row():
                 classic_btn = gr.Button("Calculate Classic Variant", variant="primary")
@@ -280,22 +301,22 @@ with gr.Blocks(title="Squid Game Calculator") as iface:
             
             gr.Examples(
                 examples=[
-                    ["0,0", 9, DEFAULT_TIER_MAP],
-                    ["1,0,1", 12, DEFAULT_TIER_MAP],
-                    ["2,0,2,0", 14, DEFAULT_TIER_MAP],
+                    ["0,0", "0,0", 9, DEFAULT_TIER_MAP],
+                    ["1,0,1", "0,0,0", 12, DEFAULT_TIER_MAP],
+                    ["2,0,2,0", "0,1,0,0", 14, DEFAULT_TIER_MAP],
                 ],
-                inputs=[distribution_input, total_squids_input, tier_map_input],
+                inputs=[distribution_input, folded_players_input, total_squids_input, tier_map_input],
             )
     
     classic_btn.click(
         fn=solve_game,
-        inputs=[distribution_input, total_squids_input, tier_map_input],
+        inputs=[distribution_input, folded_players_input, total_squids_input, tier_map_input],
         outputs=results_output
     )
     
     finite_btn.click(
         fn=solve_finite_game,
-        inputs=[distribution_input, total_squids_input],
+        inputs=[distribution_input, folded_players_input, total_squids_input],
         outputs=results_output
     )
     

squid_game_core.py

@@ -139,7 +139,8 @@ def get_expected_value_forced_lose(
     i, 
     distribution, 
     leftover, 
-    tier_map_tuple
+    tier_map_tuple,
+    folded_players
 ):
     """
     假设下一只乌贼 100% 不会给玩家 i，
@@ -161,7 +162,7 @@ def get_expected_value_forced_lose(
     # Probability = 1/(n-1)
 
     accumulated = [0.0]*n
-    valid_winners = [w for w in range(n) if w != i]
+    valid_winners = [w for w in range(n) if (w != i and not folded_players[w])]
 
     for w in valid_winners:
         dist_next = list(distribution)
@@ -176,7 +177,7 @@ def get_expected_value_forced_lose(
 
     return tuple(accumulated)
 
-def compute_ev_win_lose_two_extremes(distribution, leftover, tier_map_tuple):
+def compute_ev_win_lose_two_extremes(distribution, leftover, tier_map_tuple,folded_players):
     """
     返回一个数据结构,记录每个玩家 i 在:
       - forced_win    时的期望收益
@@ -188,7 +189,7 @@ def compute_ev_win_lose_two_extremes(distribution, leftover, tier_map_tuple):
 
     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)
+        forced_lose_vec = get_expected_value_forced_lose(i, distribution, leftover, tier_map_tuple,folded_players)
 
         # 我们可能只关心玩家 i 本人的比较, 也可以把全部人都算,
         # 这里演示只关心 i
@@ -394,7 +395,7 @@ def get_expected_value_finite_forced_win(i, distribution, remaining):
     # 在新状态上进行完全随机的EV计算
     return get_expected_value_finite(tuple(new_dist_list), remaining - 1)
 
-def get_expected_value_finite_forced_lose(i, distribution, remaining):
+def get_expected_value_finite_forced_lose(i, distribution, remaining,folded_players):
     """
     (模仿 get_expected_value_forced_lose)
     假设下一个鱿鱼 100% 不会给玩家 i。
@@ -407,7 +408,7 @@ def get_expected_value_finite_forced_lose(i, distribution, remaining):
     accumulated_ev = [0.0] * n
     
     # 找出除了i之外所有合格的候选人
-    eligible_players = [p for p, count in enumerate(distribution) if p != i]
+    eligible_players = [p for p, count in enumerate(distribution) if (p != i and not folded_players[p])]
     num_eligible = len(eligible_players)
     
     if num_eligible == 0: # 如果除了i没有别人可选了，游戏结束
@@ -432,7 +433,7 @@ def get_expected_value_finite_forced_lose(i, distribution, remaining):
         
     return tuple(accumulated_ev)
 
-def compute_ev_win_lose_finite_tuple(distribution, remaining):
+def compute_ev_win_lose_finite_tuple(distribution, remaining,folded_players):
     """
     包装函数，为每个合格玩家计算 forced_win 和 forced_lose 的EV。
     """
@@ -445,7 +446,7 @@ def compute_ev_win_lose_finite_tuple(distribution, remaining):
 
     for i in eligible_players:
         win_ev_vec = get_expected_value_finite_forced_win(i, distribution, remaining)
-        lose_ev_vec = get_expected_value_finite_forced_lose(i, distribution, remaining)
+        lose_ev_vec = get_expected_value_finite_forced_lose(i, distribution, remaining,folded_players)
         
         forced_win_i = win_ev_vec[i]
         forced_lose_i = lose_ev_vec[i]