OSCR

Single-subject auditory ERP-BCI performance enhancement in ALS via an AI coding assistant prompt.

Code ↔ Paper

10 matches between paragraphs of the paper and lines of its authors' code, computed by the harvester (lexical-v1). Click a colored paragraph or line to see its counterpart.

The 10 matches
  1. [1] § Results › Offline cross-validation accuracy ↔ analysis_codes/fig4_cv_confusion.py, lines 1–37 · score 0.87 · row normalized confusion, baseline LASSO, cross validation, Baseline LDA, StratifiedKFold, baseline SVM
  2. [2] § Results › Offline cross-validation accuracy ↔ analysis_codes/fig4_cv_confusion.py, lines 1–37 · score 0.78 · confusion matrices, baseline LASSO, cross validation, baseline LDA, StratifiedKFold, baseline SVM
  3. [3] § Materials and methods › Baseline system ↔ compute_lda_baseline.py, lines 1–24 · score 0.76 · 0.1–30 Hz, feature vector, Baseline LDA, taps, FIR, auto
  4. [4] § Materials and methods › The AI-Designed ERP classifier (AIDE) › Evaluation ↔ compute_metrics.py, lines 186–249 · score 0.74 · GroupKFold, temporal split, StratifiedKFold, LODO, LOTO, undersampled
  5. [5] § Materials and methods › The AI-Designed ERP classifier (AIDE) › Evaluation ↔ compute_lda_baseline.py, lines 197–241 · score 0.72 · GroupKFold, temporal split, StratifiedKFold, LODO, LOTO, day
  6. [6] § Results › Offline cross-validation accuracy ↔ compute_lda_baseline.py, lines 197–241 · score 0.72 · temporal split, Baseline LDA, StratifiedKFold, baseline SVM, LODO, LOTO
  7. [7] § Results › Feature space visualization ↔ compute_lda_baseline.py, lines 1–24 · score 0.71 · 0.1–30 Hz, baseline correction, feature vector, baseline SVM, FIR, downsampling
  8. [8] § Materials and methods › The AI-Designed ERP classifier (AIDE) › Preprocessing ↔ model_v2.py, lines 1–23 · score 0.65 · sub delta, low band, high band, gamma
  9. [9] § Materials and methods › The AI-Designed ERP classifier (AIDE) › Feature extraction ↔ model_v2.py, lines 1–23 · score 0.62 · log scale variance, ERP waveform, gamma, band, ds
  10. [10] § Results › Online test ↔ analysis_codes/fig7_generate_online_confusion.py, lines 1–45 · score 0.53 · online trials, confusion matrices, AIDE, Figure 7, class, baseline

Paper

Loaded from Europe PMC by your browser, not stored by OSCR: doi.org · Europe PMC

The paper is loaded when this pane is shown.

The authors' code

Python · 241 lines · 9.1 KB · no license · 4 matches

  1. """
  2. Baseline LDA cross-validation across all 5 strategies.
  4. Baseline pipeline (identical to Baseline SVM in paper):
  5. FIR bandpass 0.1-30 Hz (21 taps, filtfilt)
  6. Epoch 1000 ms (250 samples), baseline correction 5 samples
  7. SEQ=5 repetitions averaged per label
  8. Downsample: mean-pool into 10 bins (250//10 = 25 samples/bin)
  9. All 8 channels
  10. Concatenate mean ERP of labels 1, 2, 3 → feature vector
  12. Classifier swap: LinearSVC → LDA(solver='lsqr', shrinkage='auto')
  13. """
  15. import os, warnings
  16. import numpy as np
  17. import pandas as pd
  18. from sklearn.discriminant_analysis import LinearDiscriminantAnalysis as LDA
  19. from sklearn.svm import LinearSVC
  20. from sklearn.model_selection import StratifiedKFold, LeaveOneGroupOut, GroupKFold
  21. from sklearn.preprocessing import StandardScaler
  22. from scipy.signal import firwin, filtfilt
  24. warnings.filterwarnings("ignore")
  26. # ── paths & constants ──────────────────────────────────────────────────────
  27. DATA_FOLDER = "./sub1_8ch"
  28. SR = 250 # sampling rate
  29. WS = 250 # epoch window (1000 ms)
  30. SEQ = 5 # repetitions per label
  31. NUMTAPS = 21
  32. LOW_CUT = 0.1
  33. HIGH_CUT = 30.0
  34. BL = 5 # baseline samples
  35. DS_RATE = 10 # downsampling: WS//DS_RATE = 25 samples/bin → 10 bins
  36. EPOCH_PATTERN = [0, 1, 2] # labels 1, 2, 3 (indices into [L1, L2, L3, L4])
  38. # 2022 vs 2025-26 split dates
  39. TRAIN_DATES = {"20220916", "20221003", "20221101", "20221115", "20221121"}
  40. TEST_DATES = {"20250725", "20250822", "20250903", "20251217", "20260121"}
  41. ALL_DATES = sorted(TRAIN_DATES | TEST_DATES)
  43. SESSION_ORDER = {d: i for i, d in enumerate(ALL_DATES)}
  45. # ── FIR filter coefficients ────────────────────────────────────────────────
  46. nyq = SR / 2
  47. b_fir = firwin(NUMTAPS, [LOW_CUT / nyq, HIGH_CUT / nyq], pass_zero=False)
  49. # ── feature extraction for one CSV file ───────────────────────────────────
  50. def extract(path):
  51. df = pd.read_csv(path)
  52. data = df.values
  53. stim = np.nan_to_num(data[:, 9], nan=0)
  55. onsets = np.where(np.diff(stim) != 0)[0] + 1
  56. onsets = onsets[stim[onsets] != 0][: 4 * SEQ]
  58. ch_cols = [c for c in df.columns if c.startswith("Ch") and c[2:].isdigit()]
  59. cidx = [list(df.columns).index(c) for c in ch_cols]
  60. eeg = data[:, cidx] * -1 # polarity inversion
  61. eeg = StandardScaler().fit_transform(eeg) # z-score per channel
  62. eeg = filtfilt(b_fir, 1.0, eeg, axis=0) # FIR bandpass
  64. ds_factor = WS // DS_RATE # 25 samples per bin → 10 bins
  65. n_ch = eeg.shape[1]
  67. eps_by_lbl = {}
  68. for o in onsets:
  69. if o + WS <= eeg.shape[0]:
  70. lbl = int(stim[o])
  71. bs = max(0, o - BL)
  72. ep = eeg[o: o + WS] - eeg[bs:o].mean(axis=0)
  73. eps_by_lbl.setdefault(lbl, []).append(ep)
  75. label_features = []
  76. for lbl in [1, 2, 3, 4]:
  77. eps = eps_by_lbl.get(lbl, [])
  78. if eps:
  79. mean_ep = np.array(eps).mean(axis=0) # (WS, n_ch)
  80. else:
  81. mean_ep = np.zeros((WS, n_ch))
  82. down = mean_ep.reshape(-1, ds_factor, n_ch).mean(axis=1) # (10, n_ch)
  83. label_features.append(down.flatten())
  85. feat = np.concatenate([label_features[i] for i in EPOCH_PATTERN])
  86. return feat
  89. # ── load all trials ────────────────────────────────────────────────────────
  90. print("Loading data …")
  91. X_list, y_list, sessions = [], [], []
  92. for fname in sorted(os.listdir(DATA_FOLDER)):
  93. if not fname.endswith(".csv"):
  94. continue
  95. parts = fname.replace(".csv", "").split("_")
  96. if len(parts) < 3:
  97. continue
  98. date = parts[0]
  99. try:
  100. label = int(parts[-1])
  101. except ValueError:
  102. continue
  103. if label not in (1, 2, 3):
  104. continue
  106. path = os.path.join(DATA_FOLDER, fname)
  107. try:
  108. feat = extract(path)
  109. X_list.append(feat)
  110. y_list.append(label)
  111. sessions.append(SESSION_ORDER[date])
  112. except Exception as e:
  113. print(f" skip {fname}: {e}")
  115. X = np.vstack(X_list)
  116. y = np.array(y_list)
  117. sessions = np.array(sessions)
  118. print(f"Loaded {len(y)} trials, feature dim={X.shape[1]}, classes={np.unique(y)}")
  121. # ── shared evaluation helper ───────────────────────────────────────────────
  122. def undersample_train(X_tr, y_tr, rng):
  123. ulabs = np.unique(y_tr)
  124. mn = min((y_tr == l).sum() for l in ulabs)
  125. idx = np.concatenate([rng.choice(np.where(y_tr == l)[0], mn, replace=False)
  126. for l in ulabs])
  127. return X_tr[idx], y_tr[idx]
  129. def strat_kfold_acc(X, y, clf_fn, n_seeds=10):
  130. scores_all = []
  131. for seed in range(n_seeds):
  132. rng = np.random.default_rng(seed)
  133. s = []
  134. for k in (3, 4):
  135. cv = StratifiedKFold(n_splits=k, shuffle=True, random_state=seed)
  136. for tr, te in cv.split(X, y):
  137. Xtr, ytr = undersample_train(X[tr], y[tr], rng)
  138. clf = clf_fn(seed)
  139. clf.fit(Xtr, ytr)
  140. s.append(clf.score(X[te], y[te]))
  141. scores_all.append(np.mean(s))
  142. return np.mean(scores_all)
  144. def lodo_acc(X, y, sessions, clf_fn):
  145. """Leave-One-Day-Out: leave each unique session out in turn."""
  146. logo = LeaveOneGroupOut()
  147. session_scores = {}
  148. for tr, te in logo.split(X, y, sessions):
  149. sess_id = sessions[te[0]]
  150. rng = np.random.default_rng(42)
  151. Xtr, ytr = undersample_train(X[tr], y[tr], rng)
  152. clf = clf_fn(42)
  153. clf.fit(Xtr, ytr)
  154. session_scores[sess_id] = clf.score(X[te], y[te])
  155. return np.mean(list(session_scores.values())), session_scores
  157. def loto_acc(X, y, clf_fn):
  158. """Leave-One-Trial-Out: strict leave-one-out over all 189 trials."""
  159. from sklearn.model_selection import LeaveOneOut
  160. loo = LeaveOneOut()
  161. correct = 0
  162. for tr, te in loo.split(X):
  163. rng = np.random.default_rng(42)
  164. Xtr, ytr = undersample_train(X[tr], y[tr], rng)
  165. clf = clf_fn(42)
  166. clf.fit(Xtr, ytr)
  167. correct += (clf.predict(X[te]) == y[te]).sum()
  168. return correct / len(y)
  170. def temporal_split_acc(X, y, sessions, clf_fn):
  171. """Train on 2022 (sessions 0-4), test on 2025-26 (sessions 5-9)."""
  172. train_mask = sessions < 5
  173. test_mask = sessions >= 5
  174. rng = np.random.default_rng(42)
  175. Xtr, ytr = undersample_train(X[train_mask], y[train_mask], rng)
  176. clf = clf_fn(42)
  177. clf.fit(Xtr, ytr)
  178. return clf.score(X[test_mask], y[test_mask])
  180. def group_kfold_acc(X, y, sessions, clf_fn, k=5):
  181. """Day GroupKFold (k=5): sessions kept intact within each fold."""
  182. gkf = GroupKFold(n_splits=k)
  183. scores = []
  184. for tr, te in gkf.split(X, y, sessions):
  185. rng = np.random.default_rng(42)
  186. Xtr, ytr = undersample_train(X[tr], y[tr], rng)
  187. clf = clf_fn(42)
  188. clf.fit(Xtr, ytr)
  189. scores.append(clf.score(X[te], y[te]))
  190. return np.mean(scores)
  193. # ── run both classifiers ───────────────────────────────────────────────────
  194. def svm_fn(seed): return LinearSVC(C=1.0, dual=False, random_state=seed)
  195. def lda_fn(seed): return LDA(solver="lsqr", shrinkage="auto")
  197. results = {}
  199. for name, clf_fn in [("Baseline SVM", svm_fn), ("Baseline LDA", lda_fn)]:
  200. print(f"\n── {name} ──")
  202. print(" StratifiedKFold …", end=" ", flush=True)
  203. sk = strat_kfold_acc(X, y, clf_fn)
  204. print(f"{sk*100:.2f}%")
  206. print(" LODO …", end=" ", flush=True)
  207. lodo, session_detail = lodo_acc(X, y, sessions, clf_fn)
  208. print(f"{lodo*100:.2f}%")
  209. date_map = {v: k for k, v in SESSION_ORDER.items()}
  210. for sid, acc in sorted(session_detail.items()):
  211. print(f" session {date_map[sid]}: {acc*100:.1f}%")
  213. print(" LOTO …", end=" ", flush=True)
  214. lt = loto_acc(X, y, clf_fn)
  215. print(f"{lt*100:.2f}%")
  217. print(" Temporal split …", end=" ", flush=True)
  218. ts = temporal_split_acc(X, y, sessions, clf_fn)
  219. print(f"{ts*100:.2f}%")
  221. print(" GroupKFold …", end=" ", flush=True)
  222. gk = group_kfold_acc(X, y, sessions, clf_fn)
  223. print(f"{gk*100:.2f}%")
  225. results[name] = dict(
  226. StratifiedKFold=sk, LODO=lodo, LOTO=lt,
  227. TemporalSplit=ts, GroupKFold=gk
  228. )
  230. print("\n\n── Summary ──")
  231. print(f"{'Strategy':<40} {'Baseline SVM':>14} {'Baseline LDA':>14}")
  232. print("-" * 70)
  233. strats = [("StratifiedKFold (k=3,4; 10 seeds)", "StratifiedKFold"),
  234. ("Day-out LODO (10 sessions)", "LODO"),
  235. ("One-trial-out LOTO (189-fold)", "LOTO"),
  236. ("Temporal split (2022→2025-26)", "TemporalSplit"),
  237. ("Day GroupKFold (k=5)", "GroupKFold")]
  238. for label, key in strats:
  239. svm_v = results["Baseline SVM"][key] * 100
  240. lda_v = results["Baseline LDA"][key] * 100
  241. print(f"{label:<40} {svm_v:>13.2f}% {lda_v:>13.2f}%")

compute_lda_baseline.py at commit 41bd2db, no license · at the source

Overview

Authors: Mikito Ogino1
  1. Graduate School of Arts and Sciences, The University of Tokyo, Tokyo, Japan
Institutions: The University of Tokyo (Japan)
Journal: Frontiers in human neuroscience, volume 20, article 1869918
Dates: received 30 April 2026; accepted 4 June 2026; published online 1 July 2026
Type: Research article · Language: English
License: CC BY
Identifiers: DOI 10.3389/fnhum.2026.1869918 · PMID 42459893 · PMCID PMC13369013 · OpenAlex W7166842113
Open access: gold, a free copy (OpenAlex)
Status: code verified
Categories: EEG (modality), human (organism), other condition (population), clinical / translational (subfield)
Methods: Spectral & time-frequency, Machine learning, Statistics, Preprocessing, Evoked potentials, Physiology & signal measures
Keywords: brain–computer interface, auditory event-related potential, amyotrophic lateral sclerosis, single-subject optimization, large language model, linear discriminant analysis, information transfer rate
Topic: EEG and Brain-Computer Interfaces (Cognitive Neuroscience, Neuroscience), according to OpenAlex
Funding: Japan Society for the Promotion of Science (24K20462)
Citations: not cited yet (Europe PMC); 34 references in the paper

Abstract

Introduction: Auditory event-related potential (ERP) brain-computer interfaces (BCIs) offer communication support for individuals with amyotrophic lateral sclerosis (ALS) who eventually progress to completely locked-in states. However, individual-specific BCI pipeline optimization is technically demanding and time-consuming, leaving substantial room for performance improvement in practice. A central challenge is increasing selection speed while maintaining reliable classification accuracy, since slower selections reduce the sense of agency and undermine the motivational and feedback dynamics essential for sustained BCI use.

Methods: We investigated whether an AI coding assistant could address this challenge for individual patients. A three-class auditory ERP-BCI was optimized for a single ALS patient using Claude Code (Anthropic, Inc.), which iteratively generated and evaluated 23 optimization scripts over approximately 24 hours with minimal human-in-the-loop oversight. The resulting AI-Designed ERP classifier (AIDE) was evaluated on 189 EEG trials spanning 3.5 years using five cross-validation strategies.

Results: For the baseline models, halving the stimulus repetitions to shorten selection time degraded classification accuracy; AIDE prevented this degradation, achieving 85.03% mean cross-validation accuracy (selection time 17 s; ITR 2.92 bits/min). This doubled the information transfer rate from 1.43 to 2.92 bits/min. Accuracy exceeded 84% across four of five cross-validation strategies. Feature space visualization revealed that the AI autonomously selected and combined EEG features established in prior studies into an effective discriminative architecture, without domain-specific algorithmic guidance from the human researcher. In addition, online test confirmed 66.7% accuracy for AIDE versus 50.0% for the baseline model.

Discussion: These findings provide proof of concept that single-subject BCI performance can be improved via a single prompt, offering an efficient pathway to individualized optimization in clinical and research settings.

Reproduced under the paper's license (CC BY), from the paper cited above.

Repository

Its files are read in the Code ↔ Paper reader above, with 10 matches between paragraphs and lines of code.

mikito-ogino/aide-bci-analysis

License: none: the authors keep all their rights
State: the link answers, verified on 27 September 2026
Evidence: files inventoried
Commit: 41bd2dbe69b06c73fbfb957bcc9bd778bbbed632, 2 June 2026
Languages: Python (35)
Size: 39 files, 35 scripts
Software Heritage: not archived
Found in: “Data availability statement”
Holds: README
Not found: license file, CITATION.cff, environment file, tests, continuous integration, documentation
Tools: NumPy (35 files), scikit-learn (32 files), pandas (31 files), SciPy (30 files), Matplotlib (8 files), pyRiemann (2 files), LightGBM (1 file), MNE-Python (1 file), XGBoost (1 file)
Availability: 1 check, the latest on 27 September 2026: the link answers
  • 27 September 2026: the link answers
36 files
At the source: github.com/mikito-ogino/aide-bci-analysis

The paper's code and data availability statement is in the Data section.

Tracing map

Proposed by the machine: these links were found in the paper and verified at the source, without human review. The map will receive a Zenodo DOI once one of the paper's authors has validated it with their ORCID.

What the map holds:

  • 1 repository of the authors' code, each at its verified commit, with its license and how the link was found in the paper;
  • 35 scripts, each with its path and the digest of its content;
  • 10 matches between paragraphs of the paper and lines of the code (method lexical-v1);
  • neither the text of the paper nor the code itself.

Its JSON (tracing-map.json) is deposited on Zenodo with its DOI once the map is validated.

Data

No dataset and no data link were found in the paper.

Data availability statement

The EEG dataset will be made available upon reasonable request to the corresponding author. The analysis code (classifier implementations and figure-generation scripts) is publicly available at https://github.com/mikito-ogino/aide-bci-analysis.

Reproduced under the paper's license (CC BY), from the paper cited above.

Versions

The history of this record: each version stored by the harvester or made by a correction of its authors or of the maintainers of its code, and what changed in its facts. The texts of the paper (its abstract, its availability statements) are not part of it; versions that changed only those are not listed.

Version 2, 28 September 2026

  • Funding: added Japan Society for the Promotion of Science: 24K20462

Version 1, 27 September 2026: the first record

Recorded: type, language, journal, volume, pages, dates, 1 author, 7 keywords, 31 references.

Cite

This paper

Ogino, M. (2026). Single-subject auditory ERP-BCI performance enhancement in ALS via an AI coding assistant prompt. Frontiers in human neuroscience, 20, 1869918. https://doi.org/10.3389/fnhum.2026.1869918

BibTeX

@article{ogino2026single,
author = {Ogino, Mikito},
title = {{Single-subject auditory ERP-BCI performance enhancement in ALS via an AI coding assistant prompt}},
journal = {Frontiers in human neuroscience},
year = {2026},
month = jul,
volume = {20},
pages = {1869918},
publisher = {Frontiers Media SA},
issn = {1662-5161},
doi = {10.3389/fnhum.2026.1869918},
url = {https://doi.org/10.3389/fnhum.2026.1869918},
pmid = {42459893},
pmcid = {PMC13369013}
}

RIS

TY - JOUR
AU - Ogino, Mikito
TI - Single-subject auditory ERP-BCI performance enhancement in ALS via an AI coding assistant prompt
T2 - Frontiers in human neuroscience
J2 - Front Hum Neurosci
PY - 2026
DA - 2026/07/01
VL - 20
SP - 1869918
SN - 1662-5161
PB - Frontiers Media SA
DO - 10.3389/fnhum.2026.1869918
UR - https://doi.org/10.3389/fnhum.2026.1869918
LA - en
ER -

CSL-JSON

{
"id": "10.3389/fnhum.2026.1869918",
"type": "article-journal",
"title": "Single-subject auditory ERP-BCI performance enhancement in ALS via an AI coding assistant prompt",
"container-title": "Frontiers in human neuroscience",
"author": [
{
"family": "Ogino",
"given": "Mikito"
}
],
"container-title-short": "Front Hum Neurosci",
"volume": "20",
"page": "1869918",
"DOI": "10.3389/fnhum.2026.1869918",
"PMID": "42459893",
"PMCID": "PMC13369013",
"ISSN": "1662-5161",
"publisher": "Frontiers Media SA",
"URL": "https://doi.org/10.3389/fnhum.2026.1869918",
"language": "en",
"issued": {
"date-parts": [
[
2026,
7,
1
]
]
}
}

The tracing map gets a citation of its own once an author has validated it and it has a DOI.

Similar papers

The papers with a page that share the most with this one: the tools found in their code, their categories, datasets, cited references and authors, the rarest counting most.

[1] doi:10.3389/fnhum.2026.1807535
The ASME-speller: 30-class auditory brain-computer interface speller using stream segregation and the QWERTY layout.
Journal: Frontiers in human neuroscience
In common: EEG, 9 references
[2] doi:10.3389/fpsyg.2026.1774068 [code]
Analysis of cognitive mechanisms in phoneme perception and pronunciation errors among Korean language learners.
Journal: Frontiers in psychology
In common: pyRiemann, LightGBM, XGBoost, 6 other tools, EEG
[3] doi:10.3390/s26175327 [code]
Subject Identity Confounds qEEG Emotion Recognition on DEAP and DREAMER.
Journal: Sensors (Basel, Switzerland)
In common: pyRiemann, XGBoost, MNE-Python, 5 other tools, EEG
[4] doi:10.1371/journal.pone.0354510 [code]
Personalized adaptive virtual reality experience driven by electroencephalography-based pain recognition.
Journal: PloS one
In common: LightGBM, XGBoost, MNE-Python, 4 other tools, EEG
[5] doi:10.1038/s41591-026-04432-4 [code]
Activity-dependent adaptive deep brain stimulation improves gait in Parkinson's disease.
Journal: Nature medicine
In common: LightGBM, XGBoost, MNE-Python, 4 other tools, clinical / translational
[6] doi:10.3389/fnhum.2026.1895016 [code]
A confidence-gated source selection strategy for cross-session transfer in brain-computer interfaces.
Journal: Frontiers in human neuroscience
In common: pyRiemann, LightGBM, MNE-Python, 3 other tools, EEG
[7] doi:10.3390/ijms27135920 [code]
Metabolomic Classification of Myalgic Encephalomyelitis/Chronic Fatigue Syndrome via Explainable Ensemble Learning and Pareto-Guided Feature Selection.
Journal: International journal of molecular sciences
In common: LightGBM, XGBoost, scikit-learn, 4 other tools, clinical / translational
[8] doi:10.1073/pnas.2516601123 [code]
Unveiling the glymphatic system's role in brain aging: A comprehensive biomarker and modifiable intervention target.
Journal: Proceedings of the National Academy of Sciences of the United States of America
In common: LightGBM, XGBoost, scikit-learn, 4 other tools, clinical / translational
[9] doi:10.1371/journal.pone.0347671 [code]
RMETNet: A cross-subject motor imagery EEG signal classification model based on TSLANet and riemannian geometry features.
Journal: PloS one
In common: pyRiemann, MNE-Python, scikit-learn, 4 other tools, EEG
[10] doi:10.1186/s13244-026-02365-7 [code]
Super-resolution MRI and 2.5D deep learning for intratumoral-peritumoral radiomics in preoperative prediction of rectal cancer perineural invasion.
Journal: Insights into imaging
In common: LightGBM, XGBoost, scikit-learn, 4 other tools, other condition

Contribute

The authors of this paper can claim it, correct its record and validate its tracing map, and the maintainers of its code (its owner, or a public member of its organization) correct what it says of their repository; anyone signed in can ask for its removal. Every request goes to OSCR's own machine, which answers it; your account page follows them.

Sign in with ORCID to claim this paper as one of its authors, correct its record or validate its tracing map: when the paper's metadata lists your ORCID iD, you are recognized at once. Maintainers of its code: sign in with GitHub, then claim the repository on your account page.

Request its removal

To ask OSCR to remove this record, the copies of its authors' scripts or its tracing map, use the removal request page: signed in, you say who you are, what to remove and why, then review and confirm the request. Published rules decide every request (how).

Discussion, reproductions, activity

Discussion: questions and error reports about this paper and its code, from signed-in readers and its authors. It opens with sign-in.

Reproductions: reports from readers who ran the authors' code: what they reproduced, with which environment, commit and data. It opens with sign-in.

Activity: what happens around this paper: new versions of its record, its map's validation, discussions and reproductions. It opens with sign-in.