OSCR

Hippocampal theta sweeps indicate goal direction during navigation.

Code ↔ Paper

2 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 2 matches
  1. [1] § Methods › Mechanistic modeling with CANs › Directional ring attractor ↔ models.py, lines 232–260 · score 0.53 · theta modulation, directional cell, head direction, sensory, squared, animal
  2. [2] § Methods › Mechanistic modeling with CANs › Place cell attractor network ↔ models.py, lines 232–260 · score 0.52 · theta modulated, directional cell, conjunctive, sensory, pi, activities

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 · 474 lines · 15 KB · Apache-2.0 · 2 matches

  1. import jax
  2. import brainpy as bp
  3. import brainpy.math as bm
  5. import numpy as np
  6. from tqdm import trange
  9. class HD_cell_L1(bp.DynamicalSystem):
  10. def __init__(
  11. self,
  12. num: int,
  13. noise_strength: float = 0.01,
  14. tau: float = 1.0,
  15. tau_v: float = 10.0,
  16. k: float = 1.0,
  17. mbar: float = 15.0,
  18. a: float = 0.4,
  19. A: float = 3.0,
  20. J0: float = 4.0,
  21. z_min: float = -bm.pi,
  22. z_max: float = bm.pi,
  23. goal_a: float = 0.5,
  24. goal_A: float = 1.0,
  25. topdown: bool = False,
  26. ):
  27. super(HD_cell_L1, self).__init__()
  29. self.tau = tau
  30. self.tau_v = tau_v
  31. self.k = k / num * 20 # Degree of the rescaled inhibition
  32. self.a = a # Half-width of the range of excitatory connections
  33. self.A = A # Magnitude of the external input
  34. self.J0 = J0 / num * 20 # maximum connection value
  35. self.m = mbar * tau / tau_v
  36. self.noise_strength = noise_strength
  38. self.num = num
  39. self.z_min = z_min
  40. self.z_max = z_max
  41. self.z_range = z_max - z_min
  42. x1 = bm.linspace(z_min, z_max, num + 1)
  43. self.x = x1[0:-1]
  45. self.topdown = topdown
  46. self.goal_a = goal_a
  47. self.goal_A = goal_A
  49. conn_mat = self.make_conn()
  50. self.conn_fft = bm.fft.fft(conn_mat)
  52. self.r = bm.Variable(bm.zeros(num))
  53. self.u = bm.Variable(bm.zeros(num))
  54. self.v = bm.Variable(bm.zeros(num))
  55. self.input = bm.Variable(bm.zeros(num))
  56. self.center = bm.Variable(bm.zeros(1))
  57. self.centerI = bm.Variable(bm.zeros(1))
  58. self.total_input = bm.Variable(bm.zeros(num))
  60. self.integral = bp.odeint(method="exp_euler", f=self.derivative)
  62. def topdown_input(self, td_mod: float):
  63. assert bm.size(self.goal_dir) == 1
  65. d = self.dist(bm.asarray(self.goal_dir) - self.x)
  66. input_ = self.goal_A * bm.exp(-0.25 * bm.square(d / self.goal_a))
  68. input_ = input_ * td_mod
  70. return input_
  72. def dist(self, d):
  73. d = self.circle_period(d)
  74. d = bm.where(d > 0.5 * self.z_range, d - self.z_range, d)
  75. return d
  77. def make_conn(self):
  78. d = self.dist(bm.abs(self.x[0] - self.x))
  79. Jxx = self.J0 * bm.exp(-0.5 * bm.square(d / self.a)) / (2 * bm.pi * self.a ** 2)
  80. return Jxx
  82. def get_center(self, r, x):
  83. exppos = bm.exp(1j * x)
  84. center = bm.angle(bm.sum(exppos * r))
  85. return center.reshape(-1,)
  87. @property
  88. def derivative(self):
  89. du = lambda u, t, input: (-u + input - self.v) / self.tau
  90. dv = lambda v, t: (-v + self.m * self.u) / self.tau_v
  91. return bp.JointEq([du, dv])
  93. def circle_period(self, A):
  94. B = bm.where(A > bm.pi, A - 2 * bm.pi, A)
  95. B = bm.where(B < -bm.pi, B + 2 * bm.pi, B)
  96. return B
  98. def input_HD(self, HD):
  99. return self.A * bm.exp(-0.25 * bm.square(self.dist(self.x - HD) / self.a))
  101. def reset_state(self, HD_truth):
  102. self.r.value = bm.Variable(bm.zeros(self.num))
  103. self.u.value = bm.Variable(bm.zeros(self.num))
  104. self.v.value = bm.Variable(bm.zeros(self.num))
  105. self.center.value = bm.Variable(bm.zeros(1,) + HD_truth)
  107. def update(self, HD, ThetaInput, Topdown_mod, Dir2Goal):
  109. self.goal_dir = Dir2Goal
  110. self.center = self.get_center(r=self.r, x=self.x)
  111. Iext = self.input_HD(HD)
  113. if self.topdown: #top down control
  114. self.td_input = self.topdown_input(Topdown_mod)
  115. # self.total_input = Iext + ThetaInput * self.td_input
  116. self.total_input = ThetaInput * Iext + self.td_input
  117. else:
  118. self.total_input = ThetaInput * Iext
  120. # Calculate input
  121. r_fft = bm.fft.fft(self.r)
  122. Irec = bm.real(bm.fft.ifft(r_fft * self.conn_fft))
  123. input_total = self.total_input + Irec + bm.random.randn(self.num) * self.noise_strength
  125. # Update neural state
  126. u, v = self.integral(self.u, self.v, bp.share.load("t"), input_total, bm.dt)
  128. self.u.value = bm.where(u > 0, u, 0)
  129. self.v.value = v
  130. r1 = bm.square(self.u)
  131. r2 = 1.0 + self.k * bm.sum(r1)
  132. self.r.value = r1 / r2
  135. class PC_cell_L2(bp.DynamicalSystem):
  136. def __init__(
  137. self,
  138. num=100,
  139. noise_strength=0.,
  140. tau=10.0,
  141. tau_v=100.0,
  142. mbar=75.0,
  143. a=0.5,
  144. A=1.0,
  145. td_A=1.0,
  146. J0=5.0,
  147. k=1,
  148. g = 1000,
  149. x_min=-bm.pi,
  150. x_max=bm.pi,
  151. num_hd = 100,
  152. phase_offset = 1/9,
  153. ):
  154. super(PC_cell_L2, self).__init__()
  156. # dynamics parameters
  157. self.tau = tau # The synaptic time constant
  158. self.tau_v = tau_v # The time constant of the adaptation variable
  159. self.num_x = num # number of excitatory neurons for x dimension
  160. self.num_y = num # number of excitatory neurons for y dimension
  161. self.num = self.num_x * self.num_y
  162. self.num_hd = num_hd
  163. self.k = k # Degree of the rescaled inhibition
  164. self.a = a # Half-width of the range of excitatory connections
  165. self.A = A # Magnitude of the external input
  166. self.td_A = td_A # Magnitude of the topdown input
  167. self.g = g
  168. self.J0 = J0/g # maximum connection value
  169. self.m = mbar * tau / tau_v
  170. self.noise_strength = noise_strength
  171. self.phase_offset = phase_offset
  173. # feature space
  174. self.x_range = x_max - x_min
  175. phi_x = bm.linspace(x_min, x_max, self.num_x + 1) # The encoded feature values
  176. self.x = phi_x[0:-1]
  177. self.y_range = self.x_range
  178. phi_y = bm.linspace(x_min, x_max, self.num_y + 1) # The encoded feature values
  179. self.y = phi_y[0:-1]
  180. x_grid, y_grid = bm.meshgrid(self.x, self.y)
  181. self.x_grid = x_grid.flatten()
  182. self.y_grid = y_grid.flatten()
  183. self.value_grid = bm.stack([self.x_grid, self.y_grid]).T
  185. # initialize conn matrix
  186. self.conn_mat = self.make_conn()
  188. # initialize dynamical variables
  189. self.r = bm.Variable(bm.zeros(self.num))
  190. self.u = bm.Variable(bm.zeros(self.num))
  191. self.v = bm.Variable(bm.zeros(self.num))
  192. self.input = bm.Variable(bm.zeros(self.num))
  193. self.center_I = bm.Variable(bm.zeros(2))
  194. self.center_bump = bm.Variable(bm.zeros(2))
  196. # 定义积分器
  197. self.integral = bp.odeint(method="exp_euler", f=self.derivative)
  199. def circle_period(self, d):
  200. d = bm.where(d > bm.pi, d - 2 * bm.pi, d)
  201. d = bm.where(d < -bm.pi, d + 2 * bm.pi, d)
  202. return d
  204. def dist(self, d):
  205. dis = self.circle_period(d)
  206. delta_x = dis[:, 0]
  207. delta_y = dis[:, 1]
  208. dis = bm.sqrt(delta_x ** 2 + delta_y ** 2)
  209. return dis
  211. def make_conn(self):
  212. @jax.vmap
  213. def get_J(v):
  214. d = self.dist(v - self.value_grid)
  215. Jxx = (
  216. self.J0
  217. * bm.exp(-0.5 * bm.square(d / self.a))
  218. / (bm.sqrt(2 * bm.pi) * self.a)
  219. )
  220. return Jxx
  222. return get_J(self.value_grid)
  224. def Postophase(self, pos):
  225. phase = pos + bm.pi # 坐标变换
  226. phase_x = bm.mod(phase[0], 2 * bm.pi) - bm.pi
  227. phase_y = bm.mod(phase[1], 2 * bm.pi) - bm.pi
  228. Phase = bm.array([phase_x, phase_y])
  229. return Phase
  232. def input_by_conjG(self, Animal_location, HD_activity, ThetaModulator, HD_truth):
  233. assert bm.size(Animal_location) == 2
  234. num_hd = self.num_hd
  235. hd = bm.linspace(-bm.pi,bm.pi,num_hd)
  236. # each head-direction cell corresponds to a group of Conjunctive grid cells, which in turn projects to pure grid cells with assymetric connections determined by offset(hd)
  237. lagvec = -bm.array([bm.cos(HD_truth), bm.sin(HD_truth)]) * self.phase_offset * 0.3 #1.4
  238. offset = bm.array([bm.cos(hd), bm.sin(hd)]) * self.phase_offset + 1.*lagvec.reshape(-1,1)
  239. self.center_conjG = self.Postophase(
  240. Animal_location.reshape([-1,1]) + offset.reshape(-1,num_hd)
  241. ) # Ideal phase using mapping function
  242. input = bm.zeros([num_hd, self.num])
  243. for i in range(num_hd):
  244. d = self.dist(bm.asarray(self.center_conjG[:,i]) - self.value_grid)
  245. input[i] = self.td_A * bm.exp(-0.25 * bm.square(d / self.a))
  247. max_hd = bm.max(HD_activity)
  248. hd_weight = bm.where(HD_activity>0.99*max_hd, HD_activity, 0)
  249. hd_weight = hd_weight/bm.sum(hd_weight)
  251. topdown_input = bm.matmul(input.transpose(), hd_weight).reshape(-1,) * ThetaModulator
  253. #add animal location as a sensory inout which do not receive theta modulation
  254. loc_ = self.Postophase(Animal_location)
  255. d = self.dist(bm.asarray(loc_) - self.value_grid)
  256. loc_input = self.A * bm.exp(-0.25 * bm.square(d / self.a))
  258. total_input = topdown_input + loc_input
  260. return total_input
  263. def get_center(self):
  264. exppos_x = bm.exp(1j * self.x_grid)
  265. exppos_y = bm.exp(1j * self.y_grid)
  266. r = bm.where(self.r > bm.max(self.r) * 0.1, self.r, 0)
  268. #get the center of the activity bump
  269. self.center_bump[0] = bm.angle(bm.sum(exppos_x * r))
  270. self.center_bump[1] = bm.angle(bm.sum(exppos_y * r))
  272. #get the center of the middle layer input (offset input)
  273. self.center_I[0] = bm.angle(bm.sum(exppos_x * self.input))
  274. self.center_I[1] = bm.angle(bm.sum(exppos_y * self.input))
  277. @property
  278. def derivative(self):
  279. du = (
  280. lambda u, t, Irec: (
  281. -u
  282. + Irec
  283. + self.input
  284. - self.v
  285. )
  286. / self.tau
  287. )
  288. dv = lambda v, t: (-v + self.m * self.u) / self.tau_v
  289. return bp.JointEq([du, dv])
  291. def reset_state(self):
  292. self.r.value = bm.Variable(bm.zeros(self.num))
  293. self.u.value = bm.Variable(bm.zeros(self.num))
  294. self.v.value = bm.Variable(bm.zeros(self.num))
  295. self.input.value = bm.Variable(bm.zeros(self.num))
  297. def update(self, Animal_location, HD_activity, ThetaModulator, HD_truth):
  298. #update the center and store them
  299. self.get_center()
  301. #
  302. input_conjG = self.input_by_conjG(Animal_location, HD_activity, ThetaModulator, HD_truth)
  304. self.input = input_conjG
  306. Irec = bm.matmul(self.conn_mat, self.r) + self.noise_strength * bm.random.randn(
  307. (self.num)
  308. )
  309. # Update neural state
  310. u, v = self.integral(self.u, self.v, bp.share["t"], Irec, bm.dt)
  311. self.u.value = bm.where(u > 0, u, 0)
  312. self.v.value = v
  313. r1 = bm.square(self.u)
  314. r2 = 1.0 + self.k * bm.sum(r1)
  315. self.r.value = self.g*r1 / r2
  318. def simulate_model(
  319. # behavioural data
  320. loc_seq: np.ndarray,
  321. hd_seq: np.ndarray,
  322. md_seq: np.ndarray,
  323. gd_seq: np.ndarray,
  324. speed_seq: np.ndarray,
  325. # hd network parameters
  326. num_hd: int = 100,
  327. tau_hd: float = 10.0,
  328. tau_v_hd: float = 100.0,
  329. k_hd: float = 1.0,
  330. mbar_hd: float = 10.0, # hd adaptation strength
  331. a_hd: float = 0.4,
  332. A_hd: float = 3.0,
  333. J0_hd: float = 4.0,
  334. goal_a: float = 0.4,
  335. goal_A: float = 3.0,
  336. td: bool = True,
  337. # pc network parameters
  338. num_pc: int = 50,
  339. tau_pc: float = 10.0,
  340. tau_v_pc: float = 100.0,
  341. k_pc: float = 1.0,
  342. mbar_pc: float = 1.0, # pc adaptation strength
  343. a_pc: float = 0.5,
  344. A_pc: float = 5.0,
  345. td_A: float = 5.0,
  346. J0_pc: float = 10.0,
  347. g_pc: float = 1000.0,
  348. noise_strength: float = 0.0,
  349. phase_offset: float = 1.5,
  350. theta_mod_hd: float = 0.4,
  351. theta_mod_pc: float = 0.8,
  352. td_mod: float = 4.0,
  353. device: str = "cpu",
  354. dt: float = 1.0, # ms
  355. simulation_time: int = 50000,
  356. ):
  357. bm.set_platform(device)
  358. bm.set_dt(dt)
  359. bm.clear_buffer_memory(platform=device)
  361. v0 = 1.0 * bm.pi / 1000 # baseline streength
  363. # construct model
  364. hd_network = HD_cell_L1(
  365. num=num_hd,
  366. noise_strength=noise_strength,
  367. tau=tau_hd,
  368. tau_v=tau_v_hd,
  369. k=k_hd,
  370. mbar=mbar_hd,
  371. a=a_hd,
  372. A=A_hd,
  373. J0=J0_hd,
  374. z_min=-bm.pi,
  375. z_max=bm.pi,
  376. goal_a=goal_a,
  377. goal_A=goal_A,
  378. topdown=td,
  379. )
  381. pc_network = PC_cell_L2(
  382. num=num_pc,
  383. noise_strength=noise_strength,
  384. tau=tau_pc,
  385. tau_v=tau_v_pc,
  386. k=k_pc,
  387. mbar=mbar_pc,
  388. a=a_pc,
  389. A=A_pc,
  390. td_A=td_A,
  391. J0=J0_pc,
  392. g=g_pc,
  393. x_min=-bm.pi,
  394. x_max=bm.pi,
  395. num_hd=num_hd,
  396. phase_offset=phase_offset,
  397. )
  400. def run_coupled_net(i, loc, hd, speed, gd):
  401. speed_mod = (2 + speed / v0) / 5
  402. theta_mod_strength_hd = theta_mod_hd * speed / v0
  403. theta_mod_strength_pc = theta_mod_pc * speed / v0
  405. t_theta = 100 # ms (10 Hz theta oscillation)
  406. t = i * bm.dt
  407. theta_phase = bm.mod(t, t_theta) / t_theta
  409. theta_mod_hd_i = 1 + theta_mod_strength_hd * bm.cos(theta_phase * 2 * bm.pi)
  410. theta_mod_pc_i = (1 + theta_mod_strength_pc * bm.cos(theta_phase * 2 * bm.pi)) * speed_mod
  412. hd_network.step_run(i, hd, theta_mod_hd_i, td_mod, gd)
  413. hd_bump_center = hd_network.center
  414. hd_activity = hd_network.r
  416. pc_network.step_run(i, loc, hd_activity, theta_mod_pc_i, hd)
  417. pc_bump_center = pc_network.center_bump
  418. pc_activity = pc_network.r
  420. return (
  421. pc_bump_center,
  422. hd_bump_center,
  423. pc_activity,
  424. hd_activity,
  425. theta_phase,
  426. theta_mod_hd,
  427. )
  429. timesteps = np.arange(len(loc_seq))
  431. print("Running simulations...")
  433. @bm.jit
  434. def run(ts, loc, hd, speed, gd):
  435. return bm.for_loop(run_coupled_net, (ts, loc, hd, speed, gd))
  437. pc_activity = np.empty((len(loc_seq), num_pc, num_pc))
  438. hd_activity = np.empty((len(loc_seq), num_hd))
  439. pc_bump_center = np.empty((len(loc_seq), 2))
  440. hd_bump_center = np.empty((len(loc_seq), 1))
  441. theta_phase = np.empty((len(loc_seq), ))
  442. theta_rhythm = np.empty((len(loc_seq), ))
  444. for i in trange(0, len(loc_seq), simulation_time):
  445. (
  446. pc_bump_center_i,
  447. hd_bump_center_i,
  448. pc_activity_i,
  449. hd_activity_i,
  450. theta_phase_i,
  451. theta_mod_hd_i,
  452. ) = run(
  453. timesteps[i:i+simulation_time],
  454. loc_seq[i:i+simulation_time],
  455. md_seq[i:i+simulation_time],
  456. speed_seq[i:i+simulation_time],
  457. gd_seq[i:i+simulation_time],
  458. )
  460. pc_bump_center[i:i+simulation_time] = pc_bump_center_i
  461. hd_bump_center[i:i+simulation_time] = hd_bump_center_i
  462. pc_activity[i:i+simulation_time] = pc_activity_i.reshape((-1, num_pc, num_pc))
  463. hd_activity[i:i+simulation_time] = hd_activity_i
  464. theta_phase[i:i+simulation_time] = theta_phase_i
  465. theta_rhythm[i:i+simulation_time] = theta_mod_hd_i
  467. return (
  468. pc_activity,
  469. hd_activity,
  470. pc_bump_center,
  471. hd_bump_center,
  472. theta_phase,
  473. theta_rhythm,
  474. )

models.py at commit 2d1f968, under Apache-2.0 · at the source

Overview

Authors: Changmin Yu1,2, Zilong Ji2,3, Jake Ormond4,5, John O’Keefe4,6, Neil Burgess2,3,4,6
ORCID iDs: Changmin Yu, Zilong Ji, John O’Keefe, Neil Burgess
  1. Computational and Biological Learning Lab, Department of Engineering, University of Cambridge,Cambridge, UK
  2. Institute of Cognitive Neuroscience, University College London,London, UK
  3. Queen Square Institute of Neurology, University College London,London, UK
  4. Sainsbury Wellcome Centre for Neural Circuits and Behaviour, University College London,London, UK
  5. Department of Bioengineering, Imperial College London,London, UK
  6. Department of Cell and Developmental Biology, University College London,London, UK
Institutions: University of Cambridge (United Kingdom); University College London (United Kingdom); Imperial College London (United Kingdom)
Journal: Nature neuroscience, volume 29, issue 9, pages 2225-2236
Dates: received 30 September 2025; accepted 11 June 2026; published online 1 July 2026; in print 2026
Type: Research article · Language: English
License: CC BY
Identifiers: DOI 10.1038/s41593-026-02365-2 · PMID 42386950 · PMCID PMC13533849 · OpenAlex W7166826753
Open access: hybrid, a free copy (OpenAlex)
Status: code verified
Categories: computational modeling (no new data) (modality), rat (organism)
Methods: Connectivity, Statistics, Machine learning, Spectral & time-frequency, Graphs, Single-unit activity, calcium imaging, Physiology & signal measures
Keywords: Hippocampus, Spatial memory, Network models
MeSH: Goals*, Hippocampus*, Spatial Navigation*, Theta Rhythm*, Animals, Male, Maze Learning, Rats, Rats, Long-Evans (* major topic)
Topic: Memory and Neural Mechanisms (Cognitive Neuroscience, Neuroscience), according to OpenAlex
Funding: Wellcome Trust (Wellcome) (Wt203020/z/16/z, 222457/Z/21/Z); Gatsby Charitable Foundation (090843/F/09/Z)
Citations: cited by 4 papers (Europe PMC); 68 references in the paper

Abstract

Successful spatial navigation requires rapid evaluation of potential future trajectories. Hippocampal ‘theta sweeps’, the sequential activation of place cells within individual theta cycles, exhibit predictive dynamics within the ideal timeframe for this role. However, whether these sequences reflect movement-related variables, perceptual targets or more cognitive goal-directed planning remains unresolved. Using data from the ‘Honeycomb’ maze, which dissociates head, movement and goal directions, we found that theta sweeps form vectors toward remembered goal locations independent of the rat’s movement or heading directions. Stronger goal modulation preceded correct navigational choices, establishing the relevance of theta sweeps for spatial planning. A hierarchical continuous attractor network with goal-oriented directional inputs reproduced these findings and made several nontrivial predictions, which we confirmed empirically. Sequential activity during immobility-related sharp-wave ripples was also goal directed and, therefore, more aligned with theta sweeps than with previously experienced trajectories. Our findings identify hippocampal theta sweeps as neural substrates for online goal-directed planning.

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

changmin-yu/goal_directed_theta_sweeps_honeycomb_maze

License: Apache-2.0
State: the link answers, verified on 27 September 2026
Evidence: files inventoried
Commit: 2d1f96846c51823520210d861fd917071b9b0a6e, 16 October 2025
Languages: Python (4), Jupyter (1)
Size: 9 files, 5 scripts
Software Heritage: not archived
Found in: “Code availability”
Holds: README, license file, environment (requirements.txt), 1 notebook
Not found: CITATION.cff, tests, continuous integration, documentation
Tools: NumPy (5 files), SciPy (3 files), Matplotlib (2 files), JAX (1 file)
Availability: 1 check, the latest on 27 September 2026: the link answers
  • 27 September 2026: the link answers
7 files
At the source: github.com/changmin-yu/goal_directed_theta_sweeps_honeycomb_maze

Code availability

The custom Python code used for all analyses and model simulations can be accessed through the GitHub repository: https://github.com/changmin-yu/goal_directed_theta_sweeps_honeycomb_maze.

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;
  • 5 scripts, each with its path and the digest of its content;
  • 2 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 analyses in this study used previously published datasets from Ormond and O’Keefe19 (Honeycomb maze) and Pfeiffer and Foster20 (Chessboard task). Source data underlying the figures in this paper are provided with the paper. The Honeycomb maze dataset is available from the corresponding authors of the present study upon reasonable request. The Pfeiffer and Foster dataset was generated by the original authors and is not redistributed by the present authors; requests for access should be directed to the corresponding author(s) of Pfeiffer and Foster20. Source data are provided with this paper.

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

  • Publisher: n/a → Nature Portfolio

Version 1, 27 September 2026: the first record

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

Cite

This paper

Yu, C., Ji, Z., Ormond, J., O’Keefe, J., & Burgess, N. (2026). Hippocampal theta sweeps indicate goal direction during navigation. Nature neuroscience, 29(9), 2225-2236. https://doi.org/10.1038/s41593-026-02365-2

BibTeX

@article{yu2026hippocampal,
author = {Yu, Changmin and Ji, Zilong and Ormond, Jake and O’Keefe, John and Burgess, Neil},
title = {{Hippocampal theta sweeps indicate goal direction during navigation}},
journal = {Nature neuroscience},
year = {2026},
month = jul,
volume = {29},
number = {9},
pages = {2225--2236},
publisher = {Nature Portfolio},
issn = {1097-6256},
doi = {10.1038/s41593-026-02365-2},
url = {https://doi.org/10.1038/s41593-026-02365-2},
pmid = {42386950},
pmcid = {PMC13533849}
}

RIS

TY - JOUR
AU - Yu, Changmin
AU - Ji, Zilong
AU - Ormond, Jake
AU - O’Keefe, John
AU - Burgess, Neil
TI - Hippocampal theta sweeps indicate goal direction during navigation
T2 - Nature neuroscience
J2 - Nat Neurosci
PY - 2026
DA - 2026/07/01
VL - 29
IS - 9
SP - 2225
EP - 2236
SN - 1097-6256
PB - Nature Portfolio
DO - 10.1038/s41593-026-02365-2
UR - https://doi.org/10.1038/s41593-026-02365-2
LA - en
ER -

CSL-JSON

{
"id": "10.1038/s41593-026-02365-2",
"type": "article-journal",
"title": "Hippocampal theta sweeps indicate goal direction during navigation",
"container-title": "Nature neuroscience",
"author": [
{
"family": "Yu",
"given": "Changmin"
},
{
"family": "Ji",
"given": "Zilong"
},
{
"family": "Ormond",
"given": "Jake"
},
{
"family": "O’Keefe",
"given": "John"
},
{
"family": "Burgess",
"given": "Neil"
}
],
"container-title-short": "Nat Neurosci",
"volume": "29",
"issue": "9",
"page": "2225-2236",
"DOI": "10.1038/s41593-026-02365-2",
"PMID": "42386950",
"PMCID": "PMC13533849",
"ISSN": "1097-6256",
"publisher": "Nature Portfolio",
"URL": "https://doi.org/10.1038/s41593-026-02365-2",
"language": "en",
"issued": {
"date-parts": [
[
2026,
7,
1
]
]
}
}

The tracing map gets a citation of its own once an author has validated it and it has a DOI.

Similar papers

The papers with a page that share the most with this one: the tools found in their code, their categories, datasets, cited references and authors, the rarest counting most.

[1] doi:10.1126/sciadv.aeg6797 [code]
Dorsoventral gradient of theta sweeps in the medial entorhinal cortex.
Journal: Science advances
In common: JAX, SciPy, Matplotlib, 1 other tool, 9 references, 2 authors
[2] doi:10.1002/hipo.70131 [code]
Decoding Medial Entorhinal Cortical Dynamics Produces Planning-Like Alternations in Hippocampal theta Sequences.
Journal: Hippocampus
In common: JAX, SciPy, Matplotlib, 1 other tool, 15 references
[3] doi:10.64898/2026.03.08.710351
Dorsoventral gradient of theta sweeps in medial entorhinal cortex
Journal: bioRxiv (preprint)
In common: 6 references, author Zilong Ji
[4] doi: [code]
Naturalistic behavior and self-generated neural activity predictive of self-correction
Journal: bioRxiv : the preprint server for biology
In common: JAX, SciPy, Matplotlib, 1 other tool, 6 references
[5] doi:10.7554/elife.100642 [code]
Disrupted hippocampal theta-gamma coupling and spike-field coherence following experimental traumatic brain injury.
Journal: eLife
In common: rat, 8 references
[6] doi:10.1038/s41467-026-77318-1 [code]
Offline generative network reconfiguration guides insight-like accelerated learning by assimilation into schema in rats.
Journal: Nature communications
In common: SciPy, Matplotlib, rat, 5 references
[7] doi:10.7554/elife.106506 [code]
Modeling flexible behavior with remapping-based hippocampal sequence learning.
Journal: eLife
In common: SciPy, Matplotlib, NumPy, 5 references
[8] doi:10.1038/s42256-026-01254-4 [code]
Neural sampling from cognitive maps enables goal-directed imagination and planning.
Journal: Nature machine intelligence
In common: Matplotlib, NumPy, computational modeling (no new data), 5 references
[9] doi:10.1038/s41467-026-74357-6 [code]
Hippocampo-neocortical interaction as compressive retrieval-augmented generation.
Journal: Nature communications
In common: SciPy, Matplotlib, NumPy, computational modeling (no new data), 1 reference, author Neil Burgess
[10] doi:10.1038/s41467-026-75492-w [code]
Place and behavioral modulation of hippocampal neurons during immobility.
Journal: Nature communications
In common: 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.

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.