Modal Backflow Neural Quantum States for Anharmonic Vibrational Calculations.

Code ↔ Paper

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

[1] § Ab Initio Anharmonic Vibrational Hamiltonians ↔ Randomized_Watson_Hamiltonian/fnn_compare.py, lines 94–138 · score 0.67 · learning rate scheduling, Monte Carlo, CoRe, transitions, FNN, error
[2] § Ab Initio Anharmonic Vibrational Hamiltonians ↔ Randomized_Watson_Hamiltonian/vib_randomized_ham.py, lines 94–175 · score 0.56 · learning rate scheduling, CoRe, transitions, error, modal, MBF
[3] § Modal Backflow Neural Quantum States › Optimization › VSCF Pretraining ↔ nqs_vib.py, lines 133–218 · score 0.56 · VSCF solutions, modal functions, biases, zero, weights, network
[4] § Modal Backflow Neural Quantum States › Optimization › Markov Chain Monte Carlo ↔ Selected_Configs/state.py, lines 84–98 · score 0.56 · Monte Carlo sampling, quantum state, expectation, sum
[5] § Modal Backflow Neural Quantum States › Optimization › Markov Chain Monte Carlo ↔ Selected_Configs/state.py, lines 84–98 · score 0.53 · Monte Carlo sampling, quantum state, sum

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 · 520 lines · 18 KB · CC-BY-4.0 · 2 matches

# Copyright 2021 The NetKet Authors - All rights reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
# This file is modified from the MCState implementation of netket
import warnings
from functools import partial
from typing import Any
from collections.abc import Callable
import jax
import numpy as np
from jax import numpy as jnp
import time
from flax import serialization, core as fcore
from flax.core.scope import CollectionFilter, DenyList # noqa: F401
from netket import config
from netket import jax as nkjax
from netket import nn as nknn
from netket.hilbert.discrete_hilbert import DiscreteHilbert
from netket.utils import (
model_frameworks,
wrap_afun,
wrap_to_support_scalar,
_serialization as serialization_utils,
)
from netket.utils.types import PyTree, SeedT, NNInitFunc
from netket.optimizer import LinearOperator
from netket.optimizer.qgt import QGTAuto
from netket.vqs.base import VariationalState, QGTConstructor
from netket.vqs.mc.mc_state.state import check_chunk_size, _is_power_of_two
def fast_unique_configs(configs):
"""Fast unique for integer configurations using hash-based approach"""
if len(configs) < 1000: # For small arrays, jnp.unique is fine
return jnp.unique(configs, axis=0)
# Convert to tuples and use set for O(n) average case deduplication
seen = set()
unique_list = []
for config in configs:
config_tuple = tuple(config.tolist()) # Convert to hashable tuple
if config_tuple not in seen:
seen.add(config_tuple)
unique_list.append(config)
return jnp.array(unique_list) if unique_list else configs[:0] # Empty array with right shape
@partial(jax.jit, static_argnums=0)
def jit_evaluate(fun: Callable, *args):
"""
call `fun(*args)` inside of a `jax.jit` frame.
Args:
fun: the hashable callable to be evaluated.
args: the arguments to the function.
"""
return fun(*args)
@jax.jit
def _array_to_pdf(v):
pdf = jnp.abs(v) ** 2
return pdf / jnp.sum(pdf)
class SCState(VariationalState):
"""Variational State for a variational quantum state computed without Monte Carlo sampling by summing over a selected part of Hilbert
space.
Expectation values and gradients are deterministic.
The only non-deterministic part is due to the initialization seed used to generate
the parameters.
"""
_init_fun: Callable | None = None
"""The function used to initialise the parameters and model_state"""
_apply_fun: Callable
"""The function used to evaluate the model"""
_chunk_size: int | None = None
def __init__(
self,
hilbert: DiscreteHilbert,
model=None,
seed_config = None,
n_select=1,
n_expand=1,
hamiltonian = None,
init_states = None,
*,
chunk_size: int | None = None,
variables: PyTree | None = None,
init_fun: NNInitFunc | None = None,
apply_fun: Callable | None = None,
seed: SeedT | None = None,
mutable: CollectionFilter = False,
training_kwargs: dict = {},
dtype=float,
):
"""
Constructs the SCState.
Args:
hilbert: The Hilbert space
model: (Optional) The model. If not provided, you must provide init_fun and apply_fun.
variables: Optional dictionary for the initial values for the variables (parameters and model state) of the model.
seed: rng seed used to generate a set of parameters (only if parameters is not passed). Defaults to a random one.
mutable: Name or list of names of mutable arguments. Use it to specify if the model has a state that can change
during evaluation, but that should not be optimised. See also :meth:`flax.linen.Module.apply` documentation
(default=False)
init_fun: Function of the signature f(model, shape, rng_key, dtype) -> Optional_state, parameters used to
initialise the parameters. Defaults to the standard flax initialiser. Only specify if your network has
a non-standard init method.
apply_fun: Function of the signature f(model, variables, σ) that should evaluate the model. Defaults to
`model.apply(variables, σ)`. specify only if your network has a non-standard apply method.
training_kwargs: a dict containing the optional keyword arguments to be passed to the apply_fun during training.
Useful for example when you have a batchnorm layer that constructs the average/mean only during training.
chunk_size: (Defaults to `None`) If specified, calculations are split into chunks where the neural network
is evaluated at most on :code:`chunk_size` samples at once. This does not change the mathematical results,
but will trade a higher computational cost for lower memory cost.
"""
super().__init__(hilbert)
self._model_framework = None
self._states = None # Add this at the very start of __init__
if variables is not None:
# TODO: Always have shardings...
if config.netket_experimental_sharding:
par_sharding = jax.sharding.PositionalSharding(
jax.devices()
).replicate()
else:
par_sharding = jax.sharding.SingleDeviceSharding(jax.devices()[0])
variables = jax.tree_util.tree_map(
lambda x: jax.lax.with_sharding_constraint(
jnp.asarray(x), par_sharding
),
variables,
)
# Init type 1: pass in a model
if model is not None:
# extract init and apply functions
# Wrap it in an HashablePartial because if two instances of the same model are provided,
# model.apply and model2.apply will be different methods forcing recompilation, but
# model and model2 will have the same hash.
self._model_framework = model_frameworks.identify_framework(model)
_maybe_unwrapped_variables, model = self._model_framework.wrap(model)
if variables is None:
if _maybe_unwrapped_variables is not None:
variables = _maybe_unwrapped_variables
self._model = model
self._init_fun = nkjax.HashablePartial(
lambda model, *args, **kwargs: model.init(*args, **kwargs), model
)
self._apply_fun = wrap_to_support_scalar(
nkjax.HashablePartial(
lambda model, *args, **kwargs: model.apply(*args, **kwargs), model
)
)
elif apply_fun is not None:
self._apply_fun = wrap_to_support_scalar(apply_fun)
if init_fun is not None:
self._init_fun = init_fun
elif variables is None:
raise ValueError(
"If you don't provide variables, you must pass a valid init_fun."
)
self._model = wrap_afun(apply_fun)
else:
raise ValueError("Must either pass the model or apply_fun.")
self.mutable = mutable
self.training_kwargs = fcore.freeze(training_kwargs)
self.seed_config = seed_config
def _init_configs_from_hamiltonian(self, hamiltonian, n_states, dtype=float):
"""
Initializes configs by expanding from [0,...,0] using the Hamiltonian,
then selecting the n_states highest-probability configs according to the network.
"""
seed_config = jnp.zeros(self.hilbert.size, dtype=int) if self.seed_config is None else self.seed_config
# Get all connected configurations
connected, _ = hamiltonian.get_conn_padded(seed_config)
# Remove duplicates (in case zero_config is also in connected)
all_configs = fast_unique_configs(connected.reshape(-1, self.hilbert.size))
# Evaluate amplitudes
log_psi = self.log_value(all_configs)
amplitudes = jnp.real(log_psi)
# Select top n_states
idx = np.argsort(amplitudes,kind="mergesort")[-self._n_select:][::-1]
return all_configs[idx]
self._n_select = n_select
self._n_expand = n_expand
self._hamiltonian = hamiltonian
self._connected = None
if variables is not None:
self.variables = variables
else:
self.init(seed, dtype=dtype)
if seed_config is None:
seed_config = jnp.zeros((self.hilbert.size,), dtype=int)
else:
seed_config = jnp.asarray(seed_config, dtype=int)
if seed_config.shape != (self.hilbert.size,):
raise ValueError(
f"seed_config must have shape ({self.hilbert.size},), got {seed_config.shape}"
)
if init_states is None:
self._states = _init_configs_from_hamiltonian(self, self._hamiltonian, self._n_select)
else:
self._states = init_states
self._psi = jnp.exp(self.log_value(self._states))
self._array = self._psi
self._pdf = _array_to_pdf(self._array)
"""
Caches the output of `self._all_states()`.
"""
#self._array = None
"""
Caches the output of `self.to_array()`.
"""
#self._pdf = None
"""
Caches the output of `self.probability_distribution()`.
"""
self.chunk_size = chunk_size
def init(self, seed=None, dtype=None):
"""
Initialises the variational parameters of the variational state.
"""
if self._init_fun is None:
raise RuntimeError(
"Cannot initialise the parameters of this state"
"because you did not supply a valid init_function."
)
if dtype is None:
dtype = float
key = nkjax.PRNGKey(seed)
dummy_input = self.hilbert.random_state(key, 1, dtype=dtype)
variables = jit_evaluate(self._init_fun, {"params": key}, dummy_input)
self.variables = variables
@property
def hilbert(self) -> DiscreteHilbert:
r"""The descriptor of the Hilbert space
on which this variational state is defined.
.. note::
Full summation states only work over discrete hilbert spaces.
"""
return self._hilbert # type: ignore
@property
def chunk_size(self) -> int | None:
"""
Suggested *maximum size* of the chunks used in forward and backward evaluations
of the Neural Network model. If your inputs are smaller than the chunk size
this setting is ignored.
This can be used to lower the memory required to run a computation with a very
high number of samples or on a very large lattice. Notice that inputs and
outputs must still fit in memory, but the intermediate computations will now
require less memory.
This option comes at an increased computational cost. While this cost should
be negligible for large-enough chunk sizes, don't use it unless you are memory
bound!
This option is an hint: only some operations support chunking. If you perform
an operation that is not implemented with chunking support, it will fall back
to no chunking. To check if this happened, set the environment variable
`NETKET_DEBUG=1`.
"""
return self._chunk_size
@chunk_size.setter
def chunk_size(self, chunk_size: int | None):
# disable chunks if it is None
if chunk_size is None:
self._chunk_size = None
return
if not isinstance(chunk_size, int) or chunk_size <= 0:
raise ValueError("Chunk size must be a positive INTEGER. ")
if not _is_power_of_two(chunk_size):
warnings.warn(
"For performance reasons, we suggest to use a power-of-two chunk size."
)
# TODO MPI aware check for valid size
check_chunk_size(self.hilbert.n_states, chunk_size)
self._chunk_size = chunk_size
def update_configs(self):
"""
Updates self._states by expanding to all configs connected by the Hamiltonian,
then selecting the top n_select configs by probability amplitude.
"""
# 1. Expand: get all connected configs
if not hasattr(self, '_connected') or self._connected is None:
all_connected, _ = self._hamiltonian.get_conn_padded(self._states)
all_connected = all_connected.reshape(-1, self.hilbert.size)
ind = np.random.randint(0, all_connected.shape[0], size=self._n_expand)
all_connected = all_connected[ind]
else:
all_connected = self._connected[np.random.randint(0, self._connected.shape[0], size=self._n_expand)]
all_connected = jnp.concatenate((self._states, all_connected), axis=0)
# Remove duplicates
all_connected = fast_unique_configs(all_connected)
# 2. Evaluate amplitudes substitute
log_psi = self.log_value(all_connected)
amplitudes = jnp.real(log_psi)
# 3. Select top n_select
idx = np.argsort(amplitudes,kind="mergesort")[-self._n_select:][::-1]
self._states = all_connected[idx]
self._psi = jnp.exp(self.log_value(self._states))
self._array = self._psi
self._pdf = _array_to_pdf(self._array)
def reset(self):
"""
Resets the sampled states. This method is called automatically every time
that the parameters/state is updated.
"""
if self._states is None:
return
self.update_configs()
@property
def model(self) -> Any | None:
"""Returns the model definition of this variational state.
This field is optional, and is set to `None` if the variational state has
been initialized using a custom function.
"""
if self._model_framework is not None:
return self._model_framework.unwrap(self._model, self.variables)
self._model
def log_value(self, σ: jnp.ndarray) -> jnp.ndarray:
r"""
Evaluate the variational state for a batch of states and returns
the logarithm of the amplitude of the quantum state.
For pure states, this is :math:`\log(\langle\sigma|\psi\rangle)`,
whereas for mixed states
this is :math:`\log(\langle\sigma_r|\rho|\sigma_c\rangle)`, where
:math:`\psi` and :math:`\rho` are respectively a pure state
(wavefunction) and a mixed state (density matrix).
For the density matrix, the left and right-acting states (row and column)
are obtained as :code:`σr=σ[::,0:N]` and :code:`σc=σ[::,N:]`.
Given a batch of inputs :code:`(Nb, N)`, returns a batch of outputs
:code:`(Nb,)`.
"""
return jit_evaluate(self._apply_fun, self.variables, σ)
def quantum_geometric_tensor(
self, qgt_T: QGTConstructor | None = None
) -> LinearOperator:
r"""Computes an estimate of the quantum geometric tensor G_ij.
This function returns a linear operator that can be used to apply G_ij to a given vector
or can be converted to a full matrix.
Args:
qgt_T: the optional type of the quantum geometric tensor. By default it's automatically selected.
Returns:
nk.optimizer.LinearOperator: A linear operator representing the quantum geometric tensor.
"""
if qgt_T is None:
qgt_T = QGTAuto()
return qgt_T(self)
def to_array(self, normalize: bool = True, allgather: bool = True) -> jax.Array:
# Only evaluate on self._states (your subset)
if self._array is None and normalize:
self._array = jnp.exp(self.log_value(self._states))
# If you want amplitudes, use jnp.exp(self._array)
if normalize:
arr = self._array
else:
arr = jnp.exp(self.log_value(self._states))
return arr
def probability_distribution(self):
if self._pdf is None:
self._pdf = _array_to_pdf(self.to_array())
return self._pdf
# cached computations
@property
def _all_states(self):
return self._states
@property
def samples(self):
return self._states
def __repr__(self):
return (
"SCState("
+ f"\n hilbert = {self.hilbert},"
+ f"\n n_parameters = {self.n_parameters})"
)
def __str__(self):
return "SCState(" + f"hilbert = {self.hilbert}, "
# serialization
def serialize_SCState(vstate):
state_dict = {
"variables": serialization.to_state_dict(
serialization_utils.remove_prngkeys(vstate.variables)
),
"states": jnp.array(vstate._states), # <-- Add this line
}
return state_dict
def deserialize_SCState(vstate, state_dict):
import copy
new_vstate = copy.copy(vstate)
#new_vstate.reset()
vars = jax.tree_util.tree_map(
jnp.asarray,
serialization.from_state_dict(vstate.variables, state_dict["variables"]),
)
vars = serialization_utils.restore_prngkeys(vstate.variables, vars)
if config.netket_experimental_sharding:
vars = jax.tree_util.tree_map(
lambda x, y: jax.lax.with_sharding_constraint(jnp.asarray(y), x.sharding),
vstate.variables,
vars,
)
new_vstate.variables = vars
# Restore the configurations
if "states" in state_dict:
new_vstate._states = jnp.array(state_dict["states"])
return new_vstate
serialization.register_serialization_state(
SCState,
serialize_SCState,
deserialize_SCState,
)

state.py, under CC-BY-4.0 · at the source

Overview

Authors: Lexin Ding¹, Markus Reiher¹

ORCID iDs: Markus Reiher

Department of Chemistry and Applied Biosciences, ETH Zürich, Vladimir-Prelog-Weg 2, CH-8093 Zürich, Switzerland

Institutions: ETH Zurich (Switzerland)

Journal: Journal of chemical theory and computation, volume 22, issue 6, pages 3032-3043

Dates: received 4 November 2025; accepted 18 February 2026; published online 9 March 2026; in print March 2026

Type: Research article · Language: English

License: CC BY

Identifiers: DOI 10.1021/acs.jctc.5c01852 · PMID 41802182 · PMCID PMC13019627 · OpenAlex W7134805057

Open access: hybrid, a free copy (OpenAlex)

Preprint: arxiv:2511.03061

Status: code verified

Methods: Statistics, Spectral & time-frequency

Topic: Quantum many-body systems (Atomic and Molecular Physics, and Optics, Physics and Astronomy), according to OpenAlex

Funding: Eidgenössische Technische Hochschule Zürich

Citations: cited by 2 papers (Europe PMC); 93 references in the paper

Abstract

Neural quantum states (NQS) are a promising ansatz for solving many-body quantum problems due to their inherent expressiveness. Yet this expressiveness can only be harnessed efficiently for treating identical particles if the suitable physical knowledge is hardwired into the neural network itself. For electronic structure, NQS based on backflow determinants have been shown to be a powerful ansatz for capturing strong correlation. By contrast, the analogue for bosons, backflow permanents, is unpractical due to the steep cost of computing the matrix permanent and due to the lack of particle conservation in common bosonic problems. To circumvent these obstacles, we introduce a modal backflow (MBF) NQS design and demonstrate its efficacy by solving the anharmonic vibrational problem. To accommodate the demand of high accuracy in spectroscopic calculations, we implement a selected-configuration scheme for evaluating physical observables and gradients, replacing the standard stochastic approach based on Monte Carlo sampling. A vibrational self-consistent field calculation is conveniently carried out within the MBF network, which serves as a pretraining step to accelerate and stabilize the optimization. In applications to both artificial and ab initio Hamiltonians, we find that the MBF network is capable of delivering spectroscopically accurate zero-point energies and vibrational transitions in all anharmonic regimes.

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

Zenodo 17552425

License: CC-BY-4.0

State: the link answers, verified on 30 September 2026

Evidence: files inventoried

Size: 1 file

Software Heritage: not checked

Found in: the references

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

Tools: JAX (12 files), NumPy (12 files), SciPy (3 files)

Availability: 1 check, the latest on 30 September 2026: the link answers (HTTP 200)

30 September 2026: the link answers (HTTP 200)

28 files

Randomized_Watson_Hamiltonian/__init__.py, Python, 10 lines
Randomized_Watson_Hamiltonian/anharmonic_correction_sample.py, Python, 70 lines
Randomized_Watson_Hamiltonian/fnn_compare.py, Python, 154 lines, 1 match
Randomized_Watson_Hamiltonian/vib_randomized_ham.py, Python, 179 lines, 1 match
Selected_Configs/__init__.py, Python, 17 lines
Selected_Configs/expect.py, Python, 225 lines
Selected_Configs/state.py, Python, 520 lines, 2 matches
__init__.py, Python, 15 lines
driver_ex/__init__.py, Python, 9 lines
driver_ex/expect_grad_ex.py, Python, 218 lines
driver_ex/vmc_ex.py, Python, 208 lines
misc_tools.py, Python, 76 lines
molecules/__init__.py, Python, 10 lines
molecules/ham_clo2.py, Python, 115 lines
molecules/ham_h2co.py, Python, 488 lines
molecules/vib_ch3cn.py, Python, 407 lines
molecules/vib_clo2.py, Python, 178 lines
molecules/vib_h2co.py, Python, 374 lines
nqs_vib.py, Python, 248 lines, 1 match
opt_tools.py, Python, 77 lines
plotting/clo2.m, MATLAB, 82 lines
plotting/h2co.m, MATLAB, 35 lines
plotting/plot_error_stat.m, MATLAB, 56 lines
plotting/plot_fnn_mbf_comparison.m, MATLAB, 44 lines
plotting/vibham_dist.m, MATLAB, 57 lines
vib_ham.py, Python, 178 lines
vib_operators.py, Python, 197 lines
README.md, Text, 44 lines

At the source:

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:

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

zenodo:18985565, at Zenodo; found in DataCite

Data Availability Statement

The data and code for producing the result of this work are available on Zenodo.

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

Recorded: type, language, journal, volume, issue, pages, dates, 2 authors, 1 funder, 87 references.

Cite

This paper

Ding, L., & Reiher, M. (2026). Modal Backflow Neural Quantum States for Anharmonic Vibrational Calculations. Journal of chemical theory and computation, 22(6), 3032-3043. https://doi.org/10.1021/acs.jctc.5c01852

BibTeX

@article{ding2026modal, author = {Ding, Lexin and Reiher, Markus}, title = {{Modal Backflow Neural Quantum States for Anharmonic Vibrational Calculations}}, journal = {Journal of chemical theory and computation}, year = {2026}, month = mar, volume = {22}, number = {6}, pages = {3032--3043}, publisher = {American Chemical Society}, issn = {1549-9618}, doi = {10.1021/acs.jctc.5c01852}, url = {https://doi.org/10.1021/acs.jctc.5c01852}, pmid = {41802182}, pmcid = {PMC13019627} }

RIS

TY - JOUR AU - Ding, Lexin AU - Reiher, Markus TI - Modal Backflow Neural Quantum States for Anharmonic Vibrational Calculations T2 - Journal of chemical theory and computation J2 - J Chem Theory Comput PY - 2026 DA - 2026/03/09 VL - 22 IS - 6 SP - 3032 EP - 3043 SN - 1549-9618 PB - American Chemical Society DO - 10.1021/acs.jctc.5c01852 UR - https://doi.org/10.1021/acs.jctc.5c01852 LA - en ER -

CSL-JSON

{ "id": "10.1021/acs.jctc.5c01852", "type": "article-journal", "title": "Modal Backflow Neural Quantum States for Anharmonic Vibrational Calculations", "container-title": "Journal of chemical theory and computation", "author": [ { "family": "Ding", "given": "Lexin" }, { "family": "Reiher", "given": "Markus" } ], "container-title-short": "J Chem Theory Comput", "volume": "22", "issue": "6", "page": "3032-3043", "DOI": "10.1021/acs.jctc.5c01852", "PMID": "41802182", "PMCID": "PMC13019627", "ISSN": "1549-9618", "publisher": "American Chemical Society", "URL": "https://doi.org/10.1021/acs.jctc.5c01852", "language": "en", "issued": { "date-parts": [ [ 2026, 3, 9 ] ] } }

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

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.