OSCR

A minimal model of working memory in neural systems and neuromorphic circuits.

Code ↔ Paper

3 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 3 matches
  1. [1] § Results › Networks of self-excitatory neurons and mean-field models ↔ Network and Mean-field/network_analysis.ipynb, lines 285 to 373 · score 0.71 · Population firing rate, interval coefficient, Membrane potential, Raster, CV, variation · Report a mismatch
  2. [2] § Results › Networks of self-excitatory neurons and mean-field models ↔ Network and Mean-field/network_analysis.ipynb, lines 169 to 220 · score 0.70 · synaptic conductance, eQIF, gsyn, post, pre, quenched · Report a mismatch
  3. [3] § Results › Networks of self-excitatory neurons and mean-field models ↔ Network and Mean-field/network_analysis.ipynb, lines 285 to 373 · score 0.56 · inter spike intervals, coefficient, CV, variation, activity, firing · 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

Jupyter notebook · 373 lines · 13 KB · no license · 3 matches

  1. # %%
  2. import numpy as np
  3. import matplotlib.pyplot as plt
  4. from scipy.integrate import solve_ivp
  5. from brian2 import *
  6. import collections
  7. # %%
  8. def compute_chi_sliding_window(state_monitor, time_window, f_sample, window_size=50*ms, step_size=10*ms):
  9. """
  10. In each window, compute the population mean voltage and variance, and the mean of individual variances.
  11. χ(t) = sqrt(Var(V_pop) / mean(Var(V_i)))
  12. Input:
  13. state_monitor : StateMonitor, Brian2 StateMonitor with voltage recordings
  14. window_size : time of the sliding window
  15. step_size : time step between successive windows
  16. Returns:
  17. times : array, center times of each window
  18. chi_t : array, time-resolved synchrony measure
  19. """
  20. time_mask = (state_monitor.t/ms >= time_window[0]) & (state_monitor.t/ms < time_window[1])
  21. V_traces = state_monitor.V[:, time_mask] / mV
  22. effective_times = state_monitor.t[time_mask]
  23. # Convert to indices
  24. window_samples = int(window_size / f_sample)
  25. step_samples = int(step_size / f_sample)
  26. n_timepoints = V_traces.shape[1]
  27. chi_t = []
  28. times = []
  29. var_V = []
  30. mean_var_Vi = []
  31. for start_idx in range(0, n_timepoints, step_samples):
  32. end_idx = start_idx + window_samples
  33. # Extract window
  34. V_window = V_traces[:, start_idx:end_idx]
  35. # Compute χ for this window
  36. V_pop_window = np.mean(V_window, axis=0)
  37. sigma_V_squared = np.var(V_pop_window)
  38. sigma_Vi_squared = np.var(V_window, axis=1)
  39. mean_sigma_Vi_squared = np.sum(sigma_Vi_squared)/N
  40. if mean_sigma_Vi_squared > 0:
  41. chi = np.sqrt(sigma_V_squared / mean_sigma_Vi_squared)
  42. else:
  43. chi = 0.0
  44. time = effective_times[start_idx:end_idx].mean()
  45. chi_t.append(chi)
  46. times.append(time/ms)
  47. var_V.append(sigma_V_squared)
  48. mean_var_Vi.append(mean_sigma_Vi_squared)
  49. return np.array(times), np.array(chi_t), np.array(var_V), np.array(mean_var_Vi)
  50. # %%
  51. # Define parameters of the model and the default values for the mean field parameters
  52. DynMemory = collections.namedtuple(
  53. typename='DynMemory',
  54. field_names='C ,g_L ,E_L ,v_th ,T_w ,a ,b ,E_e ,Q_e ,T_s, Eta ,Delta ,v_reset, v_peak')
  55. default_adj_params = DynMemory(
  56. C=200, g_L=10, E_L=-62, v_th=-55, T_w=20, a=4, b=20, E_e=0, Q_e=4, T_s=6, Eta=10, Delta=.5, v_reset=-70., v_peak=-10.)
  57. # Define the adjusted mean field equations for a network of eQIF neurons
  58. # The correction term of the current is discussed in SuppmentaL Material section of the paper
  59. def adjusted_dmMF(t, y, p:DynMemory, I_func):
  60. r, v, w, s = y
  61. C ,g_L ,E_L ,v_th ,T_w ,a ,b ,E_e ,Q_e ,T_s, Eta ,Delta, v_reset, v_peak = p
  62. I0 = I_func(t)
  63. alpha = g_L*(v_th + E_L) + s
  64. beta = g_L*v_th*E_L + s*E_e + w + I0 + Eta
  65. mu = 4*beta/g_L - (alpha/g_L)**2
  66. if mu >= 0:
  67. gamma = np.arctan((2*v_peak - alpha/g_L)/np.sqrt(mu)) - np.arctan((2*v_reset - alpha/g_L)/np.sqrt(mu))
  68. I_adj = g_L*mu*np.pi**2 / (4*gamma**2) + alpha**2 / (4*g_L) -g_L*E_L*v_th - s*E_e - w - Eta
  69. else:
  70. I_adj = I0
  71. dr = r*(g_L*(2*v-v_th-E_L) - s) / C + Delta*g_L/(np.pi*C**2)
  72. dv = (g_L * (E_L - v) * (v_th - v) + w + I_adj + s*(E_e - v) + Eta - (np.pi*C*r)**2/g_L) / C
  73. dw = (a * (v - E_L) - w) / T_w + b*r
  74. ds = -s/T_s + Q_e*r
  75. return np.array([dr, dv, dw, ds])
  76. # %%
  77. # Define time parameters for integration
  78. dt = 0.01
  79. duration_mf = 1500
  80. dtime = dt * ms
  81. duration = duration_mf * ms
  82. defaultclock.dt = dtime
  83. # Set parameters for the mean-field model
  84. adj_params = default_adj_params
  85. # Define parameters with units for Brian2 simulation (same as in mean-field)
  86. N=5000
  87. C = adj_params.C * pF
  88. g_L = adj_params.g_L * nS/mV
  89. E_L = adj_params.E_L * mV
  90. V_T = adj_params.v_th * mV
  91. tau_w = adj_params.T_w * ms
  92. a = adj_params.a * nS
  93. b = adj_params.b * pA
  94. V_reset = adj_params.v_reset * mV
  95. V_peak = adj_params.v_peak * mV
  96. Ee = adj_params.E_e * mV
  97. Qe = adj_params.Q_e/N * nS
  98. Tsyn = adj_params.T_s * ms
  99. # %%
  100. # Define time-varying external current for mean-field simualtion
  101. AmpStep = 60
  102. BaseI = 90
  103. Pert = 10
  104. def input_current(t):
  105. # Definition of the external time-varying current
  106. if t>105 and t<250:
  107. return BaseI+AmpStep # 100-600 ms: 130 pA
  108. elif t>650 and t<720:
  109. return BaseI-Pert
  110. elif t>780 and t<850:
  111. return BaseI+Pert
  112. elif t>1000 and t<1150:
  113. return BaseI-AmpStep
  114. elif t>1250 and t<1320:
  115. return BaseI+Pert
  116. elif t>1350 and t<1420:
  117. return BaseI-Pert
  118. else:
  119. return BaseI
  120. time_array = np.arange(0, duration_mf, dt)
  121. current_array = []
  122. for step in time_array:
  123. current_array.append(input_current(step))
  124. # Define time-varying external current for Brian2 simulation using TimedArray
  125. time_steps = int(duration / dtime)
  126. current_array = np.full(time_steps, BaseI)
  127. current_array[int(100*ms/dtime):int(250*ms/dtime)] = BaseI+AmpStep
  128. current_array[int(650*ms/dtime):int(720*ms/dtime)] = BaseI-Pert
  129. current_array[int(780*ms/dtime):int(850*ms/dtime)] = BaseI+Pert
  130. current_array[int(1000*ms/dtime):int(1150*ms/dtime)] = BaseI-AmpStep
  131. current_array[int(1250*ms/dtime):int(1320*ms/dtime)] = BaseI+Pert
  132. current_array[int(1350*ms/dtime):int(1420*ms/dtime)] = BaseI-Pert
  133. I_t = TimedArray(current_array * pA, dt=dtime)
  134. # %%
  135. # Simulate the adjusted mean-field model with random initial conditions
  136. rnd = np.random.default_rng()
  137. y0 = [np.round(rnd.uniform(.001, .003), 3), np.round(rnd.uniform(-70., -65.), 3),
  138. np.round(rnd.uniform(1., 5.), 3), np.round(rnd.uniform(.001, .005), 3)]
  139. adj_sim = solve_ivp(adjusted_dmMF, (0, duration_mf), y0, args=(adj_params, lambda t: input_current(t)), max_step=dt)
  140. # %%
  141. # Define the spiking neural network in Brian2
  142. start_scope()
  143. # Set shared variable for synaptic conductance
  144. Gsyn = NeuronGroup(1, '''
  145. dGesyn/dt = -Gesyn/Tsyn : siemens
  146. ''', method='rk4')
  147. Gsyn.Gesyn = 0*siemens
  148. # eQIF model equations with synaptic input and external current
  149. adj_eqs = '''
  150. dV/dt = (g_L * (E_L - V) * (V_T - V) + w + I_ext + n - Gesyn*(V-Ee)) / C : volt
  151. dw/dt = (a * (V - E_L) - w) / tau_w : amp
  152. I_ext = I_t(t) : amp
  153. n : amp
  154. Gesyn : siemens (linked)
  155. '''
  156. # Set neuron group
  157. G = NeuronGroup(N, adj_eqs, threshold='V > V_peak', reset='V = V_reset; w += b', method='rk4')
  158. # Initialize variables for quenched heterogeneity
  159. e = adj_params.Eta
  160. d = adj_params.Delta
  161. x = np.linspace(0+1/N,1-1/N,N)
  162. rng = np.random.default_rng()
  163. adj_etas = e + d*np.tan(np.pi*(x-0.5))
  164. rng.shuffle(adj_etas)
  165. # Initialize variables with some randomness
  166. Vinit = np.round(rnd.uniform(-70., -60., size=N), 3)
  167. Winit = np.round(rnd.uniform(1., 5., size=N), 3)
  168. G.n = adj_etas * pA
  169. G.V = Vinit * mV
  170. G.w = Winit * pA
  171. G.Gesyn = linked_var(Gsyn, 'Gesyn')
  172. # Connect neurons
  173. S = Synapses(G, Gsyn, on_pre='Gesyn_post += Qe')
  174. S.connect()
  175. # Monitor variables
  176. adj_M_spike = SpikeMonitor(G)
  177. adj_M_FR = PopulationRateMonitor(G)
  178. # Optional: record membrane potential with a specific dt
  179. # instead of default one (for reduce memory usage)
  180. sample_rate = 0.1*ms
  181. adj_M_voltage = StateMonitor(G, 'V', record=True, dt=sample_rate)
  182. # Continue without recording
  183. run(duration)
  184. # %%
  185. # Safety check: plot raster to verify activity and membrane potential of a few neurons to verify dynamics
  186. raster_activity = np.array([adj_M_spike.t/ms, adj_M_spike.i])
  187. index_mask = (raster_activity[1] <= 1000)
  188. plt.figure(figsize=(15, 5))
  189. plt.plot(raster_activity[0][index_mask], raster_activity[1][index_mask], ',k')
  190. plt.show()
  191. plt.figure(figsize=(12, 6))
  192. for i in range(5):
  193. plt.plot(adj_M_voltage.t/ms, adj_M_voltage.V[i]/mV + i*20, label=f'Neuron {i}') # Offset for visibility
  194. plt.xlim(50, 1100)
  195. plt.show()
  196. # %%
  197. # Compute ISI Coefficient of Variation (CV) for each neuron within stimulation
  198. # peak period (50-1100 ms). Sliding windows used to capture time-varying behaviors
  199. time_interval = 75
  200. time_windows = np.arange(50, 1100 + time_interval, time_interval)
  201. N = int(np.max(raster_activity[1])) + 1
  202. cv_measure = [[] for _ in range(len(time_windows) - 1)]
  203. for i in range(len(time_windows) - 1):
  204. mask = (raster_activity[0] >= time_windows[i]) & (raster_activity[0] < time_windows[i+1])
  205. N = int(np.max(raster_activity[1])) + 1
  206. results = [[] for _ in range(N)]
  207. for time, idx in zip(raster_activity[0][mask], raster_activity[1][mask].astype(int)):
  208. results[idx].append(np.round(time,2))
  209. results = [times for times in results if len(times) > 0]
  210. cvs = [np.std(np.diff(times)) / np.mean(np.diff(times)) if len(times) > 2 else np.nan for times in results]
  211. cv_measure[i] = cvs
  212. # Extract mean, min, max, std for each time window and create arrays for plotting
  213. time_bin_len = int(time_interval / (dtime/ms))
  214. cv_means = np.concatenate([np.ones(time_bin_len) * mean
  215. for mean in [np.nanmean(cvs) for cvs in cv_measure]])
  216. cv_mins = np.concatenate([np.ones(time_bin_len) * mn
  217. for mn in [np.nanmin(cvs) for cvs in cv_measure]])
  218. cv_maxs = np.concatenate([np.ones(time_bin_len) * mx
  219. for mx in [np.nanmax(cvs) for cvs in cv_measure]])
  220. cv_stds = np.concatenate([np.ones(time_bin_len) * std
  221. for std in [np.nanstd(cvs) for cvs in cv_measure]])
  222. # %%
  223. # Compute time-resolved synchrony measure based on membrane potential and plot it.
  224. # NOTE: the more fsample to store the membrane values is small the more the figure is refined
  225. times, chi_t, var_V, mean_var_Vi = compute_chi_sliding_window(adj_M_voltage, [50, 1100], f_sample=sample_rate, window_size=10*ms, step_size=2*ms)
  226. plt.figure(figsize=(12, 4))
  227. ax = plt.gca()
  228. ax.plot(adj_M_FR.t[int((50/dtime)*ms):]/ms, current_array[int((50/dtime)*ms):])
  229. ax2 = ax.twinx()
  230. ax2.plot(times, chi_t)
  231. ax2.set_ylabel('χ(t)')
  232. ax2.set_xlim(50, 1500)
  233. plt.show()
  234. # %%
  235. # Final figure: top three panels full range, bottom two zoomed and aligned
  236. # Grid and style
  237. #grid_scheme = GridSpec(nrows=5, ncols=1, height_ratios=[.5, 1, 1, .5, .5], hspace=0.5)
  238. plt.rcParams.update({
  239. 'font.size': 20, # Controls default text size
  240. 'axes.titlesize': 20, # Title font size
  241. 'axes.labelsize': 20, # X/Y label font size
  242. 'xtick.labelsize': 18, # X tick labels
  243. 'ytick.labelsize': 18, # Y tick labels
  244. 'legend.fontsize': 14, # Legend font size
  245. })
  246. fig, axs = plt.subplots(5, 1 , height_ratios=[.5, 1, 1, .5, .5], figsize=(12, 12), sharex=True)
  247. ax0, ax1, ax2, ax3, ax4 = axs[0], axs[1], axs[2], axs[3], axs[4]
  248. # Plot time ranges (ms)
  249. full_start, full_end = 0, 1500
  250. zoom_start, zoom_end = 50, 1100
  251. # (a) Current array ---
  252. ax0.plot(adj_M_FR.t/ms, current_array, color='purple')
  253. ax0.set_xlim(full_start, full_end)
  254. ax0.set_ylabel('$I_{ext}$ (pA)')
  255. ax0.xaxis.set_visible(False)
  256. ax0.spines['top'].set_visible(False)
  257. ax0.spines['right'].set_visible(False)
  258. # (b) Population firing rate
  259. adj_M_FRsmt = adj_M_FR.smooth_rate(window='flat', width=1.01*ms)
  260. ax1.plot(adj_M_FR.t/ms, adj_M_FRsmt/Hz, 'k', label='SNN')
  261. ax1.plot(adj_sim.t, adj_sim.y[0]*1000, 'r', lw=2, label='MF')
  262. ax1.set_ylabel('$FR$ (Hz)')
  263. ax1.set_xlim(full_start, full_end)
  264. ax1.set_ylim(0,150)
  265. ax1.legend(loc='upper right')
  266. ax1.xaxis.set_visible(False)
  267. ax1.spines['top'].set_visible(False)
  268. ax1.spines['right'].set_visible(False)
  269. # (c) Raster plot
  270. # (green shaded area highlight the region were the measures were computed)
  271. index_mask = (raster_activity[1] <= 1000)
  272. ax2.plot(raster_activity[0][index_mask], raster_activity[1][index_mask], ',k')
  273. ax2.fill([zoom_start, zoom_start, zoom_end, zoom_end], [0, 1000, 1000, 0], color='lightgreen', alpha=0.5)
  274. ax2.set_xlim(full_start, full_end)
  275. ax2.set_ylabel('Neuron #')
  276. ax2.spines['top'].set_visible(False)
  277. ax2.spines['right'].set_visible(False)
  278. # (d) χ(t) synchrony measure (based on membrane potential)
  279. ax3.plot(times, chi_t, 'k')
  280. ax3.set_ylabel('χ(t)')
  281. ax3.xaxis.set_visible(False)
  282. ax3.spines['top'].set_visible(False)
  283. ax3.spines['right'].set_visible(False)
  284. # (e) Mean inter-spike intervals Coefficient of variation (CV) across the population
  285. cv_time = np.linspace(zoom_start, zoom_end, len(cv_means))
  286. yerr_lower = cv_means - cv_mins
  287. yerr_upper = cv_maxs - cv_means
  288. ax4.errorbar(cv_time, cv_means, yerr=[yerr_lower, yerr_upper], fmt='none', ecolor='orange', alpha=0.01)
  289. ax4.plot(cv_time, cv_means, 'k')
  290. ax4.set_ylabel('CV')
  291. ax4.set_xlabel('t (ms)')
  292. ax4.spines['top'].set_visible(False)
  293. ax4.spines['right'].set_visible(False)
  294. # Reposition bottom axes to match the highlighted horizontal region under the full-width axes
  295. # Align y-labels across subplots and ensure left margin is sufficient
  296. fig.align_ylabels(axs)
  297. fig.subplots_adjust(left=0.12)
  298. fig.canvas.draw()
  299. full_pos = ax1.get_position()
  300. # Place aligned subplot letters using figure coordinates (left of y-axis labels)
  301. # compute a common x in figure coords slightly left of the full axis left edge
  302. x_fig = full_pos.x0 - .12
  303. axes_list = [ax0, ax1, ax2, ax3, ax4]
  304. letters = ['a', 'b', 'c', 'd', 'e']
  305. for ax, letter in zip(axes_list, letters):
  306. pos = ax.get_position()
  307. y_fig = pos.y0 + pos.height * 0.98
  308. fig.text(x_fig, y_fig, letter, va='top', ha='left')
  309. plt.show()

network_analysis.ipynb at commit 5021ac2, no license · at the source

Overview

  1. Aix Marseille Université, INSERM, Institut de Neurosciences des Systèmes (INS),Marseille, France
  2. Université Paris-Saclay, CNRS, Laboratoire de Physique des Solides,Orsay, France
  3. Université Paris-Cité, CNRS, Integrative Neuroscience and Cognition Center,Paris, France
  4. Department of Physics, University of California,San Diego, CA USA
Journal: Nature communications, volume 17, issue 1, article 9867
Dates: received 10 November 2025; accepted 9 July 2026; published online 17 August 2026
Type: Research article · Language: English
License: CC BY
Identifiers: DOI 10.1038/s41467-026-75704-3 · PMID 42744781 · PMCID PMC13578268 · OpenAlex W7203623913
Open access: gold, a free copy (OpenAlex)
Status: code verified (how the code is found and verified)
Categories: computational modeling (no new data) (modality), human (organism)
Keywords: Computational neuroscience, Electronics, photonics and device physics
MeSH: Memory, Short-Term*, Models, Neurological*, Nerve Net*, Neural Networks, Computer*, Neurons*, Action Potentials, Animals, Computer Simulation, Humans (* major topic)
Topic: Advanced Memory and Neural Computing (Electrical and Electronic Engineering, Engineering), according to OpenAlex
Funding: Horizon 2020 (SGA 101147319); Agence Nationale de la Recherche (ANR-23-CE30-0040)
Citations: not cited yet (Europe PMC); 59 references in the paper

Abstract

Phenomenological spiking neuron models such as Izhikevich, adaptive quadratic integrate-and-fire (aQIF), and Adaptive Exponential (AdEx) are widely used because of their simplicity and numerical efficiency. These models reproduce diverse neuronal dynamics through a slow self-inhibitory adaptation variable. Here we introduce their symmetric counterpart by replacing adaptation with slow self-excitation, motivated by intrinsic calcium-mediated membrane currents. This minimal modification enables robust persistent spiking and working-memory dynamics without compromising computational efficiency. These properties remain in excitatory spiking neural networks. We then derive and validate a mean-field neural mass model that remains stable while retaining working-memory functionality. Additionally, we implement the single-neuron model in a minimal memristor-based neuromorphic circuit and experimentally confirm its dynamics. These results provide scalable tools for large-scale brain simulations and neuromorphic applications in robotics, brain-machine interfaces, and edge AI devices.

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

GabrieleCasagrande/MinimalNeuro_WorkingMemo

License: none: the authors keep all their rights
State: the link answers, verified on 27 September 2026
Evidence: files inventoried
Commit: 5021ac21b45b729cc9f27977e5b15aceb306a2d6, 8 June 2026
Languages: Python (6), Jupyter (4)
Size: 12 files, 10 scripts
Software Heritage: not archived
Found in: “Code availability”
Holds: README, 4 notebooks
Not found: license file, CITATION.cff, environment file, tests, continuous integration, documentation
Tools: Matplotlib (10 files), NumPy (10 files), Brian 2 (7 files), SciPy (4 files), Numba (1 file)
Availability: 1 check, the latest on 27 September 2026: the link answers
  • 27 September 2026: the link answers
11 files

Code availability

The code is available on the Ocean Code Project associated to this article and on GitHub at: https://github.com/GabrieleCasagrande/MinimalNeuro_WorkingMemo.

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

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;
  • 10 scripts, each with its path and the digest of its content;
  • 3 matches between paragraphs of the paper and lines of the code (method lexical-v1);
  • neither the text of the paper nor the code itself.

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

Data

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

Data availability

The data associated to this article are available as code and algorithms, with the link provided in the following “Code availability” section.

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

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

Cite

This paper

Depannemaecker, D., d’Hollande, A., Casagrande, G., Wu, J., & Rozenberg, M. J. (2026). A minimal model of working memory in neural systems and neuromorphic circuits. Nature communications, 17(1), 9867. https://doi.org/10.1038/s41467-026-75704-3

BibTeX

@article{depannemaecker2026minimal,
author = {Depannemaecker, Damien and d’Hollande, Adrien and Casagrande, Gabriele and Wu, Jiaming and Rozenberg, Marcelo J.},
title = {{A minimal model of working memory in neural systems and neuromorphic circuits}},
journal = {Nature communications},
year = {2026},
month = aug,
volume = {17},
number = {1},
pages = {9867},
publisher = {Nature Publishing Group},
issn = {2041-1723},
doi = {10.1038/s41467-026-75704-3},
url = {https://doi.org/10.1038/s41467-026-75704-3},
pmid = {42744781},
pmcid = {PMC13578268}
}

RIS

TY - JOUR
AU - Depannemaecker, Damien
AU - d’Hollande, Adrien
AU - Casagrande, Gabriele
AU - Wu, Jiaming
AU - Rozenberg, Marcelo J.
TI - A minimal model of working memory in neural systems and neuromorphic circuits
T2 - Nature communications
J2 - Nat Commun
PY - 2026
DA - 2026/08/17
VL - 17
IS - 1
SP - 9867
SN - 2041-1723
PB - Nature Publishing Group
DO - 10.1038/s41467-026-75704-3
UR - https://doi.org/10.1038/s41467-026-75704-3
LA - en
ER -

CSL-JSON

{
"id": "10.1038/s41467-026-75704-3",
"type": "article-journal",
"title": "A minimal model of working memory in neural systems and neuromorphic circuits",
"container-title": "Nature communications",
"author": [
{
"family": "Depannemaecker",
"given": "Damien"
},
{
"family": "d’Hollande",
"given": "Adrien"
},
{
"family": "Casagrande",
"given": "Gabriele"
},
{
"family": "Wu",
"given": "Jiaming"
},
{
"family": "Rozenberg",
"given": "Marcelo J."
}
],
"container-title-short": "Nat Commun",
"volume": "17",
"issue": "1",
"page": "9867",
"DOI": "10.1038/s41467-026-75704-3",
"PMID": "42744781",
"PMCID": "PMC13578268",
"ISSN": "2041-1723",
"publisher": "Nature Publishing Group",
"URL": "https://doi.org/10.1038/s41467-026-75704-3",
"language": "en",
"issued": {
"date-parts": [
[
2026,
8,
17
]
]
}
}

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.7554/elife.104249 [code]
Biophysically inspired mean-field model of neuronal populations driven by ion-exchange mechanisms.
Journal: eLife
In common: Brian 2, SciPy, Matplotlib, 1 other tool, 8 references
[2] doi:10.1523/eneuro.0234-21.2022 [code]
A Model for the Propagation of Seizure Activity in Normal Brain Tissue.
Journal: eNeuro
In common: Brian 2, Matplotlib, NumPy, 4 references, author Damien Depannemaecker
[3] doi:10.1038/s43588-025-00796-8 [code]
A computational approach to evaluate how molecular mechanisms impact large-scale brain activity.
Journal: Nature computational science
In common: Brian 2, Numba, SciPy, 2 other tools, computational modeling (no new data), 5 references
[4] doi:10.1371/journal.pcbi.1012262 [code]
A multi-scale study of thalamic state-dependent responsiveness.
Journal: PLoS computational biology
In common: Brian 2, SciPy, Matplotlib, 1 other tool, computational modeling (no new data), 5 references
[5] doi:10.1038/s42003-025-08297-0 [code]
Higher dopamine D1 receptor expression in prefrontal parvalbumin neurons underlies higher distractibility in marmosets versus macaques.
Journal: Communications biology
In common: Brian 2, SciPy, Matplotlib, 1 other tool, computational modeling (no new data), 5 references
[6] doi:10.7554/elife.85442 [code]
Cell type-specific connectome predicts distributed working memory activity in the mouse brain.
Journal: eLife
In common: Brian 2, SciPy, Matplotlib, 1 other tool, 5 references
[7] doi:10.7554/elife.106194 [code]
Virtual Brain Inference (VBI), a flexible and integrative toolkit for efficient probabilistic inference on whole-brain models.
Journal: eLife
In common: Numba, SciPy, Matplotlib, 1 other tool, computational modeling (no new data), 5 references
[8] doi:10.1007/s12021-023-09647-1 [code]
High-Density Exploration of Activity States in a Multi-Area Brain Model.
Journal: Neuroinformatics
In common: Numba, SciPy, Matplotlib, 1 other tool, 5 references
[9] doi:10.1007/s10827-021-00797-2 [code]
Active intrinsic conductances in recurrent networks allow for long-lasting transients and sustained activity with realistic firing rates as well as robust plasticity.
Journal: Journal of computational neuroscience
In common: 7 references
[10] doi:10.1007/s12021-022-09576-5 [code]
Cortical Representation of Touch in Silico.
Journal: Neuroinformatics
In common: SciPy, Matplotlib, NumPy, computational modeling (no new data), 6 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-75704-3.svg)](https://openscicode.org/badge/doi/10.1038/s41467-026-75704-3)
<!-- oscr-badge:end -->
reStructuredText
.. oscr-badge:start

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

.. oscr-badge:end
HTML
<!-- oscr-badge:start -->
<a href="https://openscicode.org/badge/doi/10.1038/s41467-026-75704-3"><img src="https://openscicode.org/badge/doi/10.1038/s41467-026-75704-3.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.