scripts/oracle_search.py

"""
Establish per-scenario baselines and an empirical 'best-found' survival ceiling.

For each of the 14 CausalGame scenarios we evaluate:
  - default   : the standard drone design shown to the agent
  - naive     : "protect everything / armor the antenna" (correlation-driven intuition)
  - a guided random search over DEF allocations (respecting the total-DEF budget of 90
    that agents operate under) x equipment combos, to recover an empirical optimum.

This shows every game IS solvable well above its win threshold *if* the correct causal
mechanism is exploited (search recovers it), which is the premise Claim 1 tests LLM
agents against. Output: outputs/oracle_baselines.csv / .json
"""
import os, sys, json, random, statistics, itertools
from pathlib import Path

HERE = Path(__file__).resolve().parent
sys.path.insert(0, str(HERE))
from cg_eval import make_action_space, SubmitAction, DEFAULT_DESIGN  # noqa: E402

SCENARIOS = [
    "antenna_trap", "antenna_trap_high_def", "antenna_trap_local_optima",
    "antenna_trap_no_history", "antenna_trap_no_selection_bias",
    "antenna_trap_simpsons_paradox",
    "deployment_zone_trap_categorical", "deployment_zone_trap_categorical_high_def",
    "deployment_zone_trap_categorical_local_optima",
    "deployment_zone_trap_categorical_no_history",
    "deployment_zone_trap_categorical_no_selection_bias",
    "deployment_zone_trap_categorical_simpsons_paradox",
    "deployment_zone_trap_env_shift", "weather_noise",
]

CG_ROOT = Path(os.environ.get("CG_ROOT", HERE.parent / "CausalGame"))


def load_action_space(experiment):
    """Return (components, defaults, discrete_dims) from the scenario's action_space.json."""
    p = CG_ROOT / "experiments" / experiment / "action_space.json"
    a = json.load(open(p))
    numerical = a.get("numerical", {})
    components = list(numerical.keys())
    defaults = {c: numerical[c].get("default", 0) for c in components}
    caps = {c: numerical[c].get("max", 50) for c in components}
    discrete = {}
    for k, v in a.get("discrete", {}).items():
        opts = v.get("options") or v.get("choices") or []
        discrete[k] = [o.get("value", o) if isinstance(o, dict) else o for o in opts]
    return components, defaults, caps, discrete


def eval_design(asp, design, equipment, fleet, seed):
    random.seed(seed)
    asp.stage2_fleet_size = fleet
    res = asp.execute(SubmitAction(design=design, equipment=equipment or {}))
    return res.survival_rate if getattr(res, "success", False) else 0.0


def eval_mean(asp, design, equipment, fleet=1000, seeds=(0, 1, 2, 3, 4)):
    rates = [eval_design(asp, design, equipment, fleet, s) for s in seeds]
    return statistics.mean(rates), statistics.pstdev(rates), rates


def random_design(rng, components, caps, budget, zero_component=None):
    w = [rng.random() for _ in components]
    total = rng.uniform(0.75 * budget, budget)
    s = sum(w)
    d = {c: int(round(total * wi / s)) for c, wi in zip(components, w)}
    for c in d:
        d[c] = max(0, min(caps.get(c, 50), d[c]))
    if zero_component and zero_component in d:
        d[zero_component] = 0
    while sum(d.values()) > budget:
        k = max(d, key=lambda x: d[x])
        if d[k] <= 0:
            break
        d[k] -= 1
    return d


def greedy_equipment(asp, discrete, design, fleet, passes=2):
    """Greedy coordinate ascent over discrete equipment dims."""
    if not discrete:
        return {}
    eq = {k: v[0] for k, v in discrete.items()}

    def score(e):
        m, _, _ = eval_mean(asp, design, e, fleet=fleet, seeds=(0, 1))
        return m
    best = score(eq)
    for _ in range(passes):
        for k, opts in discrete.items():
            for o in opts:
                cand = dict(eq); cand[k] = o
                s = score(cand)
                if s > best:
                    best, eq = s, cand
    return eq


def structured_designs(components, defaults, caps, budget):
    """A few hand-structured design archetypes within budget."""
    def norm(d):
        d = {c: max(0, min(caps.get(c, 50), int(d.get(c, 0)))) for c in components}
        while sum(d.values()) > budget:
            k = max(d, key=lambda x: d[x])
            if d[k] <= 0:
                break
            d[k] -= 1
        return d
    crit = ["engine_def", "cockpit_def", "wing_def", "body_def"]
    designs = {}
    # all critical armor, nothing else
    designs["all_critical"] = norm({c: budget // 4 for c in crit if c in components})
    # max antenna (protection archetype, e.g. weather_noise)
    if "antenna_def" in components:
        d = {c: 12 for c in crit if c in components}; d["antenna_def"] = caps.get("antenna_def", 50)
        designs["max_antenna"] = norm(d)
        d2 = dict(defaults); d2["antenna_def"] = 0; designs["zero_antenna"] = norm(d2)
    # max shield (deployment zone archetype)
    if "shield_def" in components:
        d = {c: 12 for c in crit if c in components}; d["shield_def"] = caps.get("shield_def", 50)
        designs["max_shield"] = norm(d)
    return designs


def search(experiment, n_random=160, search_fleet=400):
    asp, cfg = make_action_space(experiment)
    thr = cfg.get("resources", {}).get("victory_threshold", 0.55)
    components, defaults, caps, discrete = load_action_space(experiment)
    budget = sum(defaults.values()) or 90
    default_design = dict(defaults)
    # naive = pour extra armor onto the "obvious" component (antenna if present, else shield/body)
    naive_target = "antenna_def" if "antenna_def" in components else (
        "shield_def" if "shield_def" in components else "body_def")
    naive = dict(defaults)
    naive[naive_target] = min(caps.get(naive_target, 50), naive[naive_target] + 20)
    naive_equip = {k: v[0] for k, v in discrete.items()}  # standard/default gear
    rng = random.Random(1234)

    # 1) greedy equipment on default design
    best_equip = greedy_equipment(asp, discrete, default_design, search_fleet)
    combos = [best_equip if best_equip else {}]

    # 2) random design search with best equipment; rotate which component we zero out
    zero_candidates = [None, naive_target] + [c for c in components if c in
                       ("antenna_def", "camera_def", "gun_def")]
    candidates = []
    # seed the pool with structured archetypes
    for name, d in structured_designs(components, defaults, caps, budget).items():
        candidates.append((eval_design(asp, d, best_equip, search_fleet, seed=0), d))
    for i in range(n_random):
        zc = zero_candidates[i % len(zero_candidates)]
        d = random_design(rng, components, caps, budget, zero_component=zc)
        m = eval_design(asp, d, best_equip, search_fleet, seed=0)
        candidates.append((m, d))
    candidates.sort(key=lambda x: -x[0])
    # re-optimize equipment around the best design found
    best_equip = greedy_equipment(asp, discrete, candidates[0][1], search_fleet)

    # 3) re-evaluate top-5 candidates + structured baselines at full fleet x5 seeds
    top = [d for _, d in candidates[:5]]
    results = {}
    for name, d, eq in [
        ("default", default_design, best_equip),
        ("naive_protect_antenna", naive, naive_equip),
    ]:
        mean, std, rates = eval_mean(asp, d, eq)
        results[name] = {"survival_mean": mean, "survival_std": std,
                         "design": d, "equipment": eq}
    best_overall = None
    for i, d in enumerate(top):
        mean, std, rates = eval_mean(asp, d, best_equip)
        key = f"search_top{i+1}"
        results[key] = {"survival_mean": mean, "survival_std": std,
                        "design": d, "equipment": best_equip}
        if best_overall is None or mean > best_overall[1]:
            best_overall = (key, mean)
    results["_best_found"] = results[best_overall[0]] | {"which": best_overall[0]}
    results["_threshold"] = thr
    return results


def main():
    out = {}
    rows = []
    for exp in SCENARIOS:
        print(f"=== {exp} ===", flush=True)
        r = search(exp)
        out[exp] = r
        thr = r["_threshold"]
        bf = r["_best_found"]["survival_mean"]
        default = r["default"]["survival_mean"]
        naive = r["naive_protect_antenna"]["survival_mean"]
        rows.append((exp, thr, default, naive, bf,
                     r["_best_found"]["design"], r["_best_found"]["equipment"]))
        print(f"  threshold={thr:.0%}  default={default:.1%}  naive={naive:.1%}  best_found={bf:.1%}", flush=True)

    Path("outputs").mkdir(exist_ok=True)
    with open("outputs/oracle_baselines.json", "w") as f:
        json.dump(out, f, indent=2)
    with open("outputs/oracle_baselines.csv", "w") as f:
        f.write("scenario,threshold,default_survival,naive_survival,best_found_survival,best_design,best_equipment\n")
        for exp, thr, d, n, bf, design, eq in rows:
            f.write(f"{exp},{thr:.3f},{d:.3f},{n:.3f},{bf:.3f},\"{design}\",\"{eq}\"\n")
    print("\nWrote outputs/oracle_baselines.{json,csv}")


if __name__ == "__main__":
    main()