Upload folder using huggingface_hub

squid_game.py

@@ -3,6 +3,9 @@ from squid_game_core import (
     parse_tier_map,
     get_expected_value,
     compute_ev_win_lose_two_extremes,
+    finite_squid_game_probabilities,
+    dp_ev,
+    infinite_squid_game_expected_counts_partial,
 )
 from typing import List, Tuple
 
@@ -93,6 +96,100 @@ 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:
+    """Calculate the probability of each player getting a squid in the finite variant"""
+    # Validate distribution
+    valid_dist, error_msg, dist = validate_distribution(distribution)
+    if not valid_dist:
+        return error_msg
+
+    # Validate that no player has more than 1 squid (finite variant rule)
+    if any(x > 1 for x in dist):
+        return "Error: In the finite variant, players can only have 0 or 1 squid. Please adjust your input."
+
+    # Validate total squids
+    try:
+        X = int(total_squids)
+        if X < 0:
+            return "Total squids cannot be negative"
+        
+        # Check if total squids exceeds number of players
+        if X > len(dist):
+            return f"Error: In the finite variant, total squids cannot exceed the number of players ({len(dist)})"
+            
+        # Check if remaining squids + already distributed squids exceeds number of players
+        current_sum = sum(dist)
+        if current_sum + (X - current_sum) > len(dist):
+            return f"Error: Total squids to distribute ({X}) plus already distributed squids ({current_sum}) cannot exceed the number of players ({len(dist)})"
+    except ValueError:
+        return "Total squids must be an integer"
+
+    try:
+        # Clear cache for new calculation
+        dp_ev.cache_clear()
+        
+        # Calculate probabilities using the finite variant
+        n = len(dist)  # Number of players
+        
+        # Calculate remaining squids to distribute
+        remaining = X - sum(dist)
+        
+        # Create bitmask for players who already have squids
+        bitmask_u = (1 << n) - 1  # Start with all 1s
+        for i, val in enumerate(dist):
+            if val == 1:  # If player already has a squid
+                bitmask_u ^= (1 << i)  # Set bit to 0
+        
+        # Calculate probabilities
+        probs = dp_ev(n, bitmask_u, remaining)
+        
+        result = "Finite Squid Game Probabilities:\n"
+        result += "(Probability of each player getting a squid)\n\n"
+        
+        for i, prob in enumerate(probs):
+            result += f"Player {i+1}: {prob:.4f}\n"
+            
+        return result
+        
+    except Exception as e:
+        return f"Error occurred: {str(e)}"
+
+def solve_infinite_game(distribution: str) -> str:
+    """Calculate the expected final squid count for each player in the infinite variant"""
+    # Validate distribution
+    valid_dist, error_msg, dist = validate_distribution(distribution)
+    if not valid_dist:
+        return error_msg
+
+    try:
+        # Calculate expected final counts
+        expected_counts = infinite_squid_game_expected_counts_partial(dist)
+        
+        result = "Infinite Squid Game Expected Final Counts:\n"
+        result += "(Expected number of squids each player will have at the end)\n\n"
+        
+        for i, count in enumerate(expected_counts):
+            if count == float('inf'):
+                result += f"Player {i+1}: ∞ (infinite)\n"
+            else:
+                result += f"Player {i+1}: {count:.4f}\n"
+        
+        # Add explanation based on zero count
+        zero_count = sum(1 for x in dist if x == 0)
+        if zero_count == 1:
+            result += "\nExplanation: Game ends immediately as there is exactly one player with 0 squids."
+        elif zero_count == 0:
+            result += "\nExplanation: Game never ends (infinite loop) as there are no players with 0 squids."
+        else:
+            H_z = sum(1.0 / k for k in range(1, zero_count+1))
+            increment = (H_z - 1.0)
+            result += f"\nExplanation: Each player is expected to receive {increment:.4f} additional squids before the game ends."
+            
+        return result
+        
+    except Exception as e:
+        return f"Error occurred: {str(e)}"
+
 # Default value for tier map used in interface
 DEFAULT_TIER_MAP = """0-0:0
 1-2:1
@@ -103,64 +200,103 @@ DEFAULT_TIER_MAP = """0-0:0
 9-9:32
 10-100:64"""
 
-iface = gr.Interface(
-    fn=solve_game,
-    inputs=[
-        gr.Textbox(
-            label="Players' Current Squids",
-            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"""
-        ),
-        gr.Number(
-            label="Total Squids in Game",
-            value=9,
-            minimum=0,
-            step=1,
-            precision=0,
-            info="The total number of squids to be distributed (must be ≥ sum of current squids)"
-        ),
-        gr.Textbox(
-            label="Squid Value Tiers",
-            placeholder=DEFAULT_TIER_MAP,
-            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"""
-        )
-    ],
-    outputs=gr.Textbox(label="Results", lines=15),
-    title="Squid Game Expected Value Calculator",
-    description="""
+with gr.Blocks(title="Squid Game Calculator") as iface:
+    gr.Markdown("""
+    # Squid Game Expected Value Calculator
+    
     Calculate the expected payoff for each player in the Squid Game.
-
-    Rules:
+    
+    **Classic Variant 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=[
-        ["0,0", 9, DEFAULT_TIER_MAP],
-        ["1,0,1", 12, DEFAULT_TIER_MAP],
-        ["2,0,2,0", 14, DEFAULT_TIER_MAP],
-    ]
-)
+       
+    **Finite Variant Rules:**
+    1. Players take turns collecting squids randomly.
+    2. Once a player gets a squid, they can't get another one.
+    3. The game ends when all squids are distributed or only one player remains without a squid.
+    
+    **Infinite Variant Rules:**
+    1. Players take turns collecting squids randomly (unlimited supply).
+    2. Players accumulate squids over time.
+    3. The game ends only when exactly one player has 0 squids.
+    """)
+    
+    with gr.Row():
+        with gr.Column():
+            distribution_input = gr.Textbox(
+                label="Players' Current Squids",
+                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"""
+            )
+            total_squids_input = gr.Number(
+                label="Total Squids in Game (Classic & Finite Variants Only)",
+                value=9,
+                minimum=0,
+                step=1,
+                precision=0,
+                info="The total number of squids to be distributed (must be ≥ sum of current squids for classic variant)"
+            )
+            tier_map_input = gr.Textbox(
+                label="Squid Value Tiers (Classic Variant Only)",
+                placeholder=DEFAULT_TIER_MAP,
+                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"""
+            )
+        
+        with gr.Column():
+            results_output = gr.Textbox(label="Results", lines=15)
+            
+            with gr.Row():
+                classic_btn = gr.Button("Calculate Classic Variant", variant="primary")
+                finite_btn = gr.Button("Calculate Finite Variant", variant="stop")
+                infinite_btn = gr.Button("Calculate Infinite Variant", variant="secondary")
+            
+            gr.Examples(
+                examples=[
+                    ["0,0", 9, DEFAULT_TIER_MAP],
+                    ["1,0,1", 12, DEFAULT_TIER_MAP],
+                    ["2,0,2,0", 14, DEFAULT_TIER_MAP],
+                ],
+                inputs=[distribution_input, total_squids_input, tier_map_input],
+            )
+    
+    classic_btn.click(
+        fn=solve_game,
+        inputs=[distribution_input, total_squids_input, tier_map_input],
+        outputs=results_output
+    )
+    
+    finite_btn.click(
+        fn=solve_finite_game,
+        inputs=[distribution_input, total_squids_input],
+        outputs=results_output
+    )
+    
+    infinite_btn.click(
+        fn=solve_infinite_game,
+        inputs=[distribution_input],
+        outputs=results_output
+    )
 
 if __name__ == "__main__":
-    iface.launch() 
+    iface.launch()

squid_game_core.py

@@ -1,6 +1,7 @@
 # squid_game.py
 
 from functools import lru_cache
+import math
 
 def parse_tier_map(tier_str: str):
     """
@@ -204,3 +205,99 @@ def compute_ev_win_lose_two_extremes(distribution, leftover, tier_map_tuple):
             'difference': diff_i
         })
     return results
+
+# Infinite Squid Game Implementation
+def infinite_squid_game_expected_counts_partial(distribution):
+    """
+    For the "infinite squid + cumulative score, stop when only 1 player has 0" game,
+    given the current distribution (list/tuple, representing each player's current count),
+    returns a list representing the expected number of squids each player will have at the end of the game.
+    
+    Rule summary:
+      - If the current number of players with 0 squids = z:
+        * z=1 => Game stops immediately, no more squids distributed => final value = current holdings
+        * z=0 => "Exactly 1 player with 0" can never occur, infinite loop => return inf
+        * z>=2 => Expected to distribute n*(H_z -1) more times (H_z=1+1/2+...+1/z),
+                  Expected number of times each player is selected = (H_z-1),
+                  Therefore final = distribution[i] + (H_z-1).
+    """
+    n = len(distribution)
+    zero_count = sum(1 for x in distribution if x == 0)
+    
+    # Already satisfied or exceeded "end/cannot end" condition
+    if zero_count == 1:
+        # Game ends immediately => maintain current state
+        return list(distribution)
+    if zero_count == 0:
+        # "Exactly 1 player with 0" can never occur => game never ends => infinite score
+        return [math.inf]*n
+    
+    # zero_count >= 2 => continue distributing squids until z=1
+    H_z = sum(1.0 / k for k in range(1, zero_count+1))  # Harmonic number H_z
+    increment = (H_z - 1.0)
+    return [x + increment for x in distribution]
+
+# Finite Squid Game Implementation
+def get_bitmask(n):
+    """
+    Returns a list [0,1,2,...,(1<<n)-1], purely for iteration reference
+    """
+    return list(range(1 << n))
+
+def count_ones(x):
+    """Count how many 1s are in the binary representation of x"""
+    return bin(x).count("1")
+
+@lru_cache(None)
+def dp_ev(n, bitmask_u, leftover):
+    """
+    Returns a length-n tuple (prob0, prob1, ..., prob_{n-1}),
+    representing the "final probability" of each player getting a squid in state (U=bitmask_u, leftover).
+    
+    - n: total number of players
+    - bitmask_u: which players haven't received a squid yet (binary mask)
+    - leftover: remaining squids that can be distributed
+    """
+    # 1) Terminal condition
+    num_u = count_ones(bitmask_u)  # Number of players who haven't received a squid yet
+    if num_u <= 1 or leftover == 0:
+        # Game ends immediately
+        # For players who already have a squid, their probability=1
+        # For those who don't, probability=0
+        ret = []
+        for i in range(n):
+            # If i is in bitmask_u => probability=0, otherwise =1
+            if (bitmask_u & (1 << i)) != 0:
+                ret.append(0.0)
+            else:
+                ret.append(1.0)
+        return tuple(ret)
+    
+    # 2) Not terminated => randomly select 1 person from U to give a squid
+    ret_accum = [0.0]*n
+    # Randomly select w from U with equal probability
+    for w in range(n):
+        bit_w = (1 << w)
+        if (bitmask_u & bit_w) != 0:
+            # w is in U
+            # Next state: after w gets a squid, remove w from bitmask
+            next_u = bitmask_u ^ bit_w  # Set to 0
+            sub_ev = dp_ev(n, next_u, leftover - 1)
+            
+            for i in range(n):
+                ret_accum[i] += sub_ev[i] / num_u
+    
+    # 3) Return accumulated result
+    return tuple(ret_accum)
+
+def finite_squid_game_probabilities(n, r):
+    """
+    Returns a length-n probability vector: prob[i] = probability of player i getting a squid
+    Based on dp_ev().
+    
+    - n: number of players
+    - r: number of squids to distribute
+    """
+    # Initial U = (1<<n)-1, meaning no one has a squid yet
+    bitmask_u = (1 << n) - 1
+    return dp_ev(n, bitmask_u, r)