Upload folder using huggingface_hub

.gradio/certificate.pem

@@ -0,0 +1,31 @@
+-----BEGIN CERTIFICATE-----
+MIIFazCCA1OgAwIBAgIRAIIQz7DSQONZRGPgu2OCiwAwDQYJKoZIhvcNAQELBQAw
+TzELMAkGA1UEBhMCVVMxKTAnBgNVBAoTIEludGVybmV0IFNlY3VyaXR5IFJlc2Vh
+cmNoIEdyb3VwMRUwEwYDVQQDEwxJU1JHIFJvb3QgWDEwHhcNMTUwNjA0MTEwNDM4
+WhcNMzUwNjA0MTEwNDM4WjBPMQswCQYDVQQGEwJVUzEpMCcGA1UEChMgSW50ZXJu
+ZXQgU2VjdXJpdHkgUmVzZWFyY2ggR3JvdXAxFTATBgNVBAMTDElTUkcgUm9vdCBY
+MTCCAiIwDQYJKoZIhvcNAQEBBQADggIPADCCAgoCggIBAK3oJHP0FDfzm54rVygc
+h77ct984kIxuPOZXoHj3dcKi/vVqbvYATyjb3miGbESTtrFj/RQSa78f0uoxmyF+
+0TM8ukj13Xnfs7j/EvEhmkvBioZxaUpmZmyPfjxwv60pIgbz5MDmgK7iS4+3mX6U
+A5/TR5d8mUgjU+g4rk8Kb4Mu0UlXjIB0ttov0DiNewNwIRt18jA8+o+u3dpjq+sW
+T8KOEUt+zwvo/7V3LvSye0rgTBIlDHCNAymg4VMk7BPZ7hm/ELNKjD+Jo2FR3qyH
+B5T0Y3HsLuJvW5iB4YlcNHlsdu87kGJ55tukmi8mxdAQ4Q7e2RCOFvu396j3x+UC
+B5iPNgiV5+I3lg02dZ77DnKxHZu8A/lJBdiB3QW0KtZB6awBdpUKD9jf1b0SHzUv
+KBds0pjBqAlkd25HN7rOrFleaJ1/ctaJxQZBKT5ZPt0m9STJEadao0xAH0ahmbWn
+OlFuhjuefXKnEgV4We0+UXgVCwOPjdAvBbI+e0ocS3MFEvzG6uBQE3xDk3SzynTn
+jh8BCNAw1FtxNrQHusEwMFxIt4I7mKZ9YIqioymCzLq9gwQbooMDQaHWBfEbwrbw
+qHyGO0aoSCqI3Haadr8faqU9GY/rOPNk3sgrDQoo//fb4hVC1CLQJ13hef4Y53CI
+rU7m2Ys6xt0nUW7/vGT1M0NPAgMBAAGjQjBAMA4GA1UdDwEB/wQEAwIBBjAPBgNV
+HRMBAf8EBTADAQH/MB0GA1UdDgQWBBR5tFnme7bl5AFzgAiIyBpY9umbbjANBgkq
+hkiG9w0BAQsFAAOCAgEAVR9YqbyyqFDQDLHYGmkgJykIrGF1XIpu+ILlaS/V9lZL
+ubhzEFnTIZd+50xx+7LSYK05qAvqFyFWhfFQDlnrzuBZ6brJFe+GnY+EgPbk6ZGQ
+3BebYhtF8GaV0nxvwuo77x/Py9auJ/GpsMiu/X1+mvoiBOv/2X/qkSsisRcOj/KK
+NFtY2PwByVS5uCbMiogziUwthDyC3+6WVwW6LLv3xLfHTjuCvjHIInNzktHCgKQ5
+ORAzI4JMPJ+GslWYHb4phowim57iaztXOoJwTdwJx4nLCgdNbOhdjsnvzqvHu7Ur
+TkXWStAmzOVyyghqpZXjFaH3pO3JLF+l+/+sKAIuvtd7u+Nxe5AW0wdeRlN8NwdC
+jNPElpzVmbUq4JUagEiuTDkHzsxHpFKVK7q4+63SM1N95R1NbdWhscdCb+ZAJzVc
+oyi3B43njTOQ5yOf+1CceWxG1bQVs5ZufpsMljq4Ui0/1lvh+wjChP4kqKOJ2qxq
+4RgqsahDYVvTH9w7jXbyLeiNdd8XM2w9U/t7y0Ff/9yi0GE44Za4rF2LN9d11TPA
+mRGunUHBcnWEvgJBQl9nJEiU0Zsnvgc/ubhPgXRR4Xq37Z0j4r7g1SgEEzwxA57d
+emyPxgcYxn/eR44/KJ4EBs+lVDR3veyJm+kXQ99b21/+jh5Xos1AnX5iItreGCc=
+-----END CERTIFICATE-----

.gradio/flagged/dataset1.csv

@@ -0,0 +1,8 @@
+Number of Players (N),Total Squids (X),Current Distribution (comma-separated),"Tier Mapping (one range per line, e.g. '1:1\n2-4:2\n5-6:4')",Expected Value (Per Player),timestamp
+5,8,"1,0,0,3,0","1:1
+2-4:2
+5-6:4","Player 1: 0.0000
+Player 2: -1.8976
+Player 3: -1.8976
+Player 4: 0.0000
+Player 5: -1.8976",2025-02-07 19:10:39.723545

.pytest_cache/.gitignore

@@ -0,0 +1,2 @@
+# Created by pytest automatically.
+*

.pytest_cache/CACHEDIR.TAG

@@ -0,0 +1,4 @@
+Signature: 8a477f597d28d172789f06886806bc55
+# This file is a cache directory tag created by pytest.
+# For information about cache directory tags, see:
+#	https://bford.info/cachedir/spec.html

.pytest_cache/README.md

@@ -0,0 +1,8 @@
+# pytest cache directory #
+
+This directory contains data from the pytest's cache plugin,
+which provides the `--lf` and `--ff` options, as well as the `cache` fixture.
+
+**Do not** commit this to version control.
+
+See [the docs](https://docs.pytest.org/en/stable/how-to/cache.html) for more information.

.pytest_cache/v/cache/nodeids

@@ -0,0 +1,9 @@
+[
+  "test_squid_game.py::test_case1",
+  "test_squid_game.py::test_case2",
+  "test_squid_game.py::test_case3",
+  "test_squid_game.py::test_case4",
+  "test_squid_game.py::test_case5",
+  "test_squid_game.py::test_case6",
+  "test_squid_game.py::test_case7"
+]

.pytest_cache/v/cache/stepwise

@@ -0,0 +1 @@
+[]

README.md

@@ -1,12 +1,6 @@
 ---
-title: Squidgame
-emoji: 💻
-colorFrom: yellow
-colorTo: gray
+title: squidgame
+app_file: squid_game.py
 sdk: gradio
 sdk_version: 5.15.0
-app_file: app.py
-pinned: false
 ---
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference

squid_game.py

@@ -0,0 +1,201 @@
+import gradio as gr
+from functools import lru_cache
+
+# 1) Define a function to parse user input for the tier multipliers.
+#    For simplicity, we'll ask them to enter threshold -> multiplier lines, e.g.:
+#        1:1
+#        2-4:2
+#        5-6:4
+def parse_tier_map(tier_str):
+    """
+    tier_str is something like:
+        "1:1\n2-4:2\n5-6:4\n7-10:8"
+    We'll return a list of tuples [(min_k, max_k, multiplier), ...]
+    in ascending order. Or any structure you prefer.
+    """
+    lines = tier_str.strip().splitlines()
+    tier_map = []
+    for line in lines:
+        # e.g. "2-4:2"
+        # split by ':'
+        range_part, mult_part = line.split(":")
+        multiplier = float(mult_part.strip())
+        
+        # check if range_part has '-'
+        if '-' in range_part:
+            min_k_str, max_k_str = range_part.split('-')
+            min_k, max_k = int(min_k_str), int(max_k_str)
+        else:
+            # single value
+            min_k = max_k = int(range_part.strip())
+        tier_map.append((min_k, max_k, multiplier))
+    
+    # Optionally sort by min_k
+    tier_map.sort(key=lambda x: x[0])
+    return tier_map
+
+def tierMultiplier(k, tier_map):
+    """
+    Given k squids and a tier_map [(min_k, max_k, multiplier), ...],
+    return the appropriate multiplier.
+    If k=0, we can return 0 or skip. 
+    """
+    if k == 0:  # Explicitly handle k=0 case
+        return 0
+        
+    for (low, high, mult) in tier_map:
+        if low <= k <= high:
+            return mult
+    # If k is bigger than any specified range, use the highest multiplier
+    return max(mult for _, _, mult in tier_map) if tier_map else 0
+
+def is_terminal(distribution, r):
+    """
+    Check if distribution is a terminal state.
+    Condition 1: Exactly one player has 0
+    Condition 2: r == 0 (no more squids).
+    """
+    zero_count = sum(1 for x in distribution if x == 0)
+    if zero_count == 1:
+        return True
+    if r == 0:
+        return True
+    return False
+
+def compute_final_payout(distribution, tier_map):
+    """
+    Compute final payoffs in a terminal state.
+    If exactly one 0-squid player -> that player pays sum of all others' multipliers.
+    If multiple 0-squid players when r=0, they share cost proportionally (here equally).
+    """
+    n = len(distribution)
+    zero_indices = [i for i,x in enumerate(distribution) if x == 0]
+    m = len(zero_indices)  # number of zero-squid players
+    
+    # sum of multipliers for all non-zero players
+    total_cost = sum(tierMultiplier(x, tier_map) for x in distribution if x > 0)
+    
+    payouts = [0.0]*n
+    
+    if m == 0:
+        # No zero-squid players => no cost
+        return payouts
+    elif m == 1:
+        # Exactly one zero player
+        i_zero = zero_indices[0]
+        payouts[i_zero] = -float(total_cost)
+        return payouts
+    else:
+        # Multiple zero players share the cost
+        portion = float(total_cost) / m
+        for i in zero_indices:
+            payouts[i] = -portion
+        return payouts
+
+@lru_cache(None)
+def get_expected_value(distribution, r, tier_map_tuple):
+    """
+    Memoized function returning the EV vector (size N) for state=(distribution, r).
+    tier_map_tuple is a tuple-ified version of the tier map so it's hashable for caching.
+    """
+    distribution = tuple(distribution)
+    
+    # Terminal check
+    if is_terminal(distribution, r):
+        return tuple(compute_final_payout(distribution, tier_map_tuple))
+    
+    n = len(distribution)
+    # We'll accumulate the EV in an array and then average
+    accumulated_ev = [0.0]*n
+    
+    for winner in range(n):
+        new_dist = list(distribution)
+        new_dist[winner] += 1  # winner gets a squid
+        
+        sub_ev = get_expected_value(tuple(new_dist), r - 1, tier_map_tuple)
+        for i in range(n):
+            accumulated_ev[i] += sub_ev[i]
+    
+    # Average (each with probability 1/n)
+    for i in range(n):
+        accumulated_ev[i] /= n
+    
+    return tuple(accumulated_ev)
+
+def compute_ev(num_players, total_squids, current_distribution_str, tier_map_str):
+    """
+    Main function called by Gradio. 
+    - num_players (N)
+    - total_squids (X)
+    - current_distribution_str: user enters e.g. "1,0,1,2,0"
+    - tier_map_str: user enters e.g. "1:1\n2-4:2\n5-6:4"
+    Returns: string representation of EV for each player.
+    """
+    try:
+        # 1) Parse distribution
+        distribution_list = [int(x.strip()) for x in current_distribution_str.split(",")]
+        # Basic check
+        if len(distribution_list) != num_players:
+            return f"Error: distribution length ({len(distribution_list)}) must match number of players ({num_players})!"
+        
+        # 2) Parse tier map
+        parsed_tiers = parse_tier_map(tier_map_str)
+        # We'll store it in a hashable structure (tuple of tuples) for memoization
+        tier_map_tuple = tuple(parsed_tiers)
+        
+        # 3) Remaining squids
+        current_sum = sum(distribution_list)
+        if current_sum > total_squids:
+            return f"Error: distribution sum ({current_sum}) exceeds total squids ({total_squids})."
+        r = total_squids - current_sum
+        
+        # 4) Clear the cache each time we do a new computation 
+        get_expected_value.cache_clear()
+        
+        # 5) Compute EV
+        ev_result = get_expected_value(tuple(distribution_list), r, tier_map_tuple)
+        
+        # 6) Format output
+        output_lines = []
+        for i, val in enumerate(ev_result):
+            output_lines.append(f"Player {i+1}: {val:.4f}")
+        return "\n".join(output_lines)
+    except Exception as e:
+        return f"Error: {str(e)}"
+
+### Gradio Interface Definition
+
+def build_interface():
+    # Define inputs
+    num_players_input = gr.Number(label="Number of Players (N)", value=5, precision=0)
+    total_squids_input = gr.Number(label="Total Squids (X)", value=8, precision=0)
+    distribution_input = gr.Textbox(
+        label="Current Distribution (comma-separated)",
+        value="1,0,1,2,0"  # example
+    )
+    tiermap_input = gr.Textbox(
+        label="Tier Mapping (one range per line, e.g. '1:1\\n2-4:2\\n5-6:4')",
+        value="1:1\n2-4:2\n5-6:4"
+    )
+    
+    # Define output
+    result_output = gr.Textbox(label="Expected Value (Per Player)", lines=6)
+    
+    # Define the interface
+    iface = gr.Interface(
+        fn=compute_ev,
+        inputs=[num_players_input, total_squids_input, distribution_input, tiermap_input],
+        outputs=result_output,
+        title="Texas Hold'em Squid Game EV Calculator",
+        description=(
+            "Enter the number of players, total squids, current distribution, and your tier map. "
+            "Click Submit to compute each player's Expected Value (EV) from this state."
+        )
+    )
+    
+    return iface
+
+# If running as a script, you can just do:
+if __name__ == "__main__":
+    iface = build_interface()
+    iface.launch(share=True)

test_squid_game.py

@@ -0,0 +1,111 @@
+# test_squid_game.py
+
+import pytest
+from functools import lru_cache
+from math import isclose
+
+# Suppose your solver is in 'squid_game.py'
+from squid_game import get_expected_value
+
+@pytest.fixture
+def test_tier_map():
+    """
+    A simple tier map for these tests:
+      0 -> 0
+      1 -> 1
+      2 -> 2
+      3+ -> 2  (for simplicity)
+    We'll store it in tuple form: ( (min_k, max_k, multiplier), ... )
+    """
+    # You can adapt if you prefer 3 -> multiplier=3. Just be consistent.
+    return (
+        (0,0,0.0),
+        (1,1,1.0),
+        (2,2,2.0),
+        (3,10000,2.0),  # anything >=3 => 2
+    )
+
+def nearly_equal(a, b, tol=1e-9):
+    return isclose(a, b, abs_tol=tol)
+
+def test_case1(test_tier_map):
+    # N=2, X=1, dist=(0,0) => EV = (-0.5, -0.5)
+    dist = (0,0)
+    X = 1
+    r = X - sum(dist)
+    get_expected_value.cache_clear()
+    ev = get_expected_value(dist, r, tier_map_tuple=test_tier_map)
+    assert len(ev) == 2
+    assert nearly_equal(ev[0], -0.5)
+    assert nearly_equal(ev[1], -0.5)
+
+def test_case2(test_tier_map):
+    # N=2, X=2, dist=(0,0) => EV = (-0.5, -0.5)
+    dist = (0,0)
+    X = 2
+    r = X - sum(dist)
+    get_expected_value.cache_clear()
+    ev = get_expected_value(dist, r, tier_map_tuple=test_tier_map)
+    assert len(ev) == 2
+    assert nearly_equal(ev[0], -0.5)
+    assert nearly_equal(ev[1], -0.5)
+
+def test_case3(test_tier_map):
+    # N=2, X=2, dist=(1,0) => terminal => payoff = (0, -1)
+    # because there's exactly one zero-squid player at start.
+    dist = (1,0)
+    X = 2
+    r = X - sum(dist)
+    get_expected_value.cache_clear()
+    ev = get_expected_value(dist, r, tier_map_tuple=test_tier_map)
+    assert len(ev) == 2
+    assert nearly_equal(ev[0], 0.0)
+    assert nearly_equal(ev[1], -1.0)
+
+def test_case4(test_tier_map):
+    # N=3, X=3, dist=(0,0,3) => multiple zero => final => cost= tier(3)=2 => each zero pays -1 => (-1, -1, 0)
+    dist = (0,0,3)
+    X = 3
+    r = X - sum(dist)
+    get_expected_value.cache_clear()
+    ev = get_expected_value(dist, r, tier_map_tuple=test_tier_map)
+    assert len(ev) == 3
+    assert nearly_equal(ev[0], -1.0)
+    assert nearly_equal(ev[1], -1.0)
+    assert nearly_equal(ev[2],  0.0)
+
+def test_case5(test_tier_map):
+    # N=3, X=2, dist=(0,1,1) => one zero => final => cost= tier(1)+tier(1)=1+1=2 => p1=-2, p2=0, p3=0
+    dist = (0,1,1)
+    X = 2
+    r = X - sum(dist)
+    get_expected_value.cache_clear()
+    ev = get_expected_value(dist, r, tier_map_tuple=test_tier_map)
+    assert len(ev) == 3
+    assert nearly_equal(ev[0], -2.0)
+    assert nearly_equal(ev[1],  0.0)
+    assert nearly_equal(ev[2],  0.0)
+
+def test_case6(test_tier_map):
+    # N=3, X=2, dist=(1,0,1) => one zero => cost=2 => payoff= (0, -2, 0)
+    dist = (1,0,1)
+    X = 2
+    r = X - sum(dist)
+    get_expected_value.cache_clear()
+    ev = get_expected_value(dist, r, tier_map_tuple=test_tier_map)
+    assert len(ev) == 3
+    assert nearly_equal(ev[0],  0.0)
+    assert nearly_equal(ev[1], -2.0)
+    assert nearly_equal(ev[2],  0.0)
+
+def test_case7(test_tier_map):
+    # N=2, X=3, dist=(1,1) => not terminal => 1 leftover => final => either (2,1) or (1,2) => no zero => payoff=(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=test_tier_map)
+    assert len(ev) == 2
+    # Both outcomes => no zero => payoff= (0,0) with probability 1 => EV=(0,0)
+    assert nearly_equal(ev[0], 0.0)
+    assert nearly_equal(ev[1], 0.0)