plainproof 0.1.0__py3-none-any.whl

plainproof/__init__.py

@@ -0,0 +1,4 @@
+"""EDM 2027 v2, step E0: classification-testing arm, outsourcing simulator, exact stopping time.
+
+Build and test only. Nothing here produces a reportable result before the protocol is approved.
+"""

plainproof/bank_from_fit.py

@@ -0,0 +1,44 @@
+"""Item bank from the ASSIST2009 development fit, with synthetic families (ruling, 24 Oct 2026).
+
+The ASSIST2009 file has no skill tags, so families are synthetic: items are sorted by difficulty, cut into
+strata, and dealt into 12 families of 13 so each family spans the difficulty range. Two families are held out
+for transfer only. Real q_ids are kept so BOBCAT can select among the same items.
+"""
+import json
+
+import numpy as np
+
+from .simulator import split_bank
+
+N_FAMILIES, HELD_OUT = 12, (10, 11)
+
+
+def load_fit(path):
+    rows = json.loads(open(path).read())
+    rows.sort(key=lambda r: r['q_id'])
+    return rows
+
+
+def build(fit_rows, c, seed):
+    rng = np.random.default_rng(seed)
+    q = np.array([r['q_id'] for r in fit_rows])
+    a = np.array([r['a'] for r in fit_rows])
+    b = np.array([r['b'] for r in fit_rows])
+    order = np.argsort(b, kind='stable')
+    family = np.empty(len(q), dtype=int)
+    for s in range(0, len(order), N_FAMILIES):                  # one stratum = N_FAMILIES adjacent difficulties
+        stratum = order[s:s + N_FAMILIES]
+        family[stratum] = rng.permutation(N_FAMILIES)[:len(stratum)]
+    bank = split_bank(a, b, np.full(len(q), float(c)), family, HELD_OUT, rng)
+    return bank, q
+
+PROBE_COUNT = 10   # ruling 25 Oct 2026: the hardest follow-up items by fitted difficulty, fixed before the freeze
+
+
+def probes(bank, q_ids, count=PROBE_COUNT):
+    """Global row indices and q_ids of the `count` hardest follow-up items (largest fitted b; ties by q_id).
+    Probes are ordinary items for selection, stopping, calibration and every primary comparison; only the
+    secondary signature analysis reads this list."""
+    fu = bank.rows('followup')
+    order = sorted(fu, key=lambda j: (-bank.b[j], int(q_ids[j])))[:count]
+    return [int(j) for j in order], [int(q_ids[j]) for j in order]

plainproof/cli.py

@@ -0,0 +1,84 @@
+"""plainproof: the command-line front end of this reproduction package.
+
+It runs the repository's own scripts, so it needs a checkout or the unpacked sdist (the sealed scripts locate the
+repository by its layout). Pass --root, or run it from the repository root.
+
+  plainproof fetch [bobcat|heldout|all]   fetch BOBCAT + the ASSISTments file (hash-checked), and/or the Zenodo outputs
+  plainproof fit                          refit the 2PL item parameters on ASSISTments development learners
+  plainproof run e0|e0b                   held-out run and summary (refuses to overwrite an existing cell)
+  plainproof figures                      rebuild tables and figures from the held-out summaries (needs R for the plots)
+  plainproof verify                       check every sealed file against both freezes
+"""
+import argparse
+import hashlib
+import os
+import subprocess
+import sys
+from pathlib import Path
+
+
+def find_root(given):
+    root = Path(given or os.getcwd()).resolve()
+    if not (root / 'substitutions.json').exists() or not (root / 'reports' / 'edm-v2-e0' / 'freeze.json').exists():
+        raise SystemExit(f'{root} is not a plainproof checkout (no substitutions.json or reports/); use --root')
+    return root
+
+
+def sh(root, *cmd):
+    env = dict(os.environ)
+    env.setdefault('REPRO_DATA', str(root / 'data'))
+    print('+', ' '.join(str(c) for c in cmd), flush=True)
+    r = subprocess.run([str(c) for c in cmd], cwd=root, env=env)
+    if r.returncode:
+        raise SystemExit(r.returncode)
+
+
+def sha(p):
+    return hashlib.sha256(Path(p).read_bytes()).hexdigest()
+
+
+def main(argv=None):
+    ap = argparse.ArgumentParser(prog='plainproof', description=__doc__.split('\n\n')[0])
+    ap.add_argument('--root', help='repository root (default: current directory)')
+    sub = ap.add_subparsers(dest='cmd', required=True)
+    f = sub.add_parser('fetch'); f.add_argument('what', nargs='?', default='all', choices=('bobcat', 'heldout', 'all'))
+    sub.add_parser('fit')
+    r = sub.add_parser('run'); r.add_argument('study', choices=('e0', 'e0b'))
+    sub.add_parser('figures')
+    sub.add_parser('verify')
+    a = ap.parse_args(argv)
+    root = find_root(a.root)
+    py = sys.executable
+    data = Path(os.environ.get('REPRO_DATA', root / 'data'))
+    if a.cmd == 'fetch':
+        if a.what in ('bobcat', 'all'):
+            sh(root, 'bash', 'scripts/bobcat/fetch_bobcat.sh')
+        if a.what in ('heldout', 'all'):
+            if not os.environ.get('ZENODO_URL'):
+                raise SystemExit('set ZENODO_URL to the Zenodo record file URL to fetch the held-out outputs')
+            sh(root, 'bash', 'scripts/fetch_heldout.sh')
+    elif a.cmd == 'fit':
+        sh(root, py, 'scripts/edm_v2_e0/fit_assist2009.py', data / 'edm-v2-e0' / 'item-fit')
+    elif a.cmd == 'run':
+        if a.study == 'e0':
+            out = data / 'edm-v2-e0' / 'heldout'
+            sh(root, py, 'scripts/edm_v2_e0/heldout.py', 'run', out)
+            sh(root, py, 'scripts/edm_v2_e0/heldout.py', 'summarize', out)
+        else:
+            out = data / 'edm-v2-e0b' / 'heldout'
+            sh(root, py, 'scripts/edm_v2_e0b/run.py', 'run', out)
+            sh(root, py, 'scripts/edm_v2_e0b/run.py', 'summarize', out)
+    elif a.cmd == 'figures':
+        s0, s1 = data / 'edm-v2-e0' / 'heldout' / 'summary.json', data / 'edm-v2-e0b' / 'heldout' / 'summary.json'
+        sh(root, py, 'scripts/edm_v2_e0/report.py', s0)
+        sh(root, 'bash', 'scripts/rscript.sh', 'scripts/edm_v2_e0/plot_error_vs_d.R', 'reports/edm-v2-e0/error-vs-d.csv',
+           'reports/edm-v2-e0/figures/error-vs-d.png', sha(s0))
+        sh(root, py, 'scripts/edm_v2_e0b/report.py', s1)
+        sh(root, 'bash', 'scripts/rscript.sh', 'scripts/edm_v2_e0b/plot_probe_auc.R', 'reports/edm-v2-e0b/probe-auc-vs-d.csv',
+           'reports/edm-v2-e0b/figures/probe-auc-vs-d.png', sha(s1))
+    elif a.cmd == 'verify':
+        sh(root, py, 'scripts/verify_frozen.py')
+
+
+if __name__ == '__main__':
+    main()

plainproof/fit.py

@@ -0,0 +1,56 @@
+"""Two-parameter logistic fit (c = 0) by marginal maximum likelihood (EM, Gauss-Hermite quadrature).
+
+Used to anchor simulated item parameters in real responses (ASSIST2009 development learners only).
+Missing responses are allowed. Guessing is not fitted: c is set per item in the simulator and stated
+as an assumption, because sparse open-response data do not identify it.
+"""
+import hashlib
+
+import numpy as np
+
+
+def dev_learner(user_id, salt='edm-v2-e0'):
+    """Fixed development/held-out split by hashed learner ID (half each); never by outcomes."""
+    h = hashlib.sha256(f'{salt}:{user_id}'.encode()).digest()
+    return h[0] % 2 == 0
+
+
+def fit_2pl(resp, n_quad=31, iters=200, tol=1e-6, prior_sd_loga=0.5):
+    """resp: learners x items array of 0/1 with NaN for missing. Returns (a, b, log-likelihood history)."""
+    resp = np.asarray(resp, dtype=float)
+    obs = ~np.isnan(resp)
+    u = np.nan_to_num(resp)
+    x, w = np.polynomial.hermite_e.hermegauss(n_quad)
+    w = w / w.sum()
+    n_items = resp.shape[1]
+    a, b = np.ones(n_items), np.zeros(n_items)
+    hist = []
+    for _ in range(iters):
+        p = 1 / (1 + np.exp(-a[None, :] * (x[:, None] - b[None, :])))          # quad x items
+        lp, lq = np.log(np.clip(p, 1e-12, 1)), np.log(np.clip(1 - p, 1e-12, 1))
+        ll = (u * obs) @ lp.T + ((1 - u) * obs) @ lq.T                          # learners x quad
+        m = ll.max(axis=1, keepdims=True)
+        post = np.exp(ll - m) * w[None, :]
+        marg = post.sum(axis=1, keepdims=True)
+        hist.append(float((np.log(marg) + m).sum()))
+        post /= marg
+        n_k = post.T @ obs                                                       # expected attempts
+        r_k = post.T @ (u * obs)                                                 # expected corrects
+        for j in range(n_items):                                                  # Newton step per item
+            for _ in range(5):
+                pj = 1 / (1 + np.exp(-a[j] * (x - b[j])))
+                res = r_k[:, j] - n_k[:, j] * pj
+                ww = n_k[:, j] * pj * (1 - pj)
+                dz_da, dz_db = x - b[j], -a[j]
+                la = np.log(a[j])
+                g = np.array([(res * dz_da).sum() * a[j] - la / prior_sd_loga ** 2, (res * dz_db).sum()])
+                H = -np.array([[(ww * dz_da ** 2).sum() * a[j] ** 2 + 1 / prior_sd_loga ** 2,
+                                (ww * dz_da * dz_db).sum() * a[j]],
+                               [(ww * dz_da * dz_db).sum() * a[j], (ww * dz_db ** 2).sum()]])
+                step = np.linalg.solve(H, g)
+                la, b[j] = la - step[0], b[j] - step[1]
+                a[j] = float(np.clip(np.exp(la), 0.05, 6.0))
+                b[j] = float(np.clip(b[j], -6, 6))
+        if len(hist) > 1 and abs(hist[-1] - hist[-2]) < tol * abs(hist[-2]):
+            break
+    return a, b, hist

plainproof/irt.py

@@ -0,0 +1,22 @@
+"""Three-parameter logistic model with D = 1, as catIrt's brm: P = c + (1 - c) / (1 + exp(-a (theta - b)))."""
+import numpy as np
+
+
+def p3pl(theta, a, b, c):
+    """Probability of a correct answer. Broadcasts over theta and item arrays."""
+    return c + (1.0 - c) / (1.0 + np.exp(-a * (theta - b)))
+
+
+def fisher_info(theta, a, b, c):
+    """Expected Fisher information, catIrt FI.brm(type='expected'): p'(theta)^2 / (p q)."""
+    p = p3pl(theta, a, b, c)
+    e = np.exp(-a * (theta - b))
+    dp = (1.0 - c) * a * e / (1.0 + e) ** 2
+    return dp ** 2 / (p * (1.0 - p))
+
+
+def loglik(u, theta, a, b, c):
+    """Sum of Bernoulli log-likelihoods for responses u (0/1) at one theta."""
+    p = p3pl(theta, np.asarray(a), np.asarray(b), np.asarray(c))
+    u = np.asarray(u, dtype=float)
+    return float(np.sum(u * np.log(p) + (1.0 - u) * np.log(1.0 - p)))

plainproof/planted.py

@@ -0,0 +1,133 @@
+"""E0b: planted hard probes (ruling 25 Oct 2026). New code; the frozen E0 modules are not changed.
+
+Three synthetic probe items per learner, difficulty 2.5, 3.0 and 3.5, discrimination at the bank median, c = 0,
+planted at combined positions 4, 9 and 14 of every method's path (positions count every item asked). Probes are
+asked but unscored: their answers never enter SPRT, BOBCAT, the posterior, calibration or stopping.
+
+Outsourcing of a probe uses the learner's own outsourcing model on the same dial d:
+  uniform      probability d;
+  uncertainty  min(1, s * g(p)), g(p) = 4 p (1 - p), with s the learner's scale solved on the follow-up bank alone
+               (as simulator.outsourcing_probs does), so the bank's share stays exactly d.
+Probe answers come from their own random stream, so scored answers are unchanged by planting.
+"""
+import numpy as np
+
+from .irt import p3pl
+from .simulator import g
+
+PROBE_B = (2.5, 3.0, 3.5)
+POSITIONS = (4, 9, 14)
+
+
+def scale(d, p_bank):
+    """The uncertainty model's per-learner scale s on the bank alone (same bisection as outsourcing_probs)."""
+    w = g(np.asarray(p_bank, dtype=float))
+    lo, hi = 0.0, 1.0
+    while np.minimum(1.0, hi * w).mean() < d:
+        hi *= 2.0
+    for _ in range(200):
+        mid = (lo + hi) / 2.0
+        if np.minimum(1.0, mid * w).mean() < d:
+            lo = mid
+        else:
+            hi = mid
+    return hi
+
+
+def probe_outsourcing(model, d, p_probe, p_bank):
+    p_probe = np.asarray(p_probe, dtype=float)
+    if model == 'uniform' or d in (0.0, 1.0):
+        return np.full(p_probe.shape, float(d))
+    return np.minimum(1.0, scale(d, p_bank) * g(p_probe))
+
+
+def plant(theta, model, d, a_ai, a_probe, bank_a, bank_b, bank_c, rng):
+    """One learner's three probe answers and true outsourced flags."""
+    b = np.array(PROBE_B)
+    p_own = p3pl(theta, a_probe, b, 0.0)
+    q = probe_outsourcing(model, d, p_own, p3pl(theta, bank_a, bank_b, bank_c))
+    out = rng.random(3) < q
+    correct = np.where(out, rng.random(3) < a_ai, rng.random(3) < p_own)
+    return correct.astype(int), out
+
+
+def scored_before(k):
+    """Number of scored items within the first k combined positions."""
+    return k - sum(1 for p in POSITIONS if p <= k)
+
+
+def probes_before(k):
+    return sum(1 for p in POSITIONS if p <= k)
+
+
+# Third outsourcing model, exploratory (ruling 25 Oct 2026): give-up. The outsourcing weight rises as the learner's
+# own chance on the item falls, peaking at p = 0: w(p) = 1 - p, scaled per learner so the mean share over the
+# follow-up bank equals d, like the other two models. Defined here so the frozen simulator is not changed.
+
+def w_giveup(p):
+    return 1.0 - np.asarray(p, dtype=float)
+
+
+def _scale_for(weights, d):
+    lo, hi = 0.0, 1.0
+    while np.minimum(1.0, hi * weights).mean() < d:
+        hi *= 2.0
+    for _ in range(200):
+        mid = (lo + hi) / 2.0
+        if np.minimum(1.0, mid * weights).mean() < d:
+            lo = mid
+        else:
+            hi = mid
+    return hi
+
+
+def giveup_probs(d, p_bank):
+    if d in (0.0, 1.0):
+        return np.full(np.shape(p_bank), float(d))
+    w = w_giveup(p_bank)
+    return np.minimum(1.0, _scale_for(w, d) * w)
+
+
+def probe_outsourcing_any(model, d, p_probe, p_bank):
+    if model == 'giveup':
+        p_probe = np.asarray(p_probe, dtype=float)
+        if d in (0.0, 1.0):
+            return np.full(p_probe.shape, float(d))
+        return np.minimum(1.0, _scale_for(w_giveup(p_bank), d) * w_giveup(p_probe))
+    return probe_outsourcing(model, d, p_probe, p_bank)
+
+
+def plant_any(theta, model, d, a_ai, a_probe, bank_a, bank_b, bank_c, rng):
+    b = np.array(PROBE_B)
+    p_own = p3pl(theta, a_probe, b, 0.0)
+    q = probe_outsourcing_any(model, d, p_own, p3pl(theta, bank_a, bank_b, bank_c))
+    out = rng.random(3) < q
+    correct = np.where(out, rng.random(3) < a_ai, rng.random(3) < p_own)
+    return correct.astype(int), out
+
+
+def make_world(bank, n, model, d, a_ai, seed, h_share=0.3, cut=0.0, margin=0.25):
+    """A frozen simulator.World for 'uniform'/'uncertainty'; for 'giveup', a subclass whose respond() uses the
+    give-up probabilities with the same random draws and logging as the frozen respond()."""
+    from .simulator import World
+    if model != 'giveup':
+        return World(bank, n, cut=cut, margin=margin, h_share=h_share, a_ai=a_ai, model=model, d=d, seed=seed)
+
+    class GiveUpWorld(World):
+        def respond(self, learner_id, followup_index):
+            l = self.learners[learner_id]
+            j = self._fu[followup_index]
+            p_own = float(p3pl(l.theta, self.bank.a[j], self.bank.b[j], self.bank.c[j]))
+            if learner_id not in self._q:
+                fa, fb, fc = self.followup_bank()
+                self._q[learner_id] = giveup_probs(self.d, p3pl(l.theta, fa, fb, fc))
+            if self.rng.random() < self._q[learner_id][followup_index]:
+                u, outsourced = int(self.rng.random() < self.a_ai), True
+            else:
+                u, outsourced = int(self.rng.random() < p_own), False
+            self.log[learner_id].append(self._row(j, 'followup', u, outsourced))
+            return u
+
+    w = GiveUpWorld(bank, n, cut=cut, margin=margin, h_share=h_share, a_ai=a_ai, model='uniform', d=d, seed=seed)
+    w.model = 'giveup'
+    return w

plainproof/reliability.py

@@ -0,0 +1,33 @@
+"""Reporting only: decisions never infer truth from assistance or confidence."""
+import math
+
+def matched_coverage(records,coverage):
+    if not 0<coverage<=1 or not records:raise ValueError('coverage/population')
+    ids=[r['id'] for r in records]
+    if len(ids)!=len(set(ids)):raise ValueError('duplicate decision ID')
+    for r in records:
+        if not 0<=r['p_mastery']<=1 or r['truth'] not in (0,1):raise ValueError('invalid decision')
+    # Confidence and stable public ID only. Truth cannot affect the selected set.
+    ranked=sorted(records,key=lambda r:(-max(r['p_mastery'],1-r['p_mastery']),r['id']))
+    n=math.ceil(len(records)*coverage);chosen=ranked[:n]
+    fm=sum(r['p_mastery']>=.5 and r['truth']==0 for r in chosen)
+    fg=sum(r['p_mastery']<.5 and r['truth']==1 for r in chosen)
+    return dict(total=len(records),decisions=n,inconclusive=len(records)-n,coverage=n/len(records),
+                false_mastery=fm,false_gap=fg,error_given_decision=(fm+fg)/n,
+                false_mastery_all=fm/len(records),false_gap_all=fg/len(records),
+                selected_ids=[r['id'] for r in chosen])
+
+def first_stop(history,threshold):
+    """One target's actual first passage. Never selects the best realized endpoint."""
+    if not .5<threshold<=1:raise ValueError('confidence threshold')
+    previous=-1
+    for row in history:
+        if row['budget']<=previous or not 0<=row['p_mastery']<=1:raise ValueError('bad trajectory')
+        previous=row['budget']
+        if max(row['p_mastery'],1-row['p_mastery'])>=threshold:return row
+    return None
+
+def crossing(budgets,errors,target):
+    if len(budgets)!=len(errors) or not budgets or any(a>=b for a,b in zip(budgets,budgets[1:])):raise ValueError('budget grid')
+    if not all(math.isfinite(x) for x in [*errors,target]):raise ValueError('nonfinite error')
+    return next((b for b,e in zip(budgets,errors) if e<=target),None)

plainproof/signature.py

@@ -0,0 +1,141 @@
+"""Secondary, descriptive: signatures of outsourcing in per-learner logs (ruling 25 Oct 2026).
+
+Six per-learner statistics, each computed on the first k follow-ups of the learner's SPRT order (k = 5, 10, 15,
+20), plus all of the learner's homework and transfer items. The direction in which outsourcing is expected to
+move each statistic is fixed here, before any held-out data exists; AUC is P(statistic is further in that
+direction for an outsourcing-cell learner than for an honest-cell learner), with ties counted half.
+Separation line: AUC 0.75, fixed now. No selection among the six.
+
+  1 difficulty_correctness   point-biserial correlation of item difficulty b with correctness. Honest answers
+                             fall off with difficulty (negative); outsourced answers do not. Expected: higher.
+  2 lz                       standardised log-likelihood person fit (Drasgow et al. 1985) at the honest EAP
+                             theta. Outsourcing misfits the item model. Expected: lower (statistic = -lz).
+  3 llr_outsourcing          log likelihood of the answers under "honest at theta plus uniform outsourcing at d
+                             with AI accuracy a" minus under "honest at theta", at the honest EAP theta.
+                             Zero when d = 0. Expected: higher.
+  4 hw_minus_fu              EAP theta from homework minus EAP theta from follow-ups. Follow-ups inflated by
+                             outsourcing. Expected: lower (statistic = -(hw - fu)).
+  5 fu_minus_transfer        EAP theta from follow-ups minus EAP theta from transfer items (always own answers).
+                             Expected: higher.
+  6 sprt_confident_wrong     share of the k SPRT steps at which calibrated confidence was at least 0.90 and the
+                             implied decision disagreed with truth. Uses truth: a simulation-only check, not
+                             something a deployed system can compute. Expected: higher.
+  7 probe_excess             among the fixed probe items (the 10 hardest follow-ups) that the method actually asked
+                             in its first k, observed hit rate minus the rate predicted at the learner's EAP theta
+                             from those same k follow-ups. Computed per method on that method's own order, never
+                             pooled; NaN when no probe was asked, and the NaN count is reported. Expected: higher.
+Statistics 1 to 6 use the SPRT order; statistic 7 uses each method's order.
+"""
+import math
+
+import numpy as np
+
+from .irt import p3pl
+
+CHECKPOINTS = (5, 10, 15, 20)
+SEPARATION = 0.75
+DIRECTION = dict(difficulty_correctness=+1, lz=-1, llr_outsourcing=+1, hw_minus_fu=-1, fu_minus_transfer=+1,
+                 sprt_confident_wrong=+1, probe_excess=+1)
+REQUIRED_LOG_FIELDS = ('item', 'difficulty', 'bank', 'correct', 'outsourced')
+GRID = np.linspace(-4, 4, 161)
+
+
+def eap(a, b, c, u):
+    if len(u) == 0:
+        return float('nan')
+    ll = -GRID ** 2 / 2
+    for aj, bj, cj, uj in zip(a, b, c, u):
+        p = p3pl(GRID, aj, bj, cj)
+        ll = ll + np.log(p if uj else 1 - p)
+    w = np.exp(ll - ll.max())
+    return float((GRID * w).sum() / w.sum())
+
+
+def lz(a, b, c, u, theta):
+    p = p3pl(theta, np.asarray(a), np.asarray(b), np.asarray(c))
+    u = np.asarray(u, dtype=float)
+    l0 = np.sum(u * np.log(p) + (1 - u) * np.log(1 - p))
+    e = np.sum(p * np.log(p) + (1 - p) * np.log(1 - p))
+    v = np.sum(p * (1 - p) * np.log(p / (1 - p)) ** 2)
+    return float((l0 - e) / math.sqrt(v)) if v > 0 else float('nan')
+
+
+def llr_outsourcing(a, b, c, u, theta, d, a_ai):
+    p = p3pl(theta, np.asarray(a), np.asarray(b), np.asarray(c))
+    m = (1 - d) * p + d * a_ai
+    u = np.asarray(u, dtype=float)
+    return float(np.sum(u * (np.log(m) - np.log(p)) + (1 - u) * (np.log(1 - m) - np.log(1 - p))))
+
+
+def point_biserial(x, u):
+    x, u = np.asarray(x, dtype=float), np.asarray(u, dtype=float)
+    if len(x) < 2 or x.std() == 0 or u.std() == 0:
+        return 0.0
+    return float(np.corrcoef(x, u)[0, 1])
+
+
+def learner_stats(log, bank, sprt_order, k, d, a_ai, calibrated_conf, truth):
+    """log: the world's rows for one learner. sprt_order: follow-up global item ids in SPRT order.
+    calibrated_conf: calibrated SPRT confidence per step (len >= k)."""
+    for r in log:
+        for f in REQUIRED_LOG_FIELDS:
+            if f not in r:
+                raise ValueError(f'log row lacks {f}')
+    fu = {r['item']: r for r in log if r['bank'] == 'followup'}
+    asked = [fu[j] for j in sprt_order[:k]]
+    hw = [r for r in log if r['bank'] == 'homework']
+    tr = [r for r in log if r['bank'] == 'transfer']
+
+    def arr(rows):
+        it = [r['item'] for r in rows]
+        return bank.a[it], bank.b[it], bank.c[it], [r['correct'] for r in rows]
+
+    fa, fb, fc, fu_u = arr(asked)
+    th_fu = eap(fa, fb, fc, fu_u)
+    th_hw = eap(*arr(hw))
+    th_tr = eap(*arr(tr))
+    conf = np.asarray(calibrated_conf[:k])
+    if truth in (0, 1):
+        wrong = [(p >= 0.9 and truth == 0) or (p <= 0.1 and truth == 1) for p in conf]
+        cw = float(np.mean(wrong))
+    else:
+        cw = float('nan')
+    return dict(difficulty_correctness=point_biserial(fb, fu_u), lz=lz(fa, fb, fc, fu_u, th_fu),
+                llr_outsourcing=llr_outsourcing(fa, fb, fc, fu_u, th_fu, d, a_ai),
+                hw_minus_fu=th_hw - th_fu, fu_minus_transfer=th_fu - th_tr, sprt_confident_wrong=cw,
+                outsourced_share=float(np.mean([r['outsourced'] for r in asked])) if asked else float('nan'))
+
+
+def auc(honest, outsourcing, direction):
+    """P(outsourcing value is further in `direction` than an honest value); ties count half. NaNs dropped."""
+    h = np.asarray([x for x in honest if np.isfinite(x)]) * direction
+    o = np.asarray([x for x in outsourcing if np.isfinite(x)]) * direction
+    if len(h) == 0 or len(o) == 0:
+        return float('nan')
+    allv = np.concatenate([h, o])
+    order = allv.argsort(kind='mergesort')
+    ranks = np.empty(len(allv))
+    sorted_v = allv[order]
+    i = 0
+    while i < len(allv):                      # average ranks for ties
+        j = i
+        while j + 1 < len(allv) and sorted_v[j + 1] == sorted_v[i]:
+            j += 1
+        ranks[order[i:j + 1]] = (i + j) / 2 + 1
+        i = j + 1
+    r_o = ranks[len(h):].sum()
+    return float((r_o - len(o) * (len(o) + 1) / 2) / (len(h) * len(o)))
+
+
+def probe_excess(log, bank, order, k, probe_rows):
+    """Statistic 7 for one learner and one method's order (follow-up global item ids, in the order asked)."""
+    fu = {r['item']: r for r in log if r['bank'] == 'followup'}
+    asked = [fu[j] for j in order[:k]]
+    it = [r['item'] for r in asked]
+    theta = eap(bank.a[it], bank.b[it], bank.c[it], [r['correct'] for r in asked])
+    hit = [r for r in asked if r['item'] in set(probe_rows)]
+    if not hit:
+        return float('nan')
+    pj = [r['item'] for r in hit]
+    predicted = float(np.mean(p3pl(theta, bank.a[pj], bank.b[pj], bank.c[pj])))
+    return float(np.mean([r['correct'] for r in hit])) - predicted

plainproof/simulator.py

@@ -0,0 +1,165 @@
+"""Learner worlds for the outsourcing study. Truth lives here and never reaches an arm.
+
+One concept per world. Latent ability theta is drawn per learner; understanding is defined from theta alone
+(understands / gap / borderline), independent of every estimator. Items belong to families; within each
+family, homework, follow-up and transfer items come from disjoint banks, and some families are held out
+for transfer only.
+
+Answering:
+  own answer        correct with the 3PL probability P(theta) (guessing via c; slips via the upper curve)
+  outsourced answer correct with probability a_ai, whatever the learner's understanding
+Outsourcing models for follow-ups, on the same dial d in [0, 1]:
+  uniform      every follow-up is outsourced with probability d
+  uncertainty  item j is outsourced with probability min(1, s * g(p_j)), g(p) = 4 p (1 - p), which peaks at
+               p = 0.5; s is solved per learner so the mean over that learner's follow-up bank equals d.
+Homework is outsourced at its own share h (uniform). Transfer answers are always the learner's own.
+"""
+from dataclasses import dataclass
+
+import numpy as np
+
+from .irt import p3pl
+
+OUTSOURCING_MODELS = ('uniform', 'uncertainty')
+
+
+@dataclass(frozen=True)
+class Bank:
+    a: np.ndarray
+    b: np.ndarray
+    c: np.ndarray
+    family: np.ndarray
+    role: np.ndarray          # 'homework', 'followup', 'transfer'
+
+    def rows(self, role):
+        return np.flatnonzero(self.role == role)
+
+
+def split_bank(a, b, c, family, held_out_families, rng, shares=(0.4, 0.4, 0.2)):
+    """Assign roles. Held-out families are transfer-only; every other family is split three ways."""
+    a, b, c, family = (np.asarray(x) for x in (a, b, c, family))
+    role = np.empty(len(a), dtype=object)
+    for f in np.unique(family):
+        idx = np.flatnonzero(family == f)
+        if f in set(held_out_families):
+            role[idx] = 'transfer'
+            continue
+        idx = rng.permutation(idx)
+        n_hw = int(round(shares[0] * len(idx)))
+        n_fu = int(round(shares[1] * len(idx)))
+        role[idx[:n_hw]] = 'homework'
+        role[idx[n_hw:n_hw + n_fu]] = 'followup'
+        role[idx[n_hw + n_fu:]] = 'transfer'
+    return Bank(a.astype(float), b.astype(float), c.astype(float), family, role)
+
+
+def understanding(theta, cut, margin):
+    """1 understands, 0 gap, -1 borderline (kept as its own category, never forced to a side)."""
+    theta = np.asarray(theta)
+    out = np.full(theta.shape, -1)
+    out[theta >= cut + margin] = 1
+    out[theta <= cut - margin] = 0
+    return out
+
+
+def g(p):
+    return 4.0 * p * (1.0 - p)
+
+
+def outsourcing_probs(model, d, p_own):
+    """Per-item outsourcing probabilities for one learner's follow-up bank. Their mean equals d."""
+    p_own = np.asarray(p_own, dtype=float)
+    if not 0 <= d <= 1:
+        raise ValueError('d')
+    if model == 'uniform':
+        return np.full(p_own.shape, float(d))
+    if model != 'uncertainty':
+        raise ValueError('outsourcing model')
+    if d == 0:
+        return np.zeros(p_own.shape)
+    if d == 1:
+        return np.ones(p_own.shape)
+    w = g(p_own)
+    if not np.any(w > 0):
+        raise ValueError('no item near p = 0.5 can carry the share')
+    lo, hi = 0.0, 1.0
+    while np.minimum(1.0, hi * w).mean() < d:
+        hi *= 2.0
+        if hi > 1e12:
+            raise ValueError('share d not reachable')
+    for _ in range(200):
+        mid = (lo + hi) / 2.0
+        if np.minimum(1.0, mid * w).mean() < d:
+            lo = mid
+        else:
+            hi = mid
+    return np.minimum(1.0, hi * w)
+
+
+@dataclass
+class Learner:
+    id: int
+    theta: float
+    truth: int                 # 1 understands, 0 gap, -1 borderline
+    homework_score: float
+    transfer_score: float
+
+
+class World:
+    """One simulated population. Arms get only respond(); truth and theta stay here."""
+
+    def __init__(self, bank, n_learners, cut, margin, h_share, a_ai, model, d, seed,
+                 theta_mean=0.0, theta_sd=1.0):
+        if model not in OUTSOURCING_MODELS:
+            raise ValueError('outsourcing model')
+        if not (0 <= h_share <= 1 and 0 <= a_ai <= 1 and 0 <= d <= 1):
+            raise ValueError('share/accuracy')
+        self.bank, self.cut, self.margin = bank, cut, margin
+        self.a_ai, self.model, self.d = a_ai, model, d
+        self.rng = np.random.default_rng(seed)
+        theta = self.rng.normal(theta_mean, theta_sd, n_learners)
+        truth = understanding(theta, cut, margin)
+        hw, tr = bank.rows('homework'), bank.rows('transfer')
+        self.learners = []
+        self.log = {}      # truth-side per-learner log; never passed to an arm (same RNG draws as before)
+        for i, t in enumerate(theta):
+            p_hw = p3pl(t, bank.a[hw], bank.b[hw], bank.c[hw])
+            out = self.rng.random(len(hw)) < h_share
+            correct = np.where(out, self.rng.random(len(hw)) < a_ai, self.rng.random(len(hw)) < p_hw)
+            p_tr = p3pl(t, bank.a[tr], bank.b[tr], bank.c[tr])
+            tr_correct = self.rng.random(len(tr)) < p_tr
+            transfer = tr_correct.mean() if len(tr) else float('nan')
+            hw_score = float(correct.mean()) if len(hw) else float('nan')
+            self.learners.append(Learner(i, float(t), int(truth[i]), hw_score, float(transfer)))
+            self.log[i] = ([self._row(j, 'homework', c, o) for j, c, o in zip(hw, correct, out)]
+                           + [self._row(j, 'transfer', c, False) for j, c in zip(tr, tr_correct)])
+        self._fu = bank.rows('followup')
+        self._q = {}
+
+    def _row(self, j, bank_name, correct, outsourced):
+        return dict(item=int(j), difficulty=float(self.bank.b[j]), discrimination=float(self.bank.a[j]),
+                    bank=bank_name, family=int(self.bank.family[j]), correct=int(correct), outsourced=bool(outsourced))
+
+    def cohort(self, min_homework):
+        """'Comparable homework success': learners at or above a homework score, selected without truth."""
+        return [l for l in self.learners if l.homework_score >= min_homework]
+
+    def followup_bank(self):
+        """Item parameters an arm may see: follow-up items only, never truth, theta or the generator."""
+        f = self._fu
+        return self.bank.a[f].copy(), self.bank.b[f].copy(), self.bank.c[f].copy()
+
+    def respond(self, learner_id, followup_index):
+        """One follow-up answer (0/1). followup_index indexes followup_bank()."""
+        l = self.learners[learner_id]
+        j = self._fu[followup_index]
+        p_own = float(p3pl(l.theta, self.bank.a[j], self.bank.b[j], self.bank.c[j]))
+        if learner_id not in self._q:
+            fa, fb, fc = self.followup_bank()
+            self._q[learner_id] = outsourcing_probs(self.model, self.d, p3pl(l.theta, fa, fb, fc))
+        if self.rng.random() < self._q[learner_id][followup_index]:
+            u, outsourced = int(self.rng.random() < self.a_ai), True
+        else:
+            u, outsourced = int(self.rng.random() < p_own), False
+        self.log[learner_id].append(self._row(j, 'followup', u, outsourced))
+        return u

plainproof/sprt.py

@@ -0,0 +1,136 @@
+"""Wald SPRT classification at one cut score, with item selection by Fisher information at the cut.
+
+Matches catIrt 0.5.1 (termSPRT, itChoose with select='UW-FI', at='bounds', one bound):
+  log ratio = logLik(theta = cut + delta) - logLik(theta = cut - delta)
+  upper = log((1 - beta) / alpha) -> master (1); lower = log(beta / (1 - alpha)) -> non-master (0).
+  Next item: largest expected information at the cut among unused items; ties go to the earliest bank row
+  (R's order(decreasing=TRUE) is stable).
+Truncation at n_max is its own outcome ('truncated'), never a classification success. The theta-vs-cut
+fallback that catIrt applies at truncation is kept separately (fallback_decision) for replay only.
+"""
+import math
+from dataclasses import dataclass, field
+
+import numpy as np
+
+from .irt import fisher_info, loglik
+
+
+@dataclass
+class SPRTConfig:
+    cut: float
+    delta: float = 0.1
+    alpha: float = 0.05
+    beta: float = 0.05
+    n_max: int = 50
+    n_min: int = 1
+
+    def __post_init__(self):
+        if not (0 < self.alpha < 1 and 0 < self.beta < 1 and self.alpha + self.beta < 1):
+            raise ValueError('alpha/beta')
+        if self.delta <= 0 or self.n_max < 1 or not 1 <= self.n_min <= self.n_max:
+            raise ValueError('delta/n')
+
+    @property
+    def upper(self):
+        return math.log((1 - self.beta) / self.alpha)
+
+    @property
+    def lower(self):
+        return math.log(self.beta / (1 - self.alpha))
+
+
+@dataclass
+class SPRTState:
+    items: list = field(default_factory=list)
+    responses: list = field(default_factory=list)
+    log_ratios: list = field(default_factory=list)
+    decision: object = None   # 1 master, 0 non-master, 'truncated', or None while running
+
+
+class SPRTArm:
+    """One learner's sequential test over a fixed item bank (rows of a, b, c)."""
+
+    def __init__(self, a, b, c, config: SPRTConfig):
+        self.a, self.b, self.c = (np.asarray(x, dtype=float) for x in (a, b, c))
+        if not (self.a.shape == self.b.shape == self.c.shape) or self.a.ndim != 1:
+            raise ValueError('bank shape')
+        self.cfg = config
+        self.info_at_cut = fisher_info(config.cut, self.a, self.b, self.c)
+        self.state = SPRTState()
+
+    def next_item(self):
+        if self.state.decision is not None:
+            raise RuntimeError('test already ended')
+        return self.next_item_ignoring_decision()
+
+    def next_item_ignoring_decision(self):
+        used = set(self.state.items)
+        best, best_info = None, -math.inf
+        for j, v in enumerate(self.info_at_cut):
+            if j not in used and v > best_info:
+                best, best_info = j, v
+        if best is None:
+            raise RuntimeError('bank exhausted')
+        return best
+
+    def log_ratio(self):
+        it = self.state.items
+        u = self.state.responses
+        a, b, c = self.a[it], self.b[it], self.c[it]
+        return (loglik(u, self.cfg.cut + self.cfg.delta, a, b, c)
+                - loglik(u, self.cfg.cut - self.cfg.delta, a, b, c))
+
+    def answer(self, item, response):
+        if response not in (0, 1):
+            raise ValueError('response must be 0 or 1')
+        s = self.state
+        s.items.append(int(item))
+        s.responses.append(int(response))
+        lr = self.log_ratio()
+        s.log_ratios.append(lr)
+        n = len(s.items)
+        if n >= self.cfg.n_min:
+            if lr >= self.cfg.upper:
+                s.decision = 1
+            elif lr <= self.cfg.lower:
+                s.decision = 0
+        if s.decision is None and (n >= self.cfg.n_max or n >= len(self.a)):
+            s.decision = 'truncated'
+        return s.decision
+
+    def p_mastery(self):
+        """Reporting score for matched-coverage ranking: logistic of the log ratio
+        (posterior of 'cut + delta' against 'cut - delta' at equal prior). Not a calibrated probability."""
+        lr = self.state.log_ratios[-1] if self.state.log_ratios else 0.0
+        return 1.0 / (1.0 + math.exp(-lr))
+
+
+def run_sprt(a, b, c, config, respond):
+    """Run one test. respond(item_index) -> 0/1. Returns the final state."""
+    arm = SPRTArm(a, b, c, config)
+    while arm.state.decision is None:
+        j = arm.next_item()
+        arm.answer(j, respond(j))
+    return arm
+
+
+def run_sprt_full(a, b, c, config, respond):
+    """Run the fixed SPRT order to config.n_max without stopping (ruling 25 Oct 2026).
+
+    Returns (items, responses, log_ratios, native_stop, native_decision): native_stop is the first step at which
+    the boundary fired (None if never within n_max), native_decision its classification (1/0) or 'truncated'.
+    The same items, in the same order, as run_sprt up to the native stop.
+    """
+    arm = SPRTArm(a, b, c, config)
+    native_stop, native_decision = None, 'truncated'
+    for _ in range(min(config.n_max, len(arm.a))):
+        j = arm.next_item_ignoring_decision()
+        arm.state.items.append(int(j))
+        arm.state.responses.append(int(respond(j)))
+        lr = arm.log_ratio()
+        arm.state.log_ratios.append(lr)
+        n = len(arm.state.items)
+        if native_stop is None and n >= config.n_min and (lr >= config.upper or lr <= config.lower):
+            native_stop, native_decision = n, (1 if lr >= config.upper else 0)
+    return arm.state.items, arm.state.responses, arm.state.log_ratios, native_stop, native_decision

plainproof/stopping.py

@@ -0,0 +1,72 @@
+"""Expected SPRT stopping time when every item is identical (one fixed Bernoulli coin per response).
+
+With uniform outsourcing share d and AI accuracy a_ai, each follow-up is correct with probability
+    p_true = (1 - d) * P(theta) + d * a_ai,
+independently, while the SPRT still scores answers with the item model at cut +/- delta. The log ratio after
+k correct of n answers is k * w1 + (n - k) * w0, so the walk lives on (n, k) and the exact law of the stopping
+time, truncation included, is a finite-horizon calculation. Wald's approximation (no overshoot, no
+truncation) is reported beside it for reference; it is not used as the test truth.
+"""
+import math
+
+import numpy as np
+from scipy.optimize import brentq
+
+from .irt import p3pl
+
+
+def increments(a, b, c, cut, delta):
+    p_hi, p_lo = p3pl(cut + delta, a, b, c), p3pl(cut - delta, a, b, c)
+    return math.log(p_hi / p_lo), math.log((1 - p_hi) / (1 - p_lo))   # (correct, incorrect)
+
+
+def p_correct(theta, a, b, c, d, a_ai):
+    if not (0 <= d <= 1 and 0 <= a_ai <= 1):
+        raise ValueError('d/a_ai')
+    return (1 - d) * float(p3pl(theta, a, b, c)) + d * a_ai
+
+
+def exact(p_true, w1, w0, upper, lower, n_max, n_min=1):
+    """Exact stopping law. Returns expected length and the probabilities of each outcome."""
+    alive = np.zeros(n_max + 1)          # alive[k]: probability of k correct so far and not yet stopped
+    alive[0] = 1.0
+    e_n = 0.0
+    p_master = p_non = 0.0
+    for n in range(1, n_max + 1):
+        nxt = np.zeros(n_max + 1)
+        nxt[1:n + 1] += alive[:n] * p_true
+        nxt[0:n] += alive[:n] * (1 - p_true)
+        k = np.arange(n + 1)
+        lr = k * w1 + (n - k) * w0
+        if n >= n_min:
+            up = (lr >= upper) & (nxt[:n + 1] > 0)
+            dn = (lr <= lower) & (nxt[:n + 1] > 0)
+            pm, pn = nxt[:n + 1][up].sum(), nxt[:n + 1][dn].sum()
+            p_master += pm
+            p_non += pn
+            e_n += n * (pm + pn)
+            nxt[:n + 1][up | dn] = 0.0
+        alive = nxt
+    p_trunc = alive.sum()
+    e_n += n_max * p_trunc
+    return dict(expected_n=e_n, p_master=p_master, p_non_master=p_non, p_truncated=p_trunc)
+
+
+def wald(p_true, w1, w0, upper, lower):
+    """Wald's approximation without truncation: P(master) from the OC function, E[N] from Wald's identity."""
+    mu = p_true * w1 + (1 - p_true) * w0
+    A, B = upper, lower
+    if abs(mu) < 1e-12:
+        var = p_true * w1 ** 2 + (1 - p_true) * w0 ** 2
+        return dict(expected_n=-A * B / var, p_master=-B / (A - B))
+    f = lambda h: p_true * math.exp(h * w1) + (1 - p_true) * math.exp(h * w0) - 1
+    # Non-zero root h of E[exp(h Z)] = 1 has the sign opposite to mu.
+    lo, hi = (1e-9, 1.0) if mu < 0 else (-1.0, -1e-9)
+    while f(hi if mu < 0 else lo) <= 0:
+        if mu < 0:
+            hi *= 2
+        else:
+            lo *= 2
+    h = brentq(f, lo, hi)
+    p_master = (1 - math.exp(h * B)) / (math.exp(h * A) - math.exp(h * B))
+    return dict(expected_n=(p_master * A + (1 - p_master) * B) / mu, p_master=p_master)

plainproof-0.1.0.dist-info/METADATA

@@ -0,0 +1,95 @@
+Metadata-Version: 2.4
+Name: plainproof
+Version: 0.1.0
+Summary: Reproduction tool for the paper 'How many follow-up questions distinguish genuine understanding from apparent mastery?'. Not a general library. Its sealed checks can stop a run on purpose.
+Author: Vishnu Vettrivel
+License-Expression: MIT
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: numpy>=2.0
+Requires-Dist: scipy>=1.13
+Provides-Extra: run
+Requires-Dist: scikit-learn>=1.5; extra == "run"
+Requires-Dist: torch>=2.4; extra == "run"
+Provides-Extra: test
+Requires-Dist: pytest>=8; extra == "test"
+Requires-Dist: pytest-xdist>=3.5; extra == "test"
+Dynamic: license-file
+
+# plainproof
+
+Reproduction package for **"How many follow-up questions distinguish genuine understanding from apparent mastery?"** (EDM 2027 submission, simulation study). It asks how many adaptive follow-up questions a classification test needs to tell genuine understanding from apparent mastery at a calibrated confidence target, and how that changes as a learner outsources a share *d* of the follow-ups to an AI. A second, sealed study (E0b) tests whether planted hard probe items separate outsourcing learners from honest ones.
+
+Everything here is CPU-only and needs no paid service. Code: MIT (`LICENSE`). Docs, figures and tables: CC BY 4.0 (`LICENSE-docs.md`).
+
+## From clone to the figure (about 10 minutes)
+
+The `plainproof` command runs each step (`plainproof --help`); the raw script calls below are what it runs. The local path inside the sealed `scripts/edm_v2_e0/r_env.sh` is part of the frozen record; use the `scripts/rscript.sh` wrapper, which `plainproof figures` calls.
+
+```sh
+git clone <this repository> && cd plainproof
+python3.11 -m venv .venv && . .venv/bin/activate && pip install -e '.[test,run]'   # or: pip install -r requirements.txt
+
+# 1. Tests (43): SPRT against catIrt 0.5.1's saved steps, exact stopping time, simulator, signatures, planted probes
+python -m pytest -n auto -q tests
+
+# 2. Check that the code here is the sealed code (undoes the documented path substitutions, then compares sha256)
+plainproof verify
+
+# 3. Fetch the sealed held-out outputs from Zenodo (DOI: to be assigned) and check their hashes
+ZENODO_URL=<record file URL> plainproof fetch heldout
+
+# 4. Rebuild the tables and figures from the held-out summaries (needs R 4.x for the plots; base graphics only)
+python scripts/edm_v2_e0/report.py data/edm-v2-e0/heldout/summary.json
+scripts/rscript.sh scripts/edm_v2_e0/plot_error_vs_d.R reports/edm-v2-e0/error-vs-d.csv reports/edm-v2-e0/figures/error-vs-d.png aff9a8c49d48821c0e9343cd058c4e0e2f1659ffabcaa719824412f3b14abc90
+python scripts/edm_v2_e0b/report.py data/edm-v2-e0b/heldout/summary.json
+scripts/rscript.sh scripts/edm_v2_e0b/plot_probe_auc.R reports/edm-v2-e0b/probe-auc-vs-d.csv reports/edm-v2-e0b/figures/probe-auc-vs-d.png 617be427feac24df2e342da00d34e91c78d5de91592cee390ef3516ae9e2ff3f
+```
+
+The figures land in `reports/edm-v2-e0/figures/` and `reports/edm-v2-e0b/figures/`; the committed copies are the same files.
+
+## Full rerun (about 4 hours of CPU)
+
+Only if you want to regenerate everything, including the held-out outputs.
+
+```sh
+# a. BOBCAT (MIT) at the pinned commit, with the preprocessed ASSISTments 2009-2010 file; the data's own terms forbid
+#    passing it on, so you fetch it from its source and accept them yourself
+scripts/bobcat/fetch_bobcat.sh
+# b. Item fit on the development half of ASSISTments learners (the output is checked against the receipt's hash)
+python scripts/edm_v2_e0/fit_assist2009.py data/edm-v2-e0/item-fit
+# c. Retrain the BOBCAT checkpoint (about 2 hours; author defaults, fold 1, seed 221), then compare it with the original
+python scripts/bobcat/retrain.py && python scripts/bobcat/check_checkpoint.py
+# d. catIrt fixture, development stages, held-out runs (each refuses to overwrite an existing cell)
+scripts/rscript.sh scripts/edm_v2_e0/catirt_sprt_steps.R tests/fixtures/edm_v2_catirt_sprt
+python scripts/edm_v2_e0/heldout.py run data/edm-v2-e0/heldout && python scripts/edm_v2_e0/heldout.py summarize data/edm-v2-e0/heldout
+python scripts/edm_v2_e0b/run.py run data/edm-v2-e0b/heldout && python scripts/edm_v2_e0b/run.py summarize data/edm-v2-e0b/heldout
+```
+
+Two caveats, stated plainly. The sealed code checks the item fit's sha256, so a different numpy can stop step b; and it asserts that the BOBCAT checkpoint's best epoch is 105, so a retrain that is not bit-identical can stop step d. In either case, use the Zenodo outputs. The development stages (`study.py tune|calibrate|calibrate_sprt_full|pilot`) are included for the record; their outputs (synthetic learners only) are in `data/edm-v2-e0/study/`.
+
+## Fingerprints (sha256)
+
+| What | sha256 |
+|---|---|
+| E0 sealed freeze `reports/edm-v2-e0/freeze.json` | `a0f8ce404f2b5f7e671e2503a33b4554040e80714f6053553507e0972acdbcdc` |
+| E0b sealed freeze `reports/edm-v2-e0b/freeze.json` | `3fa0b8d457d813f59abd5255f9303e44deb2119ee79d6a9b92439a6c1cbf58ed` |
+| E0 held-out summary (Zenodo, `e0-heldout.tar` → `heldout/summary.json`) | `aff9a8c49d48821c0e9343cd058c4e0e2f1659ffabcaa719824412f3b14abc90` |
+| E0b held-out summary (Zenodo, `e0b-heldout.tar` → `heldout/summary.json`) | `617be427feac24df2e342da00d34e91c78d5de91592cee390ef3516ae9e2ff3f` |
+| Zenodo `e0-heldout.tar` | `bd06a11eb7163da102cad6ea0df12ea79e52ff94aab1dc35d28ec3910af2be22` |
+| Zenodo `e0b-heldout.tar` | `68219f228c41da972fe4c8f92c218e01f85f08eed864185f237cecda05314bbf` |
+| ASSISTments 2009 file at BOBCAT e6b6245e | `c07ca9fa0f08207b06488cec527725938fe96e81e3c1762839e1ad0b84f974cc` |
+| 2PL item fit (regenerated in step b) | `12a3b167cd9c9b78b3c3c7faf71b2e464b0943a454f6418faf0f99b1114cb7fc` |
+| catIrt 0.5.1 CRAN binary used for the fixture | `f5418f447e91d184791e668bd2a135ea5da40c981d4a76826018295b6ea9f079` |
+
+## What is in here
+
+- `src/plainproof/`: item model, SPRT arm, exact stopping time, simulator (uniform and uncertainty-triggered outsourcing), item fit, signatures, planted probes (with the give-up model), matched-coverage scoring.
+- `scripts/edm_v2_e0/`, `scripts/edm_v2_e0b/`: the runners, report builders and R plots. `scripts/published_cat_reference_v1/`: the BOBCAT loading code the runners call.
+- `reports/`: both sealed freezes, receipts, figures and tables. `docs/`: the E0 protocol and the pre-registration log (verbatim extract).
+- `substitutions.json`: the only differences between this code and the sealed originals (package name, file locations, data paths). `scripts/verify_frozen.py` undoes them and checks every hash. `scripts/edm_v2_e0/r_env.sh` is kept verbatim as the record of the original R runtime; use `scripts/rscript.sh` instead.
+
+## Recorded departures
+
+All are in `docs/PREREG_EDM_V2.md`: the SPRT tuning rule was revised after its first development pass (labelled post hoc); SPRT's calibration map was refitted once on full paths before the freeze; the E0 held-out run exceeded its 2 GiB memory cap (no result depends on it; the runner now enforces the cap); E0b was sealed before its pilot table had been reviewed (no result affected).

plainproof-0.1.0.dist-info/RECORD

@@ -0,0 +1,17 @@
+plainproof/__init__.py,sha256=IS3b5iDYXrJDFQpyYxD9uV59r2N81UrFMsnse3fB8GY,198
+plainproof/bank_from_fit.py,sha256=358IWp85LgIC6zG0AjwN22U1iR3lWhYDsuLDVNGHYVc,1836
+plainproof/cli.py,sha256=9-8yhSdmh2pOmBZu1yCVqooEmQUvB3EY6pEFgq45ZgM,3966
+plainproof/fit.py,sha256=lDUAW-UwSUbGCv8M-uCCwQaVC_Bv4xu345tBA4e5aHE,2850
+plainproof/irt.py,sha256=DSMeUFC8XAoC9MWyfPwk2VXUB5s1DwbgZ7oPN976MQs,852
+plainproof/planted.py,sha256=LoDNUDFb8c-vpynexEJSdwxlD2nbHUMPhK_xNXVRuHg,5272
+plainproof/reliability.py,sha256=gW4agB4FuuF3irkh6xiE-G8HJCh1JTnV9ZeCWGSjJys,1899
+plainproof/signature.py,sha256=YVLNsb3r12Q4WawhMRYNUNCpwhplaFgids8GMbxKUAg,7033
+plainproof/simulator.py,sha256=hWSUnlwupC6rL7dQKLqCtwSFl0d8iETev9mE2cbQZAw,7065
+plainproof/sprt.py,sha256=MSna0x6hGDBlGuRzhw0M6Az4Mh5IpG218KEORArGXi4,5337
+plainproof/stopping.py,sha256=XHgQt-YnvyHFJ10o8VWg_gTMqQ2YFEY1BD2p5KbsFZ8,3014
+plainproof-0.1.0.dist-info/licenses/LICENSE,sha256=5hECxLv0f1ZSjmzY2K12w-0abXZZjpaxjSeHa5gvAeM,1073
+plainproof-0.1.0.dist-info/METADATA,sha256=Wo6oexmbf6HJB8vufYTJ-_7eVdKlQ4RAfhHLOY2jFgQ,7112
+plainproof-0.1.0.dist-info/WHEEL,sha256=mOdXR9C3wMVov7cSY8PY-XCzo3SmmWCHvGQr5csJoao,91
+plainproof-0.1.0.dist-info/entry_points.txt,sha256=d2viDRssQqNdKLcwArfQN-oB-KaL5npxs7pxT2VVYWc,51
+plainproof-0.1.0.dist-info/top_level.txt,sha256=rChE4Zof7WNLGxbWIjQl5znA_v6sDKntwCqTgt3p3wM,11
+plainproof-0.1.0.dist-info/RECORD,,

plainproof-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (84.2.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

plainproof-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+plainproof = plainproof.cli:main

plainproof-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,16 @@
+MIT License
+
+Copyright (c) 2026 Vishnu Vettrivel
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated
+documentation files (the "Software"), to deal in the Software without restriction, including without limitation the
+rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit
+persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the
+Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE
+WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

plainproof-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+plainproof