OSCR

The effects of action-based predictions in early visual cortex.

Code ↔ Paper

4 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 4 matches
  1. [1] § STAR★Methods › Method details › Experimental design ↔ Code.zip/Behavioural/actPredAllTraining_v2.py, lines 125–171 · score 0.73 · wrong button, rightward gratings, passive block, clockwise, leftward, soon
  2. [2] § STAR★Methods › Quantification and statistical analysis › Eye tracking analysis ↔ Code.zip/fMRI/actPred_v2.py, lines 90–115 · score 0.61 · SR Research, EyeLink, calibration, eyetracker, tracking
  3. [3] § STAR★Methods › Method details › Experimental design ↔ Code.zip/Behavioural/actPredGratingTraining_v2.py, lines 93–117 · score 0.59 · rightward gratings, fixation dot, clockwise, leftward, counterbalanced, trained
  4. [4] § STAR★Methods › Quantification and statistical analysis › MRI analysis ↔ Code.zip/Behavioural/actPredGratingTraining_v2.py, lines 93–117 · score 0.54 · rightward gratings, fixation dot, leftward, space, predictors, cue

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 · 363 lines · 13 KB · CC-BY-4.0 · 2 matches

  1. #!/usr/bin/env python3
  2. # -*- coding: utf-8 -*-
  3. """
  4. Created on Wed Jul 7 16:13:47 2021
  6. @author: bianca
  7. """
  9. ##############################################################################
  10. #
  11. # ActPred3T_WP1
  12. #
  13. # !! Updated version !!
  14. # Cue is now fixation dot changing colour instead of enlarging
  15. #
  16. # Script to train mapping between tone and gratings.
  17. #
  18. # BvK 07-07-2021
  19. ##############################################################################
  21. from psychopy import prefs
  22. prefs.hardware['audioLib'] = ['PTB']
  23. from psychopy import visual, core, event, sound, data, gui
  24. import os, datetime, random, pickle
  25. import numpy as np
  27. # Add escape and q as escape keys
  28. #for key in ['q', 'escape']:
  29. # event.globalKeys.add(key, func=core.quit)
  31. # Paths
  32. #root_dir = '/analyse/Project0281/ActPred3T/'
  33. #src_dir = '/analyse/Project0281/ActPred3T/Behavioural/'
  34. #root_dir = 'C:/Users/Bianca/Work/Experiments/Glasgow_3T/Code_exp/'
  35. #src_dir = 'C:/Users/Bianca/Work/Experiments/Glasgow_3T/Code_exp/Behavioural/'
  36. root_dir = '/home/bianca/Work/Experiments/Glasgow_3T/Code_exp/actpred3T/' #linux laptop
  37. src_dir = root_dir + 'Behavioural/'
  38. #RT_dir = '/analyse/Project0281/ActPred3T/Behavioural/'
  39. RT_dir = root_dir + 'Behavioural/'
  41. # GUI to input participant number etc
  42. expName = 'actpred3T_gratingtraining'
  43. expInfo = {'Date':data.getDateStr(), 'Run':['1','2','3','4','5'], 'Participant_number': '', 'Participant_ID':''}
  44. diabox = gui.DlgFromDict(dictionary=expInfo,
  45. title=expName,
  46. order=['Participant_number', 'Participant_ID', 'Run', 'Date'],
  47. fixed=['Date'])
  48. s = int(expInfo['Participant_number']);
  49. run = int(expInfo['Run']);
  50. date = expInfo['Date']
  51. print('expinfo:', expInfo['Participant_number'])
  52. print('s = ', s)
  54. saving_dir = src_dir + 'data/p' + str(s) +'/'
  56. if not os.path.exists(saving_dir):
  57. os.makedirs(saving_dir)
  59. logFile = open(saving_dir + 'gratingtraining_p' + str(s) + '_run' + str(run) +'_' + date + '.txt','w')
  60. logFile.write('Date: \t' + expInfo['Date'] + '\n')
  61. logFile.write('Participant number: \t' + expInfo['Participant_number'] + '\n')
  62. logFile.write('Participant_ID: \t' + expInfo['Participant_ID'] + '\n')
  63. logFile.write('Run: \t' + expInfo['Run'] + '\n')
  64. logFile.write('Start: \t' + str(datetime.datetime.now()) + '\n')
  65. logFile.write('trialN\tPart\tCond\tPredCueOn\tpredCueOff\tCueOn\tCueOff\tTActKeyPressed\tActKeyPressed\tRT\tOrient\tStartStim1\tStopStim1\tITI\n')
  68. # Window
  69. #win = visual.Window(monitor='Laptop', units = 'deg', fullscr = True)
  70. #win = visual.Window([600,600], monitor='Laptop', units = 'deg')
  71. win = visual.Window([600,600], monitor='HomeMon', units = 'deg')
  72. #win = visual.Window([800,800], monitor='WorkPC', units = 'deg')
  73. #win = visual.Window(monitor='WorkPC', units = 'deg', fullscr = True)
  74. win.mouseVisible = False
  76. circle_color_space = 'rgb'
  78. subList = list(range(1,25)) #1:24
  80. # Load pickle file
  81. subsMaps = pickle.load(open(root_dir + 'mapping', 'rb'))
  83. # Randomise trial order for each run
  84. seed = random.sample(range(1000), k=1)
  85. random.seed(seed[0])
  86. conds_act = np.array([1,1,1,1,1,2,2,2,2,2])
  87. random.shuffle(conds_act)
  88. seed = random.sample(range(1000), k=1)
  89. random.seed(seed[0])
  90. conds_pas = np.array([4,4,4,4,4,5,5,5,5,5])
  91. random.shuffle(conds_pas)
  93. # Define all screens/stimuli
  94. part1aScreen = visual.TextStim(win, '''Part 1 \n\nWhen you hear a high tone, you will see a leftward grating. When you hear a low tone, you will see a rightward grating. \nPay close attention to the stimuli and learn which tone predicts which grating.
  95. \n\nPress space bar to continue''', wrapWidth=20)
  96. part1bScreen = visual.TextStim(win, '''Part 1 \n\nWhen you hear a high tone, you will see a rightward grating. When you hear a low tone, you will see a leftward grating. \nPay close attention to the stimuli and learn which tone predicts which grating.
  97. \n\nPress space bar to continue''', wrapWidth=20)
  98. part2aScreen = visual.TextStim(win, '''Part 2 \n\nWhen you hear a high tone, you will see a leftward grating. When you hear a low tone, you will see a rightward grating. \nPay close attention to the stimuli and learn which tone predicts which grating.
  99. \n\nPress space bar to continue''', wrapWidth=20)
  100. part2bScreen = visual.TextStim(win, '''Part 2 \n\nWhen you hear a high tone, you will see a rightward grating. When you hear a low tone, you will see a leftward grating. \nPay close attention to the stimuli and learn which tone predicts which grating.
  101. \n\nPress space bar to continue''', wrapWidth=20)
  102. part2Screen = visual.TextStim(win, '''Part 2 \n\nWhen you hear the tone, prepare for the corresponding grating to be presented. It will be presented after the fixation dot enlarges.
  103. \n\nPress space bar to continue''', wrapWidth=20)
  104. breakScreen = visual.TextStim(win, 'Questions?')
  105. predCueLow = sound.Sound(400,volume = 0.846, secs = 0.3)
  106. predCueHigh = sound.Sound(1000,volume = 0.8, secs = 0.3)
  107. predCueNo = sound.Sound(100,volume = 0.8, secs = 0.3)
  108. fix = visual.Circle(win, radius=0.15, units='deg', edges=100, lineColorSpace=circle_color_space, lineColor=[-1,-1,-1], fillColor=[-1,-1,-1], fillColorSpace=circle_color_space)
  109. cue = visual.Circle(win, radius=0.15, units='deg', edges=100, lineColorSpace=circle_color_space, lineColor=[1,-1,-1], fillColor=[1,-1,-1], fillColorSpace=circle_color_space)
  110. refStimLeft = visual.GratingStim(win,tex='sin', mask='raisedCos', maskParams = {'fringeWidth':0.1},contrast = 0.5, units='deg', ori = -45, size = 8, sf = 1.5)
  111. testStimLeft = visual.GratingStim(win,tex='sin', mask='raisedCos', maskParams = {'fringeWidth':0.1},contrast = 0.5, units='deg', size = 8, sf = 1.5)
  112. refStimRight = visual.GratingStim(win,tex='sin', mask='raisedCos', maskParams = {'fringeWidth':0.1},contrast = 0.5, units='deg', ori = 45, size = 8, sf = 1.5)
  113. testStimRight = visual.GratingStim(win,tex='sin', mask='raisedCos', maskParams = {'fringeWidth':0.1},contrast = 0.5, units='deg', size = 8, sf = 1.5)
  114. annulus = visual.Circle(win, radius=0.25, units='deg', edges=100, lineWidth = 0, fillColor = [0,0,0])
  115. refSound = sound.Sound(400, volume = 0.8, secs = 0.5)
  116. quest = visual.TextStim(win, 'Clockwise or counterclockwise?', wrapWidth=20)
  117. endScreen = visual.TextStim(win, 'End of run')
  119. def trial_sequence(cue_type, button, orient):
  120. pred_cue(cue_type)
  121. pas_trial()
  122. present_grating(orient)
  123. ITI()
  125. def pred_cue(cue_type):
  126. fix.draw()
  127. win.flip()
  128. if cue_type == 'high':
  129. predCueHigh.play()
  130. elif cue_type == 'low':
  131. predCueLow.play()
  132. elif cue_type == 'no':
  133. predCueNo.play()
  134. predCueOn = globalClock.getTime()
  135. cueClock.reset()
  136. cueClock.add(0.3)
  137. while cueClock.getTime() < 0:
  138. pass
  139. predCueOff = globalClock.getTime()
  140. logFile.write('\t'.join([str(predCueOn), str(predCueOff)])+'\t')
  142. def present_grating(orient):
  143. stimClock.reset()
  144. stimClock.add(0.2)
  145. while stimClock.getTime() < 0:
  146. pass
  148. if orient == 'left':
  149. refStimLeft.draw()
  150. elif orient == 'right':
  151. refStimRight.draw()
  152. annulus.draw()
  153. fix.draw()
  154. win.flip()
  155. stim1On = globalClock.getTime()
  157. stimClock.reset()
  158. stimClock.add(0.5)
  159. while stimClock.getTime() < 0:
  160. pass
  161. stim1Off = globalClock.getTime()
  163. if orient == 'left':
  164. logFile.write('\t'.join([str(-45), str(stim1On), str(stim1Off)])+'\t')
  165. elif orient == 'right':
  166. logFile.write('\t'.join([str(45), str(stim1On), str(stim1Off)])+'\t')
  168. def pas_trial():
  170. fix.draw()
  171. win.flip()
  173. fixClock.reset()
  174. fixClock.add(3)
  175. while fixClock.getTime() < 0:
  176. pass
  178. cue.draw()
  179. win.flip()
  180. cueOn = globalClock.getTime()
  182. cueClock.reset()
  183. cueClock.add(0.3)
  184. while cueClock.getTime() < 0:
  185. pass
  186. cueOff = globalClock.getTime()
  188. fix.draw()
  189. win.flip()
  191. RTClock.reset()
  192. #RTClock.add(RT_act)
  193. RTClock.add(1-0.2)
  194. while RTClock.getTime() < 0:
  195. pass
  197. logFile.write('\t'.join([str(cueOn), str(cueOff), str(-1), str(0), str(-1)])+'\t')
  200. def ITI():
  201. fix.draw()
  202. win.flip()
  203. ITIClock.reset()
  204. ITIClock.add(1.5)
  205. while ITIClock.getTime() < 0:
  206. pass
  207. logFile.write('\t'.join([str(1.5)])+'\n')
  209. globalClock = core.Clock()
  210. blockClock = core.Clock()
  211. cueClock = core.Clock()
  212. RTClock = core.Clock()
  213. stimClock = core.Clock()
  214. fixClock = core.Clock()
  215. isiClock = core.Clock()
  216. questClock = core.Clock()
  217. ITIClock = core.Clock()
  219. exit = False
  221. if subsMaps[s] == 1 or subsMaps[s] == 3:
  222. part1aScreen.draw()
  223. elif subsMaps[s] == 2 or subsMaps[s] == 4:
  224. part1bScreen.draw()
  225. win.flip()
  226. keys = ['']
  227. while keys[0] not in ['escape', 'space']:
  228. keys = event.waitKeys()
  229. if keys[0] == 'space':
  230. pass
  231. elif keys[0] == 'escape':
  232. exit = True
  233. win.close()
  234. core.quit()
  236. fix.draw()
  237. win.flip()
  238. blockClock.reset()
  239. blockClock.add(3)
  240. while blockClock.getTime() < 0:
  241. pass
  243. counterL = 0
  244. counterR = 0
  245. counterAct = 0
  246. counterPas = 0
  248. for trial, cond in enumerate(conds_pas,1):
  249. part = 1
  250. logFile.write('\t'.join([str(trial), str(part), str(cond)])+'\t')
  252. if cond == 4:
  253. if subsMaps[s] == 1:
  254. trial_sequence('high', 'left', 'left')
  255. counterL = counterL + 1
  256. counterPas = counterPas + 1
  257. elif subsMaps[s] == 2:
  258. trial_sequence('low', 'right', 'left')
  259. counterL = counterL + 1
  260. counterPas = counterPas + 1
  261. elif subsMaps[s] == 3:
  262. trial_sequence('high', 'right', 'left')
  263. counterL = counterL + 1
  264. counterPas = counterPas + 1
  265. elif subsMaps[s] == 4:
  266. trial_sequence('low', 'left', 'left')
  267. counterL = counterL + 1
  268. counterPas = counterPas + 1
  269. elif cond == 5:
  270. if subsMaps[s] == 1:
  271. trial_sequence('low', 'right', 'right')
  272. counterR = counterR + 1
  273. counterPas = counterPas + 1
  274. elif subsMaps[s] == 2:
  275. trial_sequence('high', 'left', 'right')
  276. counterR = counterR + 1
  277. counterPas = counterPas + 1
  278. elif subsMaps[s] == 3:
  279. trial_sequence('low', 'left', 'right')
  280. counterR = counterR + 1
  281. counterPas = counterPas + 1
  282. elif subsMaps[s] == 4:
  283. trial_sequence('high', 'right', 'right')
  284. counterR = counterR + 1
  285. counterPas = counterPas + 1
  287. #Break
  288. breakScreen.draw()
  289. win.flip()
  290. keys = event.waitKeys()
  292. #Prepare part2
  293. if subsMaps[s] == 1 or subsMaps[s] == 3:
  294. part2aScreen.draw()
  295. elif subsMaps[s] == 2 or subsMaps[s] == 4:
  296. part2bScreen.draw()
  297. win.flip()
  298. keys = ['not pressed']
  299. while keys[0] not in ['escape', 'space']:
  300. keys = event.waitKeys()
  301. if keys[0] == 'space':
  302. pass
  303. elif keys[0] == 'escape':
  304. exit = True
  305. win.close()
  306. core.quit()
  308. fix.draw()
  309. win.flip()
  310. blockClock.reset()
  311. blockClock.add(3)
  312. while blockClock.getTime() < 0:
  313. pass
  315. counterL = 0
  316. counterR = 0
  317. counterAct = 0
  318. counterPas = 0
  320. for trial, cond in enumerate(conds_pas,1):
  321. part = 2
  322. logFile.write('\t'.join([str(trial), str(part), str(cond)])+'\t')
  324. if cond == 4:
  325. if subsMaps[s] == 1:
  326. trial_sequence('high', 'left', 'left')
  327. counterL = counterL + 1
  328. counterPas = counterPas + 1
  329. elif subsMaps[s] == 2:
  330. trial_sequence('low', 'right', 'left')
  331. counterL = counterL + 1
  332. counterPas = counterPas + 1
  333. elif subsMaps[s] == 3:
  334. trial_sequence('high', 'right', 'left')
  335. counterL = counterL + 1
  336. counterPas = counterPas + 1
  337. elif subsMaps[s] == 4:
  338. trial_sequence('low', 'left', 'left')
  339. counterL = counterL + 1
  340. counterPas = counterPas + 1
  341. elif cond == 5:
  342. if subsMaps[s] == 1:
  343. trial_sequence('low', 'right', 'right')
  344. counterR = counterR + 1
  345. counterPas = counterPas + 1
  346. elif subsMaps[s] == 2:
  347. trial_sequence('high', 'left', 'right')
  348. counterR = counterR + 1
  349. counterPas = counterPas + 1
  350. elif subsMaps[s] == 3:
  351. trial_sequence('low', 'left', 'right')
  352. counterR = counterR + 1
  353. counterPas = counterPas + 1
  354. elif subsMaps[s] == 4:
  355. trial_sequence('high', 'right', 'right')
  356. counterR = counterR + 1
  357. counterPas = counterPas + 1
  359. endScreen.draw()
  360. win.flip()
  361. event.waitKeys(keyList=['escape'])
  362. win.close()
  363. core.quit()

actPredGratingTraining_v2.py, under CC-BY-4.0 · at the source

Overview

Authors: Bianca M. van Kemenade1,2, Lars F. Muckli2
ORCID iDs: Bianca M. van Kemenade
  1. Center for Psychiatry, Justus Liebig University Giessen, Klinikstrasse 36, 35392 Giessen, Germany
  2. Centre for Cognitive Neuroimaging (CCNi), School of Psychology and Neuroscience, University of Glasgow, 62 Hillhead Street, Glasgow, UK
Institutions: Justus-Liebig-Universität Gießen (Germany); University of Glasgow (United Kingdom)
Journal: iScience, volume 29, issue 9, article 117074
Dates: received 3 October 2025; accepted 20 July 2026; published online 18 August 2026
Type: Research article · Language: English
License: CC BY
Identifiers: DOI 10.1016/j.isci.2026.117074 · PMID 42662421 · PMCID PMC13520625 · OpenAlex W4413900552
Open access: gold, a free copy (OpenAlex)
Preprint: doi:10.1101/2025.08.28.672792
Status: code verified
Categories: fMRI (modality), systems (subfield)
Methods: Statistics, Machine learning, Preprocessing, fMRI & imaging, Physiology & signal measures
Keywords: voluntary action, visual perception, early visual cortex, fMRI
Topic: Neural dynamics and brain function (Cognitive Neuroscience, Neuroscience), according to OpenAlex
Funding: Deutsche Forschungsgemeinschaft (DFG) (222641018); RCUK | Biotechnology and Biological Sciences Research Council (BBSRC); UK Medical Research Council
Citations: not cited yet (Europe PMC); 55 references in the paper
Research resources: Matlab R2019b RRID:SCR_001622, PsychoPy 3.2.4 RRID:SCR_006571, LibSVM RRID:SCR_010243, BrainVoyager 22.0 for Linux RRID:SCR_013057

Abstract

Voluntary action typically results in reduced sensitivity to sensory action outcomes. The forward model theory proposes that this is due to neural suppression. However, this theory has recently been challenged by the pre-activation account, sharpening, and opposing process theory. In this fMRI study, we compared these theories by using univariate and multivariate analyses. Participants performed a visual orientation discrimination task on two sequential gratings, which were presented automatically (passive condition) or triggered by button press (active condition). Decoding of predicted stimulus orientation from early visual cortex activity prior to stimulus presentation was significantly above chance in both active and passive conditions. During stimulus presentation, actively generated stimuli elicited larger blood-oxygen-level-dependent (BOLD) responses. However, both decoding accuracy and the timing of the BOLD responses did not differ between conditions. These results differ from the forward model’s predicted sensory attenuation, the pre-activation account’s earlier BOLD response, and the enhanced precision of the sharpening hypothesis. Instead, they mostly fit the opposing process theory, which posits pre-activation in both conditions. However, the stronger BOLD response for actively generated stimuli is not predicted by any existing theory, implicating additional mechanisms, such as heightened attention or motor-related enhancement.

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 4 matches between paragraphs and lines of code.

Zenodo 20507627

License: CC-BY-4.0
State: the link answers, verified on 27 September 2026
Evidence: files inventoried
Size: 3 files
Software Heritage: not checked
Found in: “Data and code availability”
Not found: README, license file, CITATION.cff, environment file, tests, continuous integration, documentation
Tools: NumPy (8 files), PsychoPy (8 files)
Availability: 1 check, the latest on 27 September 2026: the link answers (HTTP 200)
  • 27 September 2026: the link answers (HTTP 200)
8 files
At the source: doi.org/10.5281/zenodo.20507627

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;
  • 8 scripts, each with its path and the digest of its content;
  • 4 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 and code availability

• Data have been deposited at Zenodo and are publicly available as of the date of publication at https://doi.org/10.5281/zenodo.20507627. • Code has been deposited at Zenodo and is publicly available as of the date of publication at https://doi.org/10.5281/zenodo.20507627. • For other inquiries, please contact the lead contact.

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

  • Authors: added Bianca M. van Kemenade (0000-0002-8631-9893); removed Bianca M. van Kemenade

Version 1, 27 September 2026: the first record

Recorded: type, language, journal, volume, issue, pages, dates, 2 authors, 4 keywords, 3 funders, 54 references, 4 RRIDs.

Cite

This paper

van Kemenade, B. M., & Muckli, L. F. (2026). The effects of action-based predictions in early visual cortex. iScience, 29(9), 117074. https://doi.org/10.1016/j.isci.2026.117074

BibTeX

@article{vankemenade2026effects,
author = {van Kemenade, Bianca M. and Muckli, Lars F.},
title = {{The effects of action-based predictions in early visual cortex}},
journal = {iScience},
year = {2026},
month = aug,
volume = {29},
number = {9},
pages = {117074},
publisher = {Elsevier},
issn = {2589-0042},
doi = {10.1016/j.isci.2026.117074},
url = {https://doi.org/10.1016/j.isci.2026.117074},
pmid = {42662421},
pmcid = {PMC13520625}
}

RIS

TY - JOUR
AU - van Kemenade, Bianca M.
AU - Muckli, Lars F.
TI - The effects of action-based predictions in early visual cortex
T2 - iScience
J2 - iScience
PY - 2026
DA - 2026/08/18
VL - 29
IS - 9
SP - 117074
SN - 2589-0042
PB - Elsevier
DO - 10.1016/j.isci.2026.117074
UR - https://doi.org/10.1016/j.isci.2026.117074
LA - en
ER -

CSL-JSON

{
"id": "10.1016/j.isci.2026.117074",
"type": "article-journal",
"title": "The effects of action-based predictions in early visual cortex",
"container-title": "iScience",
"author": [
{
"family": "van Kemenade",
"given": "Bianca M."
},
{
"family": "Muckli",
"given": "Lars F."
}
],
"container-title-short": "iScience",
"volume": "29",
"issue": "9",
"page": "117074",
"DOI": "10.1016/j.isci.2026.117074",
"PMID": "42662421",
"PMCID": "PMC13520625",
"ISSN": "2589-0042",
"publisher": "Elsevier",
"URL": "https://doi.org/10.1016/j.isci.2026.117074",
"language": "en",
"issued": {
"date-parts": [
[
2026,
8,
18
]
]
}
}

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.1523/jneurosci.0889-25.2026 [code]
Neural Evidence for Action-Related Somatosensory Predictions.
Journal: The Journal of neuroscience : the official journal of the Society for Neuroscience
In common: 15 references
[2] doi:10.7554/elife.103689 [code]
Dissociable dynamic effects of expectation during statistical learning.
Journal: eLife
In common: 6 references
[3] doi:10.1523/jneurosci.0154-26.2026 [code]
Faster but less precise: expectation enhances response speed while reducing sensory fidelity.
Journal: The Journal of neuroscience : the official journal of the Society for Neuroscience
In common: 6 references
[4] doi:10.1016/j.neuroimage.2026.122004
Preventing visual feedback of the moving limb during grasping preferentially activates parietofrontal premotor areas.
Journal: NeuroImage
In common: fMRI, systems, 2 references
[5] doi:10.1038/s41467-026-74824-0 [code]
Learning regularities in noise engages both neural predictive activity and representational changes.
Journal: Nature communications
In common: NumPy, 2 references
[6] doi:10.3758/s13428-026-03150-6 [code]
Tetrix: A novel Tetris-based paradigm for neuroimaging research and clinical applications.
Journal: Behavior research methods
In common: PsychoPy, NumPy, fMRI
[7] doi:10.1016/j.dcn.2026.101791 [code]
Age-related differences in hippocampal network engagement during safety processing in adolescents.
Journal: Developmental cognitive neuroscience
In common: PsychoPy, NumPy, fMRI
[8] doi:10.1162/nol.a.271 [code]
Compositional Complexity in Text and Images.
Journal: Neurobiology of language (Cambridge, Mass.)
In common: PsychoPy, NumPy, fMRI
[9] doi:10.1038/s41380-026-03694-1 [code]
Targeting cortico-striatal-amygdalar networks via theta-band frontoparietal synchronization in opioid use disorder: a randomized tACS-fMRI Trial.
Journal: Molecular psychiatry
In common: PsychoPy, NumPy, fMRI
[10] doi:10.1038/s41467-026-72605-3 [code]
Resolving mesoscale brainstem-prefrontal-striatal pathways underlying decisions upon salient events using submillimeter-resolution fMRI.
Journal: Nature communications
In common: PsychoPy, NumPy, fMRI

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.