Glucose metabolism echoes long-range temporal correlations in the human brain.

Code ↔ Paper

6 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 6 matches

[1] § Methods › Hurst exponent mapping ↔ m/bfn_mfin_ml.m, lines 1–84 · score 0.93 · univariate maximum likelihood, discrete wavelet transform, wavelet filter, fractionally integrated, bounds, lb
[2] § Methods › Hurst exponent mapping ↔ m/bfn_mfin_lms.m, lines 1–68 · score 0.82 · discrete wavelet transform, wavelet filter, fractionally integrated, univariate, Haar, noise
[3] § Methods › Anatomical, rs-fMRI and PET processing › rs-fMRI ↔ brainsmash/utils/dataio.py, lines 87–146 · score 0.64 · Subcortical volumes, surface vertices, CIFTI, MNI, voxels
[4] § Methods › Anatomical, rs-fMRI and PET processing › rs-fMRI ↔ brainsmash/workbench/geo.py, lines 180–290 · score 0.57 · subcortical voxels, atlas, resolution, CIFTI, MNI, volumes
[5] § Methods › Statistical analyses › Across-subject regression ↔ brainsmash/mapgen/sampled.py, lines 311–337 · score 0.54 · independent variable, linear, fitted, regression
[6] § Methods › Statistical analyses › Spatial analyses ↔ brainsmash/mapgen/sampled.py, lines 16–71 · score 0.52 · empirical map, BrainSMASH, permuting, surrogate, variogram, exponent

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 paper is loaded by your browser, with JavaScript: read it at doi.org or on Europe PMC.

The authors' code

Python · 502 lines · 15 KB · GPL-3.0 · 2 matches

"""
Generate spatial autocorrelation-preserving surrogate maps from memory-mapped
arrays with random subsampling.
"""
from ..utils.dataio import dataio
from ..utils.checks import check_map, check_pv, check_deltas
from .kernels import check_kernel
from sklearn.linear_model import LinearRegression
from sklearn.utils.validation import check_random_state
import numpy as np
from joblib import Parallel, delayed
__all__ = ['Sampled']
class Sampled:
"""
Sampling implementation of map generator.
Parameters
----------
x : filename or 1D np.ndarray
Target brain map
D : filename or (N,N) np.ndarray or np.memmap
Pairwise distance matrix between elements of `x`. Each row of `D` should
be sorted. Indices used to sort each row are passed to the `index`
argument. See :func:`brainsmash.mapgen.memmap.txt2memmap` or the online
documentation for more details (brainsmash.readthedocs.io)
index : filename or (N,N) np.ndarray or np.memmap
See above
ns : int, default 500
Take a subsample of `ns` rows from `D` when fitting variograms
deltas : np.ndarray or List[float], default [0.3, 0.5, 0.7, 0.9]
Proportions of neighbors to include for smoothing, in (0, 1]
kernel : str, default 'exp'
Kernel with which to smooth permuted maps
- 'gaussian' : gaussian function
- 'exp' : exponential decay function
- 'invdist' : inverse distance
- 'uniform' : uniform weights (distance independent)
pv : int, default 70
Percentile of the pairwise distance distribution (in `D`) at
which to truncate during variogram fitting
nh : int, default 25
Number of uniformly spaced distances at which to compute variogram
knn : int, default 1000
Number of nearest regions to keep in the neighborhood of each region
b : float or None, default None
Gaussian kernel bandwidth for variogram smoothing. if None,
three times the distance interval spacing is used.
resample : bool, default False
Resample surrogate map values from the target brain map
verbose : bool, default False
Print surrogate count each time new surrogate map created
seed : None or int or np.random.RandomState instance (default None)
Specify the seed for random number generation (or random state instance)
n_jobs : int (default 1)
Number of jobs to use for parallelizing creation of surrogate maps
Notes
-----
Passing resample=True will preserve the distribution of values in the
target map, at the expense of worsening simulated surrogate maps'
variograms fits. This worsening will increase as the empirical map
more strongly deviates from normality.
Raises
------
ValueError : `x` and `D` have inconsistent sizes
"""
def __init__(self, x, D, index, ns=500, pv=70, nh=25, knn=1000, b=None,
deltas=np.arange(0.3, 1., 0.2), kernel='exp', resample=False,
verbose=False, seed=None, n_jobs=1):
self._rs = check_random_state(seed)
self._n_jobs = n_jobs
self._verbose = verbose
self.x = x
n = self._x.size
self.nmap = int(n)
self.knn = knn
self.D = D
self.index = index
self.resample = resample
self.nh = int(nh)
self.deltas = deltas
self.ns = int(ns)
self.b = b
self.pv = pv
self._ikn = np.arange(self._nmap)[:, None]
# Store k nearest neighbors from distance and index matrices
self.kernel = kernel # Smoothing kernel selection
self._dmax = np.percentile(self._D, self._pv)
self.h = np.linspace(self._D.min(), self._dmax, self._nh)
if not self._b:
self.b = 3 * (self.h[1] - self.h[0])
# Linear regression model
self._lm = LinearRegression(fit_intercept=True)
def __call__(self, n=1):
"""
Randomly generate new surrogate map(s).
Parameters
----------
n : int, default 1
Number of surrogate maps to randomly generate
Returns
-------
(n,N) np.ndarray
Randomly generated map(s) with matched spatial autocorrelation
Notes
-----
Chooses a level of smoothing that produces a smoothed variogram which
best approximates the true smoothed variogram. Selecting resample='True'
preserves the map value distribution at the expense of worsening the
surrogate maps' variogram fits.
"""
rs = self._rs.randint(np.iinfo(np.int32).max, size=n)
surrs = np.row_stack(
Parallel(self._n_jobs)(
delayed(self._call_method)(rs=i) for i in rs
)
)
return np.asarray(surrs.squeeze())
def _call_method(self, rs=None):
""" Subfunction used by .__call__() for parallelization purposes """
# Reset RandomState so parallel jobs yield different results
self._rs = check_random_state(rs)
# Randomly permute map
x_perm = self.permute_map()
# Randomly select subset of regions to use for variograms
idx = self.sample()
# Compute empirical variogram
v = self.compute_variogram(self._x, idx)
# Variogram ordinates; use nearest neighbors because local effect
u = self._D[idx, :]
uidx = np.where(u < self._dmax)
# Smooth empirical variogram
smvar, u0 = self.smooth_variogram(u[uidx], v[uidx], return_h=True)
res = dict.fromkeys(self._deltas)
for d in self._deltas: # foreach neighborhood size
k = int(d * self._knn)
# Smooth the permuted map using k nearest neighbors to
# reintroduce spatial autocorrelation
sm_xperm = self.smooth_map(x=x_perm, k=k)
# Calculate variogram values for the smoothed permuted map
vperm = self.compute_variogram(sm_xperm, idx)
# Calculate smoothed variogram of the smoothed permuted map
smvar_perm = self.smooth_variogram(u[uidx], vperm[uidx])
# Fit linear regression btwn smoothed variograms
res[d] = self.regress(smvar_perm, smvar)
alphas, betas, residuals = np.array(
[res[d] for d in self._deltas], dtype=float).T
# Select best-fit model and regression parameters
iopt = np.argmin(residuals)
dopt = self._deltas[iopt]
self._dopt = dopt
kopt = int(dopt * self._knn)
aopt = alphas[iopt]
bopt = betas[iopt]
# Transform and smooth permuted map using best-fit parameters
sm_xperm_best = self.smooth_map(x=x_perm, k=kopt)
surr = (np.sqrt(np.abs(bopt)) * sm_xperm_best +
np.sqrt(np.abs(aopt)) * self._rs.randn(self._nmap))
if self._resample: # resample values from empirical map
sorted_map = np.sort(self._x)
ii = np.argsort(surr)
np.put(surr, ii, sorted_map)
else:
surr = surr - np.nanmean(surr) # De-mean
if self._ismasked:
return np.ma.masked_array(
data=surr, mask=np.isnan(surr)).squeeze()
return surr.squeeze()
def compute_variogram(self, x, idx):
"""
Compute variogram of `x` using pairs of regions indexed by `idx`.
Parameters
----------
x : (N,) np.ndarray
Brain map
idx : (ns,) np.ndarray[int]
Indices of randomly sampled brain regions
Returns
-------
v : (ns,ns) np.ndarray
Variogram y-coordinates, i.e. 0.5 * (x_i - x_j) ^ 2, for i,j in idx
"""
diff_ij = x[idx][:, None] - x[self._index[idx, :]]
return 0.5 * np.square(diff_ij)
def permute_map(self):
"""
Return a random permutation of the target brain map.
Returns
-------
(N,) np.ndarray
Random permutation of target brain map
"""
perm_idx = self._rs.permutation(self._nmap)
if self._ismasked:
mask_perm = self._x.mask[perm_idx]
x_perm = self._x.data[perm_idx]
return np.ma.masked_array(data=x_perm, mask=mask_perm)
return self._x[perm_idx]
def smooth_map(self, x, k):
"""
Smooth `x` using `k` nearest neighboring regions.
Parameters
----------
x : (N,) np.ndarray
Brain map
k : float
Number of nearest neighbors to include for smoothing
Returns
-------
x_smooth : (N,) np.ndarray
Smoothed brain map
Notes
-----
Assumes `D` provided at runtime has been sorted.
"""
jkn = self._index[:, :k] # indices of k nearest neighbors
xkn = x[jkn] # values of k nearest neighbors
dkn = self._D[:, :k] # distances to k nearest neighbors
weights = self._kernel(dkn) # distance-weighted kernel
# Kernel-weighted sum
return (weights * xkn).sum(axis=1) / weights.sum(axis=1)
def smooth_variogram(self, u, v, return_h=False):
"""
Smooth a variogram.
Parameters
----------
u : (N,) np.ndarray
Pairwise distances, ie variogram x-coordinates
v : (N,) np.ndarray
Squared differences, ie ariogram y-coordinates
return_h : bool, default False
Return distances at which smoothed variogram is computed
Returns
-------
(nh,) np.ndarray
Smoothed variogram samples
(nh,) np.ndarray
Distances at which smoothed variogram was computed (returned if
`return_h` is True)
Raises
------
ValueError : `u` and `v` are not identically sized
"""
if len(u) != len(v):
raise ValueError("u and v must have same number of elements")
# Subtract each element of h from each pairwise distance `u`.
# Each row corresponds to a unique h.
du = np.abs(u - self._h[:, None])
w = np.exp(-np.square(2.68 * du / self._b) / 2)
denom = np.nansum(w, axis=1)
wv = w * v[None, :]
num = np.nansum(wv, axis=1)
output = num / denom
if not return_h:
return output
return output, self._h
def regress(self, x, y):
"""
Linearly regress `x` onto `y`.
Parameters
----------
x : (N,) np.ndarray
Independent variable
y : (N,) np.ndarray
Dependent variable
Returns
-------
alpha : float
Intercept term (offset parameter)
beta : float
Regression coefficient (scale parameter)
res : float
Sum of squared residuals
"""
self._lm.fit(X=np.expand_dims(x, -1), y=y)
beta = self._lm.coef_.item()
alpha = self._lm.intercept_
ypred = self._lm.predict(np.expand_dims(x, -1))
res = np.sum(np.square(y-ypred))
return alpha, beta, res
def sample(self):
"""
Randomly sample (without replacement) brain areas for variogram
computation.
Returns
-------
(self.ns,) np.ndarray
Indices of randomly sampled areas
"""
return self._rs.choice(
a=self._nmap, size=self._ns, replace=False).astype(np.int32)
@property
def x(self):
""" (N,) np.ndarray : brain map scalars """
if self._ismasked:
return np.ma.copy(self._x)
return np.copy(self._x)
@x.setter
def x(self, x):
self._ismasked = False
x_ = dataio(x)
check_map(x=x_)
mask = np.isnan(x_)
if mask.any():
self._ismasked = True
brain_map = np.ma.masked_array(data=x_, mask=mask)
else:
brain_map = x_
self._x = brain_map
@property
def D(self):
""" (N,N) np.memmap : Pairwise distance matrix """
return np.copy(self._D)
@D.setter
def D(self, x):
x_ = dataio(x)
n = self._x.size
if x_.shape[0] != n:
raise ValueError(
"D size along axis=0 must equal brain map size")
self._D = x_[:, 1:self._knn + 1] # prevent self-coupling
@property
def index(self):
""" (N,N) np.memmap : indexes used to sort each row of dist. matrix """
return np.copy(self._index)
@index.setter
def index(self, x):
x_ = dataio(x)
n = self._x.size
if x_.shape[0] != n:
raise ValueError(
"index size along axis=0 must equal brain map size")
self._index = x_[:, 1:self._knn+1].astype(np.int32)
@property
def nmap(self):
""" int : length of brain map """
return self._nmap
@nmap.setter
def nmap(self, x):
self._nmap = int(x)
@property
def pv(self):
""" int : percentile of pairwise distances at which to truncate """
return self._pv
@pv.setter
def pv(self, x):
pv = check_pv(x)
self._pv = pv
@property
def deltas(self):
""" np.ndarray or List[float] : proportions of nearest neighbors """
return self._deltas
@deltas.setter
def deltas(self, x):
check_deltas(deltas=x)
self._deltas = x
@property
def nh(self):
""" int : number of variogram distance intervals """
return self._nh
@nh.setter
def nh(self, x):
self._nh = x
@property
def kernel(self):
""" Callable : smoothing kernel function
Notes
-----
When setting kernel, use name of kernel as defined in ``config.py``.
"""
return self._kernel
@kernel.setter
def kernel(self, x):
kernel_callable = check_kernel(x)
self._kernel = kernel_callable
@property
def resample(self):
""" bool : whether to resample surrogate map values from target maps """
return self._resample
@resample.setter
def resample(self, x):
if not isinstance(x, bool):
raise TypeError("expected bool, got {}".format(type(x)))
self._resample = x
@property
def knn(self):
""" int : number of nearest neighbors included in distance matrix """
return self._knn
@knn.setter
def knn(self, x):
if x > self._nmap:
raise ValueError('knn must be less than len(X)')
self._knn = int(x)
@property
def ns(self):
""" int : number of randomly sampled regions used to construct map """
return self._ns
@ns.setter
def ns(self, x):
self._ns = int(x)
@property
def b(self):
""" numeric : Gaussian kernel bandwidth """
return self._b
@b.setter
def b(self, x):
self._b = x
@property
def h(self):
""" np.ndarray : distances at which variogram is evaluated """
return self._h
@h.setter
def h(self, x):
self._h = x

sampled.py at commit f6a9c37, under GPL-3.0 · at the source

Overview

Authors: Massimiliano Facca^1,2, Anna Ridolfo^1,2, Miriam Celli³, Claudia Tarricone^1,2, Ilaria Mazzonetto⁴, Tommaso Volpi⁵, Andrei G. Vlassenko⁶, Manu S. Goyal⁶, Maurizio Corbetta^1,3,4, Alessandra Bertoldo^1,2

Padova Neuroscience Center (PNC), University of Padova (Unipd), Padova, Italy
Department of Information Engineering, University of Padova (Unipd), Padova, Italy
Department of Neuroscience, University of Padova (Unipd), Padova, Italy
Venetian Institute of Molecular Medicine (VIMM), Padova, Italy
Department of Radiology and Biomedical Imaging, Yale University, New Haven, CT, United States
Neuroimaging Laboratories Research Center at the Mallinckrodt Institute of Radiology, Washington University School of Medicine, St Louis, MO, United States

Institutions: University of Padua (Italy); Veneto Institute of Molecular Medicine (Italy); Yale University (United States); Washington University in St. Louis (United States)

Journal: Imaging neuroscience (Cambridge, Mass.), volume 4, article IMAG.a.1275

Dates: received 1 December 2025; accepted 20 May 2026; published online 16 June 2026

Type: Research article · Language: English

License: CC BY

Identifiers: DOI 10.1162/imag.a.1275 · PMID 42318034 · PMCID PMC13274566 · OpenAlex W4412759797

Open access: diamond, a free copy (OpenAlex)

Preprint: doi:10.1101/2025.07.29.667370

Status: code verified

Categories: fMRI (modality), PET / SPECT (modality), human (organism)

Methods: Connectivity, Statistics, Smoothing, state filtering, decompositions, Machine learning, Preprocessing, Complexity, fMRI & imaging

Keywords: glucose metabolism, fMRI, PET, criticality, long-range temporal correlations, hurst exponent

Topic: Functional Brain Connectivity Studies (Cognitive Neuroscience, Neuroscience), according to OpenAlex

Funding: NIH (R01AG053503, R01AG057536, RF1AG073210, RF1AG074992); Ministry of University and Research (MUR), National Recovery and Resilience Plan (NRRP) (Project MNESYS (PE0000006)); EU (EBRAINS 2.0: A Research Infrastructure to Advance Neuroscience and Brain Health (HORIZON-INFRA-2022-SERV-B-01, grant n.101147319))

Citations: not cited yet (Europe PMC); 85 references in the paper

Abstract

Intrinsic brain activity is characterized by pervasive long-range temporal correlations. While these scale-invariant dynamics are a fundamental hallmark of brain function, their implications for individual-level metabolic regulation remain poorly understood. Here, we address this gap by integrating resting-state functional Magnetic Resonance Imaging (fMRI) and dynamic [18F]FDG Positron Emission Tomography (PET) data acquired from the same cohort of participants. We uncover a systematic relationship between long-range temporal correlations, quantified via the Hurst exponent, and glucose metabolism. Our findings reveal that persistent temporal dependencies are associated with a measurable metabolic cost, with brains exhibiting higher long-range temporal correlations incurring greater energetic demands. Full kinetic modeling of the [18F]FDG PET data traces this association specifically to intracellular glucose phosphorylation, pointing to a direct link with neuronal energy metabolism. Beyond glucose metabolism, we also show that these dynamics are likely supported by continuous biosynthetic processes, such as protein synthesis, which are critical for neural circuit maintenance and remodeling. Overall, our results suggest that a significant fraction of the brain’s so-called “Dark Energy” may be linked to spontaneous long-range temporal correlations.

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

Repositories

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

wonsang/nonfractal

License: BSD-2-Clause

State: the link answers, verified on 27 September 2026

Evidence: files inventoried

Commit: 38accd45956af6c8a65a0d0b4005d04261e73b76, 2 November 2018

Languages: MATLAB (18)

Size: 24 files, 18 scripts

Software Heritage: archived

Found in: “Data and Code Availability”

Holds: README, license file

Not found: CITATION.cff, environment file, tests, continuous integration, documentation

Tools: Statistics and Machine Learning Toolbox (3 files), Wavelet Toolbox (2 files)

Availability: 1 check, the latest on 27 September 2026: the link answers

27 September 2026: the link answers

20 files

demo/bfn_demo_nonfractal.m — MATLAB, 47 lines
m/bfn_CovToCor.m — MATLAB, 58 lines
m/bfn_acorr.m — MATLAB, 55 lines
m/bfn_dwt_brick_wall.m — MATLAB, 40 lines
m/bfn_finsdf.m — MATLAB, 45 lines
m/bfn_finsdf_b.m — MATLAB, 52 lines
m/bfn_getsigma_m.m — MATLAB, 54 lines
m/bfn_mfin_lms.m — MATLAB, 454 lines, 1 match
m/bfn_mfin_ml.m — MATLAB, 511 lines, 1 match
m/bfn_modwt_brick_wall.m — MATLAB, 28 lines
m/bfn_modwt_wvar_ci.m — MATLAB, 223 lines
m/bfn_parseArgs.m — MATLAB, 253 lines
m/bfn_readtable.m — MATLAB, 55 lines
m/bfn_trim_nonchar.m — MATLAB, 33 lines
m/bfn_wave_cor_dwt.m — MATLAB, 64 lines
m/bfn_wave_cov_dwt.m — MATLAB, 73 lines
m/bfn_wave_sum_dwt.m — MATLAB, 39 lines
m/bfn_wave_var_dwt.m — MATLAB, 69 lines
LICENSE — License, 10 lines
README.md — Text, 43 lines

At the source: github.com/wonsang/nonfractal

murraylab/brainsmash

License: GPL-3.0

State: the link answers, verified on 27 September 2026

Evidence: files inventoried

Commit: f6a9c375ba2e591acbc2edc161fbcff12609749d, 18 February 2024

Languages: Python (18)

Size: 83 files, 18 scripts

Software Heritage: archived

Found in: “Data and Code Availability”

Holds: README, license file, environment (requirements.txt, setup.py), documentation

Not found: CITATION.cff, tests, continuous integration

Tools: NumPy (11 files), NiBabel (3 files), SciPy (3 files), BrainSMASH (2 files), scikit-learn (2 files), Matplotlib (1 file), pandas (1 file)

Availability: 1 check, the latest on 27 September 2026: the link answers

27 September 2026: the link answers

20 files

brainsmash/__init__.py — Python, 1 line
brainsmash/config.py — Python, 17 lines
brainsmash/mapgen/__init__.py — Python, 5 lines
brainsmash/mapgen/base.py — Python, 423 lines
brainsmash/mapgen/eval.py — Python, 198 lines
brainsmash/mapgen/kernels.py — Python, 155 lines
brainsmash/mapgen/memmap.py — Python, 120 lines
brainsmash/mapgen/sampled.py — Python, 502 lines, 2 matches
brainsmash/mapgen/stats.py — Python, 128 lines
brainsmash/utils/__init__.py — Python, 4 lines
brainsmash/utils/checks.py — Python, 288 lines
brainsmash/utils/dataio.py — Python, 188 lines, 1 match
brainsmash/workbench/__init__.py — Python, 7 lines
brainsmash/workbench/geo.py — Python, 716 lines, 1 match
brainsmash/workbench/io.py — Python, 101 lines
brainsmash/workbench/surf.py — Python, 190 lines
docs/conf.py — Python, 92 lines
setup.py — Python, 28 lines
LICENSE — License, 202 lines
README.md — Text, 85 lines

At the source: github.com/murraylab/brainsmash

The paper's code and data availability statement is in the Data section.

Tracing map

Proposed by the machine: these links were found in the paper and verified at the source, without human review. The map will receive a Zenodo DOI once one of the paper's authors has validated it with their ORCID.

What the map holds:

2 repositories of the authors' code, each at its verified commit, with its license and how the link was found in the paper;
36 scripts, each with its path and the digest of its content;
6 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

doi:10.18112/openneuro.ds004733.v1.0.0 — at OpenNeuro; found in the text, “Cerebral protein synthesis rate (rCPS)”

Data and Code Availability

The data are available upon reasonable request. They are not publicly shared to protect the privacy of research participants. The code for estimating the Hurst exponent is publicly available in the MATLAB nonfractal toolbox (https://github.com/wonsang/nonfractal). Functions for ICC(1,1) and other versions are available in the Python package Pingouin (https://github.com/raphaelvallat/pingouin). The code for SA-preserving null models is available in the BrainSMASH package (https://github.com/murraylab/brainsmash). The function for dominance analysis is included in the Netneurotools toolbox (https://github.com/netneurolab/netneurotools).

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, pages, dates, 10 authors, 6 keywords, 3 funders, 83 references.

Cite

This paper

Facca, M., Ridolfo, A., Celli, M., Tarricone, C., Mazzonetto, I., Volpi, T., Vlassenko, A. G., Goyal, M. S., Corbetta, M., & Bertoldo, A. (2026). Glucose metabolism echoes long-range temporal correlations in the human brain. Imaging neuroscience (Cambridge, Mass.), 4, IMAG.a.1275. https://doi.org/10.1162/imag.a.1275

BibTeX

@article{facca2026glucose, author = {Facca, Massimiliano and Ridolfo, Anna and Celli, Miriam and Tarricone, Claudia and Mazzonetto, Ilaria and Volpi, Tommaso and Vlassenko, Andrei G. and Goyal, Manu S. and Corbetta, Maurizio and Bertoldo, Alessandra}, title = {{Glucose metabolism echoes long-range temporal correlations in the human brain}}, journal = {Imaging neuroscience (Cambridge, Mass.)}, year = {2026}, month = jun, volume = {4}, pages = {IMAG.a.1275}, publisher = {MIT Press}, issn = {2837-6056}, doi = {10.1162/imag.a.1275}, url = {https://doi.org/10.1162/imag.a.1275}, pmid = {42318034}, pmcid = {PMC13274566} }

RIS

TY - JOUR AU - Facca, Massimiliano AU - Ridolfo, Anna AU - Celli, Miriam AU - Tarricone, Claudia AU - Mazzonetto, Ilaria AU - Volpi, Tommaso AU - Vlassenko, Andrei G. AU - Goyal, Manu S. AU - Corbetta, Maurizio AU - Bertoldo, Alessandra TI - Glucose metabolism echoes long-range temporal correlations in the human brain T2 - Imaging neuroscience (Cambridge, Mass.) J2 - Imaging Neurosci (Camb) PY - 2026 DA - 2026/06/16 VL - 4 SP - IMAG.a.1275 SN - 2837-6056 PB - MIT Press DO - 10.1162/imag.a.1275 UR - https://doi.org/10.1162/imag.a.1275 LA - en ER -

CSL-JSON

{ "id": "10.1162/imag.a.1275", "type": "article-journal", "title": "Glucose metabolism echoes long-range temporal correlations in the human brain", "container-title": "Imaging neuroscience (Cambridge, Mass.)", "author": [ { "family": "Facca", "given": "Massimiliano" }, { "family": "Ridolfo", "given": "Anna" }, { "family": "Celli", "given": "Miriam" }, { "family": "Tarricone", "given": "Claudia" }, { "family": "Mazzonetto", "given": "Ilaria" }, { "family": "Volpi", "given": "Tommaso" }, { "family": "Vlassenko", "given": "Andrei G." }, { "family": "Goyal", "given": "Manu S." }, { "family": "Corbetta", "given": "Maurizio" }, { "family": "Bertoldo", "given": "Alessandra" } ], "container-title-short": "Imaging Neurosci (Camb)", "volume": "4", "page": "IMAG.a.1275", "DOI": "10.1162/imag.a.1275", "PMID": "42318034", "PMCID": "PMC13274566", "ISSN": "2837-6056", "publisher": "MIT Press", "URL": "https://doi.org/10.1162/imag.a.1275", "language": "en", "issued": { "date-parts": [ [ 2026, 6, 16 ] ] } }

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.1162/imag.a.1252 [code]: Does the brain's E:I balance really shape long-range temporal correlations? Lessons learned from 3T MRI.
Journal: Imaging neuroscience (Cambridge, Mass.)
In common: NiBabel, scikit-learn, pandas, 3 other tools, fMRI, 8 references
[2] doi:10.1162/imag.a.1248 [code]: Estimating fMRI timescale maps.
Journal: Imaging neuroscience (Cambridge, Mass.)
In common: NiBabel, scikit-learn, pandas, 3 other tools, fMRI, 9 references
[3] doi:10.1038/s41467-026-74466-2 [code]: Neuromorphic hierarchical modular reservoirs.
Journal: Nature communications
In common: NiBabel, scikit-learn, pandas, 3 other tools, 10 references
[4] doi:10.1073/pnas.2531706123 [code]: Metabolism-weighted brain connectome reveals synaptic integration and vulnerability to neurodegeneration.
Journal: Proceedings of the National Academy of Sciences of the United States of America
In common: BrainSMASH, NiBabel, scikit-learn, 4 other tools, PET / SPECT, 6 references
[5] doi:10.1038/s41467-026-75959-w [code]: Charting higher-order models of brain function beyond pairwise interactions.
Journal: Nature communications
In common: NiBabel, Statistics and Machine Learning Toolbox, scikit-learn, 4 other tools, 8 references
[6] doi:10.7554/elife.106081 [code]: Heritability of movie-evoked brain activity and connectivity.
Journal: eLife
In common: BrainSMASH, NiBabel, Statistics and Machine Learning Toolbox, 3 other tools, 6 references
[7] doi:10.1038/s42003-026-10011-7 [code]: Learning brain dynamics across distinct scaling regimes reveals psychiatric signatures.
Journal: Communications biology
In common: NiBabel, scikit-learn, pandas, 3 other tools, 7 references
[8] doi:10.1038/s42003-026-10276-y [code]: The cellular correlates and adolescent reorganisation of cortical myelination networks in the common marmoset.
Journal: Communications biology
In common: BrainSMASH, NiBabel, Statistics and Machine Learning Toolbox, 5 other tools, 4 references
[9] doi:10.1038/s42003-025-09444-3 [code]: Decoupling of neurophysiological activity from structure mirrors global microarchitectural and neuromodulatory trends.
Journal: Communications biology
In common: NiBabel, Statistics and Machine Learning Toolbox, scikit-learn, 4 other tools, 5 references
[10] doi:10.1038/s41593-026-02359-0 [code]: The cross-site reproducibility of MRI morphometric phenotypes in psychiatric disorders.
Journal: Nature neuroscience
In common: BrainSMASH, NiBabel, Statistics and Machine Learning Toolbox, 5 other tools, 3 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.