OSCR

The Absent P3a. Performance Monitoring ERPs Differentiate Trust in Humans and Autonomous Systems.

Code ↔ Paper

1 match 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 1 match
  1. [1] § Methods › EEG Recording and Preprocessing ↔ philistine/mne/_base.py, lines 374–409 · score 0.65 · EEG channels, rejected, voltage, MNE, Epochs, EOG

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 · 481 lines · 18 KB · BSD-3-Clause · 1 match

  1. # -*- coding: utf-8 -*-
  2. # Copyright (C) 2017-2023 Phillip Alday <[email hidden]>
  3. # License: BSD (3-clause)
  4. """MNE-based functionality not further categorized."""
  6. from collections import namedtuple # noqa: I100
  8. import matplotlib.pyplot as plt
  10. import mne # noqa: F401
  12. import numpy as np
  14. import pandas as pd
  16. from scipy import stats
  17. from scipy.ndimage import center_of_mass
  18. from scipy.signal import argrelmin, savgol_filter
  20. IafEst = namedtuple('IAFEstimate',
  21. ['PeakAlphaFrequency', 'CenterOfGravity', 'AlphaBand'])
  24. def savgol_iaf(raw, picks=None, # noqa: C901
  25. fmin=None, fmax=None,
  26. resolution=0.25,
  27. average=True,
  28. ax=None,
  29. window_length=11, polyorder=5,
  30. pink_max_r2=0.9):
  31. """Estimate individual alpha frequency (IAF).
  33. Parameters
  34. ----------
  35. raw : instance of Raw
  36. The raw data to do these estimations on.
  37. picks : array-like of int | None
  38. List of channels to use.
  39. fmin : int | None
  40. Lower bound of alpha frequency band. If None, it will be
  41. empirically estimated using a polynomial fitting method to
  42. determine the edges of the central parabolic peak density,
  43. with assumed center of 10 Hz.
  44. fmax : int | None
  45. Upper bound of alpha frequency band. If None, it will be
  46. empirically estimated using a polynomial fitting method to
  47. determine the edges of the central parabolic peak density,
  48. with assumed center of 10 Hz.
  49. resolution : float
  50. The resolution in the frequency domain for calculating the PSD.
  51. average : bool
  52. Whether to average the PSD estimates across channels or provide
  53. a separate estimate for each channel. Currently, only True is
  54. supported.
  55. ax : instance of matplotlib Axes | None | False
  56. Axes to plot PSD analysis into. If None, axes will be created
  57. (and plot not shown by default). If False, no plotting will be done.
  58. window_length : int
  59. Window length in samples to use for Savitzky-Golay smoothing of
  60. PSD when estimating IAF.
  61. polyorder : int
  62. Polynomial order to use for Savitzky-Golay smoothing of
  63. PSD when estimating IAF.
  64. pink_max_r2 : float
  65. Maximum R^2 allowed when comparing the PSD distribution to the
  66. pink noise 1/f distribution on the range 1 to 30 Hz.
  67. If this threshold is exceeded, then IAF is assumed unclear and
  68. None is returned for both PAF and CoG.
  70. Returns
  71. -------
  72. IafEst : instance of ``collections.namedtuple`` called IAFEstimate
  74. Named tuple with fields for the peak alpha frequency (PAF),
  75. alpha center of gravity (CoG), and the bounds of the alpha band
  76. (as a tuple).
  78. Notes
  79. -----
  80. Based on method developed by
  81. `Andrew Corcoran <https://zenodo.org/badge/latestdoi/80904585>`_.
  82. In addition to appropriate software citation (Zenodo DOI or
  83. git commit), please cite:
  85. Corcoran, A. W., Alday, P. M., Schlesewsky, M., &
  86. Bornkessel-Schlesewsky, I. (2018). Toward a reliable, automated method
  87. of individual alpha frequency (IAF) quantification. Psychophysiology,
  88. e13064. doi:10.1111/psyp.13064
  89. """
  90. n_fft = int(raw.info['sfreq'] / resolution)
  91. spectrum = raw.compute_psd(method="welch", picks=picks, n_fft=n_fft,
  92. fmin=1., fmax=30.)
  93. psd = spectrum.get_data()
  94. freqs = spectrum.freqs
  95. if ax is None:
  96. fig = plt.figure() # noqa: F841
  97. ax = plt.gca()
  99. if average:
  100. psd = np.mean(psd, axis=0)
  102. if fmin is None or fmax is None:
  103. if fmin is None:
  104. fmin_bound = 5
  105. else:
  106. fmin_bound = fmin
  108. if fmax is None:
  109. fmax_bound = 15
  110. else:
  111. fmax_bound = fmax
  113. alpha_search = np.logical_and(freqs >= fmin_bound,
  114. freqs <= fmax_bound)
  115. freqs_search = freqs[alpha_search]
  116. psd_search = savgol_filter(psd[alpha_search],
  117. window_length=psd[alpha_search].shape[0],
  118. polyorder=10)
  119. # argrel min returns a tuple, so we flatten that with [0]
  120. # then we get the last element of the resulting array with [-1]
  121. # which is the minimum closest to the 'median' alpha of 10 Hz
  122. if fmin is None:
  123. try:
  124. left_min = argrelmin(psd_search[freqs_search < 10])[0][-1]
  125. fmin = freqs_search[freqs_search < 10][left_min]
  126. except IndexError:
  127. raise ValueError("Unable to automatically determine lower end of alpha band.") # noqa: 501
  128. if fmax is None:
  129. # here we want the first element of the array which is closest to
  130. # the 'median' alpha of 10 Hz
  131. try:
  132. right_min = argrelmin(psd_search[freqs_search > 10])[0][0]
  133. fmax = freqs_search[freqs_search > 10][right_min]
  134. except IndexError:
  135. raise ValueError("Unable to automatically determine upper end of alpha band.") # noqa: 501
  136. psd_smooth = savgol_filter(psd,
  137. window_length=window_length,
  138. polyorder=polyorder)
  139. alpha_band = np.logical_and(freqs >= fmin, freqs <= fmax)
  141. slope, intercept, r, p, se = stats.linregress(np.log(freqs),
  142. np.log(psd_smooth))
  143. if r**2 > pink_max_r2:
  144. paf = None
  145. cog = None
  146. else:
  147. paf_idx = np.argmax(psd_smooth[alpha_band])
  148. paf = freqs[alpha_band][paf_idx]
  150. cog_idx = center_of_mass(psd_smooth[alpha_band])
  151. try:
  152. cog_idx = int(np.round(cog_idx[0]))
  153. cog = freqs[alpha_band][cog_idx]
  154. except ValueError:
  155. cog = None
  156. # set PAF to None as well, because this is a pathological case
  157. paf = None
  159. if ax:
  160. plt_psd, = ax.plot(freqs, psd, label="Raw PSD")
  161. plt_smooth, = ax.plot(freqs, psd_smooth, label="Smoothed PSD")
  162. plt_pink, = ax.plot(freqs,
  163. np.exp(slope * np.log(freqs) + intercept),
  164. label='$1/f$ fit ($R^2={:0.2}$)'.format(r**2))
  165. try:
  166. plt_search, = ax.plot(freqs_search, psd_search,
  167. label='Alpha-band Search Parabola')
  168. ax.legend(handles=[plt_psd, plt_smooth, plt_search, plt_pink])
  169. except UnboundLocalError:
  170. # this happens when the user fully specified an alpha band
  171. ax.legend(handles=[plt_psd, plt_smooth, plt_pink])
  173. ax.set_ylabel("PSD")
  174. ax.set_xlabel("Hz")
  176. return IafEst(paf, cog, (fmin, fmax))
  179. def attenuation_iaf(raws, picks=None, # noqa: C901
  180. fmin=None, fmax=None,
  181. resolution=0.25,
  182. average=True,
  183. ax=None,
  184. savgol=False,
  185. window_length=11, polyorder=5,
  186. flat_max_r=0.98):
  187. """Estimate individual alpha frequency (IAF).
  189. Parameters
  190. ----------
  191. raws : list-like of Raw
  192. Two Raws to calculate IAF from difference (attenuation) in PSD from.
  193. picks : array-like of int | None
  194. List of channels to use.
  195. fmin : int | None
  196. Lower bound of alpha frequency band. If None, it will be
  197. empirically estimated using a polynomial fitting method to
  198. determine the edges of the central parabolic peak density,
  199. with assumed center of 10 Hz.
  200. fmax : int | None
  201. Upper bound of alpha frequency band. If None, it will be
  202. empirically estimated using a polynomial fitting method to
  203. determine the edges of the central parabolic peak density,
  204. with assumed center of 10 Hz.
  205. resolution : float
  206. The resolution in the frequency domain for calculating the PSD.
  207. average : bool
  208. Whether to average the PSD estimates across channels or provide
  209. a separate estimate for each channel. Currently, only True is
  210. supported.
  211. ax : instance of matplotlib Axes | None | False
  212. Axes to plot PSD analysis into. If None, axes will be created
  213. (and plot not shown by default). If False, no plotting will be done.
  214. savgol : False | 'each' | 'diff'
  215. Use Savitzky-Golay filtering to smooth PSD estimates -- either applied
  216. to either each PSD estimate or to the difference (i.e. the attenuation
  217. estimate).
  218. window_length : int
  219. Window length in samples to use for Savitzky-Golay smoothing of
  220. PSD when estimating IAF.
  221. polyorder : int
  222. Polynomial order to use for Savitzky-Golay smoothing of
  223. PSD when estimating IAF.
  224. flat_max_r: float
  225. Maximum (Pearson) correlation allowed when comparing the raw PSD
  226. distributions to each other in the range 1 to 30 Hz.
  227. If this threshold is exceeded, then IAF is assumed unclear and
  228. None is returned for both PAF and CoG. Note that the sign of the
  229. coefficient is ignored.
  231. Returns
  232. -------
  233. IafEst : instance of ``collections.namedtuple`` called IAFEstimate
  235. Named tuple with fields for the peak alpha frequency (PAF),
  236. alpha center of gravity (CoG), and the bounds of the alpha band
  237. (as a tuple).
  239. Notes
  240. -----
  241. Based on method developed by
  242. `Andrew Corcoran <https://zenodo.org/badge/latestdoi/80904585>`_.
  243. In addition to appropriate software citation (Zenodo DOI or
  244. git commit), please cite:
  246. Corcoran, A. W., Alday, P. M., Schlesewsky, M., &
  247. Bornkessel-Schlesewsky, I. (2018). Toward a reliable, automated method
  248. of individual alpha frequency (IAF) quantification. Psychophysiology,
  249. e13064. doi:10.1111/psyp.13064
  251. """
  252. # TODO: check value of savgol parameter
  253. def psd_est(r):
  254. n_fft = int(r.info['sfreq'] / resolution)
  255. spectrum = r.compute_psd(method="welch", picks=picks, n_fft=n_fft,
  256. fmin=1., fmax=30.)
  257. psd = spectrum.get_data()
  258. freqs = spectrum.freqs
  259. return psd, freqs
  261. psd, freqs = zip(*[psd_est(r) for r in raws])
  262. assert np.allclose(*freqs)
  264. if savgol == 'each':
  265. psd = [savgol_filter(p,
  266. window_length=window_length,
  267. polyorder=polyorder) for p in psd]
  269. att_psd = psd[1] - psd[0]
  271. if average:
  272. att_psd = np.mean(att_psd, axis=0)
  273. psd = [np.mean(p, axis=0) for p in psd]
  275. att_psd = np.abs(att_psd)
  277. att_freqs = freqs[0]
  279. if ax is None:
  280. fig = plt.figure() # noqa: F841
  281. ax = plt.gca()
  283. if fmin is None or fmax is None:
  284. if fmin is None:
  285. fmin_bound = 5
  286. else:
  287. fmin_bound = fmin
  289. if fmax is None:
  290. fmax_bound = 15
  291. else:
  292. fmax_bound = fmax
  294. alpha_search = np.logical_and(att_freqs >= fmin_bound,
  295. att_freqs <= fmax_bound)
  296. freqs_search = att_freqs[alpha_search]
  297. # set the window to the entire interval
  298. # don't use the name window_length because that's used as a
  299. # parameter for the function as a whole
  300. wlen = att_psd[alpha_search].shape[0]
  301. psd_search = savgol_filter(att_psd[alpha_search],
  302. window_length=wlen,
  303. polyorder=10)
  304. # argrel min returns a tuple, so we flatten that with [0]
  305. # then we get the last element of the resulting array with [-1]
  306. # which is the minimum closest to the 'median' alpha of 10 Hz
  307. if fmin is None:
  308. try:
  309. left_min = argrelmin(psd_search[freqs_search < 10])[0][-1]
  310. fmin = freqs_search[freqs_search < 10][left_min]
  311. except IndexError:
  312. raise ValueError("Unable to automatically determine lower end of alpha band.") # noqa: 501
  313. if fmax is None:
  314. # here we want the first element of the array which is closest to
  315. # the 'median' alpha of 10 Hz
  316. try:
  317. right_min = argrelmin(psd_search[freqs_search > 10])[0][0]
  318. fmax = freqs_search[freqs_search > 10][right_min]
  319. except IndexError:
  320. raise ValueError("Unable to automatically determine upper end of alpha band.") # noqa: 501
  322. if savgol == 'diff':
  323. att_psd = savgol_filter(att_psd,
  324. window_length=window_length,
  325. polyorder=polyorder)
  327. alpha_band = np.logical_and(att_freqs >= fmin, att_freqs <= fmax)
  329. r, p = stats.pearsonr(psd[0], psd[1])
  331. if np.abs(r) > np.abs(flat_max_r):
  332. paf = None
  333. cog = None
  334. else:
  335. paf_idx = np.argmax(att_psd[alpha_band])
  336. # print(att_psd[alpha_band])
  337. # print(paf_idx)
  338. # print(att_freqs[alpha_band])
  339. paf = att_freqs[alpha_band][paf_idx]
  341. cog_idx = center_of_mass(att_psd[alpha_band])
  342. cog_idx = int(np.round(cog_idx[0]))
  343. cog = att_freqs[alpha_band][cog_idx]
  345. if ax:
  346. sgnote = '(with SG-Smoothing)' if savgol == 'each' else ''
  347. plt_psd1, = ax.plot(freqs[0], psd[0],
  348. label="Raw PSD #1 {}".format(sgnote))
  349. plt_psd2, = ax.plot(freqs[1], psd[1],
  350. label="Raw PSD #2 {}".format(sgnote))
  352. sgnote = '(with SG-Smoothing)' if savgol == 'diff' else ''
  353. plt_att_psd, = ax.plot(att_freqs, att_psd,
  354. label="Attenuated PSD {}".format(sgnote))
  355. # plt_pink, = ax.plot(att_freqs,
  356. # np.exp(slope * np.log(att_freqs) + intercept),
  357. # label='$1/f$ fit ($R^2={:0.2}$)'.format(r**2))
  358. ax.text(np.max(att_freqs) * 0.5, np.max(att_psd) * 0.67,
  359. 'Raw PSD Pearson $r={:0.2}$'.format(r))
  360. try:
  361. plt_search, = ax.plot(freqs_search, psd_search,
  362. label='Alpha-band Search Parabola')
  363. ax.legend(handles=[plt_psd1, plt_psd2, plt_att_psd, plt_search])
  364. except UnboundLocalError:
  365. # this happens when the user fully specified an alpha band
  366. ax.legend(handles=[plt_psd1, plt_psd2, plt_att_psd])
  368. ax.set_ylabel("PSD")
  369. ax.set_xlabel("Hz")
  371. return IafEst(paf, cog, (fmin, fmax))
  374. def abs_threshold(epochs, threshold,
  375. eeg=True, eog=False, misc=False, stim=False):
  376. """Compute mask for dropping epochs based on absolute voltage threshold.
  378. Parameters
  379. ----------
  380. epochs : instance of Epochs
  381. The epoched data to do threshold rejection on.
  382. threshold : float
  383. The absolute threshold (in *volts*) to reject at.
  384. eeg : bool
  385. If True include EEG channels in thresholding procedure.
  386. eog : bool
  387. If True include EOG channels in thresholding procedure.
  388. misc : bool
  389. If True include miscellaneous channels in thresholding procedure.
  390. stim : bool
  391. If True include stimulus channels in thresholding procedure.
  393. Returns
  394. -------
  395. rej : instance of ndarray
  396. Boolean mask for whether or not the epochs exceeded the rejection
  397. threshold at any time point for any channel.
  399. Notes
  400. -----
  401. More precise selection of channels can be performed by passing a
  402. 'reduced' Epochs instance from the various ``picks`` methods.
  403. """
  404. data = epochs.pick_types(eeg=eeg, misc=misc, stim=stim).get_data()
  405. # channels and times are last two dimension in MNE ndarrays,
  406. # and we collapse across them to get a (n_epochs,) shaped array
  407. rej = np.any( np.abs(data) > threshold, axis=(-1, -2) ) # noqa: E201, E202
  409. return rej
  412. def retrieve(epochs, windows, items=None,
  413. summary_fnc=dict(mean=np.mean), **kwargs):
  414. """Retrieve summarized epoch data for further statistical analysis.
  416. Parameters
  417. ----------
  418. epochs : instance of Epochs
  419. The epoched data to extract windowed summary statistics from.
  420. windows : dict of tuples
  421. Named tuples defining time windows for extraction (relative to
  422. epoch-locking event). Units are dependent on the keyword argument
  423. scale_time. Default is milliseconds.
  424. summary_fnc : dict of functions
  425. Functions to apply to generate summary statistics in each time
  426. window. The keys serve as column names.
  427. items : ndarray | None
  428. Items corresponding to the individual epoch / trials (for
  429. e.g. repeated measure designs). Shape should be (n_epochs,). If
  430. None (default), then item numbers will not be included in the
  431. generated data frame.
  432. kwargs :
  433. Keyword arguments to pass to Epochs.to_data_frame. Particularly
  434. relevant are ``scalings`` and ``scale_time``.
  436. Returns
  437. -------
  438. dat : instance of pandas.DataFrame
  439. Long-format data frame of summarized data
  441. """
  442. df = epochs.to_data_frame(index=['epoch', 'time'], **kwargs)
  443. chs = [c for c in df.columns if c not in ('condition')]
  444. # the order is important here!
  445. # otherwise the shortcut with items later won't work
  446. factors = ['epoch', 'condition']
  447. sel = factors + chs
  448. df = df.reset_index()
  450. id_vars = ['epoch', 'condition', 'win', 'wname']
  451. if items is not None:
  452. id_vars += ['item']
  454. dat = pd.DataFrame(columns=id_vars)
  455. for fnc_name, fnc in summary_fnc.items():
  456. d = []
  457. for w in windows:
  458. temp = df[ df.time >= windows[w][0] ] # noqa: E201, E202
  459. dfw = temp[ temp.time <= windows[w][1] ] # noqa: E201, E202
  460. dfw_summary = dfw[sel].groupby(factors).apply(fnc)
  462. if items is not None:
  463. dfw_summary["item"] = items
  464. dfw_summary["win"] = "{}..{}".format(*windows[w])
  465. dfw_summary["wname"] = w
  466. d.append(dfw_summary)
  468. d = pd.concat(d)
  469. # get rid of epoch and condition if they're already columns
  470. # before we can move them from the index to columns
  471. d.drop('epoch', axis=1, inplace=True, errors='ignore')
  472. d.drop('condition', axis=1, inplace=True, errors='ignore')
  473. d.reset_index(inplace=True)
  474. d = pd.melt(d,
  475. id_vars=id_vars,
  476. value_vars=chs,
  477. var_name="channel",
  478. value_name=fnc_name)
  479. dat = pd.merge(dat, d, how='outer')
  481. return dat

_base.py at commit 1f4613b, under BSD-3-Clause · at the source

Overview

Authors: Daniel A Rogers1, Kirsty J Brooks2, Anthony Finn3, Matthias Schlesewsky4, Markus Ullsperger5,6, Ina Bornkessel‐Schlesewsky1
ORCID iDs: Daniel A Rogers
  1. School of Psychology, Adelaide University, Adelaide, Australia
  2. Department of Experimental Psychology, Ludwig Maximilian University of Munich, Munich, Germany
  3. School of Electrical and Mechanical Engineering, Adelaide University, Adelaide, Australia
  4. Australian Research Center for Interactive and Virtual Environments, University of South Australia, Adelaide, Australia
  5. Institute of Psychology, Otto von Guericke University Magdeburg, Magdeburg, Germany
  6. Center for Behavioral Brain Sciences Magdeburg, Magdeburg, Germany
Institutions: Adelaide University (Australia); The University of Adelaide (Australia); Ludwig-Maximilians-Universität München (Germany); University of South Australia (Australia); Center for Behavioral Brain Sciences (Germany); Otto-von-Guericke-Universität Magdeburg (Germany)
Journal: Psychophysiology, volume 63, issue 7, article e70354
Dates: received 10 June 2025; accepted 23 June 2026; published online 10 July 2026; in print July 2026
Type: Research article · Language: English
License: CC BY-NC
Identifiers: DOI 10.1111/psyp.70354 · PMID 42429322 · PMCID PMC13353041 · OpenAlex W7167899374
Open access: hybrid, a free copy (OpenAlex)
Status: code verified
Categories: EEG (modality), human (organism), cognitive (subfield)
Methods: Spectral & time-frequency, Smoothing, state filtering, decompositions, Preprocessing, Evoked potentials, Statistics
Keywords: automation complacency, feedback‐related negativity, P3, P3a, performance monitoring, social neuroscience, trust in automation
MeSH: Brain*, Event-Related Potentials, P300*, Psychomotor Performance*, Trust*, Adult, Electroencephalography, Feedback, Sensory, Female, Humans, Male, Young Adult (* major topic)
Topic: Human-Automation Interaction and Safety (Social Psychology, Psychology), according to OpenAlex
Funding: Australian Government Research Training Program
Citations: not cited yet (Europe PMC); 65 references in the paper

Abstract

To address suggestions that human brain responses to autonomous system errors may be used as brain‐based measures of trust in automation, the present study asked participants to monitor the performance of either a virtual human or an autonomous system partner performing a novel, complex, real‐world image classification task. We predicted visual feedback of partner errors would elicit the feedback‐related negativity and P3 ERP components, and that these components would differ between the human and system groups. Behavioral results showed that while participants calibrated their trust in their partner according to our intended manipulation of error rates, no group differences were found. The ERP data, however, revealed FRN and P3 effects for both groups, modulated by accuracy and error rate. An unexpected finding was that the P3 topography differed between groups, with both a frontal P3a and posterior P3b component seen for the human condition, while for the system condition only the posterior P3b was observed and the P3a was completely absent. We suggest that this selective absence of the P3a may reflect reduced frontal attention during system monitoring in passive task conditions potentially resulting from reduced social and emotional processing for the system partner. This study demonstrates the potential for EEG‐based measures of trust in automation to surpass the sensitivity of traditional measures of trust while additionally uncovering a potential neural signature of automation complacency in the absent P3a. This identifies potential boundary conditions under which the application of human correlates of performance monitoring may not apply to the monitoring of an automated system.

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

Repositories

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

Zenodo 7535495

License: other-open
State: the link answers, verified on 27 September 2026
Evidence: files inventoried
Size: 1 file
Software Heritage: not checked
Found in: the references
Not found: README, license file, CITATION.cff, environment file, tests, continuous integration, documentation
Tools: MNE-Python (6 files), NumPy (6 files), pandas (2 files), Matplotlib (1 file), SciPy (1 file)
Availability: 1 check, the latest on 27 September 2026: the link answers (HTTP 200)
  • 27 September 2026: the link answers (HTTP 200)
15 files
At the source:

palday/philistine

License: BSD-3-Clause
State: the link answers, verified on 27 September 2026
Evidence: files inventoried
Commit: 1f4613b9a15e1e0910056644a2a6bb8b0a1ab2c7, 13 January 2023
Languages: Python (13)
Size: 27 files, 13 scripts
Software Heritage: archived
Found in: the Zenodo archive record
Holds: README, license file, environment (requirements.txt, setup.cfg, setup.py), tests, continuous integration, documentation
Not found: CITATION.cff
Tools: MNE-Python (6 files), NumPy (6 files), pandas (2 files), Matplotlib (1 file), SciPy (1 file)
Availability: 1 check, the latest on 27 September 2026: the link answers
  • 27 September 2026: the link answers
15 files
At the source: github.com/palday/philistine/tree/v0.2.0

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:

  • 2 repositories of the authors' code, each at its verified commit, with its license and how the link was found in the paper;
  • 26 scripts, each with its path and the digest of its content;
  • 1 match 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 data that support the findings of this study are available from the corresponding author upon reasonable request.

Reproduced under the paper's license (CC BY-NC), 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

  • Publisher: — → Wiley

Version 1, 27 September 2026: the first record

Recorded: type, language, journal, volume, issue, pages, dates, 6 authors, 7 keywords, 11 MeSH terms, 1 funder, 53 references.

Cite

This paper

Rogers, D. A., Brooks, K. J., Finn, A., Schlesewsky, M., Ullsperger, M., & Bornkessel‐Schlesewsky, I. (2026). The Absent P3a. Performance Monitoring ERPs Differentiate Trust in Humans and Autonomous Systems. Psychophysiology, 63(7), e70354. https://doi.org/10.1111/psyp.70354

BibTeX

@article{rogers2026absent,
author = {Rogers, Daniel A and Brooks, Kirsty J and Finn, Anthony and Schlesewsky, Matthias and Ullsperger, Markus and Bornkessel‐Schlesewsky, Ina},
title = {{The Absent P3a. Performance Monitoring ERPs Differentiate Trust in Humans and Autonomous Systems}},
journal = {Psychophysiology},
year = {2026},
month = jul,
volume = {63},
number = {7},
pages = {e70354},
publisher = {Wiley},
issn = {0048-5772},
doi = {10.1111/psyp.70354},
url = {https://doi.org/10.1111/psyp.70354},
pmid = {42429322},
pmcid = {PMC13353041}
}

RIS

TY - JOUR
AU - Rogers, Daniel A
AU - Brooks, Kirsty J
AU - Finn, Anthony
AU - Schlesewsky, Matthias
AU - Ullsperger, Markus
AU - Bornkessel‐Schlesewsky, Ina
TI - The Absent P3a. Performance Monitoring ERPs Differentiate Trust in Humans and Autonomous Systems
T2 - Psychophysiology
J2 - Psychophysiology
PY - 2026
DA - 2026/07/01
VL - 63
IS - 7
SP - e70354
SN - 0048-5772
PB - Wiley
DO - 10.1111/psyp.70354
UR - https://doi.org/10.1111/psyp.70354
LA - en
ER -

CSL-JSON

{
"id": "10.1111/psyp.70354",
"type": "article-journal",
"title": "The Absent P3a. Performance Monitoring ERPs Differentiate Trust in Humans and Autonomous Systems",
"container-title": "Psychophysiology",
"author": [
{
"family": "Rogers",
"given": "Daniel A"
},
{
"family": "Brooks",
"given": "Kirsty J"
},
{
"family": "Finn",
"given": "Anthony"
},
{
"family": "Schlesewsky",
"given": "Matthias"
},
{
"family": "Ullsperger",
"given": "Markus"
},
{
"family": "Bornkessel‐Schlesewsky",
"given": "Ina"
}
],
"container-title-short": "Psychophysiology",
"volume": "63",
"issue": "7",
"page": "e70354",
"DOI": "10.1111/psyp.70354",
"PMID": "42429322",
"PMCID": "PMC13353041",
"ISSN": "0048-5772",
"publisher": "Wiley",
"URL": "https://doi.org/10.1111/psyp.70354",
"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.1162/imag.a.1321 [code]
Phase similarity between similar objects indicates representational merging across retrieval training but not sleep.
Journal: Imaging neuroscience (Cambridge, Mass.)
In common: MNE-Python, pandas, SciPy, 2 other tools, EEG, cognitive, 2 references
[2] doi:10.1167/jov.26.8.4 [code]
The neural processes of illusory occlusion in object recognition.
Journal: Journal of vision
In common: MNE-Python, pandas, SciPy, 2 other tools, EEG, cognitive, 1 reference
[3] doi:10.1097/j.pain.0000000000004044 [code]
No effect of rhythmic visual stimulation on experimental pain perception.
Journal: Pain
In common: MNE-Python, pandas, SciPy, 2 other tools, EEG, cognitive, 1 reference
[4] doi:10.1371/journal.pone.0350140 [code]
Signal combination in flutter vibration perception.
Journal: PloS one
In common: MNE-Python, pandas, SciPy, 2 other tools, EEG, cognitive, 1 reference
[5] doi:10.1038/s42003-026-10394-7 [code]
Cognitive load weakens neural speech tracking without altering response timing.
Journal: Communications biology
In common: MNE-Python, pandas, SciPy, 2 other tools, EEG, cognitive, 1 reference
[6] doi:10.1186/s11689-026-09706-z [code]
Neural oscillatory dynamics reveal altered top-down and integrative mechanisms during face processing in autistic children and unaffected siblings of autistic children.
Journal: Journal of neurodevelopmental disorders
In common: MNE-Python, pandas, SciPy, 2 other tools, EEG, cognitive, 1 reference
[7] doi:10.1111/ejn.70538 [code]
Neural Tracking of Sustained Attention, Attention Switching, and Natural Conversation in Audiovisual Environments Using Wearable EEG.
Journal: The European journal of neuroscience
In common: MNE-Python, pandas, SciPy, 2 other tools, EEG, cognitive, 1 reference
[8] doi:10.1162/imag.a.105 [code]
Right posterior theta reflects human parahippocampal phase resetting by salient cues during goal-directed navigation
Journal: —
In common: MNE-Python, pandas, SciPy, 2 other tools, EEG, cognitive, 1 reference
[9] doi:10.3389/fnhum.2026.1869918 [code]
Single-subject auditory ERP-BCI performance enhancement in ALS via an AI coding assistant prompt.
Journal: Frontiers in human neuroscience
In common: MNE-Python, pandas, SciPy, 2 other tools, EEG, 1 reference
[10] doi:10.1162/nol.a.247 [code]
Same Sentences, Different Grammars, Different Brain Responses?: An MEG Study on Case and Agreement Encoding in Hindi and Nepali Split-Ergative Structures.
Journal: Neurobiology of language (Cambridge, Mass.)
In common: MNE-Python, pandas, SciPy, 2 other tools, 2 references

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.