SYNTOLOGY HomeExplorerAtlasCodeMethodologyAboutDevelopersFeedPricing
Paper · 2410.07974 · NeurIPS · 2024

Doob's Lagrangian: A Sample-Efficient Variational Approach to Transition Path Sampling

Rob Brekelmans, Frank Noé, Carla Gomes, Yuanqi Du, Kirill Neklyudov, Michael Plainer, Alán Aspuru-Guzik, Chenru Duan

arXiv · PDF · Open in the Atlas

Code that ran

12 of 13 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, 3 violated it and 0 have no contract verdict; 9 failures of our instrument; 1 no recorded run), measured 2026-11-22; 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/2410.07974.json · badge: /api/ran/2410.07974.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
plainerman/variational-doob canonical (classifier label)
classifier basis: census
12 ran · 1 no recorded run
FunctionStatusWhere it lives
U_double_well Ran
ran, violated the contract we drafted
plainerman/variational-doob/potentials.py
code served (permissive licence) · get_code("b5c718f1aa14ec63")
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 1, dtype family float, shape (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
import numpy as np

torch.manual_seed(0)

# Construct xs as a 2D tensor with shape (batch_size, 2)
# The function expects xs[:, 0] for x and xs[:, 1] for y
xs = torch.randn(2, 2)

# Define all parameters
ARGS = {
    "xs": xs,
    "a": 1.0,
    "b": -4.0,
    "c": 0,
    "d": 1.0,
    "beta": 1.0,
}
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 Tensor, ndim 1, dtype family float, shape (2,) — shape (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
U_double_well_dual_channel Ran
ran, violated the contract we drafted
plainerman/variational-doob/potentials.py
code served (permissive licence) · get_code("8baa6fbffc8ae462")
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 ArrayImpl, ndim 1, dtype family float, shape (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 jax.numpy as jnp
import numpy as np

# Create sample input: a 2D array with shape (batch_size, 2)
# The function expects xs to be a 2D array where each row is [x, y]
xs = jnp.array([
    [0.1, 0.2],
    [-0.3, 0.4]
], dtype=jnp.float32)

beta = 1.0

ARGS = {
    "xs": xs,
    "beta": beta
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
jax, numpy — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type ArrayImpl, ndim 1, dtype family float, shape (2,) — shape (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
U_double_well_hard Ran
ran; our contract draft was wrong, not the code
plainerman/variational-doob/potentials.py
code served (permissive licence) · get_code("fba185b286872592")
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 ArrayImpl, ndim 1, dtype family float, shape (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 jax.numpy as jnp

# Create sample input data
# The function expects xs to be a 2D array or will reshape 1D to 2D
# Shape should be (batch_size, feature_dim) where feature_dim=2 based on function logic
xs = jnp.array([
    [-2.5, 0.1],
    [2.8, -0.2]
])

# The function also accepts a beta parameter (default 1.0)
beta = 1.0

ARGS = {
    "xs": xs,
    "beta": beta
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
jax — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type ArrayImpl, ndim 1, dtype family float, shape (2,) — shape (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
interpolate Ran
ran; the contract check could not run (RAISES, DEP_MISSING or TIMEOUT)
plainerman/variational-doob/tps_baseline_mueller.py
code served (permissive licence) · get_code("e15e209ec043ecb5")
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 list, ndim 2, 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 jax.numpy as jnp
import numpy as np

# Set seed for reproducibility
np.random.seed(0)

# Define arguments for the interpolate function
# points: a list of array-like objects to interpolate between
# steps: number of interpolation steps

points = [
    np.array([0.0, 1.0, 2.0, 3.0]),
    np.array([4.0, 5.0, 6.0, 7.0]),
    np.array([8.0, 9.0, 10.0, 11.0])
]

steps = 10

ARGS = {
    "points": points,
    "steps": steps
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
jax, numpy — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type list, ndim 2, dtype family float — a list 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
is_within Ran
ran, violated the contract we drafted
plainerman/variational-doob/tps_baseline.py
code served (permissive licence) · get_code("53f10abe63ad7724")
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 ArrayImpl, ndim 1, dtype family float, shape (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 jax
import jax.numpy as jnp

# Construct arguments for is_within function
# The function expects:
# - _phis_psis: array of shape (N, 2) representing angles/positions
# - _center: array of shape (2,) representing center position
# - _radius: scalar representing radius threshold
# - _period: scalar representing period (default 2*pi)

# Create small test data
_phis_psis = jnp.array([
    [1.0, 2.0],
    [1.5, 2.5]
], dtype=jnp.float32)

_center = jnp.array([1.2, 2.1], dtype=jnp.float32)

_radius = 0.5

_period = 2 * jnp.pi

ARGS = {
    "_phis_psis": _phis_psis,
    "_center": _center,
    "_radius": _radius,
    "_period": _period
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
jax — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type ArrayImpl, ndim 1, dtype family float, shape (2,) — shape (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
load Ran
ran; our contract draft was wrong, not the code
plainerman/variational-doob/eval/evaluate_mueller.py
code served (permissive licence) · get_code("77675113fedd2bb9")
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 list. 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 numpy as np
import tempfile
import os

# Create a temporary directory and file for testing
temp_dir = tempfile.mkdtemp()
temp_file = os.path.join(temp_dir, "test_data.npy")

# Create sample data: a list of arrays that will be reshaped to (-1, 2)
# We'll create 2 arrays with different shapes to test the functionality
sample_data = [
    np.array([[1.5, 2.5], [3.5, 4.5], [5.5, 6.5]], dtype=np.float64),
    np.array([[7.5, 8.5], [9.5, 10.5]], dtype=np.float64)
]

# Save the sample data using np.save with allow_pickle=True
np.save(temp_file, np.array(sample_data, dtype=object), allow_pickle=True)

ARGS = {
    "path": temp_file
}
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 list — a list 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
mcmc_shooting Ran
ran; the contract check could not run (RAISES, DEP_MISSING or TIMEOUT)
plainerman/variational-doob/tps/first_order.py
code served (permissive licence) · get_code("a60329e7a81e48fe")
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 jax
import jax.numpy as jnp
import numpy as np

# Define a simple system class that the proposal function will use
class SimpleSystem:
    def __init__(self):
        self.params = jnp.array([1.0, 0.5, 0.2, 0.1])
    
    def force(self, state):
        return -self.params * state

# Define a proposal function that generates new trajectories
def proposal_fn(system, trajectory, fixed_length, key):
    """
    Proposal function that generates a new trajectory.
    Takes: system, previous trajectory, fixed_length, random key
    Returns: (found: bool, new_trajectory: array)
    """
    # Simulate finding a new trajectory or not
    subkey1, subkey2 = jax.random.split(key)
    
    # With high probability, find a trajectory
    found = jax.random.uniform(subkey1) > 0.1
    
    if not found:
        return False, trajectory
    
    # Generate a new trajectory with slightly different length
    current_length = len(trajectory)
    if fixed_length > 0:
        new_length = fixed_length
    else:
        # Random length between current_length and current_length + 5
        new_length = current_length + jax.random.randint(subkey2, (), 0, 6)
        new_length = min(new_length, 1000)  # Respect MAX_STEPS
    
    # Create new trajectory as random walk from last state
    new_trajectory = jnp.concatenate([
        trajectory,
        jax.random.normal(subkey2, (new_length - current_length, 4))
    ], axis=0)
    
    return True, new_trajectory

# Create initial trajectory (small, starting with shape (5, 4))
initial_trajectory = jnp.array([
    [1.0, 0.5, 0.2, 0.1],
    [0.9, 0.6, 0.3, 0.0],
    [0.8, 0.7, 0.1, 0.2],
    [0.7, 0.4, 0.4, 0.3],
    [0.6, 0.5, 0.2, 0.4],
])

# Create system
system = SimpleSystem()

# Create JAX random key
key = jax.random.PRNGKey(0)

ARGS = {
    'system': system,
    'proposal': proposal_fn,
    'initial_trajectory': initial_trajectory,
    'num_paths': 5,
    'key': key,
    'fixed_length': 0,
    'warmup': 2,
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
jax, numpy, tqdm — 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
one_way_shooting Ran
ran; our contract draft was wrong, not the code
plainerman/variational-doob/tps/first_order.py
code served (permissive licence) · get_code("585c37179b5aba1c")
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 jax
import jax.numpy as jnp
import jax.random as jr

# Create a minimal system class that satisfies the interface
class MockSystem:
    def __init__(self):
        self.state_dim = 4
    
    def step(self, state, key):
        # Takes a state and key, returns next state
        # state shape: (4,), returns (4,)
        noise = jr.normal(key, shape=(self.state_dim,)) * 0.01
        return state + noise
    
    def start_state(self, state):
        # Returns True if state is a start state
        return jnp.allclose(state, 0.0, atol=1e-3)
    
    def target_state(self, state):
        # Returns True if state is a target state
        return jnp.allclose(state, 1.0, atol=1e-3)

# Create trajectory as a list of jax arrays
key = jr.PRNGKey(0)
system = MockSystem()

# Initialize trajectory with a few points
trajectory = [
    jnp.array([0.0, 0.0, 0.0, 0.0]),  # start state
    jnp.array([0.1, 0.1, 0.1, 0.1]),
    jnp.array([0.2, 0.2, 0.2, 0.2]),
    jnp.array([0.9, 0.9, 0.9, 0.9]),  # near target
    jnp.array([1.0, 1.0, 1.0, 1.0]),  # target state
]

fixed_length = 0

ARGS = {
    "system": system,
    "trajectory": trajectory,
    "fixed_length": fixed_length,
    "key": key,
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
jax — 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
plot_iterative_min_max_energy Ran
ran; our contract draft was wrong, not the code
plainerman/variational-doob/eval/path_metrics.py
code served (permissive licence) · get_code("ce65dad4f367f7f9")
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 list, 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 jax.numpy as jnp
import numpy as np
from tqdm import tqdm

# Define a simple potential energy function
def potential_func(path):
    """Simple potential that sums squared values"""
    return jnp.sum(path ** 2)

# Create sample paths - list of small JAX arrays
paths = [
    jnp.array([1.0, 2.0, 3.0, 4.0]),
    jnp.array([0.5, 1.5, 2.5, 3.5]),
    jnp.array([2.0, 3.0, 4.0, 5.0]),
]

# Define potential function U that takes a path and returns energy
U = potential_func

# Define potential_calls - number of calls for each path
potential_calls = [4, 4, 4]

ARGS = {
    'paths': paths,
    'U': U,
    'potential_calls': potential_calls,
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
jax, matplotlib, numpy, tqdm — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type list, ndim 1, dtype family float — a list 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
plot_path_energy Ran
ran; our contract draft was wrong, not the code
plainerman/variational-doob/eval/path_metrics.py
code served (permissive licence) · get_code("f3b550629c7127d4")
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 ArrayImpl, ndim 1, dtype family float, shape (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 jax.numpy as jnp
import numpy as np

# Define a simple potential energy function U that takes a path and returns energies
def potential_energy(path):
    """
    Simple potential energy function.
    Takes a path (array) and returns an array of energy values.
    """
    return jnp.sum(path ** 2, axis=1) if len(path.shape) > 1 else jnp.array([jnp.sum(path ** 2)])

# Create sample paths - list of jnp arrays
# Each path is a trajectory/sequence of positions
paths = [
    jnp.array([[1.0, 2.0, 0.5, -0.3],
               [0.8, 1.9, 0.4, -0.2],
               [0.6, 1.8, 0.3, -0.1]]),
    jnp.array([[0.5, -1.0, 0.2, 0.1],
               [0.4, -0.9, 0.15, 0.05],
               [0.3, -0.8, 0.1, 0.0]]),
]

# Define ARGS dict with all parameters
ARGS = {
    'paths': paths,
    'U': potential_energy,
    'reduce': jnp.max,
    'add': 0.0,
    'already_ln': False,
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
jax, matplotlib, numpy, tqdm — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type ArrayImpl, ndim 1, dtype family float, shape (2,) — shape (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
step_n Ran
ran; our contract draft was wrong, not the code
plainerman/variational-doob/tps_baseline.py
code served (permissive licence) · get_code("b1c11cc844c6637e")
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 4, 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 jax
import jax.numpy as jnp

# Define a simple step function that takes (_x, _v, _key) and returns updated (_x, _v)
def simple_step(_x, _v, _key):
    # Simple update: add small noise to x and v
    noise_x = jax.random.normal(_key, _x.shape) * 0.01
    noise_v = jax.random.normal(_key, _v.shape) * 0.01
    return _x + noise_x, _v + noise_v

# Create small initial tensors
_x = jnp.ones((2, 4))  # batch=2, features=4
_v = jnp.ones((2, 4))  # batch=2, features=4

# Create initial random key
_key = jax.random.PRNGKey(0)

# Number of iterations
n = 3

ARGS = {
    "step": simple_step,
    "_x": _x,
    "_v": _v,
    "n": n,
    "_key": _key,
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
jax — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type tuple, ndim 4, 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
two_way_shooting Ran
ran; our contract draft was wrong, not the code
plainerman/variational-doob/tps/first_order.py
code served (permissive licence) · get_code("2f18c8a3ab7cf955")
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 jax
import jax.numpy as jnp
import jax.random

# Define a simple system class that implements the required interface
class SimpleSystem:
    def __init__(self):
        self.state_dim = 4
        
    def step(self, point, key):
        """Take a step in the system dynamics"""
        # Simple linear step with small noise
        noise = jax.random.normal(key, point.shape) * 0.01
        return point * 0.99 + noise
    
    def start_state(self, point):
        """Check if point is a start state"""
        # Start state is approximately [1, 0, 0, 0]
        return jnp.linalg.norm(point - jnp.array([1.0, 0.0, 0.0, 0.0])) < 0.2
    
    def target_state(self, point):
        """Check if point is a target state"""
        # Target state is approximately [-1, 0, 0, 0]
        return jnp.linalg.norm(point - jnp.array([-1.0, 0.0, 0.0, 0.0])) < 0.2


# Create system instance
system = SimpleSystem()

# Create a trajectory - a list of small jax arrays
trajectory = [
    jnp.array([1.0, 0.1, 0.0, 0.0]),
    jnp.array([0.95, 0.05, 0.0, 0.0]),
    jnp.array([0.90, 0.02, 0.0, 0.0]),
    jnp.array([0.85, 0.0, 0.0, 0.0]),
    jnp.array([0.80, -0.05, 0.0, 0.0]),
    jnp.array([-1.0, 0.0, 0.0, 0.0]),
]

# fixed_length parameter: 0 means use MAX_STEPS, otherwise use specified length
fixed_length = 0

# Create a random key for JAX
key = jax.random.PRNGKey(42)

# Construct the ARGS dictionary
ARGS = {
    "system": system,
    "trajectory": trajectory,
    "fixed_length": fixed_length,
    "key": key,
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
jax — 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
decorrelated Not yet run
unverified (harvested, no recorded run)
plainerman/variational-doob/tps/paths.py
code served (permissive licence) · get_code("f1acf61f58cd67a5")
How it ran

no invocation recorded.

Also present in other papers' code

Of 13 samples lifted from this paper's linked repositories, 13 carry a function identity and 0 do not. Of the 13 distinct functions with an identity, 0 are also present in other papers whose code we hold (0 with at least one paper dated earlier, 0 the same month, 0 later) and 13 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.

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-22.

Repositories linked to this paper

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

Abstract

Rare event sampling in dynamical systems is a fundamental problem arising in the natural sciences, which poses significant computational challenges due to an exponentially large space of trajectories. For settings where the dynamical system of interest follows a Brownian motion with known drift, the question of conditioning the process to reach a given endpoint or desired rare event is definitively answered by Doob's h-transform. However, the naive estimation of this transform is infeasible, as it requires simulating sufficiently many forward trajectories to estimate rare event probabilities. In this work, we propose a variational formulation of Doob's h-transform as an optimization problem over trajectories between a given initial point and the desired ending point. To solve this optimization, we propose a simulation-free training objective with a model parameterization that imposes the desired boundary conditions by design. Our approach significantly reduces the search space over trajectories and avoids expensive trajectory simulation and inefficient importance sampling estimators which are required in existing methods. We demonstrate the ability of our method to find feasible transition paths on real-world molecular simulation and protein folding tasks.

For agents

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

get_harvested_code_for_paper("2410.07974")
get_code_for_paper("2410.07974")
have("2410.07974")

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

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

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

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

Connect an agent — have() is free.