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.

17 blocks of code here have a permanent identifier (oscr:b:…), listed with the matches below: citable for good, with a page of its own. Select a match and press Cite to copy it. What a block identifier is.

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 to 138 · score 0.94 · D2 pathway activity, receptor activity, phasic peak, arbitrary units, D1, concentration · block oscr:b:RNCVFYJ7WYVE8-L · Report a mismatch
  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 to 101 · score 0.88 · permanent threshold, sustained threshold, cumulative nDKL, harris gallistel, crossings, odds · block oscr:b:NQXXK91XPMMQP-8 · Report a mismatch
  3. [3] § Methods › Simulation testing the importance of different cortical “modules” to actor/critic/policy-IG learning ↔ Circuit_design/agents.py, lines 17 to 55 · score 0.78 · conflict resolution, environmental stimuli, motor programs, Actor, Critic, agent · block oscr:b:RVACNCVHPCFTH-X · Report a mismatch
  4. [4] § Methods › Simulation showing the effect of dopamine→striosome connection weight on policy-IG control ↔ Circuit_design/striosome_dopamine_control.py, lines 72 to 81 · score 0.76 · weak inhibition, strong inhibition, dopamine activity, striosome dopamine, excitatory · block oscr:b:WA9XFSFWNAKYP-8 · Report a mismatch
  5. [5] § Methods › Policy-IG/RPE relationship in Gymnasium tasks ↔ Associative_learning_correlations/open_gym_comparison.py, lines 34 to 35 · score 0.75 · Taxi v3, CliffWalking, FrozenLake, v1 · block oscr:b:7CBWKZM53HFQC-Q · Report a mismatch
  6. [6] § Methods › Simulation exploring the space of possible action-boundary profiles ↔ Action_initiation/clusters_of_brackets.py, lines 154 to 226 · score 0.74 · noise multiplier, normalized policy, profiles, classified, gap, bracketing · block oscr:b:VTPG9XDZ8A0XW-9 · Report a mismatch
  7. [7] § Methods › Simulations comparing TD and policy-IG learning algorithms ↔ Multi_cue_learning/chunking_vs_TD_learning_blocking_task.py, lines 81 to 211 · score 0.73 · delayed start, multi cue, compound, epochs, licking, trace · block oscr:b:3EEBWCGY88SRX-1 · Report a mismatch
  8. [8] § Methods › Simulations showing relationship between Weber law surprise and policy-IG ↔ Weber_law_surprise/Webers_law_and_policyIG.py, lines 23 to 80 · score 0.72 · Weber law surprise, est, log2, interval, exponential, simulated · block oscr:b:1TY9CHV51F87Z-R · Report a mismatch
  9. [9] § Methods › Simulation testing the importance of different cortical “modules” to actor/critic/policy-IG learning ↔ Circuit_design/layers.py, lines 185 to 234 · score 0.71 · conflict strength, conflict resolution, confidences, preferences, uncertainty, errors · block oscr:b:BHDMQA54KA06X-9 · Report a mismatch
  10. [10] § Methods › Reinforcement learning simulations showing a linear RPE/policy-IG relationship ↔ Associative_learning_correlations/associative_learning_RPE_pIG_correlation.py, lines 33 to 69 · score 0.68 · q_cue, learning_rate, Shannon entropy, simulated, softmax, RPE · block oscr:b:3EFRNKMNEHH5Q-Q · Report a mismatch
  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 to 76 · score 0.64 · p_cue, offset, power, firing, sigmoid, unexpected · block oscr:b:RF8Q3AEG6PCAS-3 · Report a mismatch
  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 to 94 · score 0.63 · trial bin, dopamine response, decline, neutral, stimuli, fit · block oscr:b:KVTB5BZW07SB8-B · Report a mismatch
  13. [13] § Methods › Simulation illustrating the emergence of policy-IG correlates ↔ Naturalistic_foraging/naturalistic_rodent_foraging.py, lines 317 to 395 · score 0.61 · causal learning, eligibility, traces, Rolling, timestep, foraging · block oscr:b:T0CW1A6SN1WTC-N · Report a mismatch
  14. [14] § Methods › Simulation illustrating different heterogenous policy-IG reactions to the same stimuli ↔ Circuit_design/four_stream_policies_over_time.py, lines 31 to 101 · score 0.61 · streams, drift, Limbic, Oculomotor, strength, pulses · block oscr:b:87NKQGWWYAGYY-D · Report a mismatch
  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 to 54 · score 0.56 · interpolate utility, spline, intercept, slope, fitted, nats · block oscr:b:MVRZR3JEJ2A50-T · Report a mismatch
  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 to 286 · score 0.53 · TD algorithm, TD learning, stimulation, cue · block oscr:b:ZBMPDD48AM39A-8 · Report a mismatch
  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 to 148 · score 0.51 · learning agent, surprise, arbitrarily, foraging, spaced, episodes · block oscr:b:D4WH4JA7BN396-3 · Report a mismatch

Paper

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

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.1523/jneurosci.1527-22.2023
Anticipation of Appetitive Operant Action Induces Sustained Dopamine Release in the Nucleus Accumbens.
Journal: The Journal of neuroscience : the official journal of the Society for Neuroscience
In common: cognitive, 27 references
[2] doi:10.1038/s41467-025-61466-x [code]
A decision-space model explains context-specific decision-making.
Journal: Nature communications
In common: Statistics and Machine Learning Toolbox, SciPy, Matplotlib, 1 other tool, cognitive, 18 references, author Alexander Friedman
[3] doi:10.1371/journal.pcbi.1010340 [code]
The dopamine circuit as a reward-taxis navigation system.
Journal: PLoS computational biology
In common: pandas, SciPy, Matplotlib, 1 other tool, 22 references
[4] doi:10.1038/s41586-022-05611-2 [code]
Spontaneous behaviour is structured by reinforcement without explicit reward.
Journal: Nature
In common: statsmodels, seaborn, pandas, 3 other tools, 20 references
[5] doi:10.1126/sciadv.adn4203 [code]
Mesostriatal dopamine is sensitive to changes in specific cue-reward contingencies.
Journal: Science advances
In common: Statistics and Machine Learning Toolbox, pandas, SciPy, 2 other tools, 18 references
[6] doi:10.7554/elife.62583 [code]
Slowly evolving dopaminergic activity modulates the moment-to-moment probability of reward-related self-timed movements.
Journal: eLife
In common: Statistics and Machine Learning Toolbox, 20 references
[7] doi:10.1016/j.celrep.2024.114080
Distributional coding of associative learning in discrete populations of midbrain dopamine neurons.
Journal: Cell reports
In common: cognitive, 21 references
[8] doi:10.1038/s41593-025-02104-z [code]
Estrogen modulates reward prediction errors and reinforcement learning.
Journal: Nature neuroscience
In common: Optimization Toolbox, Statistics and Machine Learning Toolbox, 18 references
[9] doi:10.1016/j.cub.2024.09.045 [code]
Pre-existing visual responses in a projection-defined dopamine population explain individual learning trajectories.
Journal: Current biology : CB
In common: statsmodels, seaborn, pandas, 3 other tools, cognitive, 16 references
[10] doi:10.1038/s41593-023-01401-9 [code]
Unique functional responses differentially map onto genetic subtypes of dopamine neurons.
Journal: Nature neuroscience
In common: Statistics and Machine Learning Toolbox, 19 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.

Add the badge to the code's README

OSCR: the badge of this paper

If you are an author or a maintainer of this paper's code, you can add this badge. It says what OSCR knows of the paper (its code, its validated tracing map) and links the code to this page. Paste one of these snippets under the README's title. Keep the two marks around it, so that the badge can be replaced in place and is never added twice. OSCR changes nothing in your repository.

Markdown
<!-- oscr-badge:start -->
[![OSCR](https://openscicode.org/badge/doi/10.1038/s41467-026-73994-1.svg)](https://openscicode.org/badge/doi/10.1038/s41467-026-73994-1)
<!-- oscr-badge:end -->
reStructuredText
.. oscr-badge:start

.. image:: https://openscicode.org/badge/doi/10.1038/s41467-026-73994-1.svg
   :target: https://openscicode.org/badge/doi/10.1038/s41467-026-73994-1
   :alt: OSCR

.. oscr-badge:end
HTML
<!-- oscr-badge:start -->
<a href="https://openscicode.org/badge/doi/10.1038/s41467-026-73994-1"><img src="https://openscicode.org/badge/doi/10.1038/s41467-026-73994-1.svg" alt="OSCR"></a>
<!-- oscr-badge:end -->

On GitHub, open the README, choose Edit (the pencil), paste the snippet under the title, then "Commit changes".

If you choose to, you can have the badge kept up to date for you, with oscr badge --write from the command line or with the GitHub Action in your repository's workflows. Every other form and option (a card, AsciiDoc, LaTeX, shields.io) is on the badge 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: code errors and mismatches between the code and the paper about this paper and its code, from readers and its authors, beside the paper and its tracing map.

Report a mismatch between the code and the paper · Report a code error (signed in)

Reproductions: reports from readers who ran the authors' code and did not get the paper's result, what they ran, with which environment, commit and data.

Report a reproduction failure (signed in)

Versions of its code: the releases of its code tied to a version of this paper (the preprint, the accepted manuscript, the version of record…), each with the tracing map versioned with it.

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