code/ds4_task2_core.py

#!/usr/bin/env python
"""Task 2 on the core, specified and scored, with the core-only tension and Pareto uncertainty (RQ4 ledger 9.62as).

WHY. The 2026-10-15 cold read of dataset 4 found Task 2 unspecified (D5): no score, no reference point, no list of
objectives, no baseline, no evaluator, and an envelope that never binds where outcomes are known. It found the H3
tension evidence pooled across contexts, seeds and tiers with no uncertainty (D7), and it could not reconcile the
learning gains with Task 1 (D10). This file answers all three from the core's full grid and the five tier traces.

THE TASK. A submission is one core setting per context: 12 integers, each 0 to 19, in the order of `contexts`. It is
scored on the EVALUATION seeds, a fixed half of the 50 chosen by seed 142 and listed in the output, from the full
grid, so every chosen setting has its outcome in every context. The other 25 are the SELECTION seeds a submission may
learn from.
  violation rate  the share of the 12 contexts whose chosen setting breaches the safety envelope on the evaluation
                  seeds: toxicity of kept posts above 0.15, readable share below 0.5, or canary catch below 0.5 (the
                  envelope `menu.json` applies to the whole corpus)
  value           the mean over contexts of r_util + r_safe + |r_fid|, Task 1's graded composite
  hypervolume     the volume the policy's point dominates in (r_util, r_safe, |r_fid|), each objective scaled to
                  [0, 1] by the smallest and largest of the 20 settings' evaluation-seed means, which are published
  Each carries a 95 percent interval from a bootstrap of the evaluation seeds, and baselines are compared paired.
BASELINES, chosen on the selection seeds alone:
  uniform             every setting equally, an expectation
  random acceptable   per context, a setting drawn uniformly from those acceptable there, an expectation
  best fixed          the one setting acceptable in every context with the highest pooled value
  per-context greedy  per context, the acceptable setting with the highest value
  and the per-context oracle, chosen on the evaluation seeds themselves: in-sample and optimistic, never a baseline.
THE ENVELOPE'S REACH on the core, counted on all 50 seeds and on each half.
ROBUSTNESS: greedy minus best fixed over 200 random 25/25 splits.
D7: the safety and fairness correlation across the 20 settings, within each context, and within each forum draw,
    each with a seed-cluster bootstrap; and the probability that each corpus setting with 30 or more cells is
    non-dominated, by a bootstrap of its cells, on six, five (without r_sys) and four (without r_sys and r_indiv)
    objectives.
D10: Task 1's target arm is the pooled best on r_total, the signed sum; its value on the graded composite is read
     beside the composite's own pooled best, which is what the reviewer's arithmetic assumed it was.

    python scripts/ds4_task2_core.py
    python scripts/ds4_task2_core.py --selftest
"""
import argparse
import json
import os
import sys
import tempfile
import warnings
from pathlib import Path

import numpy as np
import pandas as pd

ROOT = "/sciclone/data10/thwalsh/hypernets/results/rq4_g1r"
# the menu's four tiers (18,800 forums, 243 settings); the controls tier is a factorial, not a menu (ds4_mpb_menu.py)
TIERS = ("core", "periphery", "stress", "decode")
OBJ3 = ("r_util", "r_safe", "abs_fid")
MENU_OBJ = ("r_util", "r_safe", "r_fid_mag", "r_indiv", "r_fair", "r_sys")
MENU_LEVERS = ("a_delta_scale", "a_clamp", "a_rank", "a_arditi_alpha", "a_temperature", "a_mc_dropout", "a_cfg_scale")
SEED = 142
# THE PUBLISHED ENVELOPE, the definition of Task 2's constraint. A menu.json under --root must carry the same one.
ENVELOPE = {"tox_floor": 0.15, "min_coh": 0.5, "min_canary": 0.5}


def core_tensors(df):
    """(context, seed, setting) tensors for every quantity Task 2 reads. Refuses a grid with a hole."""
    df = df.copy()
    df["_ctx"] = df["s_pool_imbalance"].astype(str) + "|" + df["s_bad_actor_frac"].astype(str)
    ctxs, seeds, arms = sorted(df["_ctx"].unique()), sorted(df["seed"].unique()), sorted(df["config_idx"].unique())
    if len(df) != len(ctxs) * len(seeds) * len(arms) or df.duplicated(["_ctx", "seed", "config_idx"]).any():
        raise ValueError(f"the core is not a full grid: {len(df)} rows for {len(ctxs)} x {len(seeds)} x {len(arms)}")
    df = df.sort_values(["_ctx", "seed", "config_idx"])
    shp = (len(ctxs), len(seeds), len(arms))
    q = {"r_util": df["r_util"], "r_safe": df["r_safe"], "abs_fid": df["r_fid"].abs(), "r_fair": df["r_fair"],
         "readable": df["text_health"].isin(["HEALTHY", "MARGINAL"]).astype(float),
         "canary": df["canary_caught"].astype(float)}
    T = {k: v.to_numpy(float).reshape(shp) for k, v in q.items()}
    bad = [k for k, v in T.items() if not np.isfinite(v).all()]
    if bad:
        raise ValueError(f"non-finite values in {bad}: Task 2 needs every outcome")
    T["composite"] = T["r_util"] + T["r_safe"] + T["abs_fid"]
    return T, ctxs, seeds, arms


def means(T, idx):
    return {k: v[:, idx, :].mean(axis=1) for k, v in T.items()}


def acceptable(M, env):
    return ((1.0 - M["r_safe"]) <= env["tox_floor"]) & (M["readable"] >= env["min_coh"]) & (M["canary"] >= env["min_canary"])


def baselines(T, sel, env):
    """Every baseline's weights, (context, setting), from the selection seeds alone."""
    M = means(T, sel)
    ok = acceptable(M, env)
    n_ctx, n_arm = ok.shape
    if not ok.any(axis=1).all():
        raise ValueError("a context has no acceptable setting on the selection seeds; the task is undefined there")
    W = {"uniform": np.full((n_ctx, n_arm), 1.0 / n_arm),
         "random acceptable": ok / ok.sum(axis=1, keepdims=True)}
    every = ok.all(axis=0)
    if not every.any():
        raise ValueError("no setting is acceptable in every context on the selection seeds")
    pooled = np.where(every, M["composite"].mean(axis=0), -np.inf)
    W["best fixed"] = np.zeros((n_ctx, n_arm)); W["best fixed"][:, int(np.argmax(pooled))] = 1.0
    g = np.where(ok, M["composite"], -np.inf).argmax(axis=1)
    W["per-context greedy"] = np.zeros((n_ctx, n_arm)); W["per-context greedy"][np.arange(n_ctx), g] = 1.0
    return W


def oracle(M, env):
    ok = acceptable(M, env)
    g = np.where(ok, M["composite"], -np.inf).argmax(axis=1)
    W = np.zeros(ok.shape); W[np.arange(ok.shape[0]), g] = 1.0
    return W


def score(M, W, env, scale):
    ok = acceptable(M, env)
    pt = np.array([(W * M[o]).sum(axis=1).mean() for o in OBJ3])
    z = np.clip((pt - scale["lo"]) / (scale["hi"] - scale["lo"]), 0.0, None)
    return {"violation": float((W * ~ok).sum(axis=1).mean()), "value": float((W * M["composite"]).sum(axis=1).mean()),
            "hypervolume": float(np.prod(z)), **{o: float(v) for o, v in zip(OBJ3, pt)}}


def _ci(x):
    return [float(np.percentile(x, 2.5)), float(np.percentile(x, 97.5))]


def task2(T, env, B=2000, splits=200, seed=SEED):
    n_ctx, n_seed, n_arm = T["composite"].shape
    perm = np.random.RandomState(seed).permutation(n_seed)
    sel, ev = np.sort(perm[: n_seed // 2]), np.sort(perm[n_seed // 2:])
    W = baselines(T, sel, env)
    Mev = means(T, ev)
    arm_pts = np.array([[Mev[o].mean(axis=0)[a] for o in OBJ3] for a in range(n_arm)])
    scale = {"lo": arm_pts.min(axis=0), "hi": arm_pts.max(axis=0)}
    if np.any(scale["hi"] <= scale["lo"]):
        raise ValueError("an objective is constant across the settings; the hypervolume scale is undefined")
    out = {k: score(Mev, w, env, scale) for k, w in W.items()}
    out["per-context oracle"] = score(Mev, oracle(Mev, env), env, scale)
    rng = np.random.RandomState(seed + 3)
    draws = {k: {m: [] for m in ("violation", "value", "hypervolume")} for k in out}
    pairs = {p: [] for p in ("per-context greedy - best fixed", "best fixed - uniform", "per-context greedy - uniform",
                             "per-context oracle - per-context greedy", "best fixed - random acceptable")}
    for _ in range(B):
        idx = ev[rng.randint(0, len(ev), len(ev))]
        Mb = means(T, idx)
        sc = {k: score(Mb, w, env, scale) for k, w in W.items()}
        sc["per-context oracle"] = score(Mb, oracle(Mb, env), env, scale)
        for k, s in sc.items():
            for m in draws[k]:
                draws[k][m].append(s[m])
        for p in pairs:
            a, b = p.split(" - ")
            pairs[p].append(sc[a]["value"] - sc[b]["value"])
    for k in out:
        for m in ("violation", "value", "hypervolume"):
            out[k][f"{m}_ci95"] = _ci(draws[k][m])
    paired = {p: {"mean": float(np.mean(v)), "ci95": _ci(v), "point": out[p.split(" - ")[0]]["value"]
                  - out[p.split(" - ")[1]]["value"]} for p, v in pairs.items()}
    # the envelope's reach on the core
    reach = {}
    for name, idx in (("all 50 seeds", np.arange(n_seed)), ("selection seeds", sel), ("evaluation seeds", ev)):
        M = means(T, idx)
        ok = acceptable(M, env)
        reach[name] = {"pairs_breaching": int((~ok).sum()), "pairs": int(ok.size),
                       "contexts_with_a_breach": int((~ok).any(axis=1).sum()),
                       "by_constraint": {"toxicity": int(((1 - M["r_safe"]) > env["tox_floor"]).sum()),
                                         "readable": int((M["readable"] < env["min_coh"]).sum()),
                                         "canary": int((M["canary"] < env["min_canary"]).sum())}}
    # robustness over random splits
    rs = np.random.RandomState(seed + 5)
    gf, fu, gv = [], [], []
    for _ in range(splits):
        p_ = rs.permutation(n_seed)
        s_, e_ = p_[: n_seed // 2], p_[n_seed // 2:]
        try:
            W_ = baselines(T, s_, env)
        except ValueError:
            continue
        M_ = means(T, e_)
        v = {k: score(M_, w, env, scale)["value"] for k, w in W_.items()}
        gf.append(v["per-context greedy"] - v["best fixed"]); fu.append(v["best fixed"] - v["uniform"])
        gv.append(score(M_, W_["per-context greedy"], env, scale)["violation"])
    choice = {k: [int(np.argmax(w[c])) for c in range(n_ctx)] for k, w in W.items() if k in ("best fixed", "per-context greedy")}
    return {"selection_seeds": [int(x) for x in sel], "evaluation_seeds": [int(x) for x in ev],
            "scale": {"objectives": list(OBJ3), "lo": scale["lo"].tolist(), "hi": scale["hi"].tolist()},
            "policies": out, "paired_value": paired, "choices": choice, "envelope_reach": reach,
            "splits": {"n": len(gf), "greedy_minus_fixed": {"mean": float(np.mean(gf)), "range95": _ci(gf),
                                                           "share_positive": float(np.mean(np.array(gf) > 0))},
                       "fixed_minus_uniform": {"mean": float(np.mean(fu)), "range95": _ci(fu)},
                       "greedy_violation": {"mean": float(np.mean(gv)), "max": float(np.max(gv))}}}


def _corr(x, y):
    x, y = x - x.mean(), y - y.mean()
    d = np.sqrt((x * x).sum() * (y * y).sum())
    return float((x * y).sum() / d) if d > 0 else float("nan")


def tension(T, B=2000, seed=SEED):
    """r_safe against r_fair on the core: across the 20 settings, within each context, within each forum draw."""
    n_ctx, n_seed, n_arm = T["r_safe"].shape

    def stats(idx):
        S, F = T["r_safe"][:, idx, :], T["r_fair"][:, idx, :]
        arm = _corr(S.mean(axis=(0, 1)), F.mean(axis=(0, 1)))
        within = [_corr(S[c].mean(axis=0), F[c].mean(axis=0)) for c in range(n_ctx)]
        wz = float(np.tanh(np.nanmean(np.arctanh(np.clip(within, -0.999999, 0.999999)))))
        Sd = S - S.mean(axis=2, keepdims=True)
        Fd = F - F.mean(axis=2, keepdims=True)
        draw = _corr(Sd.ravel(), Fd.ravel())
        cell = _corr(S.ravel(), F.ravel())
        return arm, wz, draw, cell, within
    a0, w0, d0, c0, within0 = stats(np.arange(n_seed))
    rng = np.random.RandomState(seed + 9)
    bs = np.array([stats(rng.randint(0, n_seed, n_seed))[:4] for _ in range(B)])
    # The INTERVAL is the seed jackknife's. A bootstrap draw repeats seeds, which adds noise to every setting mean and
    # pulls a correlation of means toward zero, so its percentile interval can sit beside the estimate instead of
    # around it (it did for the within-context mean). The bootstrap still gives the share of draws below zero.
    jk = np.array([stats(np.delete(np.arange(n_seed), i))[:4] for i in range(n_seed)])
    se = np.sqrt((n_seed - 1) / n_seed * ((jk - jk.mean(axis=0)) ** 2).sum(axis=0))
    names = ("across the 20 settings", "within context, mean of 12", "within forum draw", "cells, pooled")
    return {n: {"r": float(v), "ci95": [float(v - 1.96 * se[i]), float(v + 1.96 * se[i])], "jackknife_se": float(se[i]),
                "boot_range95": _ci(bs[:, i]), "share_negative": float(np.mean(bs[:, i] < 0))}
            for i, (n, v) in enumerate(zip(names, (a0, w0, d0, c0)))} | {
        "within_context_each": [float(x) for x in within0], "contexts_negative": int(np.sum(np.array(within0) < 0))}


def pareto_mask(M):
    X = np.where(np.isfinite(M), M, -np.inf)
    n = len(X)
    nd = np.ones(n, bool)
    for i in range(n):
        dom = np.all(X >= X[i], axis=1) & np.any(X > X[i], axis=1)
        nd[i] = not dom.any()
    return nd


def pareto_uncertainty(df, min_cells=30, B=1000, seed=SEED):
    df = df.copy()
    df["r_fid_mag"] = df["r_fid"]
    df["arm_key"] = df[list(MENU_LEVERS)].astype(str).agg("|".join, axis=1)
    g = df.groupby("arm_key")
    n = g.size()
    keep = n[n >= min_cells].index
    sub = df[df["arm_key"].isin(keep)]
    groups = [grp[list(MENU_OBJ)].to_numpy(float) for _, grp in sub.groupby("arm_key")]
    keys = [k for k, _ in sub.groupby("arm_key")]

    def arm_means(rows):
        with warnings.catch_warnings():
            warnings.simplefilter("ignore", category=RuntimeWarning)   # an all-NaN column is NaN, ranked worst
            m = np.array([np.nanmean(r, axis=0) for r in rows])
        m[:, MENU_OBJ.index("r_fid_mag")] = np.abs(m[:, MENU_OBJ.index("r_fid_mag")])
        return m
    sets = {"six objectives": list(range(6)), "five, without r_sys": [0, 1, 2, 3, 4],
            "four, without r_sys and r_indiv": [0, 1, 2, 4]}
    point = arm_means(groups)
    rng = np.random.RandomState(seed + 17)
    hits = {s: np.zeros(len(groups)) for s in sets}
    for _ in range(B):
        bm = arm_means([r[rng.randint(0, len(r), len(r))] for r in groups])
        for s, cols in sets.items():
            hits[s] += pareto_mask(bm[:, cols])
    out = {"min_cells": min_cells, "settings": len(groups), "boot": B, "sets": {}}
    for s, cols in sets.items():
        p = hits[s] / B
        nd = pareto_mask(point[:, cols])
        out["sets"][s] = {"non_dominated_point": int(nd.sum()), "expected_non_dominated": float(p.sum()),
                          "p_at_least_0.95": int((p >= 0.95).sum()), "p_at_least_0.5": int((p >= 0.5).sum()),
                          "p_below_0.05": int((p < 0.05).sum())}
    out["all_settings_rankable"] = int((n >= 4).sum())
    out["keys"] = keys
    return out


def task1_target(core):
    """Task 1's targets mix toward the pooled best arm on r_total (signed). Read its composite value beside the
    composite's own pooled best and the uniform policy, on all 50 seeds."""
    c = core.copy()
    c["comp"] = c["r_util"] + c["r_safe"] + c["r_fid"].abs()
    by = c.groupby("config_idx")
    a_tot, a_comp = int(by["r_total"].mean().idxmax()), int(by["comp"].mean().idxmax())
    u = float(c["comp"].mean())
    return {"pooled_best_on_r_total": a_tot, "pooled_best_on_composite": a_comp,
            "composite_uniform": u, "composite_of_r_total_best": float(by["comp"].mean()[a_tot]),
            "composite_of_composite_best": float(by["comp"].mean()[a_comp]),
            "gain_r_total_best_over_uniform": float(by["comp"].mean()[a_tot] - u),
            "gain_composite_best_over_uniform": float(by["comp"].mean()[a_comp] - u)}


def load(root):
    core = pd.read_parquet(os.path.join(root, "core", "trace.parquet"))
    frames = []
    for t in TIERS:
        f = os.path.join(root, t, "trace.parquet")
        if not os.path.isfile(f):
            raise SystemExit(f"[task2] FATAL: {f} is missing; the Pareto reading covers the menu's four tiers")
        d = pd.read_parquet(f); d["tier"] = t; frames.append(d)
    return core, pd.concat(frames, ignore_index=True)


def run(root, out, B=2000, splits=200, pboot=1000):
    mp = os.path.join(root, "menu.json")
    env = dict(ENVELOPE)
    if os.path.isfile(mp):
        menv = {k: float(json.load(open(mp))["envelope"][k]) for k in ENVELOPE}
        if menv != ENVELOPE:
            raise SystemExit(f"[task2] FATAL: {mp} was built with the envelope {menv}, not the published {ENVELOPE}; "
                             f"Task 2's constraint is the published one")
    core, allt = load(root)
    T, ctxs, seeds, arms = core_tensors(core)
    res = {"protocol": __doc__.split("THE TASK.")[1].split("BASELINES")[0].strip(), "root": root,
           "envelope": env, "envelope_source": "the published envelope" + (", matched by menu.json"
                                                                           if os.path.isfile(mp) else ""),
           "contexts": ctxs, "arms": [int(a) for a in arms], "n_seeds": len(seeds)}
    res["task2"] = task2(T, env, B=B, splits=splits)
    res["tension"] = tension(T, B=B)
    res["pareto"] = pareto_uncertainty(allt, B=pboot)
    res["task1_target"] = task1_target(core)
    Path(out).write_text(json.dumps(res, indent=1))
    t2 = res["task2"]
    for k, s in t2["policies"].items():
        print(f"[task2] {k:<20} violation {s['violation']:.3f} {s['violation_ci95']}  value {s['value']:.4f} "
              f"[{s['value_ci95'][0]:.4f}, {s['value_ci95'][1]:.4f}]  hypervolume {s['hypervolume']:.3f}")
    for p, v in t2["paired_value"].items():
        print(f"[task2] {p:<40} {v['point']:+.4f}  bootstrap [{v['ci95'][0]:+.4f}, {v['ci95'][1]:+.4f}]")
    print(f"[task2] envelope reach: {json.dumps(t2['envelope_reach'])}")
    print(f"[task2] splits: {json.dumps(t2['splits'])}")
    print(f"[task2] choices: {t2['choices']}")
    for n, v in res["tension"].items():
        if isinstance(v, dict):
            print(f"[tension] {n:<28} r {v['r']:+.3f} [{v['ci95'][0]:+.3f}, {v['ci95'][1]:+.3f}] negative in "
                  f"{100 * v['share_negative']:.1f}% of draws")
    print(f"[tension] contexts with a negative within-context r: {res['tension']['contexts_negative']} of {len(ctxs)}")
    print(f"[pareto] {json.dumps({k: v for k, v in res['pareto'].items() if k != 'keys'})}")
    print(f"[task1] {json.dumps(res['task1_target'])}")
    print(f"[task2] wrote {out}")
    return res


def _fixture(td, signal=True):
    rng = np.random.RandomState(4)
    rows = []
    for c in range(4):
        for s in range(20):
            for a in range(6):
                best = 2 if c < 2 else 4
                u = 0.5 + (0.2 if (signal and a == best) else 0.0) + rng.normal(0, 0.02)
                rows.append({"s_pool_imbalance": float(c), "s_bad_actor_frac": 0.1, "seed": s, "config_idx": a,
                             "r_util": u, "r_safe": (0.95 if not (signal and a == 5 and c == 0) else 0.80)
                             + (0.0 if signal else rng.normal(0, 0.005)),
                             "r_fid": -0.1 - (0.01 * a if signal else rng.normal(0, 0.005)),
                             "r_fair": -0.05 - 0.002 * a + rng.normal(0, 0.005), "r_total": u,
                             "text_health": "HEALTHY", "canary_caught": 1.0, "r_indiv": 0.3, "r_sys": -1.0,
                             "a_delta_scale": 1.0, "a_clamp": 0.0025, "a_rank": 24.0, "a_arditi_alpha": float(a),
                             "a_temperature": 0.7, "a_mc_dropout": 0.0, "a_cfg_scale": 1.0})
    return pd.DataFrame(rows)


def selftest():
    ok = True
    env = {"tox_floor": 0.15, "min_coh": 0.5, "min_canary": 0.5}
    T, *_ = core_tensors(_fixture(None))
    r = task2(T, env, B=200, splits=40)
    pol = r["policies"]
    good = (r["choices"]["per-context greedy"] == [2, 2, 4, 4]
            and r["paired_value"]["per-context greedy - best fixed"]["ci95"][0] > 0
            and r["envelope_reach"]["all 50 seeds"]["pairs_breaching"] == 1
            and r["envelope_reach"]["all 50 seeds"]["by_constraint"]["toxicity"] == 1
            and pol["random acceptable"]["violation"] == 0.0 and abs(pol["uniform"]["violation"] - 1 / 24) < 1e-12)
    print(f"  PLANTED-PASS   a contextual best (2, 2, 4, 4) is found by the greedy baseline, beats the best fixed "
          f"setting with its interval clear of zero, and the one breaching pair is counted -> {'OK' if good else 'FAIL'}")
    ok &= good
    T0, *_ = core_tensors(_fixture(None, signal=False))
    r0 = task2(T0, env, B=200, splits=40)
    lo, hi = r0["paired_value"]["per-context greedy - best fixed"]["ci95"]
    good = lo < 0.01 and r0["splits"]["greedy_minus_fixed"]["mean"] < 0.01
    print(f"  PLANTED-FAIL 1 on pure noise the greedy baseline gains nothing over the best fixed setting "
          f"({r0['splits']['greedy_minus_fixed']['mean']:+.4f}) -> {'OK' if good else 'FAIL'}")
    ok &= good
    holed = _fixture(None).iloc[1:]
    try:
        core_tensors(holed)
        print("  PLANTED-FAIL 2 a core with a missing cell was NOT refused -> FAIL"); ok = False
    except ValueError:
        print("  PLANTED-FAIL 2 a core with a missing cell is refused -> OK")
    strict = {"tox_floor": 0.01, "min_coh": 0.5, "min_canary": 0.5}
    try:
        baselines(T, np.arange(10), strict)
        print("  PLANTED-FAIL 3 an envelope no setting meets was NOT refused -> FAIL"); ok = False
    except ValueError:
        print("  PLANTED-FAIL 3 an envelope no setting meets is refused, never scored as zero -> OK")
    nan_df = _fixture(None); nan_df.loc[0, "r_safe"] = np.nan
    try:
        core_tensors(nan_df)
        print("  PLANTED-FAIL 4 a missing outcome was NOT refused -> FAIL"); ok = False
    except ValueError:
        print("  PLANTED-FAIL 4 a non-finite outcome is refused -> OK")
    M = np.array([[1, 1], [0, 0], [1, 0], [0.5, 2]], float)
    good = pareto_mask(M).tolist() == [True, False, False, True]
    print(f"  PLANTED-PASS   the Pareto mask keeps exactly the two non-dominated rows -> {'OK' if good else 'FAIL'}")
    ok &= good
    print("\n  SELFTEST PASSED" if ok else "\n  SELFTEST FAILED")
    return 0 if ok else 1


def main():
    ap = argparse.ArgumentParser(description=__doc__.split("\n")[0])
    ap.add_argument("--root", default=ROOT)
    ap.add_argument("--out", default="")
    ap.add_argument("--boot", type=int, default=2000)
    ap.add_argument("--splits", type=int, default=200)
    ap.add_argument("--pareto_boot", type=int, default=1000)
    ap.add_argument("--selftest", action="store_true")
    a = ap.parse_args()
    if a.selftest:
        return selftest()
    run(a.root, a.out or os.path.join(a.root, "core", "task2_core.json"), B=a.boot, splits=a.splits,
        pboot=a.pareto_boot)
    return 0


if __name__ == "__main__":
    sys.exit(main())