Upload folder using huggingface_hub

bench/gradio_app/app.py

@@ -121,25 +121,28 @@ def _filter_game_names(category_tag):
     return sorted(_KEY_TO_NAME[k] for k in matching_keys if k in _KEY_TO_NAME)
 
 # ---------------------------------------------------------------------------
-# Inline 2-player strategies
+# 2-player strategies (from the real strategy registry)
 # ---------------------------------------------------------------------------
-def _strat_random(actions, _h):
-    return _rand.choice(actions)
-
-def _strat_first(actions, _h):
-    return actions[_ZERO]
-
-def _strat_last(actions, _h):
-    return actions[min(_ONE, len(actions) - _ONE)]
-
-def _strat_tft(actions, h):
-    if not h:
+try:
+    from common.strategies import STRATEGIES as _STRAT_REGISTRY
+    STRATEGIES_2P = _STRAT_REGISTRY
+    _HAS_FULL_STRATEGIES = True
+except ImportError:
+    # Minimal fallback
+    def _strat_random(actions, _h):
+        return _rand.choice(actions)
+    def _strat_first(actions, _h):
         return actions[_ZERO]
-    prev = h[_NEG_ONE]["player_action"]
-    return prev if prev in actions else actions[_ZERO]
-
-STRATEGIES_2P = {"random": _strat_random, "always_cooperate": _strat_first,
-                 "always_defect": _strat_last, "tit_for_tat": _strat_tft}
+    def _strat_last(actions, _h):
+        return actions[min(_ONE, len(actions) - _ONE)]
+    def _strat_tft(actions, h):
+        if not h:
+            return actions[_ZERO]
+        prev = h[_NEG_ONE]["player_action"]
+        return prev if prev in actions else actions[_ZERO]
+    STRATEGIES_2P = {"random": _strat_random, "always_cooperate": _strat_first,
+                     "always_defect": _strat_last, "tit_for_tat": _strat_tft}
+    _HAS_FULL_STRATEGIES = False
 
 # N-player strategy names
 _NPLAYER_STRAT_NAMES = list(NPLAYER_STRATEGIES.keys()) if _HAS_NPLAYER_ENV else ["random"]
@@ -256,7 +259,12 @@ def play_round(action_str, state):
             opp_act_list = list(opp_actions)
         else:
             opp_act_list = info["actions"]
-        opp = STRATEGIES_2P[state["strategy"]](opp_act_list, state["history"])
+        strat = STRATEGIES_2P[state["strategy"]]
+        game_type = info.get("game_type", "matrix")
+        if _HAS_FULL_STRATEGIES:
+            opp = strat.choose_action(game_type, opp_act_list, state["history"])
+        else:
+            opp = strat(opp_act_list, state["history"])
         p_pay, o_pay = info["payoff_fn"](action_str, opp)
         state["round"] += _ONE
         state["p_score"] += p_pay

common/games.py

@@ -165,6 +165,8 @@ _PG_CONTRIBUTIONS: list[str] = [
 # Game registry
 # ---------------------------------------------------------------------------
 
+GAME_FACTORIES: dict[str, Callable[[], GameConfig]] = {}
+
 GAMES: dict[str, GameConfig] = {
     "prisoners_dilemma": GameConfig(
         name="Prisoner's Dilemma",
@@ -246,15 +248,21 @@ GAMES: dict[str, GameConfig] = {
 def get_game(name: str) -> GameConfig:
     """Retrieve a GameConfig by its registry key.
 
+    If *name* is in :data:`GAME_FACTORIES`, the factory is called to
+    produce a fresh :class:`GameConfig` with independent mutable state.
+    Otherwise falls back to the static :data:`GAMES` registry.
+
     Args:
-        name: Key in the GAMES registry (e.g. ``"prisoners_dilemma"``).
+        name: Key in GAME_FACTORIES or GAMES.
 
     Returns:
         The corresponding :class:`GameConfig` instance.
 
     Raises:
-        KeyError: If *name* is not present in the registry.
+        KeyError: If *name* is not in either registry.
     """
+    if name in GAME_FACTORIES:
+        return GAME_FACTORIES[name]()
     return GAMES[name]
 
 
@@ -273,6 +281,7 @@ def _load_extensions() -> None:
         "common.games_coop.dynamic", "common.games_coop.pd_variants",
         "common.games_coop.infinite", "common.games_coop.stochastic",
         "common.meta.meta_games",
+        "common.games_adaptive.factories",
     ]:
         try:
             importlib.import_module(mod)

common/games_adaptive/__init__.py

@@ -0,0 +1 @@
+"""Adaptive payoff game factories."""

common/games_adaptive/factories.py

@@ -0,0 +1,192 @@
+"""Adaptive payoff game factories with history-dependent payoff functions."""
+from __future__ import annotations
+from typing import Callable
+from common.games import GameConfig, GAME_FACTORIES, _PD_MATRIX, _HD_MATRIX
+from constant_definitions.game_constants import (
+    TRUST_MULTIPLIER, EVAL_ZERO_FLOAT, EVAL_ONE_FLOAT,
+)
+from constant_definitions.var.meta.adaptive_constants import (
+    ADAPTIVE_PD_MULTIPLIER_MIN_NUMERATOR,
+    ADAPTIVE_PD_MULTIPLIER_MIN_DENOMINATOR,
+    ADAPTIVE_PD_MULTIPLIER_MAX_NUMERATOR,
+    ADAPTIVE_PD_MULTIPLIER_MAX_DENOMINATOR,
+    ADAPTIVE_PD_MULTIPLIER_STEP_NUMERATOR,
+    ADAPTIVE_PD_MULTIPLIER_STEP_DENOMINATOR,
+    ARMS_RACE_COST_STEP_NUMERATOR, ARMS_RACE_COST_STEP_DENOMINATOR,
+    ARMS_RACE_MAX_COST_NUMERATOR, ARMS_RACE_MAX_COST_DENOMINATOR,
+    TRUST_EROSION_DECAY_NUMERATOR, TRUST_EROSION_DECAY_DENOMINATOR,
+    TRUST_EROSION_RECOVERY_NUMERATOR, TRUST_EROSION_RECOVERY_DENOMINATOR,
+    MARKET_DEMAND_SHIFT_NUMERATOR, MARKET_DEMAND_SHIFT_DENOMINATOR,
+    REPUTATION_BONUS_NUMERATOR, REPUTATION_BONUS_DENOMINATOR,
+    ADAPTIVE_DEFAULT_ROUNDS, ADAPTIVE_GAME_TYPE,
+)
+
+_ZERO = int()
+_ONE = int(bool(True))
+_TWO = _ONE + _ONE
+
+# Market dynamics tables
+_MKT_OUT = {"low": _TWO, "medium": _TWO + _TWO, "high": _TWO * _TWO + _TWO}
+_MKT_COST = {"low": _ONE, "medium": _TWO + _ONE, "high": _TWO * _TWO + _TWO}
+_MKT_INTERCEPT = (_TWO + _TWO) * (_TWO + _ONE)
+
+def _adaptive_pd_factory() -> GameConfig:
+    """PD where mutual cooperation increases future payoffs."""
+    min_m = ADAPTIVE_PD_MULTIPLIER_MIN_NUMERATOR / ADAPTIVE_PD_MULTIPLIER_MIN_DENOMINATOR
+    max_m = ADAPTIVE_PD_MULTIPLIER_MAX_NUMERATOR / ADAPTIVE_PD_MULTIPLIER_MAX_DENOMINATOR
+    step = ADAPTIVE_PD_MULTIPLIER_STEP_NUMERATOR / ADAPTIVE_PD_MULTIPLIER_STEP_DENOMINATOR
+    _s = [EVAL_ONE_FLOAT]
+
+    def payoff_fn(p_act: str, o_act: str) -> tuple[float, float]:
+        mult = _s[_ZERO]
+        base = _PD_MATRIX[(p_act, o_act)]
+        result = (base[_ZERO] * mult, base[_ONE] * mult)
+        if p_act == "cooperate" and o_act == "cooperate":
+            _s[_ZERO] = min(max_m, _s[_ZERO] + step)
+        elif p_act == "defect" and o_act == "defect":
+            _s[_ZERO] = max(min_m, _s[_ZERO] - step)
+        return result
+
+    return GameConfig(
+        name="Adaptive Prisoner's Dilemma",
+        description=(
+            "A Prisoner's Dilemma where mutual cooperation increases "
+            "future payoffs via a growing multiplier, while mutual "
+            "defection decreases it. Mixed outcomes leave it unchanged."
+        ),
+        actions=["cooperate", "defect"],
+        game_type=ADAPTIVE_GAME_TYPE,
+        default_rounds=ADAPTIVE_DEFAULT_ROUNDS,
+        payoff_fn=payoff_fn,
+    )
+
+
+def _arms_race_factory() -> GameConfig:
+    """Hawk-Dove where hawk-hawk conflict costs escalate each round."""
+    c_step = ARMS_RACE_COST_STEP_NUMERATOR / ARMS_RACE_COST_STEP_DENOMINATOR
+    max_c = ARMS_RACE_MAX_COST_NUMERATOR / ARMS_RACE_MAX_COST_DENOMINATOR
+    _s = [EVAL_ZERO_FLOAT]
+
+    def payoff_fn(p_act: str, o_act: str) -> tuple[float, float]:
+        cost = _s[_ZERO]
+        base = _HD_MATRIX[(p_act, o_act)]
+        if p_act == "hawk" and o_act == "hawk":
+            result = (base[_ZERO] - cost, base[_ONE] - cost)
+            _s[_ZERO] = min(max_c, _s[_ZERO] + c_step)
+        else:
+            result = base
+            _s[_ZERO] = max(EVAL_ZERO_FLOAT, _s[_ZERO] - c_step / _TWO)
+        return result
+
+    return GameConfig(
+        name="Arms Race",
+        description=(
+            "A Hawk-Dove game where mutual hawk play incurs "
+            "escalating costs each round. Non-hawk rounds "
+            "de-escalate the accumulated conflict cost."
+        ),
+        actions=["hawk", "dove"],
+        game_type=ADAPTIVE_GAME_TYPE,
+        default_rounds=ADAPTIVE_DEFAULT_ROUNDS,
+        payoff_fn=payoff_fn,
+    )
+
+
+def _trust_erosion_factory() -> GameConfig:
+    """Trust-like PD where a multiplier decays after mutual defection."""
+    decay = TRUST_EROSION_DECAY_NUMERATOR / TRUST_EROSION_DECAY_DENOMINATOR
+    recov = TRUST_EROSION_RECOVERY_NUMERATOR / TRUST_EROSION_RECOVERY_DENOMINATOR
+    _s = [float(TRUST_MULTIPLIER)]
+
+    def payoff_fn(p_act: str, o_act: str) -> tuple[float, float]:
+        mult = _s[_ZERO]
+        base = _PD_MATRIX[(p_act, o_act)]
+        result = (base[_ZERO] * mult, base[_ONE] * mult)
+        if p_act == "defect" and o_act == "defect":
+            _s[_ZERO] = _s[_ZERO] * decay
+        elif p_act == "cooperate" and o_act == "cooperate":
+            _s[_ZERO] = min(float(TRUST_MULTIPLIER), _s[_ZERO] + recov)
+        return result
+
+    return GameConfig(
+        name="Trust Erosion",
+        description=(
+            "A Prisoner's Dilemma where a trust multiplier amplifies "
+            "all payoffs. Mutual defection erodes trust, while mutual "
+            "cooperation slowly rebuilds it."
+        ),
+        actions=["cooperate", "defect"],
+        game_type=ADAPTIVE_GAME_TYPE,
+        default_rounds=ADAPTIVE_DEFAULT_ROUNDS,
+        payoff_fn=payoff_fn,
+    )
+
+
+def _market_dynamics_factory() -> GameConfig:
+    """Cournot-like duopoly where demand shifts based on total output."""
+    shift = MARKET_DEMAND_SHIFT_NUMERATOR / MARKET_DEMAND_SHIFT_DENOMINATOR
+    _s = [float(_MKT_INTERCEPT)]
+
+    def payoff_fn(p_act: str, o_act: str) -> tuple[float, float]:
+        intercept = _s[_ZERO]
+        p_out, o_out = _MKT_OUT[p_act], _MKT_OUT[o_act]
+        total = p_out + o_out
+        price = max(EVAL_ZERO_FLOAT, intercept - total)
+        p_rev = price * p_out - _MKT_COST[p_act]
+        o_rev = price * o_out - _MKT_COST[o_act]
+        if total > (_MKT_INTERCEPT / _TWO):
+            _s[_ZERO] = max(float(_TWO), _s[_ZERO] - shift)
+        else:
+            _s[_ZERO] = min(float(_MKT_INTERCEPT), _s[_ZERO] + shift)
+        return (p_rev, o_rev)
+
+    return GameConfig(
+        name="Market Dynamics",
+        description=(
+            "A Cournot-like duopoly where each player chooses output "
+            "level. The demand curve shifts based on past total output: "
+            "high output depresses future demand, restraint recovers it."
+        ),
+        actions=["low", "medium", "high"],
+        game_type=ADAPTIVE_GAME_TYPE,
+        default_rounds=ADAPTIVE_DEFAULT_ROUNDS,
+        payoff_fn=payoff_fn,
+    )
+
+
+def _reputation_payoffs_factory() -> GameConfig:
+    """Base PD with payoff bonus proportional to cooperation history."""
+    bonus_rate = REPUTATION_BONUS_NUMERATOR / REPUTATION_BONUS_DENOMINATOR
+    _s = [_ZERO, _ZERO]  # [coop_count, total_rounds]
+
+    def payoff_fn(p_act: str, o_act: str) -> tuple[float, float]:
+        base = _PD_MATRIX[(p_act, o_act)]
+        total = _s[_ONE]
+        coop_rate = _s[_ZERO] / total if total > _ZERO else EVAL_ZERO_FLOAT
+        bonus = coop_rate * bonus_rate
+        result = (base[_ZERO] + bonus, base[_ONE] + bonus)
+        _s[_ONE] += _ONE
+        if p_act == "cooperate":
+            _s[_ZERO] += _ONE
+        return result
+
+    return GameConfig(
+        name="Reputation Payoffs",
+        description=(
+            "A Prisoner's Dilemma where both players receive a bonus "
+            "proportional to the player's historical cooperation rate. "
+            "Building a cooperative reputation pays future dividends."
+        ),
+        actions=["cooperate", "defect"],
+        game_type=ADAPTIVE_GAME_TYPE,
+        default_rounds=ADAPTIVE_DEFAULT_ROUNDS,
+        payoff_fn=payoff_fn,
+    )
+
+
+# Register all factories
+GAME_FACTORIES["adaptive_prisoners_dilemma"] = _adaptive_pd_factory
+GAME_FACTORIES["arms_race"] = _arms_race_factory
+GAME_FACTORIES["trust_erosion"] = _trust_erosion_factory
+GAME_FACTORIES["market_dynamics"] = _market_dynamics_factory
+GAME_FACTORIES["reputation_payoffs"] = _reputation_payoffs_factory

common/games_meta/game_tags.py

@@ -184,6 +184,13 @@ GAME_TAGS: dict[str, frozenset[str]] = {
     "rule_signal_stag_hunt": frozenset({CHEAP_TALK, COMPLETE_INFORMATION, SIMULTANEOUS, REPEATED, COORDINATION, SOCIAL_DILEMMA, LARGE_CHOICE, META_GOVERNANCE}),
     "rule_signal_hawk_dove": frozenset({CHEAP_TALK, COMPLETE_INFORMATION, SIMULTANEOUS, REPEATED, ANTI_COORDINATION, SOCIAL_DILEMMA, LARGE_CHOICE, META_GOVERNANCE}),
 
+    # ── games_adaptive/factories.py ──
+    "adaptive_prisoners_dilemma": frozenset({NO_COMMUNICATION, COMPLETE_INFORMATION, SIMULTANEOUS, REPEATED, SYMMETRIC_PAYOFF, SOCIAL_DILEMMA, BINARY_CHOICE}),
+    "arms_race": frozenset({NO_COMMUNICATION, COMPLETE_INFORMATION, SIMULTANEOUS, REPEATED, ANTI_COORDINATION, SOCIAL_DILEMMA, BINARY_CHOICE}),
+    "trust_erosion": frozenset({NO_COMMUNICATION, COMPLETE_INFORMATION, SIMULTANEOUS, REPEATED, SYMMETRIC_PAYOFF, SOCIAL_DILEMMA, BINARY_CHOICE}),
+    "market_dynamics": frozenset({NO_COMMUNICATION, COMPLETE_INFORMATION, SIMULTANEOUS, REPEATED, SYMMETRIC_PAYOFF, MARKET_COMPETITION, SMALL_CHOICE}),
+    "reputation_payoffs": frozenset({NO_COMMUNICATION, COMPLETE_INFORMATION, SIMULTANEOUS, REPEATED, SYMMETRIC_PAYOFF, SOCIAL_DILEMMA, BINARY_CHOICE}),
+
     # ── meta/meta_games.py (gossip) ──
     "gossip_prisoners_dilemma": frozenset({CHEAP_TALK, COMPLETE_INFORMATION, SIMULTANEOUS, REPEATED, SYMMETRIC_PAYOFF, SOCIAL_DILEMMA, LARGE_CHOICE, META_GOVERNANCE}),
     "gossip_stag_hunt": frozenset({CHEAP_TALK, COMPLETE_INFORMATION, SIMULTANEOUS, REPEATED, COORDINATION, SOCIAL_DILEMMA, LARGE_CHOICE, META_GOVERNANCE}),

constant_definitions/slides/__init__.py

@@ -0,0 +1 @@
+"""Slides layout constants."""

constant_definitions/slides/layout.py

@@ -0,0 +1,94 @@
+"""Numeric constants for slide generation layout and Wisent brand colors."""
+
+# Wisent brand palette from wisent-visuals (RGB tuples 0-255)
+ACCENT_R = 197
+ACCENT_G = 255
+ACCENT_B = 200
+RED_R = 250
+RED_G = 90
+RED_B = 70
+PURPLE_R = 177
+PURPLE_G = 158
+PURPLE_B = 204
+DARK_R = 18
+DARK_G = 18
+DARK_B = 18
+GRID_R = 45
+GRID_G = 49
+GRID_B = 48
+LEGEND_R = 118
+LEGEND_G = 153
+LEGEND_B = 120
+WHITE_VAL = 255
+BLACK_VAL = 0
+
+# Font sizes in points
+PT_TITLE = 36
+PT_SUBTITLE = 20
+PT_BODY = 16
+PT_SMALL = 12
+PT_STAT = 48
+PT_LABEL = 14
+PT_TEAM = 28
+
+# Slide dimensions in inches (for widescreen 16:9)
+SLIDE_W_INCHES = 10
+SLIDE_H_NUMER = 45
+SLIDE_H_DENOM = 8
+
+# Position helpers in inches
+POS_HALF = 0.5
+POS_ONE = 1.0
+POS_ONE_HALF = 1.5
+POS_TWO = 2.0
+POS_TWO_HALF = 2.5
+POS_THREE = 3.0
+POS_THREE_HALF = 3.5
+POS_FOUR = 4.0
+POS_FOUR_HALF = 4.5
+POS_FIVE = 5.0
+POS_SIX = 6.0
+POS_SEVEN = 7.0
+POS_EIGHT = 8.0
+POS_NINE = 9.0
+
+# Image dimensions
+IMG_FIG_W = 7.0
+IMG_FIG_H = 3.5
+IMG_KANT_W = 3.0
+IMG_KANT_H = 4.0
+
+# Column layout
+COL_LEFT_X = 0.5
+COL_RIGHT_X = 5.0
+COL_W = 4.5
+COL_H = 4.0
+
+# Stat column positions
+STAT_COL_ONE_X = 0.5
+STAT_COL_TWO_X = 3.5
+STAT_COL_THREE_X = 6.5
+STAT_COL_W = 3.0
+
+# Title position
+TITLE_X = 0.5
+TITLE_Y = 0.3
+TITLE_W = 9.0
+TITLE_H = 1.0
+
+# Centered text position
+CENTER_Y = 1.5
+CENTER_W = 8.0
+CENTER_H = 3.5
+CENTER_X = 1.0
+
+# Footer position
+FOOTER_Y = 4.8
+FOOTER_H = 0.5
+
+# Team layout
+TEAM_NAME_Y = 2.5
+TEAM_NAME_H = 1.0
+TEAM_COL_ONE_X = 1.0
+TEAM_COL_TWO_X = 5.5
+TEAM_COL_W = 3.5

constant_definitions/var/meta/adaptive_constants.py

@@ -0,0 +1,39 @@
+"""Constants for adaptive payoff games."""
+
+# Adaptive PD: cooperation multiplier range
+ADAPTIVE_PD_MULTIPLIER_MIN_NUMERATOR = 5
+ADAPTIVE_PD_MULTIPLIER_MIN_DENOMINATOR = 10
+
+ADAPTIVE_PD_MULTIPLIER_MAX_NUMERATOR = 2
+ADAPTIVE_PD_MULTIPLIER_MAX_DENOMINATOR = 1
+
+ADAPTIVE_PD_MULTIPLIER_STEP_NUMERATOR = 1
+ADAPTIVE_PD_MULTIPLIER_STEP_DENOMINATOR = 10
+
+# Arms Race: cost escalation per round
+ARMS_RACE_COST_STEP_NUMERATOR = 1
+ARMS_RACE_COST_STEP_DENOMINATOR = 2
+
+ARMS_RACE_MAX_COST_NUMERATOR = 5
+ARMS_RACE_MAX_COST_DENOMINATOR = 1
+
+# Trust Erosion: multiplier decay after defection
+TRUST_EROSION_DECAY_NUMERATOR = 8
+TRUST_EROSION_DECAY_DENOMINATOR = 10
+
+TRUST_EROSION_RECOVERY_NUMERATOR = 1
+TRUST_EROSION_RECOVERY_DENOMINATOR = 10
+
+# Market dynamics: demand shift per round
+MARKET_DEMAND_SHIFT_NUMERATOR = 1
+MARKET_DEMAND_SHIFT_DENOMINATOR = 2
+
+# Reputation payoffs: cooperation bonus scaling
+REPUTATION_BONUS_NUMERATOR = 1
+REPUTATION_BONUS_DENOMINATOR = 5
+
+# Default rounds for adaptive games
+ADAPTIVE_DEFAULT_ROUNDS = 10
+
+# Game type identifier
+ADAPTIVE_GAME_TYPE = "adaptive"

constant_definitions/var/meta/self_play_constants.py

@@ -0,0 +1,32 @@
+"""Constants for self-play multi-agent training."""
+
+# Opponent update frequency (steps between opponent refresh)
+SELF_PLAY_OPPONENT_UPDATE_INTERVAL = 50
+
+# Maximum frozen checkpoints kept in the opponent pool
+SELF_PLAY_POOL_MAX_SIZE = 5
+
+# Self-play reward weights (numerator / denominator pairs)
+SELF_PLAY_EXPLOIT_WEIGHT_NUMERATOR = 3
+SELF_PLAY_EXPLOIT_WEIGHT_DENOMINATOR = 10
+
+SELF_PLAY_COOP_WEIGHT_NUMERATOR = 3
+SELF_PLAY_COOP_WEIGHT_DENOMINATOR = 10
+
+SELF_PLAY_PARETO_WEIGHT_NUMERATOR = 2
+SELF_PLAY_PARETO_WEIGHT_DENOMINATOR = 10
+
+SELF_PLAY_FAIRNESS_WEIGHT_NUMERATOR = 1
+SELF_PLAY_FAIRNESS_WEIGHT_DENOMINATOR = 10
+
+SELF_PLAY_ADAPT_WEIGHT_NUMERATOR = 1
+SELF_PLAY_ADAPT_WEIGHT_DENOMINATOR = 10
+
+# Training defaults
+SELF_PLAY_DEFAULT_EPISODES_PER_STEP = 16
+SELF_PLAY_DEFAULT_MAX_STEPS = 500
+SELF_PLAY_CHECKPOINT_PREFIX = "self_play_step"
+SELF_PLAY_WARMUP_EPISODES = 32
+
+# Opponent strategy label used in trajectory metadata
+SELF_PLAY_OPPONENT_LABEL = "agent"