OSCR

Prediction error correlates in the striosome-dopamine circuit emerge from information gain.

Code ↔ Paper

17 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 17 matches
  1. [1] § Methods › Simulation illustrating how phasic and tonic dopamine components differentially drive D1 versus D2 pathway activity ↔ Circuit_design/d1_d2_lead_to_dual_param_control.py, lines 54–138 · score 0.94 · D2 pathway activity, receptor activity, phasic peak, arbitrary units, D1, concentration
  2. [2] § Methods › Analyzing the relationship between policy-IG and informativeness as predictors of Pavlovian acquisition using Harris and Gallistel (2025) data ↔ Harris_and_Gallistel_analysis/Harris_Gallistel_analysis.m, lines 23–101 · score 0.88 · permanent threshold, sustained threshold, cumulative nDKL, harris gallistel, crossings, odds
  3. [3] § Methods › Simulation testing the importance of different cortical “modules” to actor/critic/policy-IG learning ↔ Circuit_design/agents.py, lines 17–55 · score 0.78 · conflict resolution, environmental stimuli, motor programs, Actor, Critic, agent
  4. [4] § Methods › Simulation showing the effect of dopamine→striosome connection weight on policy-IG control ↔ Circuit_design/striosome_dopamine_control.py, lines 72–81 · score 0.76 · weak inhibition, strong inhibition, dopamine activity, striosome dopamine, excitatory
  5. [5] § Methods › Policy-IG/RPE relationship in Gymnasium tasks ↔ Associative_learning_correlations/open_gym_comparison.py, lines 34–35 · score 0.75 · Taxi v3, CliffWalking, FrozenLake, v1
  6. [6] § Methods › Simulation exploring the space of possible action-boundary profiles ↔ Action_initiation/clusters_of_brackets.py, lines 154–226 · score 0.74 · noise multiplier, normalized policy, profiles, classified, gap, bracketing
  7. [7] § Methods › Simulations comparing TD and policy-IG learning algorithms ↔ Multi_cue_learning/chunking_vs_TD_learning_blocking_task.py, lines 81–211 · score 0.73 · delayed start, multi cue, compound, epochs, licking, trace
  8. [8] § Methods › Simulations showing relationship between Weber law surprise and policy-IG ↔ Weber_law_surprise/Webers_law_and_policyIG.py, lines 23–80 · score 0.72 · Weber law surprise, est, log2, interval, exponential, simulated
  9. [9] § Methods › Simulation testing the importance of different cortical “modules” to actor/critic/policy-IG learning ↔ Circuit_design/layers.py, lines 185–234 · score 0.71 · conflict strength, conflict resolution, confidences, preferences, uncertainty, errors
  10. [10] § Methods › Reinforcement learning simulations showing a linear RPE/policy-IG relationship ↔ Associative_learning_correlations/associative_learning_RPE_pIG_correlation.py, lines 33–69 · score 0.68 · q_cue, learning_rate, Shannon entropy, simulated, softmax, RPE
  11. [11] § Methods › Analyzing the relationship between policy-IG and dopamine responses using Eshel et al. (2016) data ↔ Associative_learning_correlations/eshel_et_al_fitting.py, lines 33–76 · score 0.64 · p_cue, offset, power, firing, sigmoid, unexpected
  12. [12] § Methods › Analyzing the relationship between policy-IG and dopamine responses to novel stimuli using Kutlu et al. (2021) data ↔ Associative_learning_correlations/experimental_data_fit_Kutlu_et_al_novelty.py, lines 67–94 · score 0.63 · trial bin, dopamine response, decline, neutral, stimuli, fit
  13. [13] § Methods › Simulation illustrating the emergence of policy-IG correlates ↔ Naturalistic_foraging/naturalistic_rodent_foraging.py, lines 317–395 · score 0.61 · causal learning, eligibility, traces, Rolling, timestep, foraging
  14. [14] § Methods › Simulation illustrating different heterogenous policy-IG reactions to the same stimuli ↔ Circuit_design/four_stream_policies_over_time.py, lines 31–101 · score 0.61 · streams, drift, Limbic, Oculomotor, strength, pulses
  15. [15] § Methods › Analyzing the relationship between policy-IG and dopamine responses using Stauffer et al. (2014) data ↔ Associative_learning_correlations/experimental_data_fit_Stauffer_et_al.py, lines 12–54 · score 0.56 · interpolate utility, spline, intercept, slope, fitted, nats
  16. [16] § Results › Prediction: policy-IG learning resembles contingency and temporal difference learning ↔ Multi_cue_learning/chunking_vs_TD_learning_blocking_task.py, lines 216–286 · score 0.53 · TD algorithm, TD learning, stimulation, cue
  17. [17] § Methods › Policy-IG/RPE relationship during foraging with surprising costs ↔ Associative_learning_correlations/foraging_with_large_costs_RPE_pIG_relationship.py, lines 86–148 · score 0.51 · learning agent, surprise, arbitrarily, foraging, spaced, episodes

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 · 286 lines · 13 KB · no license · 2 matches

  1. import numpy as np
  2. import matplotlib.pyplot as plt
  4. np.random.seed(0)
  6. class Policy:
  7. def __init__(self, p_lick_target_init=0.5):
  8. self.p_lick_target = p_lick_target_init
  9. self.p_lick_current = 0.5
  10. self._update_probabilities()
  12. def _update_probabilities(self):
  13. self.p_lick = np.clip(self.p_lick_current, 1e-9, 1 - 1e-9)
  14. self.p_no_lick = 1.0 - self.p_lick
  15. self.actions = ["Lick", "No Lick"]
  16. self.probabilities = np.array([self.p_lick, self.p_no_lick])
  17. self.entropy = self._calculate_entropy()
  19. def _calculate_entropy(self):
  20. if np.allclose(self.p_lick, 0) or np.allclose(self.p_lick, 1):
  21. return 0.0
  22. if self.p_lick <= 1e-9 or self.p_no_lick <= 1e-9:
  23. return 0.0
  24. return -(self.p_lick * np.log(self.p_lick + 1e-9) + self.p_no_lick * np.log(self.p_no_lick + 1e-9))
  26. def update_learning(self, learning_rate):
  27. self.p_lick_current += learning_rate * (self.p_lick_target - self.p_lick_current)
  28. self._update_probabilities()
  30. def get_current_p_lick_for_display(self):
  31. return self.p_lick_current
  34. class Chunk:
  35. def __init__(self, name, cues, p_lick_target_for_policy=0.5):
  36. self.name = name
  37. self.cues = cues
  38. self.policy = Policy(p_lick_target_init=p_lick_target_for_policy)
  39. self.h_max = np.log(len(self.policy.actions)) if len(self.policy.actions) > 0 else 0
  40. self.q_intrinsic = 0
  41. self.is_learning_active = False
  42. self.update_q_intrinsic()
  44. def update_q_intrinsic(self):
  45. self.q_intrinsic = self.h_max - self.policy.entropy
  47. def learn_policy_step(self, learning_rate):
  48. if self.is_learning_active:
  49. self.policy.update_learning(learning_rate)
  50. self.update_q_intrinsic()
  53. # params
  54. H_MAX_GLOBAL = np.log(2)
  55. EPISODES_PER_EPOCH = 40
  56. TOTAL_EPOCHS = 4
  57. POLICY_LEARNING_RATE_CHUNKER = 0.15
  58. ALPHA_Q = 0.15
  59. GAMMA_Q = 0.9
  60. TEMPERATURE_Q = 1.0 # softmax temperature
  62. STATE_CHEESE_NO_CUE = 0
  63. STATE_RED_BELL_ONLY = 1
  64. STATE_BLUE_BELL_ONLY = 2
  65. STATE_RED_BLUE_COMPOUND = 3
  66. NUM_STATES_Q = 4
  67. ACTION_LICK_Q = 0
  68. ACTION_NO_LICK_Q = 1
  69. NUM_ACTIONS_Q = 2
  72. def choose_action(q_values, temperature):
  73. # subtract max for numerical stability
  74. z = q_values / temperature
  75. z = z - np.max(z)
  76. exp_z = np.exp(z)
  77. probs = exp_z / np.sum(exp_z)
  78. return np.random.choice(NUM_ACTIONS_Q, p=probs)
  81. def simulate_delayed_start_plot():
  82. chunk_dictionary = {}
  83. total_sim_episodes = TOTAL_EPOCHS * EPISODES_PER_EPOCH
  85. policy_baseline_chunk = Policy(p_lick_target_init=0.5)
  87. chunker_traces = {
  88. "CheeseOnly": [np.nan] * total_sim_episodes,
  89. "Red+cheese": [np.nan] * total_sim_episodes,
  90. "Red+blue+cheese": [np.nan] * total_sim_episodes
  91. }
  93. q_table = np.zeros((NUM_STATES_Q, NUM_ACTIONS_Q))
  94. qlearner_traces = {
  95. "V(S_Cheese)": [np.nan] * total_sim_episodes,
  96. "V(S_Red)": [np.nan] * total_sim_episodes,
  97. "V(S_BlueOnly)": [np.nan] * total_sim_episodes,
  98. "V(S_RedBlueCompound)": [np.nan] * total_sim_episodes
  99. }
  101. P_LICK_TARGET_UNIVERSAL = 0.95
  102. P_LICK_TARGET_CHEESE_ONLY = P_LICK_TARGET_UNIVERSAL
  103. P_LICK_TARGET_RED = P_LICK_TARGET_UNIVERSAL
  104. P_LICK_TARGET_RED_BLUE = P_LICK_TARGET_UNIVERSAL
  106. stim_epoch = 4
  107. stim_duration_episodes = int(EPISODES_PER_EPOCH * 0.5)
  108. stim_start_episode_global_idx = (stim_epoch - 1) * EPISODES_PER_EPOCH
  109. stim_end_episode_global_idx = stim_start_episode_global_idx + stim_duration_episodes
  111. global_episode_idx = 0
  112. for epoch in range(1, TOTAL_EPOCHS + 1):
  113. # chunker learning activation
  114. if epoch > 1 and "CheeseOnly" in chunk_dictionary:
  115. chunk_dictionary["CheeseOnly"].is_learning_active = False
  116. if epoch > 2 and "Red+cheese" in chunk_dictionary:
  117. chunk_dictionary["Red+cheese"].is_learning_active = False
  118. if "Red+blue+cheese" in chunk_dictionary:
  119. chunk_dictionary["Red+blue+cheese"].is_learning_active = False
  121. if epoch == 1:
  122. if "CheeseOnly" not in chunk_dictionary:
  123. chunk_dictionary["CheeseOnly"] = Chunk("CheeseOnly", {"Cheese"}, P_LICK_TARGET_CHEESE_ONLY)
  124. chunk_dictionary["CheeseOnly"].is_learning_active = True
  125. elif epoch == 2:
  126. if "Red+cheese" not in chunk_dictionary:
  127. chunk_dictionary["Red+cheese"] = Chunk("Red+cheese", {"RedBell"}, P_LICK_TARGET_RED)
  128. chunk_dictionary["Red+cheese"].is_learning_active = True
  129. elif epoch == 3:
  130. if "Red+blue+cheese" not in chunk_dictionary:
  131. chunk_dictionary["Red+blue+cheese"] = Chunk("Red+blue+cheese", {"RedBell", "BlueBell"},
  132. P_LICK_TARGET_RED_BLUE)
  134. for episode_in_epoch in range(EPISODES_PER_EPOCH):
  135. # chunker logic
  136. if epoch == stim_epoch and stim_start_episode_global_idx <= global_episode_idx < stim_end_episode_global_idx and "Red+blue+cheese" in chunk_dictionary:
  137. chunk_dictionary["Red+blue+cheese"].is_learning_active = True
  138. elif "Red+blue+cheese" in chunk_dictionary and global_episode_idx >= stim_end_episode_global_idx:
  139. chunk_dictionary["Red+blue+cheese"].is_learning_active = False
  141. for chunk_obj in chunk_dictionary.values():
  142. chunk_obj.learn_policy_step(POLICY_LEARNING_RATE_CHUNKER)
  144. # record chunker traces
  145. if epoch >= 1 and "CheeseOnly" in chunk_dictionary:
  146. chunker_traces["CheeseOnly"][global_episode_idx] = chunk_dictionary["CheeseOnly"].q_intrinsic
  147. if epoch >= 2 and "Red+cheese" in chunk_dictionary:
  148. chunker_traces["Red+cheese"][global_episode_idx] = chunk_dictionary["Red+cheese"].q_intrinsic
  149. if epoch >= 3 and "Red+blue+cheese" in chunk_dictionary:
  150. chunker_traces["Red+blue+cheese"][global_episode_idx] = chunk_dictionary["Red+blue+cheese"].q_intrinsic
  152. # q-learner logic
  153. q_learner_current_trial_states = []
  154. enable_blue_to_red_propagation = False
  156. if epoch == 1:
  157. q_learner_current_trial_states.append(STATE_CHEESE_NO_CUE)
  158. elif epoch == 2:
  159. q_learner_current_trial_states.append(STATE_RED_BELL_ONLY)
  160. elif epoch == 3:
  161. rand_e3 = np.random.rand()
  162. if rand_e3 < 0.5:
  163. q_learner_current_trial_states.append(STATE_BLUE_BELL_ONLY)
  164. else:
  165. q_learner_current_trial_states.append(STATE_RED_BLUE_COMPOUND)
  166. elif epoch == 4:
  167. q_learner_current_trial_states.extend(
  168. [STATE_BLUE_BELL_ONLY, STATE_RED_BLUE_COMPOUND, STATE_RED_BELL_ONLY])
  169. if global_episode_idx >= stim_start_episode_global_idx:
  170. enable_blue_to_red_propagation = True
  172. if q_learner_current_trial_states:
  173. current_q_s = np.random.choice(q_learner_current_trial_states)
  174. action_q = choose_action(q_table[current_q_s], TEMPERATURE_Q)
  175. reward_q = 0
  176. next_s_max_q = 0
  178. if current_q_s == STATE_BLUE_BELL_ONLY and enable_blue_to_red_propagation:
  179. s_blue = STATE_BLUE_BELL_ONLY
  180. a_blue = action_q
  181. r_blue = 0
  182. s_next_after_blue = STATE_RED_BELL_ONLY
  183. val_of_s_next_after_blue = np.max(q_table[s_next_after_blue])
  184. q_table[s_blue, a_blue] += ALPHA_Q * (
  185. r_blue + GAMMA_Q * val_of_s_next_after_blue - q_table[s_blue, a_blue])
  186. elif current_q_s == STATE_BLUE_BELL_ONLY and not enable_blue_to_red_propagation:
  187. r_blue_only = 0
  188. q_table[current_q_s, action_q] += ALPHA_Q * (
  189. r_blue_only + GAMMA_Q * 0 - q_table[current_q_s, action_q])
  190. else:
  191. if current_q_s == STATE_CHEESE_NO_CUE and action_q == ACTION_LICK_Q:
  192. reward_q = 1.0
  193. elif current_q_s == STATE_RED_BELL_ONLY and action_q == ACTION_LICK_Q:
  194. reward_q = 1.0
  195. elif current_q_s == STATE_RED_BLUE_COMPOUND and action_q == ACTION_LICK_Q:
  196. reward_q = 1.0
  197. q_table[current_q_s, action_q] += ALPHA_Q * (
  198. reward_q + GAMMA_Q * next_s_max_q - q_table[current_q_s, action_q])
  200. # record Q traces
  201. if epoch >= 1:
  202. qlearner_traces["V(S_Cheese)"][global_episode_idx] = np.max(q_table[STATE_CHEESE_NO_CUE])
  203. if epoch >= 2:
  204. qlearner_traces["V(S_Red)"][global_episode_idx] = np.max(q_table[STATE_RED_BELL_ONLY])
  205. if epoch >= 3:
  206. qlearner_traces["V(S_BlueOnly)"][global_episode_idx] = np.max(q_table[STATE_BLUE_BELL_ONLY])
  207. qlearner_traces["V(S_RedBlueCompound)"][global_episode_idx] = np.max(q_table[STATE_RED_BLUE_COMPOUND])
  209. global_episode_idx += 1
  211. return chunker_traces, qlearner_traces, q_table
  214. chunker_res_delay, qlearner_res_delay, final_q_delay = simulate_delayed_start_plot()
  216. # plotting
  217. total_eps_delay = TOTAL_EPOCHS * EPISODES_PER_EPOCH
  218. eps_numbers_delay = np.arange(1, total_eps_delay + 1)
  220. fig, ax1 = plt.subplots(figsize=(10, 6))
  222. colors = {'cheese': 'green', 'red': 'red', 'blue': 'blue', 'purple': 'purple'}
  224. ax1.plot(eps_numbers_delay, chunker_res_delay["CheeseOnly"], color=colors['cheese'], linestyle='-', linewidth=2,
  225. label="Cheese chunk")
  226. ax1.plot(eps_numbers_delay, chunker_res_delay["Red+cheese"], color=colors['red'], linestyle='-', linewidth=2,
  227. label="Red+cheese chunk")
  228. ax1.plot(eps_numbers_delay, chunker_res_delay["Red+blue+cheese"], color=colors['purple'], linestyle='-', linewidth=2,
  229. label="Red+blue+cheese chunk")
  231. ax1.plot(eps_numbers_delay, qlearner_res_delay["V(S_Cheese)"], color=colors['cheese'], linestyle='--', linewidth=2,
  232. alpha=0.7, label="Cheese value (TD algorithm)")
  233. ax1.plot(eps_numbers_delay, qlearner_res_delay["V(S_Red)"], color=colors['red'], linestyle='--', linewidth=2, alpha=0.7,
  234. label="Red cue value (TD algorithm)")
  235. ax1.plot(eps_numbers_delay, qlearner_res_delay["V(S_BlueOnly)"], color=colors['blue'], linestyle='--', linewidth=2,
  236. alpha=0.7, label="Blue cue value (TD algorithm)")
  238. ax1.set_xlabel("Episode Number", fontsize=10)
  239. ax1.set_ylabel('Value (chunk or cue)', color='black', fontsize=10)
  240. ax1.tick_params(axis='y', labelsize=9)
  241. ax1.tick_params(axis='x', labelsize=9)
  242. ax1.set_ylim(-0.05, 1.10)
  244. epoch_labels_delay = ["E1: Learn Cheese", "E2: Learn Red", "E3: Blue Intro", "E4: Stim. + Consolidate"]
  245. stim_epoch_plot_delay = 4
  246. stim_duration_plot_delay = int(EPISODES_PER_EPOCH * 0.5)
  247. stim_band_plot_start_delay = (stim_epoch_plot_delay - 1) * EPISODES_PER_EPOCH + 0.5
  248. stim_band_plot_end_delay = stim_band_plot_start_delay + stim_duration_plot_delay
  250. for i in range(1, TOTAL_EPOCHS):
  251. xc = i * EPISODES_PER_EPOCH
  252. ax1.axvline(x=xc + 0.5, color='dimgray', linestyle=':', linewidth=1.0)
  254. ax1.axvspan(stim_band_plot_start_delay, stim_band_plot_end_delay, color='yellow', alpha=0.3)
  256. tick_pos_delay = [i * EPISODES_PER_EPOCH + EPISODES_PER_EPOCH / 2 for i in range(TOTAL_EPOCHS)]
  257. valid_tick_pos_delay = [tp for tp in tick_pos_delay if tp <= total_eps_delay]
  258. valid_tick_labels_delay = [epoch_labels_delay[i] for i, tp in enumerate(tick_pos_delay) if tp <= total_eps_delay]
  259. ax1.set_xticks(valid_tick_pos_delay)
  260. ax1.set_xticklabels(valid_tick_labels_delay, rotation=10, ha="right", fontsize=8)
  262. import matplotlib.patches as mpatches
  264. handles, labels = ax1.get_legend_handles_labels()
  265. stim_patch = mpatches.Patch(color='yellow', alpha=0.3, label='Artificial stimulation')
  266. if 'Artificial stimulation' not in labels:
  267. handles.append(stim_patch)
  268. labels.append('Artificial stimulation')
  270. desired_order_map = {
  271. "Cheese chunk": 0, "Red+cheese chunk": 1, "Red+blue+cheese chunk": 2,
  272. "Cheese value (TD algorithm)": 3, "Red cue value (TD algorithm)": 4,
  273. "Blue cue value (TD algorithm)": 5, "Artificial stimulation": 6
  274. }
  275. sorted_handles_labels = sorted(zip(handles, labels), key=lambda x: desired_order_map.get(x[1], 99))
  276. if sorted_handles_labels:
  277. sorted_handles, sorted_labels = zip(*sorted_handles_labels)
  278. ax1.legend(sorted_handles, sorted_labels, fontsize=8, loc='center left', bbox_to_anchor=(1.02, 0.5))
  279. else:
  280. ax1.legend(fontsize=8, loc='center left', bbox_to_anchor=(1.02, 0.5))
  282. ax1.grid(False)
  283. fig.tight_layout(rect=[0, 0, 0.75, 1])
  284. plt.rcParams['pdf.fonttype'] = 42
  285. plt.savefig('chunking_vs_TD_learning_blocking_task.pdf')
  286. plt.show()

chunking_vs_TD_learning_blocking_task.py at commit 1b65f2b, no license · at the source

Overview

Authors: Dirk W Beck1, Alexander Friedman1,2
ORCID iDs: Alexander Friedman
  1. Computational Science Program, University of Texas at El Paso, El Paso, TX USA
  2. Department of Biological Sciences, University of Texas at El Paso, El Paso, TX USA
Institutions: The University of Texas at El Paso (United States)
Journal: Nature communications, volume 17, issue 1, article 8066
Dates: received 11 July 2025; accepted 21 May 2026; published online 27 June 2026
Type: Research article · Language: English
License: CC BY-NC-ND
Identifiers: DOI 10.1038/s41467-026-73994-1 · PMID 42364984 · PMCID PMC13454626 · OpenAlex W7166295042
Open access: gold, a free copy (OpenAlex)
Status: code verified
Categories: human (organism), cognitive (subfield)
Methods: Statistics, Preprocessing, Evoked potentials, Connectivity, Machine learning, Spectral & time-frequency
Keywords: Learning algorithms, Reward, Neural circuits, Classical conditioning, Basal ganglia
MeSH: Corpus Striatum*, Dopamine*, Dopaminergic Neurons*, Animals, Bayes Theorem, Decision Making, Humans, Models, Neurological, Reward (* major topic)
Topic: Neural and Behavioral Psychology Studies (Cognitive Neuroscience, Neuroscience), according to OpenAlex
Funding: NIMH NIH HHS (R01 MH142540); NIDA NIH HHS (R01 DA058653)
Citations: not cited yet (Europe PMC); 198 references in the paper

Abstract

The abstract is not reproduced here: the paper's license (CC BY-NC-ND) does not allow it. Read it in the paper, at the publisher or on Europe PMC.

Repository

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

dirkbeck/dopamine_modeling

License: none: the authors keep all their rights
State: the link answers, verified on 27 September 2026
Evidence: files inventoried
Commit: 1b65f2be6ecdaf5aca5000cacffee0c062b74119, 22 February 2026
Languages: Python (39), MATLAB (2)
Size: 53 files, 41 scripts
Software Heritage: not archived
Found in: “Code availability”
Holds: README, environment (requirements.txt)
Not found: license file, CITATION.cff, tests, continuous integration, documentation
Tools: NumPy (39 files), Matplotlib (35 files), SciPy (16 files), pandas (8 files), statsmodels (2 files), Optimization Toolbox (1 file), Statistics and Machine Learning Toolbox (1 file), seaborn (1 file)
Availability: 1 check, the latest on 27 September 2026: the link answers
  • 27 September 2026: the link answers
42 files
At the source: github.com/dirkbeck/dopamine_modeling

Code availability statement

The paper has a code availability statement. Its license (CC BY-NC-ND) does not allow reproducing it here; in short, from what the harvester recognized in it:

Read it in the paper: doi.org/10.1038/s41467-026-73994-1.

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;
  • 41 scripts, each with its path and the digest of its content;
  • 17 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

Datasets cited

Data availability statement

The paper has a data availability statement. Its license (CC BY-NC-ND) does not allow reproducing it here; in short, from what the harvester recognized in it:

  • no repository, dataset or request procedure was recognized in it

Read it in the paper: doi.org/10.1038/s41467-026-73994-1.

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 1, 27 September 2026: the first record

Recorded: type, language, journal, volume, issue, pages, dates, 2 authors, 5 keywords, 9 MeSH terms, 2 funders, 184 references.

Cite

This paper

Beck, D. W., & Friedman, A. (2026). Prediction error correlates in the striosome-dopamine circuit emerge from information gain. Nature communications, 17(1), 8066. https://doi.org/10.1038/s41467-026-73994-1

BibTeX

@article{beck2026prediction,
author = {Beck, Dirk W and Friedman, Alexander},
title = {{Prediction error correlates in the striosome-dopamine circuit emerge from information gain}},
journal = {Nature communications},
year = {2026},
month = jun,
volume = {17},
number = {1},
pages = {8066},
publisher = {Nature Publishing Group},
issn = {2041-1723},
doi = {10.1038/s41467-026-73994-1},
url = {https://doi.org/10.1038/s41467-026-73994-1},
pmid = {42364984},
pmcid = {PMC13454626}
}

RIS

TY - JOUR
AU - Beck, Dirk W
AU - Friedman, Alexander
TI - Prediction error correlates in the striosome-dopamine circuit emerge from information gain
T2 - Nature communications
J2 - Nat Commun
PY - 2026
DA - 2026/06/27
VL - 17
IS - 1
SP - 8066
SN - 2041-1723
PB - Nature Publishing Group
DO - 10.1038/s41467-026-73994-1
UR - https://doi.org/10.1038/s41467-026-73994-1
LA - en
ER -

CSL-JSON

{
"id": "10.1038/s41467-026-73994-1",
"type": "article-journal",
"title": "Prediction error correlates in the striosome-dopamine circuit emerge from information gain",
"container-title": "Nature communications",
"author": [
{
"family": "Beck",
"given": "Dirk W"
},
{
"family": "Friedman",
"given": "Alexander"
}
],
"container-title-short": "Nat Commun",
"volume": "17",
"issue": "1",
"page": "8066",
"DOI": "10.1038/s41467-026-73994-1",
"PMID": "42364984",
"PMCID": "PMC13454626",
"ISSN": "2041-1723",
"publisher": "Nature Publishing Group",
"URL": "https://doi.org/10.1038/s41467-026-73994-1",
"language": "en",
"issued": {
"date-parts": [
[
2026,
6,
27
]
]
}
}

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.1016/j.isci.2026.117130 [code]
Region-specific weighting of sensory intensity and reward prediction error by dopamine signals.
Journal: iScience
In common: statsmodels, seaborn, pandas, 3 other tools, cognitive, 15 references
[2] doi:10.1073/pnas.2613593123 [code]
Calbindin stratifies midbrain dopaminergic neurons governing distinct aspects of locomotion.
Journal: Proceedings of the National Academy of Sciences of the United States of America
In common: 16 references
[3] doi:10.1523/jneurosci.1762-25.2026 [code]
Mesocorticostriatal Reinforcement Learning of State Representation and Value with Implications for the Mechanisms of Schizophrenia.
Journal: The Journal of neuroscience : the official journal of the Society for Neuroscience
In common: 14 references
[4] doi:10.1038/s41467-026-75371-4 [code]
Cerebellar neural populations orchestrate dopamine reward signaling with single-trial precision.
Journal: Nature communications
In common: statsmodels, Statistics and Machine Learning Toolbox, seaborn, 4 other tools, 10 references
[5] doi:10.1038/s42003-026-10485-5 [code]
Dopamine dynamics as a regulatory mechanism for shifting between defensive and reward-seeking behaviors.
Journal: Communications biology
In common: 13 references
[6] doi:10.1016/j.celrep.2026.117298 [code]
Midbrain endocannabinoids actuate dopamine-based action selection.
Journal: Cell reports
In common: pandas, Matplotlib, 10 references
[7] doi:10.1038/s41467-026-71357-4 [code]
Social reward outcompetes drug seeking dopaminergic ensembles to prevent relapse.
Journal: Nature communications
In common: Optimization Toolbox, Statistics and Machine Learning Toolbox, SciPy, 2 other tools, 6 references
[8] doi:10.1155/da/7682055 [code]
Striosome-Like Structural Connectivity Is Reduced in the Rostral Putamen in Anxiety Disorder.
Journal: Depression and anxiety
In common: 8 references
[9] doi:10.1016/j.isci.2026.116498 [code]
The Tower Foraging Park: A paradigm for studying cognitive and motor processes underlying behavioral flexibility in freely moving mice.
Journal: iScience
In common: SciPy, Matplotlib, NumPy, 6 references
[10] doi:10.1111/ejn.70486
Dopamine in the Nucleus Accumbens Signals Salience of Auditory Deviance.
Journal: The European journal of neuroscience
In common: cognitive, 7 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.