SYNTOLOGY HomeExplorerAtlasCodeMethodologyAboutDevelopersFeedPricing
Paper · 2003.00868 · 2020

Differentiable Molecular Simulations for Control and Learning

arXiv · PDF · Open in the Atlas

Code that ran

10 of 11 samples (functions and classes) lifted from this paper's linked repositories executed on a synthesized input in Syntology's jail (0 of them constructed an object rather than computing a result; 0 honoured the contract we drafted, 0 violated it and 10 have no contract verdict; 0 failures of our instrument; 1 no recorded run), measured 2026-11-21; repository links from the Papers with Code archive attributed under CC BY-SA, no affiliation; bodies inline only under a permissive licence as GitHub detects it. Not a reproduction of the paper's results.

"Ran" means the function executed on a synthesized input and returned a value. It is not a reproduction of the paper's results. This record, dated, as JSON: /api/ran/2003.00868.json · badge: /api/ran/2003.00868.svg

Each repository's role is a label: a classifier's output recorded on the link, or, where no role is recorded, what the Papers with Code archive marked. The line under it names its basis. Neither says who wrote the code.

RepositoryRoleRan
wwang2/torchmd canonical (classifier label)
classifier basis: census
10 ran · 0 no recorded run
torchmd/mdgrad reimplementation (classifier label)
classifier basis: classifier_2025
0 ran · 1 no recorded run
FunctionStatusWhere it lives
NHverlet_update Ran
ran on a synthesized input
wwang2/torchmd/torchmd/sovlers.py
code served (permissive licence) · get_code("b9cdc21dc11ac13b")
How it ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned tuple, ndim 1, dtype family float; no output shape is stated. The image it ran in was not recorded. If your copy returns the same type and ndim on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import torch
import numpy as np

torch.manual_seed(0)

# Define a simple function that takes (t, y) and returns derivatives
# For the forward case (len(y) == 3), it should return (a_0, v_0, dpvdt_0)
# For the backward case (len(y) == 8), it should return 8 derivatives
def dynamics_func(t, y):
    if len(y) == 3:
        # Forward dynamics: return (a_0, v_0, dpvdt_0)
        a_0 = torch.tensor(0.1, dtype=torch.float32)
        v_0 = torch.tensor(0.2, dtype=torch.float32)
        dpvdt_0 = torch.tensor(0.05, dtype=torch.float32)
        return (a_0, v_0, dpvdt_0)
    elif len(y) == 8:
        # Backward dynamics with adjoints: return 8 derivatives
        dydt_0 = (
            torch.tensor(0.1, dtype=torch.float32),  # dydt[0]
            torch.tensor(0.15, dtype=torch.float32),  # dydt[1]
            torch.tensor(0.05, dtype=torch.float32),  # dydt[2]
            torch.tensor(0.02, dtype=torch.float32),  # dydt[3] - vadjoint
            torch.tensor(0.03, dtype=torch.float32),  # dydt[4] - qadjoint
            torch.tensor(0.01, dtype=torch.float32),  # dydt[5] - pvadjoint
            torch.tensor(0.001, dtype=torch.float32),  # dydt[6] - dLdt
            torch.tensor(0.002, dtype=torch.float32),  # dydt[7] - dLdpar
        )
        return dydt_0
    else:
        raise ValueError(f"Unexpected y length: {len(y)}")

# Test with forward case (len(y) == 3)
t_forward = 0.0
dt_forward = 0.01
y_forward = (
    torch.tensor(1.0, dtype=torch.float32),   # position
    torch.tensor(0.5, dtype=torch.float32),   # velocity
    torch.tensor(0.1, dtype=torch.float32),   # pv
)

# Test with backward case (len(y) == 8)
t_backward = 0.0
dt_backward = 0.01
y_backward = (
    torch.tensor(1.0, dtype=torch.float32),   # position
    torch.tensor(0.5, dtype=torch.float32),   # q
    torch.tensor(0.1, dtype=torch.float32),   # pv
    torch.tensor(0.01, dtype=torch.float32),  # v_adjoint
    torch.tensor(0.02, dtype=torch.float32),  # q_adjoint
    torch.tensor(0.005, dtype=torch.float32), # pv_adjoint
    torch.tensor(0.0001, dtype=torch.float32),# dL/dt
    torch.tensor(0.0002, dtype=torch.float32),# dL/dpar
)

# Use forward case as primary test
ARGS = {
    'func': dynamics_func,
    't': t_forward,
    'dt': dt_forward,
    'y': y_forward,
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
numpy, torch — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type tuple, ndim 1, dtype family float — a tuple output has no array shape of its own; none is stated
dtype family
int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
compute_angle Ran
ran on a synthesized input
wwang2/torchmd/demo/fold.py
code served (permissive licence) · get_code("5cf6994a9a6425de")
How it ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned Tensor, ndim 2, dtype family float, shape (2, 3) as a later run recorded it. The image it ran in was not recorded. If your copy returns the same type, ndim and shape on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import torch

torch.manual_seed(0)

# xyz: shape (n_frames, N, 3)
# n_frames=2, N=4, coordinates in 3D
xyz = torch.randn(2, 4, 3)

# angles: shape (n_angles, 3)
# Each row contains 3 indices into the N=4 atoms
# Valid indices are 0, 1, 2, 3
angles = torch.tensor([
    [0, 1, 2],
    [1, 2, 3],
    [0, 2, 3]
], dtype=torch.long)

ARGS = {
    "xyz": xyz,
    "angles": angles
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
torch — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type Tensor, ndim 2, dtype family float, shape (2, 3) — shape (2, 3) as a later run recorded it
dtype family
int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
compute_dihe Ran
ran on a synthesized input
wwang2/torchmd/torchmd/observable.py
code served (permissive licence) · get_code("b86ff523a2f0e810")
How it ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned Tensor, ndim 2, dtype family float, shape (2, 2) as a later run recorded it. The image it ran in was not recorded. If your copy returns the same type, ndim and shape on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import torch

torch.manual_seed(0)

# xyz: shape (n_frames, N, 3)
# This is a batch of atomic coordinates
# n_frames=2, N=4 (4 atoms), 3 spatial dimensions
xyz = torch.randn(2, 4, 3)

# dihes: shape (n_dihedrals, 4)
# Each row contains 4 atom indices defining a dihedral angle
# We need indices that are valid (< N=4)
dihes = torch.tensor([
    [0, 1, 2, 3],
    [1, 2, 3, 0]
], dtype=torch.long)

ARGS = {
    "xyz": xyz,
    "dihes": dihes
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
torch — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type Tensor, ndim 2, dtype family float, shape (2, 2) — shape (2, 2) as a later run recorded it
dtype family
int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
compute_dis Ran
ran on a synthesized input
wwang2/torchmd/torchmd/topology.py
code served (permissive licence) · get_code("0eeb2f0f43eaf83f")
How it ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned Tensor, ndim 2, dtype family float, shape (2, 1) as a later run recorded it. The image it ran in was not recorded. If your copy returns the same type, ndim and shape on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import torch

torch.manual_seed(0)

# xyz: coordinates tensor, indexed by nbr_list
# Shape should be (num_atoms, 3) for 3D coordinates
xyz = torch.randn(2, 3)

# nbr_list: indices of neighbor pairs
# Shape (num_pairs, 2) where each row is [atom_i, atom_j]
nbr_list = torch.tensor([[0, 1], [1, 0]], dtype=torch.long)

# offsets: image offsets for periodic boundary conditions
# Shape (num_pairs, 3) - one offset vector per neighbor pair
offsets = torch.randn(2, 3)

# cell: unit cell vectors
# Shape (3, 3) for 3D periodic boundary conditions
cell = torch.randn(3, 3)

ARGS = {
    "xyz": xyz,
    "nbr_list": nbr_list,
    "offsets": offsets,
    "cell": cell,
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
torch — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type Tensor, ndim 2, dtype family float, shape (2, 1) — shape (2, 1) as a later run recorded it
dtype family
int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
gen_helix Ran
ran on a synthesized input
wwang2/torchmd/demo/fold.py
code served (permissive licence) · get_code("669849ecf9b0d34b")
How it ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned ndarray, ndim 2, dtype family float, shape (10, 3) as a later run recorded it. The image it ran in was not recorded. If your copy returns the same type, ndim and shape on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import numpy as np

ARGS = {
    "n_spirals": 3,
    "n_atoms": 10,
    "a": 2.5,
    "dz": 0.5
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
numpy — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type ndarray, ndim 2, dtype family float, shape (10, 3) — shape (10, 3) as a later run recorded it
dtype family
int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
generate_nbr_list Ran
ran on a synthesized input
wwang2/torchmd/torchmd/topology.py
code served (permissive licence) · get_code("474cbec5cfcaae60")
How it ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned tuple. The image it ran in was not recorded. If your copy returns the same type on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import torch
import itertools

torch.manual_seed(0)

# Create xyz tensor: shape (batch=2, num_atoms=4, coords=3)
xyz = torch.randn(2, 4, 3)

# Create cutoff distance
cutoff = 2.5

# Create cell tensor: shape (3, 3) for a 3D periodic cell
cell = torch.eye(3) * 5.0

# Create index_tuple: tuple of two lists specifying atom pairs to include
# First list: atoms from group 0, Second list: atoms from group 1
index_tuple = ([0, 1], [2, 3])

# Create ex_pairs: tensor of atom pairs to exclude, shape (num_pairs, 2)
ex_pairs = torch.LongTensor([[0, 2]])

# Flag to request distances
get_dis = True

ARGS = {
    "xyz": xyz,
    "cutoff": cutoff,
    "cell": cell,
    "index_tuple": index_tuple,
    "ex_pairs": ex_pairs,
    "get_dis": get_dis,
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
torch — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type tuple — a tuple output has no array shape of its own; none is stated
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
generate_pair_index Ran
ran on a synthesized input
wwang2/torchmd/torchmd/topology.py
code served (permissive licence) · get_code("778f96b725724f3d")
How it ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned Tensor, ndim 2, dtype family float, shape (5, 5) as a later run recorded it. The image it ran in was not recorded. If your copy returns the same type, ndim and shape on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import torch
import itertools

torch.manual_seed(0)

# Analyze the function:
# - N: integer (size of square matrix)
# - index_tuple: either None or a tuple of two iterables (index_tuple[0] and index_tuple[1])
#   The function creates pairs from itertools.product of these two iterables

# Create valid arguments
N = 5  # Size of the NxN matrix

# Create index_tuple with two sequences
# index_tuple[0] will be indices for first dimension
# index_tuple[1] will be indices for second dimension
index_tuple = (
    [0, 1, 2],      # First set of indices
    [2, 3, 4]       # Second set of indices
)

ARGS = {
    "N": N,
    "index_tuple": index_tuple
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
torch — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type Tensor, ndim 2, dtype family float, shape (5, 5) — shape (5, 5) as a later run recorded it
dtype family
int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
generate_vol_bins Ran
ran on a synthesized input
wwang2/torchmd/torchmd/observable.py
code served (permissive licence) · get_code("2e2e7b806a567fc8")
How it ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned tuple. The image it ran in was not recorded. If your copy returns the same type on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import torch
import numpy as np

torch.manual_seed(0)

# Define arguments for generate_vol_bins
ARGS = {
    "start": 0.0,
    "end": 10.0,
    "nbins": 5,
    "dim": 3
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
numpy, torch — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type tuple — a tuple output has no array shape of its own; none is stated
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
rk4_alt_step_func Ran
ran on a synthesized input
wwang2/torchmd/torchmd/tinydiffeq.py
code served (permissive licence) · get_code("915f7ec0ef60ec9a")
How it ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned tuple, ndim 3, dtype family float; no output shape is stated. The image it ran in was not recorded. If your copy returns the same type and ndim on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import torch
import numpy as np

torch.manual_seed(0)

# The function expects:
# - func: a callable that takes (t, y) where y is a tuple and returns a tuple
# - t: a scalar time value
# - dt: a scalar time step
# - y: a tuple of tensors
# - k1: optional tuple of tensors (derivatives at current point)

# Create a simple ODE function that takes (t, y_tuple) and returns derivatives
def ode_func(t, y):
    """Simple ODE function: dy/dt = -y for each element in the tuple."""
    return tuple(-y_i for y_i in y)

# Create small initial state as a tuple of tensors
y_initial = (
    torch.randn(2, 4),  # batch of 2, dimension 4
    torch.randn(2, 4),  # second component
)

# Time parameters
t_current = 0.0
dt_step = 0.1

# Optionally pre-compute k1 to test the k1 parameter
k1_precomputed = ode_func(t_current, y_initial)

# Arguments for the function
ARGS = {
    "func": ode_func,
    "t": t_current,
    "dt": dt_step,
    "y": y_initial,
    "k1": k1_precomputed,
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
numpy, torch — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type tuple, ndim 3, dtype family float — a tuple output has no array shape of its own; none is stated
dtype family
int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
verlet_update Ran
ran on a synthesized input
wwang2/torchmd/torchmd/sovlers.py
code served (permissive licence) · get_code("ef6cc877c3ceba79")
How it ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned tuple, ndim 1, dtype family float; no output shape is stated. The image it ran in was not recorded. If your copy returns the same type and ndim on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import torch
import numpy as np

torch.manual_seed(0)

# For the forward pass (len(y) == 2)
def func_forward(t, y):
    """Returns (a_0, v_0) tuple"""
    a_0 = torch.tensor(0.5, dtype=torch.float32)
    v_0 = torch.tensor(1.2, dtype=torch.float32)
    return (a_0, v_0)

# For the backward pass (len(y) == 6)
def func_backward(t, y):
    """Returns (dv, dx, vad_vjp_full, xad_vjp_full, vjp_t, vjp_params) tuple"""
    dv = torch.tensor(0.1, dtype=torch.float32)
    dx = torch.tensor(0.2, dtype=torch.float32)
    vad_vjp_full = torch.tensor(0.3, dtype=torch.float32)
    xad_vjp_full = torch.tensor(0.4, dtype=torch.float32)
    vjp_t = torch.tensor(0.05, dtype=torch.float32)
    vjp_params = torch.tensor(0.06, dtype=torch.float32)
    return (dv, dx, vad_vjp_full, xad_vjp_full, vjp_t, vjp_params)

# Test case 1: forward pass with NUM_VAR = 2
y_forward = (torch.tensor(1.0, dtype=torch.float32), torch.tensor(0.5, dtype=torch.float32))
t_val = torch.tensor(0.0, dtype=torch.float32)
dt_val = 0.01

# Test case 2: backward pass with NUM_VAR * 2 + 2 = 6
y_backward = (
    torch.tensor(1.0, dtype=torch.float32),  # v_full
    torch.tensor(2.0, dtype=torch.float32),  # x_full
    torch.tensor(0.1, dtype=torch.float32),  # vad_full
    torch.tensor(0.2, dtype=torch.float32),  # xad_full
    torch.tensor(0.05, dtype=torch.float32), # vjp_t accumulation
    torch.tensor(0.06, dtype=torch.float32)  # vjp_params accumulation
)

ARGS = {
    "func": func_forward,
    "t": t_val,
    "dt": dt_val,
    "y": y_forward
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
numpy, torch — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type tuple, ndim 1, dtype family float — a tuple output has no array shape of its own; none is stated
dtype family
int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
JS_rdf Not yet run
unverified (harvested, no recorded run)
torchmd/mdgrad/demo/fit_rdf_gnn.py
code served (permissive licence) · get_code("4ef118b99c1874d1")
How it ran

no invocation recorded.

Also present in other papers' code

Of 11 samples lifted from this paper's linked repositories, 11 carry a function identity and 0 do not. Of the 11 distinct functions with an identity, 1 are also present in other papers whose code we hold (1 with at least one paper dated earlier, 0 the same month, 0 later) and 10 are only here among the 52,977 papers whose code Syntology holds (as of 2026-09-26).

Only here means: among the 52,977 papers whose code Syntology holds (51,887 with lifted samples, 1,090 through their assemblies only), as of 2026-09-26, no other paper's lifted samples or current assembly bricks contain an identical function body after normalisation.

FunctionAlso present inEarliest-datedOthers named
rk4_alt_step_func 2 other papers
2 dated earlier
1806.07366 (2018-06)
Neural Ordinary Differential Equations
1905.10403 (2019-05)
Neural Jump Stochastic Differential Equations

Presence, not direction: an identical function body in two papers' repositories does not say who wrote it, which came from which, or that either paper's method rests on it. Matching is exact after normalisation, so a renamed or edited function is not matched. Dates are when papers appeared, not when code was written. Only .py files the harvester lifted are covered; notebooks are not read. A new-style arXiv id YYMM.NNNN dates a paper to the month 20YY-MM; otherwise Paper.year dates it to the year; otherwise it is undated. Dates are when the paper appeared, not when the code was written. Read 2026-11-21.

Repositories linked to this paper

Some links come from the archived Papers with Code dataset (CC BY-SA 4.0): attribution and licence.

Abstract

Molecular dynamics simulations use statistical mechanics at the atomistic scale to enable both the elucidation of fundamental mechanisms and the engineering of matter for desired tasks. The behavior of molecular systems at the microscale is typically simulated with differential equations parameterized by a Hamiltonian, or energy function. The Hamiltonian describes the state of the system and its interactions with the environment. In order to derive predictive microscopic models, one wishes to infer a molecular Hamiltonian that agrees with observed macroscopic quantities. From the perspective of engineering, one wishes to control the Hamiltonian to achieve desired simulation outcomes and structures, as in self-assembly and optical control, to then realize systems with the desired Hamiltonian in the lab. In both cases, the goal is to modify the Hamiltonian such that emergent properties of the simulated system match a given target. We demonstrate how this can be achieved using differentiable simulations where bulk target observables and simulation outcomes can be analytically differentiated with respect to Hamiltonians, opening up new routes for parameterizing Hamiltonians to infer macroscopic models and develop control protocols.

For agents

The same record, over MCP at https://syntology.ai/mcp:

get_harvested_code_for_paper("2003.00868")
get_code_for_paper("2003.00868")
have("2003.00868")

The run record, dated, one paper per request, free:

curl https://syntology.ai/api/ran/2003.00868.json

A badge for a README (the split and the date, never a ratio):

[![Syntology run record](https://syntology.ai/api/ran/2003.00868.svg)](https://syntology.ai/paper/2003.00868)

Connect an agent — have() is free.