SYNTOLOGY HomeExplorerAtlasCodeMethodologyAboutDevelopersFeedPricing
Paper · 1806.07366 · 2018

Neural Ordinary Differential Equations

David Duvenaud, Ricky Chen, Yulia Rubanova, Jesse Bettencourt

arXiv · PDF · Open in the Atlas

Code that ran

98 of 124 samples (functions and classes) lifted from this paper's linked repositories executed on a synthesized input in Syntology's jail (44 of them constructed an object rather than computing a result; 2 honoured the contract we drafted, 5 violated it and 55 have no contract verdict; 36 failures of our instrument; 26 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/1806.07366.json · badge: /api/ran/1806.07366.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
teopb/ode-net-examples community
not in the paper's declared repositories
27 ran · 6 no recorded run
xuanqing94/torchdiffeq community
not in the paper's declared repositories
12 ran · 2 no recorded run
TheStageAI/TorchIntegral community
Papers with Code archive
8 ran · 3 no recorded run
BruceNolascoFC/RN-2021-1 community
Papers with Code archive
8 ran · 2 no recorded run
HolmesShuan/OISR-PyTorch community (classifier label)
classifier basis not recorded on the link
6 ran · 0 no recorded run
alexandrejash/Chivvo community
Papers with Code archive
5 ran · 0 no recorded run
5yearsKim/HamiltonianFlow community
Papers with Code archive
5 ran · 0 no recorded run
boschresearch/numerics_independent_neural_odes community
Papers with Code archive
4 ran · 6 no recorded run
Lauu1023/ODENet community (classifier label)
classifier basis not recorded on the link
4 ran · 1 no recorded run
feicccccccc/Neural-ODE-Ex community
Papers with Code archive
2 ran · 2 no recorded run
UofTrees/ProjectX2020 community
Papers with Code archive
2 ran · 1 no recorded run
lye0618/torchdiffeq community (classifier label)
classifier basis not recorded on the link
2 ran · 1 no recorded run
kakao/DAFT community
not in the paper's declared repositories
2 ran · 0 no recorded run
ipeter50/graph_ode community
not in the paper's declared repositories
1 ran · 1 no recorded run
m-qiang/cortexode community
not in the paper's declared repositories
1 ran · 0 no recorded run
xwinxu/bayesian-sde community
not in the paper's declared repositories
1 ran · 0 no recorded run
kfallah/NODE-Denoiser community
not in the paper's declared repositories
1 ran · 0 no recorded run
dungxibo123/neural_ode community
not in the paper's declared repositories
1 ran · 0 no recorded run
abaietto/neural_ode_classification community
Papers with Code archive
1 ran · 0 no recorded run
copperwire/neural_ode community
Papers with Code archive
1 ran · 0 no recorded run
tianfr/mononerf community
not in the paper's declared repositories
1 ran · 0 no recorded run
johnhw/simple_neural_ode community
not in the paper's declared repositories
1 ran · 0 no recorded run
dlinzner-bcs/min_neuralODEs community
Papers with Code archive
1 ran · 0 no recorded run
jrbotvinick/learning-dynamics-on-invariant-measures community
not in the paper's declared repositories
1 ran · 0 no recorded run
geoffsmith/gan-ode community
not in the paper's declared repositories
0 ran · 1 no recorded run
FunctionStatusWhere it lives
AdamsBashforth Ran
ran on a synthesized input · constructed an object; no result was computed
teopb/ode-net-examples/torchdiffeq/_impl/odeint.py
code served (permissive licence) · get_code("7980b2520b28c2f2")
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 an instance of its own class, AdamsBashforth: the run constructed the object and did not call it, so no result was computed. 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 torch.nn as nn
import abc

torch.manual_seed(0)

def _handle_unused_kwargs(self, unused_kwargs):
    pass

def _assert_increasing(t):
    pass

class SimpleODEFunc(nn.Module):
    def __init__(self):
        super().__init__()
        self.linear = nn.Linear(4, 4)
    
    def forward(self, t, y):
        return self.linear(y[0]).unsqueeze(0)

class ConcreteFixedGridODESolver:
    def __init__(self, func, y0, step_size=None, grid_constructor=None, **unused_kwargs):
        unused_kwargs.pop('rtol', None)
        unused_kwargs.pop('atol', None)
        _handle_unused_kwargs(self, unused_kwargs)
        del unused_kwargs
        self.func = func
        self.y0 = y0
        if step_size is not None and grid_constructor is None:
            self.grid_constructor = self._grid_constructor_from_step_size(step_size)
        elif grid_constructor is None:
            self.grid_constructor = lambda f, y0, t: t
        else:
            raise ValueError('step_size and grid_constructor are exclusive arguments.')

    def _grid_constructor_from_step_size(self, step_size):
        def _grid_constructor(func, y0, t):
            start_time = t[0]
            end_time = t[-1]
            niters = torch.ceil((end_time - start_time) / step_size + 1).item()
            t_infer = torch.arange(0, niters).to(t) * step_size + start_time
            if t_infer[-1] > t[-1]:
                t_infer[-1] = t[-1]
            return t_infer
        return _grid_constructor

    @property
    def order(self):
        return 1

    def step_func(self, func, t, dt, y):
        return tuple(torch.zeros_like(y_) for y_ in y)

func = SimpleODEFunc()
y0 = (torch.randn(2, 4),)
step_size = 0.1

ARGS = {
    'func': func,
    'y0': y0,
    'step_size': step_size,
    'grid_constructor': None
}
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 AdamsBashforth — the run constructed an instance of its own class and did not call it; no shape is stated — the instrument coerces any output to an array; for a AdamsBashforth output the recorded ndim 0 and dtype family float describe that coercion, not the output, and are not 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
AdamsBashforth Ran
ran on a synthesized input · constructed an object; no result was computed
xuanqing94/torchdiffeq/torchdiffeq/_impl/odeint.py
code served (permissive licence) · get_code("106d95c9ca4a144c")
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 an instance of its own class, AdamsBashforth: the run constructed the object and did not call it, so no result was computed. 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 torch.nn as nn
import abc

torch.manual_seed(0)

def _handle_unused_kwargs(self, unused_kwargs):
    pass

def _assert_increasing(t):
    pass

class SimpleODEFunc(nn.Module):
    def __init__(self):
        super(SimpleODEFunc, self).__init__()
        self.linear = nn.Linear(4, 4)
    
    def forward(self, t, y):
        return self.linear(y)

class ConcreteODESolver(object):
    __metaclass__ = abc.ABCMeta

    def __init__(self, func, y0, step_size=None, grid_constructor=None, **unused_kwargs):
        unused_kwargs.pop('rtol', None)
        unused_kwargs.pop('atol', None)
        _handle_unused_kwargs(self, unused_kwargs)
        del unused_kwargs
        self.func = func
        self.y0 = y0
        if step_size is not None and grid_constructor is None:
            self.grid_constructor = self._grid_constructor_from_step_size(step_size)
        elif grid_constructor is None:
            self.grid_constructor = lambda f, y0, t: t
        else:
            raise ValueError('step_size and grid_constructor are exclusive arguments.')

    def _grid_constructor_from_step_size(self, step_size):
        def _grid_constructor(func, y0, t):
            start_time = t[0]
            end_time = t[-1]
            niters = torch.ceil((end_time - start_time) / step_size + 1).item()
            t_infer = torch.arange(0, niters).to(t) * step_size + start_time
            t_infer[-1] = t[-1]
            return t_infer
        return _grid_constructor

    @property
    def order(self):
        return 1

    def step_func(self, func, t, dt, y):
        return tuple(torch.zeros_like(y_) for y_ in y)

    def integrate(self, t):
        _assert_increasing(t)
        t = t.type_as(self.y0[0])
        time_grid = self.grid_constructor(self.func, self.y0, t)
        assert time_grid[0] == t[0] and time_grid[-1] == t[-1], f'{time_grid[0]}!={t[0]}, {time_grid[-1]}!={t[-1]}'
        time_grid = time_grid.to(self.y0[0])
        solution = [self.y0]
        j = 1
        y0 = self.y0
        for t0, t1 in zip(time_grid[:-1], time_grid[1:]):
            dy = self.step_func(self.func, t0, t1 - t0, y0)
            y1 = tuple((y0_ + dy_ for y0_, dy_ in zip(y0, dy)))
            y0 = y1
            while j < len(t) and t1 >= t[j]:
                solution.append(self._linear_interp(t0, t1, y0, y1, t[j]))
                j += 1
        return tuple(map(torch.stack, tuple(zip(*solution))))

    def _linear_interp(self, t0, t1, y0, y1, t):
        if t == t0:
            return y0
        if t == t1:
            return y1
        t0, t1, t = (t0.to(y0[0]), t1.to(y0[0]), t.to(y0[0]))
        slope = tuple(((y1_ - y0_) / (t1 - t0) for y0_, y1_ in zip(y0, y1)))
        return tuple((y0_ + slope_ * (t - t0) for y0_, slope_ in zip(y0, slope)))

func = SimpleODEFunc()
y0 = (torch.randn(2, 4), torch.randn(2, 4))
step_size = 0.1
t = torch.linspace(0.0, 1.0, 5)

ARGS = {
    'func': func,
    'y0': y0,
    'step_size': step_size,
    'grid_constructor': None,
}
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 AdamsBashforth — the run constructed an instance of its own class and did not call it; no shape is stated — the instrument coerces any output to an array; for a AdamsBashforth output the recorded ndim 0 and dtype family float describe that coercion, not the output, and are not 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
AdamsBashforthMoulton Ran
ran on a synthesized input · constructed an object; no result was computed
teopb/ode-net-examples/torchdiffeq/_impl/odeint.py
code served (permissive licence) · get_code("1cbcd7f7db72e996")
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 an instance of its own class, AdamsBashforthMoulton: the run constructed the object and did not call it, so no result was computed. 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 torch.nn as nn

torch.manual_seed(0)

# Helper function that the code uses
def _handle_unused_kwargs(obj, kwargs):
    if kwargs:
        raise ValueError(f'Unexpected keyword arguments: {list(kwargs.keys())}')

def _assert_increasing(t):
    if not torch.all(t[1:] > t[:-1]):
        raise ValueError('t must be strictly increasing')

# Define a simple ODE function
class SimpleODEFunc(nn.Module):
    def __init__(self):
        super().__init__()
        self.linear = nn.Linear(4, 4)
    
    def forward(self, t, y):
        # y is a tuple of tensors
        return tuple(self.linear(y_i) for y_i in y)

# Create initial state y0 as a tuple of tensors
y0 = (torch.randn(2, 4), torch.randn(2, 4))

# Create the ODE function
func = SimpleODEFunc()

# Create time points
t = torch.linspace(0, 1, 5)

# Arguments for FixedGridODESolver.__init__
ARGS = {
    'func': func,
    'y0': y0,
    'step_size': 0.1,
    'grid_constructor': None,
}
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 AdamsBashforthMoulton — the run constructed an instance of its own class and did not call it; no shape is stated — the instrument coerces any output to an array; for a AdamsBashforthMoulton output the recorded ndim 0 and dtype family float describe that coercion, not the output, and are not 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
AdamsBashforthMoulton Ran
ran on a synthesized input · constructed an object; no result was computed
xuanqing94/torchdiffeq/torchdiffeq/_impl/odeint.py
code served (permissive licence) · get_code("279f4f78d04ad28b")
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 an instance of its own class, AdamsBashforthMoulton: the run constructed the object and did not call it, so no result was computed. 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 torch.nn as nn

torch.manual_seed(0)

def _handle_unused_kwargs(obj, kwargs):
    if kwargs:
        raise ValueError(f'Unexpected keyword arguments: {list(kwargs.keys())}')

def _assert_increasing(t):
    if not torch.all(t[1:] > t[:-1]):
        raise ValueError('t must be strictly increasing')

class SimpleFunc(nn.Module):
    def __init__(self):
        super().__init__()
        self.linear = nn.Linear(4, 4)
    
    def forward(self, t, y):
        # y is a tuple of tensors
        return tuple(self.linear(y_i) for y_i in y)

func = SimpleFunc()

y0 = (torch.randn(4), torch.randn(4))

t = torch.tensor([0.0, 0.5, 1.0, 1.5, 2.0])

ARGS = {
    'func': func,
    'y0': y0,
    'step_size': 0.1,
    'grid_constructor': None
}
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 AdamsBashforthMoulton — the run constructed an instance of its own class and did not call it; no shape is stated — the instrument coerces any output to an array; for a AdamsBashforthMoulton output the recorded ndim 0 and dtype family float describe that coercion, not the output, and are not 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
AdaptiveStepsizeODESolver Ran
ran on a synthesized input · constructed an object; no result was computed
teopb/ode-net-examples/torchdiffeq/_impl/odeint.py
code served (permissive licence) · get_code("e8208a8b9886cd85")
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 an instance of its own class, AdaptiveStepsizeODESolver: the run constructed the object and did not call it, so no result was computed. 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 torch.nn as nn

torch.manual_seed(0)

# Define a simple ODE function that takes (t, y) and returns dy/dt
class SimpleODEFunc(nn.Module):
    def __init__(self):
        super(SimpleODEFunc, self).__init__()
        self.linear = nn.Linear(4, 4)
    
    def forward(self, t, y):
        # y is a list or tuple of tensors
        if isinstance(y, (list, tuple)):
            return [self.linear(yi) for yi in y]
        else:
            return self.linear(y)

# Create function instance
func = SimpleODEFunc()

# Create initial conditions y0 as a list of tensors (batch_size=2, dim=4)
y0 = [torch.randn(2, 4), torch.randn(2, 4)]

# Tolerance parameters
atol = 1e-6
rtol = 1e-5

ARGS = {
    'func': func,
    'y0': y0,
    'atol': atol,
    'rtol': rtol,
}
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 AdaptiveStepsizeODESolver — the run constructed an instance of its own class and did not call it; no shape is stated — the instrument coerces any output to an array; for a AdaptiveStepsizeODESolver output the recorded ndim 0 and dtype family float describe that coercion, not the output, and are not 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
AdaptiveStepsizeODESolver Ran
ran on a synthesized input · constructed an object; no result was computed
xuanqing94/torchdiffeq/torchdiffeq/_impl/odeint.py
code served (permissive licence) · get_code("2f5e41ed5c35fa64")
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 an instance of its own class, AdaptiveStepsizeODESolver: the run constructed the object and did not call it, so no result was computed. 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 torch.nn as nn

torch.manual_seed(0)

class SimpleODEFunc(nn.Module):
    """Minimal ODE function that returns y-shaped output"""
    def __init__(self, hidden_dim):
        super(SimpleODEFunc, self).__init__()
        self.hidden_dim = hidden_dim
    
    def forward(self, t, y):
        # Returns a tensor of same shape as y
        return -y

# Create tiny test tensors
batch_size = 2
state_dim = 4
y0 = [torch.randn(batch_size, state_dim)]

# Create the ODE function
func = SimpleODEFunc(state_dim)

# Tolerance parameters
atol = 1e-6
rtol = 1e-3

ARGS = {
    "func": func,
    "y0": y0,
    "atol": atol,
    "rtol": rtol,
}
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 AdaptiveStepsizeODESolver — the run constructed an instance of its own class and did not call it; no shape is stated — the instrument coerces any output to an array; for a AdaptiveStepsizeODESolver output the recorded ndim 0 and dtype family float describe that coercion, not the output, and are not 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
CortexODE Ran
ran on a synthesized input · constructed an object; no result was computed
m-qiang/cortexode/model/net.py
pointer only (licence: NONE) · get_code("042c58847599eec2")
How it ran

The body of this sample is withheld: GitHub detected no licence in this paper's repository, m-qiang/cortexode when it was checked. The setup block that called it is withheld with it, because it is written against that body. source_path and origin say where the code lives, to read under the repository's own terms. A run is recorded.

DAFT Ran
ran on a synthesized input · constructed an object; no result was computed
kakao/DAFT/model.py
code served (permissive licence) · get_code("43b0462e8ae59a39")
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 an instance of its own class, DAFT: the run constructed the object and did not call it, so no result was computed. 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 torch.nn as nn
from torch.nn.init import xavier_uniform_

torch.manual_seed(0)

def linear(in_dim, out_dim, bias=True):
    lin = nn.Linear(in_dim, out_dim, bias=bias)
    xavier_uniform_(lin.weight)
    if bias:
        lin.bias.data.zero_()
    return lin

class DAFT(nn.Module):

    def __init__(self, dim):
        super().__init__()
        self.attn = linear(dim + 1, 1)
        self.different_question_projs = linear(dim + 1, dim)
        self.nfe = 0

    def set_context(self, context, question):
        self.context = context
        self.question = question

    def forward(self, t, attn_weight):
        self.nfe += 1
        tt = torch.ones_like(self.question[:, :1]) * t
        ttx = torch.cat([tt, self.question], dim=1)
        question = self.different_question_projs(ttx)
        context_prod = question.unsqueeze(1) * self.context
        context_prod = torch.cat([context_prod, attn_weight], dim=2)
        attn_weight_diff = self.attn(context_prod)
        return attn_weight_diff

# Create a DAFT instance with dim=4
dim = 4
daft_model = DAFT(dim=dim)

# Set context and question for the model
batch_size = 2
context_len = 3
question_dim = dim

# context shape: (batch_size, context_len, question_dim)
context = torch.randn(batch_size, context_len, question_dim)
# question shape: (batch_size, question_dim)
question = torch.randn(batch_size, question_dim)

daft_model.set_context(context, question)

# Create arguments for forward pass
t = 0.5
# attn_weight shape: (batch_size, context_len, 1)
attn_weight = torch.randn(batch_size, context_len, 1)

ARGS = {
    "dim": dim,
}
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 DAFT — the run constructed an instance of its own class and did not call it; no shape is stated — the instrument coerces any output to an array; for a DAFT output the recorded ndim 0 and dtype family float describe that coercion, not the output, and are not 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
Data Ran
ran on a synthesized input · constructed an object; no result was computed
UofTrees/ProjectX2020/mr_node/model/odefunc.py
pointer only (licence: NONE) · get_code("afcd5754477bf8a7")
How it ran

The body of this sample is withheld: GitHub detected no licence in this paper's repository, UofTrees/ProjectX2020 when it was checked. The setup block that called it is withheld with it, because it is written against that body. source_path and origin say where the code lives, to read under the repository's own terms. A run is recorded.

DiffEqWrapper Ran
ran; our contract draft was wrong, not the code
xwinxu/bayesian-sde/brax/_impl/diffeq_layers.py
code served (permissive licence) · get_code("b4e4766812fea13a")
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) 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 torch.nn as nn

torch.manual_seed(0)

# Create a simple layer function pair (init_fun, layer_apply_fun)
# The layer_apply_fun takes (params, x, **kwargs) and returns output

def simple_init_fun(key, input_shape):
    """Initialize parameters for a simple linear layer"""
    return {'weight': torch.randn(4, 4), 'bias': torch.randn(4)}

def simple_apply_fun(params, x, **kwargs):
    """Apply a simple linear transformation"""
    return torch.nn.functional.linear(x, params['weight'], params['bias'])

# Create the layer tuple
layer = (simple_init_fun, simple_apply_fun)

ARGS = {
    'layer': layer
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1
Imports
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
Dopri5Solver Ran
ran on a synthesized input · constructed an object; no result was computed
teopb/ode-net-examples/torchdiffeq/_impl/odeint.py
code served (permissive licence) · get_code("2f030eba6be5e4b6")
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 an instance of its own class, Dopri5Solver: the run constructed the object and did not call it, so no result was computed. 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 torch.nn as nn
import collections

torch.manual_seed(0)

# Define a simple ODE function
class SimpleODEFunc(nn.Module):
    def __init__(self):
        super(SimpleODEFunc, self).__init__()
        self.linear = nn.Linear(4, 4)
    
    def forward(self, t, y):
        # y is a tuple of tensors
        if isinstance(y, tuple):
            return tuple(self.linear(y_i) for y_i in y)
        else:
            return self.linear(y)

# Create the ODE function
func = SimpleODEFunc()

# Create initial state y0 as a tuple of tensors
y0 = (torch.randn(2, 4), torch.randn(2, 4))

# Set tolerance parameters
atol = 1e-6
rtol = 1e-3

# Build the ARGS dictionary
ARGS = {
    'func': func,
    'y0': y0,
    'atol': atol,
    'rtol': rtol,
}
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 Dopri5Solver — the run constructed an instance of its own class and did not call it; no shape is stated — the instrument coerces any output to an array; for a Dopri5Solver output the recorded ndim 0 and dtype family float describe that coercion, not the output, and are not 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
Dopri5Solver Ran
ran on a synthesized input · constructed an object; no result was computed
xuanqing94/torchdiffeq/torchdiffeq/_impl/odeint.py
code served (permissive licence) · get_code("f121c10d5d8c5250")
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 an instance of its own class, Dopri5Solver: the run constructed the object and did not call it, so no result was computed. 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 torch.nn as nn
import collections

torch.manual_seed(0)

# Define a simple ODE function
class SimpleODEFunc(nn.Module):
    def __init__(self):
        super(SimpleODEFunc, self).__init__()
        self.linear = nn.Linear(4, 4)
    
    def forward(self, t, y):
        # y is a tuple of tensors
        if isinstance(y, tuple):
            return tuple(self.linear(y_i) for y_i in y)
        else:
            return self.linear(y)

# Create function instance
func = SimpleODEFunc()

# Create initial condition - tuple of tensors as expected by integrate()
y0 = (torch.randn(2, 4), torch.randn(2, 4))

# Tolerance parameters
atol = 1e-6
rtol = 1e-5

# Create time points (strictly increasing)
t = torch.linspace(0, 1, 5, dtype=torch.float64)

ARGS = {
    'func': func,
    'y0': y0,
    'atol': atol,
    'rtol': rtol,
}
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 Dopri5Solver — the run constructed an instance of its own class and did not call it; no shape is stated — the instrument coerces any output to an array; for a Dopri5Solver output the recorded ndim 0 and dtype family float describe that coercion, not the output, and are not 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
Euler Ran
ran on a synthesized input · constructed an object; no result was computed
teopb/ode-net-examples/torchdiffeq/_impl/odeint.py
code served (permissive licence) · get_code("43e9e562dc3f595e")
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 an instance of its own class, Euler: the run constructed the object and did not call it, so no result was computed. 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 torch.nn as nn

torch.manual_seed(0)

# Define a simple ODE function that takes (t, y) and returns derivatives
class SimpleODEFunc(nn.Module):
    def __init__(self):
        super().__init__()
        self.linear = nn.Linear(4, 4)
    
    def forward(self, t, y):
        # y is a tuple of tensors
        # Return a tuple of derivatives with same structure as y
        result = self.linear(y[0])
        return (result,)

# Create the function
func = SimpleODEFunc()

# Create initial condition y0 as a tuple of tensors
# Batch size 2, feature dim 4
y0 = (torch.randn(2, 4),)

# Create time grid
t = torch.tensor([0.0, 0.1, 0.2, 0.3, 0.4, 0.5])

ARGS = {
    'func': func,
    'y0': y0,
    'step_size': 0.05,
    'grid_constructor': None,
}
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 Euler — the run constructed an instance of its own class and did not call it; no shape is stated — the instrument coerces any output to an array; for a Euler output the recorded ndim 0 and dtype family float describe that coercion, not the output, and are not 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
Euler Ran
ran on a synthesized input · constructed an object; no result was computed
alexandrejash/Chivvo/anode/odesolver.py
pointer only (licence: GPL-3.0) · get_code("6fba12214cae5e2d")
How it ran

The body of this sample is withheld: GPL-3.0, as GitHub detects it on this paper's repository, alexandrejash/Chivvo, is not in the permissive set Syntology serves inline. The setup block that called it is withheld with it, because it is written against that body. source_path and origin say where the code lives, to read under the repository's own terms. A run is recorded.

Euler Ran
ran on a synthesized input · constructed an object; no result was computed
xuanqing94/torchdiffeq/torchdiffeq/_impl/odeint.py
code served (permissive licence) · get_code("70d97d2f6b74251c")
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 an instance of its own class, Euler: the run constructed the object and did not call it, so no result was computed. 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 torch.nn as nn

torch.manual_seed(0)

# Define a simple ODE function that takes (t, y) and returns dy/dt
class SimpleODEFunc(nn.Module):
    def __init__(self):
        super().__init__()
        self.linear = nn.Linear(4, 4)
    
    def forward(self, t, y):
        # y is a tuple of tensors
        # Return tuple of same structure with derivatives
        return tuple(self.linear(y_) for y_ in y)

# Create function instance
func = SimpleODEFunc()

# Initial condition: tuple of 2 tensors, each of shape (2, 4)
# batch_size=2, feature_dim=4
y0 = (torch.randn(2, 4), torch.randn(2, 4))

# Time grid: strictly increasing
t = torch.linspace(0, 1, 5)

# Create Euler solver instance
ARGS = {
    'func': func,
    'y0': y0,
    'step_size': 0.1,
    'grid_constructor': None,
}
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 Euler — the run constructed an instance of its own class and did not call it; no shape is stated — the instrument coerces any output to an array; for a Euler output the recorded ndim 0 and dtype family float describe that coercion, not the output, and are not 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
Euler Ran
ran on a synthesized input · constructed an object; no result was computed
5yearsKim/HamiltonianFlow/anode/odesolver.py
pointer only (licence: GPL-3.0) · get_code("9406c2abc025c528")
How it ran

The body of this sample is withheld: GPL-3.0, as GitHub detects it on this paper's repository, 5yearsKim/HamiltonianFlow, is not in the permissive set Syntology serves inline. The setup block that called it is withheld with it, because it is written against that body. source_path and origin say where the code lives, to read under the repository's own terms. A run is recorded.

FixedGridODESolver Ran
ran on a synthesized input · constructed an object; no result was computed
xuanqing94/torchdiffeq/torchdiffeq/_impl/odeint.py
code served (permissive licence) · get_code("10f0d6dfa6f48005")
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 an instance of its own class, FixedGridODESolver: the run constructed the object and did not call it, so no result was computed. 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 torch.nn as nn

torch.manual_seed(0)

# Define a simple ODE function that takes (t, y) and returns dy/dt
class SimpleODEFunc(nn.Module):
    def __init__(self):
        super().__init__()
        self.linear = nn.Linear(4, 4)
    
    def forward(self, t, y):
        # y is a tuple of tensors, return tuple of same structure
        return (self.linear(y[0]),)

# Create the function
func = SimpleODEFunc()

# Create initial state y0 as a tuple of tensors
# Using shape (2, 4) for batch_size=2, feature_dim=4
y0 = (torch.randn(2, 4),)

# Create time grid - strictly increasing
t = torch.tensor([0.0, 0.5, 1.0, 1.5, 2.0])

# Define step_size for grid construction
step_size = 0.1

ARGS = {
    'func': func,
    'y0': y0,
    'step_size': step_size,
    'grid_constructor': None,
}
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 FixedGridODESolver — the run constructed an instance of its own class and did not call it; no shape is stated — the instrument coerces any output to an array; for a FixedGridODESolver output the recorded ndim 0 and dtype family float describe that coercion, not the output, and are not 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
IGrid Ran
ran on a synthesized input · constructed an object; no result was computed
TheStageAI/TorchIntegral/torch_integral/model.py
code served (permissive licence) · get_code("62feec9141b4e5c3")
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 an instance of its own class, IGrid: the run constructed the object and did not call it, so no result was computed. 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 torch.nn as nn

torch.manual_seed(0)

# IGrid is a base class that doesn't require any __init__ parameters
# beyond what's inherited from nn.Module
# The forward() method checks self.curr_grid and calls generate_grid() if needed
# The class uses self.curr_grid and self.eval_size attributes

# Since this is a base class with no parameters to __init__,
# ARGS should be an empty dict
ARGS = {}
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 IGrid — the run constructed an instance of its own class and did not call it; no shape is stated — the instrument coerces any output to an array; for a IGrid output the recorded ndim 0 and dtype family float describe that coercion, not the output, and are not 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
MLP Ran
ran on a synthesized input
ipeter50/graph_ode/odegnn.py
code served (permissive licence) · get_code("a963843951a2916d")
How it ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, class construct-then-call prompt, model not recorded) and returned Tensor, ndim 3, dtype family float, shape (2, 5, 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
import torch.nn as nn
import torch.nn.functional as F

class MLP(nn.Module):
    """Two-layer fully-connected ELU net with batch norm."""

    def __init__(self, n_in, n_hid, n_out, do_prob=0.0):
        super(MLP, self).__init__()
        self.fc1 = nn.Linear(n_in, n_hid)
        self.fc2 = nn.Linear(n_hid, n_out)
        self.bn = nn.BatchNorm1d(n_out)
        self.dropout_prob = do_prob
        self.init_weights()

    def init_weights(self):
        for m in self.modules():
            if isinstance(m, nn.Linear):
                nn.init.xavier_normal_(m.weight.data)
                m.bias.data.fill_(0.1)
            elif isinstance(m, nn.BatchNorm1d):
                m.weight.data.fill_(1)
                m.bias.data.zero_()

    def batch_norm(self, inputs):
        x = inputs.view(inputs.size(0) * inputs.size(1), -1)
        x = self.bn(x)
        return x.view(inputs.size(0), inputs.size(1), -1)

    def forward(self, inputs):
        x = F.elu(self.fc1(inputs))
        x = F.dropout(x, self.dropout_prob, training=self.training)
        x = F.elu(self.fc2(x))
        return self.batch_norm(x)


INIT_ARGS = {
    'n_in': 4,
    'n_hid': 8,
    'n_out': 3,
    'do_prob': 0.1,
}

ARGS = {
    'inputs': torch.randn(2, 5, 4),
}

if __name__ == '__main__':
    model = MLP(**INIT_ARGS)
    model.eval()
    output = model(**ARGS)
    print(f"Output shape: {output.shape}")
    print(f"Output: {output}")
Setup block drafted by
a language model, class construct-then-call prompt, model not recorded
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 3, dtype family float, shape (2, 5, 3) — shape (2, 5, 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: torch and numpy seeded to 0 by the harness immediately before the class was constructed from INIT_ARGS (fixture_check.py)
Midpoint Ran
ran on a synthesized input · constructed an object; no result was computed
teopb/ode-net-examples/torchdiffeq/_impl/odeint.py
code served (permissive licence) · get_code("6a98a0fc2403db3c")
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 an instance of its own class, Midpoint: the run constructed the object and did not call it, so no result was computed. 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 torch.nn as nn

torch.manual_seed(0)

# Define a simple ODE function that takes (t, y) and returns dy/dt
class SimpleODEFunc(nn.Module):
    def __init__(self):
        super().__init__()
        self.linear = nn.Linear(4, 4)
    
    def forward(self, t, y):
        # y is a tuple of tensors
        # Return a tuple of the same structure with gradients
        return tuple(self.linear(y_).unsqueeze(0) for y_ in y)

# Create function instance
func = SimpleODEFunc()

# Initial condition: tuple of tensors (batch_size=2, dim=4)
y0 = (torch.randn(2, 4), torch.randn(2, 4))

# Time points (strictly increasing)
t = torch.linspace(0, 1, 5)

ARGS = {
    'func': func,
    'y0': y0,
    'step_size': 0.1,
    'grid_constructor': None,
}
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 Midpoint — the run constructed an instance of its own class and did not call it; no shape is stated — the instrument coerces any output to an array; for a Midpoint output the recorded ndim 0 and dtype family float describe that coercion, not the output, and are not 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
Midpoint Ran
ran on a synthesized input · constructed an object; no result was computed
xuanqing94/torchdiffeq/torchdiffeq/_impl/odeint.py
code served (permissive licence) · get_code("99ec31db7c208dcf")
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 an instance of its own class, Midpoint: the run constructed the object and did not call it, so no result was computed. 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 torch.nn as nn

torch.manual_seed(0)

# Define a simple ODE function that takes (t, y) and returns dy/dt
class SimpleODEFunc(nn.Module):
    def __init__(self):
        super().__init__()
        self.linear = nn.Linear(4, 4)
    
    def forward(self, t, y):
        # y is a tuple of tensors
        # Return a tuple of the same structure with derivatives
        return tuple(self.linear(y_) for y_ in y)

# Create the function
func = SimpleODEFunc()

# Create initial conditions as a tuple of tensors
# Using batch size 2, feature dimension 4
y0 = (torch.randn(2, 4), torch.randn(2, 4))

# Create time points (must be strictly increasing)
t = torch.linspace(0, 1, 5)

# Set up arguments for Midpoint solver
ARGS = {
    'func': func,
    'y0': y0,
    'step_size': 0.1,
    'grid_constructor': None
}
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 Midpoint — the run constructed an instance of its own class and did not call it; no shape is stated — the instrument coerces any output to an array; for a Midpoint output the recorded ndim 0 and dtype family float describe that coercion, not the output, and are not 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
ODEAdjoint Ran
ran on a synthesized input · constructed an object; no result was computed
feicccccccc/Neural-ODE-Ex/NeuralODE.py
code served (permissive licence) · get_code("a932ba75143e9ecb")
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 an instance of its own class, ODEAdjoint: the run constructed the object and did not call it, so no result was computed. 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 torch.nn as nn
import numpy as np
import math

torch.manual_seed(0)

# Create a simple ODEfunc subclass
class SimpleODEFunc(nn.Module):
    def __init__(self, input_dim, hidden_dim):
        super().__init__()
        self.net = nn.Sequential(
            nn.Linear(input_dim, hidden_dim),
            nn.Tanh(),
            nn.Linear(hidden_dim, input_dim)
        )
    
    def forward(self, z, t):
        return self.net(z)
    
    def forward_with_grad(self, z, t, grad_outputs):
        batch_size = z.shape[0]
        out = self.forward(z, t)
        a = grad_outputs
        adfdz, adfdt, *adfdp = torch.autograd.grad(
            (out,), 
            (z, t) + tuple(self.parameters()), 
            grad_outputs=a, 
            allow_unused=True, 
            retain_graph=True
        )
        if adfdp is not None:
            adfdp = torch.cat([p_grad.flatten() for p_grad in adfdp]).unsqueeze(0)
            adfdp = adfdp.expand(batch_size, -1) / batch_size
        if adfdt is not None:
            adfdt = adfdt.expand(batch_size, 1) / batch_size
        return (out, adfdz, adfdt, adfdp)
    
    def flatten_parameters(self):
        p_shapes = []
        flat_parameters = []
        for p in self.parameters():
            p_shapes.append(p.size())
            flat_parameters.append(p.flatten())
        return torch.cat(flat_parameters)

# Create input tensors
batch_size = 2
z_dim = 4
time_steps = 3

z0 = torch.randn(batch_size, z_dim)
t = torch.linspace(0, 1, time_steps).unsqueeze(-1).unsqueeze(-1)

# Create the ODE function
func = SimpleODEFunc(input_dim=z_dim, hidden_dim=8)

# Get flat parameters
flat_parameters = func.flatten_parameters()

# Create gradient tensor for backward
dLdz = torch.randn(time_steps, batch_size, z_dim)

ARGS = {
    "z0": z0,
    "t": t,
    "flat_parameters": flat_parameters,
    "func": func
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
numpy, pydevd, torch — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type ODEAdjoint — the run constructed an instance of its own class and did not call it; no shape is stated — the instrument coerces any output to an array; for a ODEAdjoint output the recorded ndim 0 and dtype family float describe that coercion, not the output, and are not 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
ODEBlock Ran
ran on a synthesized input · constructed an object; no result was computed
kfallah/NODE-Denoiser/models/NODE.py
pointer only (licence: NONE) · get_code("59f408ca8aaaf9f3")
How it ran

The body of this sample is withheld: GitHub detected no licence in this paper's repository, kfallah/NODE-Denoiser when it was checked. The setup block that called it is withheld with it, because it is written against that body. source_path and origin say where the code lives, to read under the repository's own terms. A run is recorded.

ODEBlock Ran
ran on a synthesized input · constructed an object; no result was computed
dungxibo123/neural_ode/utils/model.py
pointer only (licence: NONE) · get_code("92137b4f2c7365e8")
How it ran

The body of this sample is withheld: GitHub detected no licence in this paper's repository, dungxibo123/neural_ode when it was checked. The setup block that called it is withheld with it, because it is written against that body. source_path and origin say where the code lives, to read under the repository's own terms. A run is recorded.

ODENet Ran
ran on a synthesized input · constructed an object; no result was computed
abaietto/neural_ode_classification/models.py
pointer only (licence: NONE) · get_code("6bbb55a0b9a1ee9c")
How it ran

The body of this sample is withheld: GitHub detected no licence in this paper's repository, abaietto/neural_ode_classification when it was checked. The setup block that called it is withheld with it, because it is written against that body. source_path and origin say where the code lives, to read under the repository's own terms. A run is recorded.

ODENet Ran
ran on a synthesized input · constructed an object; no result was computed
boschresearch/numerics_independent_neural_odes/models/models.py
pointer only (licence: AGPL-3.0) · get_code("ce3b538793b44a3f")
How it ran

The body of this sample is withheld: AGPL-3.0, as GitHub detects it on this paper's repository, boschresearch/numerics_independent_neural_odes, is not in the permissive set Syntology serves inline. The setup block that called it is withheld with it, because it is written against that body. source_path and origin say where the code lives, to read under the repository's own terms. A run is recorded.

OdeSolver Ran
ran on a synthesized input · constructed an object; no result was computed
copperwire/neural_ode/src/ode_solvers/solvers.py
pointer only (licence: NONE) · get_code("fd17b14e17a04cc7")
How it ran

The body of this sample is withheld: GitHub detected no licence in this paper's repository, copperwire/neural_ode when it was checked. The setup block that called it is withheld with it, because it is written against that body. source_path and origin say where the code lives, to read under the repository's own terms. A run is recorded.

ParametrizedModel Ran
ran on a synthesized input · constructed an object; no result was computed
TheStageAI/TorchIntegral/torch_integral/model.py
code served (permissive licence) · get_code("6a10221436726b78")
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 an instance of its own class, ParametrizedModel: the run constructed the object and did not call it, so no result was computed. 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 torch.nn as nn
from torch.nn.utils import parametrize

torch.manual_seed(0)

# Create a simple base model
class SimpleModel(nn.Module):
    def __init__(self):
        super().__init__()
        self.linear1 = nn.Linear(4, 3)
        self.linear2 = nn.Linear(3, 2)
    
    def forward(self, x):
        x = self.linear1(x)
        x = self.linear2(x)
        return x

# Create a simple parametrization
class SimpleParametrization(nn.Module):
    def forward(self, x):
        return x * 0.5

# Build the base model
base_model = SimpleModel()

# Add a parametrization to the model
parametrize.register_parametrization(
    base_model.linear1,
    'weight',
    SimpleParametrization(),
    unsafe=True
)

ARGS = {
    'model': base_model
}
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 ParametrizedModel — the run constructed an instance of its own class and did not call it; no shape is stated — the instrument coerces any output to an array; for a ParametrizedModel output the recorded ndim 0 and dtype family float describe that coercion, not the output, and are not 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
PrunableModel Ran
ran on a synthesized input · constructed an object; no result was computed
TheStageAI/TorchIntegral/torch_integral/model.py
code served (permissive licence) · get_code("d8a06e2aaf08a085")
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 an instance of its own class, PrunableModel: the run constructed the object and did not call it, so no result was computed. 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 torch.nn as nn
from torch.nn.utils import parametrize

torch.manual_seed(0)

# Create a simple base model
class SimpleModel(nn.Module):
    def __init__(self):
        super(SimpleModel, self).__init__()
        self.linear1 = nn.Linear(4, 3)
        self.linear2 = nn.Linear(3, 2)
    
    def forward(self, x):
        x = self.linear1(x)
        x = self.linear2(x)
        return x

# Create a simple group/pruning group class
class PruningGroup(nn.Module):
    def __init__(self, name, param_count=10):
        super(PruningGroup, self).__init__()
        self.name = name
        self.param_count = param_count
    
    def forward(self):
        # This is called in forward_groups
        pass
    
    def count_parameters(self):
        return self.param_count
    
    def __call__(self):
        return self.forward()

# Create base model instance
base_model = SimpleModel()

# Create pruning groups with different parameter counts
group1 = PruningGroup("group1", param_count=5)
group2 = PruningGroup("group2", param_count=15)
group3 = PruningGroup("group3", param_count=10)

groups = [group1, group2, group3]

ARGS = {
    'model': base_model,
    'groups': groups
}
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 PrunableModel — the run constructed an instance of its own class and did not call it; no shape is stated — the instrument coerces any output to an array; for a PrunableModel output the recorded ndim 0 and dtype family float describe that coercion, not the output, and are not 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
RK2 Ran
ran on a synthesized input · constructed an object; no result was computed
alexandrejash/Chivvo/anode/odesolver.py
pointer only (licence: GPL-3.0) · get_code("5512b8d472ebad2a")
How it ran

The body of this sample is withheld: GPL-3.0, as GitHub detects it on this paper's repository, alexandrejash/Chivvo, is not in the permissive set Syntology serves inline. The setup block that called it is withheld with it, because it is written against that body. source_path and origin say where the code lives, to read under the repository's own terms. A run is recorded.

RK2 Ran
ran on a synthesized input · constructed an object; no result was computed
5yearsKim/HamiltonianFlow/anode/odesolver.py
pointer only (licence: GPL-3.0) · get_code("33a0d576e23c028f")
How it ran

The body of this sample is withheld: GPL-3.0, as GitHub detects it on this paper's repository, 5yearsKim/HamiltonianFlow, is not in the permissive set Syntology serves inline. The setup block that called it is withheld with it, because it is written against that body. source_path and origin say where the code lives, to read under the repository's own terms. A run is recorded.

RK4 Ran
ran on a synthesized input · constructed an object; no result was computed
teopb/ode-net-examples/torchdiffeq/_impl/odeint.py
code served (permissive licence) · get_code("26fbbe135361b126")
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 an instance of its own class, RK4: the run constructed the object and did not call it, so no result was computed. 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 torch.nn as nn
import warnings
import abc

torch.manual_seed(0)

# Mock rk_common module
class rk_common:
    @staticmethod
    def rk4_alt_step_func(func, t, dt, y):
        # Simple mock implementation that returns a tuple of zero tensors with same shape as y
        return tuple(torch.zeros_like(y_i) for y_i in y)

# Define a simple ODE function
class SimpleODEFunc(nn.Module):
    def __init__(self):
        super(SimpleODEFunc, self).__init__()
        self.linear = nn.Linear(4, 4)
    
    def forward(self, t, y):
        # y is a tuple, convert to tensor for processing
        if isinstance(y, tuple):
            y_tensor = y[0]
        else:
            y_tensor = y
        return (self.linear(y_tensor),)

# Create function instance
func = SimpleODEFunc()

# Create initial state y0 as a tuple of tensors
y0 = (torch.randn(2, 4),)

# Create time grid
t = torch.tensor([0.0, 0.5, 1.0, 1.5, 2.0])

# Construct ARGS dict for RK4.__init__
ARGS = {
    'func': func,
    'y0': y0,
    'step_size': 0.1,
    'grid_constructor': None,
}
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 RK4 — the run constructed an instance of its own class and did not call it; no shape is stated — the instrument coerces any output to an array; for a RK4 output the recorded ndim 0 and dtype family float describe that coercion, not the output, and are not 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 Ran
ran on a synthesized input · constructed an object; no result was computed
alexandrejash/Chivvo/anode/odesolver.py
pointer only (licence: GPL-3.0) · get_code("127c92027e96c4f8")
How it ran

The body of this sample is withheld: GPL-3.0, as GitHub detects it on this paper's repository, alexandrejash/Chivvo, is not in the permissive set Syntology serves inline. The setup block that called it is withheld with it, because it is written against that body. source_path and origin say where the code lives, to read under the repository's own terms. A run is recorded.

RK4 Ran
ran on a synthesized input · constructed an object; no result was computed
xuanqing94/torchdiffeq/torchdiffeq/_impl/odeint.py
code served (permissive licence) · get_code("52750e1480f37d55")
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 an instance of its own class, RK4: the run constructed the object and did not call it, so no result was computed. 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 torch.nn as nn
import warnings
import abc

torch.manual_seed(0)

# Mock rk_common module since RK4 references it
class rk_common:
    @staticmethod
    def rk4_alt_step_func(func, t, dt, y):
        # Simple mock implementation that returns a tuple of zero deltas
        return tuple(torch.zeros_like(y_) for y_ in y)

# Define a simple ODE function
class SimpleODEFunc(nn.Module):
    def __init__(self):
        super().__init__()
        self.linear = nn.Linear(4, 4)
    
    def forward(self, t, y):
        # y is a tuple of tensors
        # Return dy/dt as a tuple
        if isinstance(y, tuple):
            combined = torch.cat(y, dim=-1)
            result = self.linear(combined)
            # Split back into tuple
            return (result,)
        else:
            return (self.linear(y),)

# Create instances
func = SimpleODEFunc()

# y0 should be a tuple of tensors (batch_size=2, features=4)
y0 = (torch.randn(2, 4),)

# Time grid - strictly increasing
t = torch.tensor([0.0, 0.5, 1.0, 1.5, 2.0])

# step_size
step_size = 0.1

# Create the RK4 solver with arguments
ARGS = {
    'func': func,
    'y0': y0,
    'step_size': step_size,
    'grid_constructor': None,
}
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 RK4 — the run constructed an instance of its own class and did not call it; no shape is stated — the instrument coerces any output to an array; for a RK4 output the recorded ndim 0 and dtype family float describe that coercion, not the output, and are not 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 Ran
ran on a synthesized input · constructed an object; no result was computed
5yearsKim/HamiltonianFlow/anode/odesolver.py
pointer only (licence: GPL-3.0) · get_code("1fc91b40082e955e")
How it ran

The body of this sample is withheld: GPL-3.0, as GitHub detects it on this paper's repository, 5yearsKim/HamiltonianFlow, is not in the permissive set Syntology serves inline. The setup block that called it is withheld with it, because it is written against that body. source_path and origin say where the code lives, to read under the repository's own terms. A run is recorded.

Time_Stepper Ran
ran on a synthesized input · constructed an object; no result was computed
alexandrejash/Chivvo/anode/odesolver.py
pointer only (licence: GPL-3.0) · get_code("2c812a9f084716eb")
How it ran

The body of this sample is withheld: GPL-3.0, as GitHub detects it on this paper's repository, alexandrejash/Chivvo, is not in the permissive set Syntology serves inline. The setup block that called it is withheld with it, because it is written against that body. source_path and origin say where the code lives, to read under the repository's own terms. A run is recorded.

Time_Stepper Ran
ran on a synthesized input · constructed an object; no result was computed
5yearsKim/HamiltonianFlow/anode/odesolver.py
pointer only (licence: GPL-3.0) · get_code("78706994d851e4b4")
How it ran

The body of this sample is withheld: GPL-3.0, as GitHub detects it on this paper's repository, 5yearsKim/HamiltonianFlow, is not in the permissive set Syntology serves inline. The setup block that called it is withheld with it, because it is written against that body. source_path and origin say where the code lives, to read under the repository's own terms. A run is recorded.

TrainableGrid1D Ran
ran on a synthesized input · constructed an object; no result was computed
TheStageAI/TorchIntegral/torch_integral/model.py
code served (permissive licence) · get_code("60b35461edf3f214")
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 an instance of its own class, TrainableGrid1D: the run constructed the object and did not call it, so no result was computed. 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 torch.nn as nn

torch.manual_seed(0)

# Parameters for TrainableGrid1D.__init__
size = 5
init_value = torch.linspace(-1, 1, 5)

ARGS = {
    'size': size,
    'init_value': init_value
}
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 TrainableGrid1D — the run constructed an instance of its own class and did not call it; no shape is stated — the instrument coerces any output to an array; for a TrainableGrid1D output the recorded ndim 0 and dtype family float describe that coercion, not the output, and are not 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
Tsit5Solver Ran
ran on a synthesized input · constructed an object; no result was computed
teopb/ode-net-examples/torchdiffeq/_impl/odeint.py
code served (permissive licence) · get_code("a04d5636674a9ec2")
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 an instance of its own class, Tsit5Solver: the run constructed the object and did not call it, so no result was computed. 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 torch.nn as nn

torch.manual_seed(0)

# Define a simple ODE function that takes t and y and returns dy/dt
class SimpleODEFunc(nn.Module):
    def __init__(self):
        super(SimpleODEFunc, self).__init__()
        self.linear = nn.Linear(4, 4)
    
    def forward(self, t, y):
        # y could be a tuple or tensor
        if isinstance(y, tuple):
            return tuple(self.linear(y_i) for y_i in y)
        else:
            return self.linear(y)

# Create the ODE function
func = SimpleODEFunc()

# Create initial state y0 as a tuple of tensors
y0 = (torch.randn(2, 4), torch.randn(2, 4))

# Tolerance parameters
atol = 1e-6
rtol = 1e-5

# Create time points (must be strictly increasing)
t = torch.linspace(0, 1, 5, dtype=torch.float64)

ARGS = {
    'func': func,
    'y0': y0,
    'atol': atol,
    'rtol': rtol,
}
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 Tsit5Solver — the run constructed an instance of its own class and did not call it; no shape is stated — the instrument coerces any output to an array; for a Tsit5Solver output the recorded ndim 0 and dtype family float describe that coercion, not the output, and are not 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
Tsit5Solver Ran
ran on a synthesized input · constructed an object; no result was computed
xuanqing94/torchdiffeq/torchdiffeq/_impl/odeint.py
code served (permissive licence) · get_code("a65d81dc9b13762d")
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 an instance of its own class, Tsit5Solver: the run constructed the object and did not call it, so no result was computed. 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 torch.nn as nn

torch.manual_seed(0)

# Define a simple ODE function that takes (t, y) and returns dy/dt
class SimpleODEFunc(nn.Module):
    def __init__(self):
        super().__init__()
        self.linear = nn.Linear(4, 4)
    
    def forward(self, t, y):
        # y is a tuple of tensors, convert to single tensor for processing
        if isinstance(y, tuple):
            y_tensor = y[0]
        else:
            y_tensor = y
        return (self.linear(y_tensor),)

# Create the function
func = SimpleODEFunc()

# Create initial state y0 as a tuple of tensors (batch_size=2, dim=4)
y0 = (torch.randn(2, 4),)

# Set tolerance parameters
atol = 1e-6
rtol = 1e-3

ARGS = {
    'func': func,
    'y0': y0,
    'atol': atol,
    'rtol': rtol,
}
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 Tsit5Solver — the run constructed an instance of its own class and did not call it; no shape is stated — the instrument coerces any output to an array; for a Tsit5Solver output the recorded ndim 0 and dtype family float describe that coercion, not the output, and are not 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
VariableCoefficientAdamsBashforth Ran
ran on a synthesized input · constructed an object; no result was computed
teopb/ode-net-examples/torchdiffeq/_impl/odeint.py
code served (permissive licence) · get_code("180e9fe199764f78")
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 an instance of its own class, VariableCoefficientAdamsBashforth: the run constructed the object and did not call it, so no result was computed. 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 torch.nn as nn

torch.manual_seed(0)

# Define a simple ODE function that takes (t, y) and returns dy/dt
class SimpleODEFunc(nn.Module):
    def __init__(self):
        super(SimpleODEFunc, self).__init__()
        self.linear = nn.Linear(4, 4)
    
    def forward(self, t, y):
        # y is a tuple of tensors, return tuple of same structure
        if isinstance(y, (tuple, list)):
            return tuple(self.linear(y_i) for y_i in y)
        else:
            return self.linear(y)

# Create ODE function
func = SimpleODEFunc()

# Initial condition - tuple of tensors
y0 = (torch.randn(2, 4), torch.randn(2, 4))

# Tolerances
atol = 1e-6
rtol = 1e-3

# Time points for integration
t = torch.linspace(0, 1, 5, dtype=torch.float64)

ARGS = {
    'func': func,
    'y0': y0,
    'atol': atol,
    'rtol': rtol,
    't': t,
}
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 VariableCoefficientAdamsBashforth — the run constructed an instance of its own class and did not call it; no shape is stated — the instrument coerces any output to an array; for a VariableCoefficientAdamsBashforth output the recorded ndim 0 and dtype family float describe that coercion, not the output, and are not 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
VariableCoefficientAdamsBashforth Ran
ran on a synthesized input · constructed an object; no result was computed
xuanqing94/torchdiffeq/torchdiffeq/_impl/odeint.py
code served (permissive licence) · get_code("0875a31606cadf64")
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 an instance of its own class, VariableCoefficientAdamsBashforth: the run constructed the object and did not call it, so no result was computed. 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 torch.nn as nn
import collections

torch.manual_seed(0)

# Define a simple ODE function
class SimpleODEFunc(nn.Module):
    def __init__(self):
        super(SimpleODEFunc, self).__init__()
        self.linear = nn.Linear(4, 4)
    
    def forward(self, t, y):
        # y is a tuple of tensors
        if isinstance(y, tuple):
            result = tuple(self.linear(y_i) for y_i in y)
        else:
            result = (self.linear(y),)
        return result

# Create test data
func = SimpleODEFunc()

# Initial state y0 as a tuple of tensors (batch_size=2, feature_dim=4)
y0 = (torch.randn(2, 4), torch.randn(2, 4))

# Time points to integrate over
t = torch.linspace(0, 1, 5, dtype=torch.float64)

# Tolerance parameters
atol = 1e-6
rtol = 1e-3

# Build ARGS dictionary
ARGS = {
    'func': func,
    'y0': y0,
    'atol': atol,
    'rtol': rtol,
    't': t,
}
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 VariableCoefficientAdamsBashforth — the run constructed an instance of its own class and did not call it; no shape is stated — the instrument coerces any output to an array; for a VariableCoefficientAdamsBashforth output the recorded ndim 0 and dtype family float describe that coercion, not the output, and are not 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
VelocityField Ran
ran on a synthesized input · constructed an object; no result was computed
tianfr/mononerf/src/model/velocity_field.py
pointer only (licence: NOASSERTION) · get_code("f031bcc19da6d85a")
How it ran

The body of this sample is withheld: GitHub could not classify the licence of this paper's repository, tianfr/mononerf (NOASSERTION). The setup block that called it is withheld with it, because it is written against that body. source_path and origin say where the code lives, to read under the repository's own terms. A run is recorded.

_RungeKuttaState Ran
ran on a synthesized input · constructed an object; no result was computed
teopb/ode-net-examples/torchdiffeq/_impl/odeint.py
code served (permissive licence) · get_code("443bb371b2a31d9b")
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 an instance of its own class, _RungeKuttaState: the run constructed the object and did not call it, so no result was computed. 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 collections

torch.manual_seed(0)

# Create sample tensors with distinct dimensions
# y1: function value at end of last time step
y1 = torch.randn(2, 4)

# f1: derivative at end of last time step
f1 = torch.randn(2, 4)

# t0: scalar float64 tensor, start of last time step
t0 = torch.tensor(0.0, dtype=torch.float64)

# t1: scalar float64 tensor, end of last time step
t1 = torch.tensor(0.1, dtype=torch.float64)

# dt: scalar float64 tensor, size for next time step
dt = torch.tensor(0.05, dtype=torch.float64)

# interp_coeff: list of tensors for polynomial interpolation
# Typically stores coefficients for interpolation between t0 and t1
interp_coeff = [
    torch.randn(2, 4),
    torch.randn(2, 4),
    torch.randn(2, 4),
]

ARGS = {
    'y1': y1,
    'f1': f1,
    't0': t0,
    't1': t1,
    'dt': dt,
    'interp_coeff': interp_coeff,
}
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 _RungeKuttaState — the run constructed an instance of its own class and did not call it; no shape 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
_VCABMState Ran
ran on a synthesized input · constructed an object; no result was computed
teopb/ode-net-examples/torchdiffeq/_impl/odeint.py
code served (permissive licence) · get_code("4b236303800173d5")
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 an instance of its own class, _VCABMState: the run constructed the object and did not call it, so no result was computed. 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 collections

torch.manual_seed(0)

class _VCABMState(collections.namedtuple('_VCABMState', 'y_n, prev_f, prev_t, next_t, phi, order')):
    """Saved state of the variable step size Adams-Bashforth-Moulton solver as described in

        Solving Ordinary Differential Equations I - Nonstiff Problems III.5
        by Ernst Hairer, Gerhard Wanner, and Syvert P Norsett.
    """
    pass

# Construct arguments for _VCABMState
ARGS = {
    'y_n': torch.randn(2, 4),  # batch_size=2, state_dim=4
    'prev_f': torch.randn(2, 4),  # previous function evaluation
    'prev_t': torch.tensor(0.0),  # previous time step
    'next_t': torch.tensor(0.1),  # next time step
    'phi': [torch.randn(2, 4) for _ in range(3)],  # list of phi coefficients for Adams-Bashforth-Moulton
    'order': 2  # integration order
}
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 _VCABMState — the run constructed an instance of its own class and did not call it; no shape 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
_check_inputs Ran
ran; the contract check could not run (RAISES, DEP_MISSING or TIMEOUT)
teopb/ode-net-examples/torchdiffeq/_impl/odeint.py
code served (permissive licence) · get_code("ea3c58d4e24eebb6")
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

torch.manual_seed(0)

def dummy_func(t, y):
    """A simple ODE function that returns dy/dt"""
    if isinstance(y, tuple):
        return tuple(torch.zeros_like(y_) for y_ in y)
    else:
        return torch.zeros_like(y)

# Create initial state as a tensor
y0_tensor = torch.randn(2, 4, dtype=torch.float32)

# Create time points (increasing, so no reversal needed)
t = torch.linspace(0, 1, 5, dtype=torch.float32)

ARGS = {
    'func': dummy_func,
    'y0': y0_tensor,
    't': t
}
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
_check_inputs Ran
ran; the contract check could not run (RAISES, DEP_MISSING or TIMEOUT)
xuanqing94/torchdiffeq/torchdiffeq/_impl/odeint.py
code served (permissive licence) · get_code("2224684f11a7a3c9")
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

torch.manual_seed(0)

# Define a simple ODE function that takes (t, y) and returns dy/dt
def ode_func(t, y):
    # y is a tensor, return its negative (simple decay)
    return -y

# Create initial condition as a single tensor
y0_tensor = torch.randn(2, 4, dtype=torch.float32)

# Create time points (increasing order, small values)
t = torch.tensor([0.0, 0.1, 0.2, 0.3], dtype=torch.float32)

ARGS = {
    "func": ode_func,
    "y0": y0_tensor,
    "t": t
}
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
_compute_error_ratio Ran
ran; our contract draft was wrong, not the code
teopb/ode-net-examples/torchdiffeq/_impl/odeint.py
code served (permissive licence) · get_code("8b87a183c9dbf249")
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

torch.manual_seed(0)

# Create small tensors for y0 and y1
y0 = [torch.randn(2, 4), torch.randn(2, 4)]
y1 = [torch.randn(2, 4), torch.randn(2, 4)]

# Create error_estimate as a tuple of tensors
error_estimate = (torch.randn(2, 4), torch.randn(2, 4))

# Create rtol and atol - can be scalars or iterables
rtol = [0.1, 0.1]
atol = [1e-3, 1e-3]

ARGS = {
    "error_estimate": error_estimate,
    "error_tol": None,
    "rtol": rtol,
    "atol": atol,
    "y0": y0,
    "y1": y1,
}
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, 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
_convert_to_tensor Ran
ran; our contract draft was wrong, not the code
teopb/ode-net-examples/torchdiffeq/_impl/odeint.py
code served (permissive licence) · get_code("baa65f15f31a9777")
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 (4,) 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)

ARGS = {
    "a": [1.0, 2.0, 3.0, 4.0],
    "dtype": torch.float32,
    "device": torch.device("cpu")
}
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 1, dtype family float, shape (4,) — shape (4,) 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
_decreasing Ran
ran, violated the contract we drafted
teopb/ode-net-examples/torchdiffeq/_impl/odeint.py
code served (permissive licence) · get_code("ec95d60f4289b25e")
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 0, dtype family float, shape () 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)

# The function _decreasing takes parameter 't' and checks if each element
# is strictly less than the previous element (i.e., the sequence is decreasing)
# It uses indexing t[1:] and t[:-1], and calls .all() on a boolean tensor
# So 't' should be a torch tensor

# Create a decreasing tensor
t = torch.tensor([5.0, 4.0, 3.0, 2.0, 1.0])

ARGS = {
    "t": t
}
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 0, dtype family float, shape () — shape () 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
_decreasing Ran
ran; the contract check could not run (RAISES, DEP_MISSING or TIMEOUT)
xuanqing94/torchdiffeq/torchdiffeq/_impl/odeint.py
code served (permissive licence) · get_code("aef26a4386aa599b")
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 bool, ndim 0, dtype family float, shape () 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)

# The function _decreasing takes a parameter t and calls .item() on t[1] and t[0]
# This means t should be indexable and contain elements with .item() methods
# Tensors satisfy this requirement

t = torch.tensor([5.0, 3.0])

ARGS = {
    "t": t
}
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 bool, ndim 0, dtype family float, shape () — shape () 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
_has_converged Ran
ran, violated the contract we drafted
teopb/ode-net-examples/torchdiffeq/_impl/odeint.py
code served (permissive licence) · get_code("80aaab169a92f738")
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 bool, ndim 0, dtype family float, shape () 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)

# The function expects:
# - y0: an iterable of tensors
# - y1: an iterable of tensors (same length as y0)
# - rtol: a float (relative tolerance)
# - atol: a float (absolute tolerance)

# Create small tensors with distinct shapes to probe dimensions
y0_tensor1 = torch.randn(2, 4)
y0_tensor2 = torch.randn(3, 5)

y1_tensor1 = y0_tensor1 + torch.randn(2, 4) * 0.01  # Small perturbation
y1_tensor2 = y0_tensor2 + torch.randn(3, 5) * 0.01  # Small perturbation

ARGS = {
    "y0": [y0_tensor1, y0_tensor2],
    "y1": [y1_tensor1, y1_tensor2],
    "rtol": 0.1,
    "atol": 0.01
}
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 bool, ndim 0, dtype family float, shape () — shape () 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
_interp_coeff_tsit5 Ran
ran, honoured the contract we drafted
teopb/ode-net-examples/torchdiffeq/_impl/odeint.py
code served (permissive licence) · get_code("a80bde1c9ec425d6")
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 torch
import numpy as np

# Define arguments for _interp_coeff_tsit5
# The function takes three scalar arguments: t0, dt, and eval_t
# These are used to compute normalized time t and then interpolation coefficients

t0 = 0.0
dt = 0.1
eval_t = 0.05

ARGS = {
    "t0": t0,
    "dt": dt,
    "eval_t": eval_t,
}
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 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
_interp_eval_tsit5 Ran
ran; our contract draft was wrong, not the code
teopb/ode-net-examples/torchdiffeq/_impl/odeint.py
code served (permissive licence) · get_code("69c9ce066153b90b")
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 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 torch

torch.manual_seed(0)

# Analyzing _interp_eval_tsit5:
# - t0: float, time at start
# - t1: float, time at end
# - k: tuple of tuples, where each inner tuple contains tensors (k_[0] is accessed)
# - eval_t: float, evaluation time
# 
# The function:
# 1. Computes dt = t1 - t0
# 2. Extracts y0 from k (first element of each inner tuple)
# 3. Calls _interp_coeff_tsit5 which does arithmetic on floats
# 4. Calls _scaled_dot_product with dt (scale), interp_coeff list, and k_ (tuple from k)
# 5. _scaled_dot_product multiplies scale * x * y for pairs from two lists
#    where x comes from interp_coeff (floats) and y comes from k_ (tuples of tensors)

# Create small tensors for the state vectors
# k should be a tuple of tuples, where each inner tuple represents derivatives/coefficients
# For a system with 2 state variables, we'd have k with 2 inner tuples
# Each inner tuple should have multiple elements (k_[0] is accessed, and then k_ is zipped with interp_coeff)

# Let's create a setup with 2 state dimensions
state_dim = 2
tensor_dim = 4

# Create k as a tuple of tuples
# Each inner tuple has 7 elements (one for each b1-b7 coefficient)
k_tuple_1 = tuple(torch.randn(tensor_dim) for _ in range(7))
k_tuple_2 = tuple(torch.randn(tensor_dim) for _ in range(7))
k = (k_tuple_1, k_tuple_2)

# Time parameters
t0 = 0.0
t1 = 1.0
eval_t = 0.5

ARGS = {
    "t0": t0,
    "t1": t1,
    "k": k,
    "eval_t": eval_t,
}
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, ndim 2, 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
_is_finite Ran
ran; our contract draft was wrong, not the code
teopb/ode-net-examples/torchdiffeq/_impl/odeint.py
code served (permissive licence) · get_code("443e9b25ad3ae079")
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 bool, ndim 0, dtype family float, shape () 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)

# The function _is_finite checks if a tensor contains any inf or nan values
# It takes a single parameter: tensor
# We need to construct a valid tensor argument

# Create a small tensor with finite values
tensor = torch.randn(2, 4)

ARGS = {
    "tensor": tensor
}
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 bool, ndim 0, dtype family float, shape () — shape () 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
_is_iterable Ran
ran, violated the contract we drafted
teopb/ode-net-examples/torchdiffeq/_impl/odeint.py
code served (permissive licence) · get_code("9d72df2efb3a66fe")
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 bool, ndim 0, dtype family float, shape () 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)

# Test case 1: list (iterable)
inputs_list = [1, 2, 3, 4]

# Test case 2: string (iterable)
inputs_string = "hello"

# Test case 3: tensor (iterable)
inputs_tensor = torch.randn(2, 4)

# Test case 4: dict (iterable)
inputs_dict = {"a": 1, "b": 2}

# Test case 5: tuple (iterable)
inputs_tuple = (1, 2, 3)

# Test case 6: range (iterable)
inputs_range = range(5)

# Test case 7: int (not iterable)
inputs_int = 42

# Test case 8: float (not iterable)
inputs_float = 3.14

# Test case 9: None (not iterable)
inputs_none = None

# We'll use one representative case for the ARGS
# The function takes 'inputs' as its only parameter
ARGS = {
    "inputs": [1, 2, 3, 4]
}
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 bool, ndim 0, dtype family float, shape () — shape () 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
_norm Ran
ran; our contract draft was wrong, not the code
teopb/ode-net-examples/torchdiffeq/_impl/odeint.py
code served (permissive licence) · get_code("c3ee29e30b47fb06")
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 0, dtype family float, shape () 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)

# Test case 1: single tensor
x_tensor = torch.randn(2, 4)

# Test case 2: list of tensors
x_list = [torch.randn(2, 4), torch.randn(3, 5)]

# We'll use the tensor case for ARGS
ARGS = {
    "x": x_tensor
}
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 0, dtype family float, shape () — shape () 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
_possibly_nonzero Ran
ran, violated the contract we drafted
teopb/ode-net-examples/torchdiffeq/_impl/odeint.py
code served (permissive licence) · get_code("285104682369ab82")
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 bool, ndim 0, dtype family float, shape () 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)

ARGS = {
    "x": torch.tensor([1.0, 2.0, 3.0, 4.0])
}
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 bool, ndim 0, dtype family float, shape () — shape () 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
_runge_kutta_step Ran
ran; our contract draft was wrong, not the code
teopb/ode-net-examples/torchdiffeq/_impl/odeint.py
code served (permissive licence) · get_code("2a9f0b547af9d443")
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

torch.manual_seed(0)

# Define a minimal Butcher tableau class with required attributes
class ButcherTableau:
    def __init__(self):
        self.alpha = [0.0, 0.5, 1.0]  # Stage time coefficients
        self.beta = [
            [],  # First stage (empty, no previous stages)
            [0.5],  # Second stage
            [0.0, 1.0]  # Third stage
        ]
        self.c_sol = [1/6, 2/3, 1/6]  # Solution weights
        self.c_error = [1/6 - 1/8, 2/3 - 1/3, 1/6 - 1/24]  # Error weights

# Define a simple function that takes (t, y) and returns derivatives
def simple_func(t, y):
    """Returns time derivatives for each component in y."""
    # y is a tuple of tensors, return same structure
    return tuple(torch.ones_like(y_i) for y_i in y)

# Create initial state y0 as a tuple of tensors (batch_size=2, feature_dim=4)
y0 = (
    torch.randn(2, 4),
    torch.randn(2, 4)
)

# Create initial derivative f0 (same shape as y0)
f0 = (
    torch.randn(2, 4),
    torch.randn(2, 4)
)

# Create time parameters
t0 = torch.tensor(0.0, dtype=torch.float64)
dt = torch.tensor(0.1, dtype=torch.float64)

# Create tableau
tableau = ButcherTableau()

ARGS = {
    "func": simple_func,
    "y0": y0,
    "f0": f0,
    "t0": t0,
    "dt": dt,
    "tableau": tableau
}
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
_scaled_dot_product Ran
ran on a synthesized input
teopb/ode-net-examples/torchdiffeq/_impl/odeint.py
code served (permissive licence) · get_code("de5906cda333c484")
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, 4) 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)

# The function takes:
# - scale: a scalar multiplier
# - xs: a list of tensors (or values)
# - ys: a list of tensors (or values)

# From the function body, we see:
# - scale is multiplied with tensors
# - xs and ys are zipped together
# - each x and y can be a Tensor or a number (0)
# - _possibly_nonzero checks if something is a Tensor or != 0

scale = 2.5

xs = [
    torch.randn(2, 4),
    torch.randn(2, 4),
    0,  # zero value to test _possibly_nonzero filtering
]

ys = [
    torch.randn(2, 4),
    torch.randn(2, 4),
    torch.randn(2, 4),
]

ARGS = {
    "scale": scale,
    "xs": xs,
    "ys": ys,
}
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, 4) — shape (2, 4) 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

Showing the first 60. An agent gets every one from get_harvested_code_for_paper("1806.07366").

Also present in other papers' code

Of 124 samples lifted from this paper's linked repositories, 124 carry a function identity and 0 do not. Of the 108 distinct functions with an identity, 13 are also present in other papers whose code we hold (5 with at least one paper dated earlier, 0 the same month, 12 later) and 95 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
default_conv 57 other papers
3 dated earlier, 54 later · 2 only as an assembly brick
1707.02921 (2017-07)
Enhanced Deep Residual Networks for Single Image Super-Resolution
1803.02735 (2018-03)
Deep Back-Projection Networks For Super-Resolution
1803.04626 (2018-03)
Maintaining Natural Image Statistics with the Contextual Loss
and 54 more not named here
logsumexp_2d 13 other papers
13 later
1807.06521 (2018-07)
CBAM: Convolutional Block Attention Module
1810.12348 (2018-10)
Gather-Excite: Exploiting Feature Context in Convolutional Neural Networks
and 10 more not named here
quantize 12 other papers
2 dated earlier, 10 later
1803.02735 (2018-03)
Deep Back-Projection Networks For Super-Resolution
1803.04626 (2018-03)
Maintaining Natural Image Statistics with the Contextual Loss
1906.12021 (2019-06)
Densely Residual Laplacian Super-Resolution
and 9 more not named here
calc_psnr 2 other papers
1 dated earlier, 1 later
1803.02735 (2018-03)
Deep Back-Projection Networks For Super-Resolution
2402.15704 (2024-02)
Adaptive Convolutional Neural Network for Image Super-resolution
projection_conv 2 other papers
1 dated earlier, 1 later
1803.02735 (2018-03)
Deep Back-Projection Networks For Super-Resolution
2004.13824 (2020-04)
Pyramid Attention Networks for Image Restoration
rk4_alt_step_func 2 other papers
2 later
1905.10403 (2019-05)
Neural Jump Stochastic Differential Equations
2003.00868 (2020-03)
Differentiable Molecular Simulations for Control and Learning
compute_implicit_phi
brick of this paper's assembly: helper
1 other paper
1 later
1905.10403 (2019-05)
Neural Jump Stochastic Differential Equations
g_and_explicit_phi
brick of this paper's assembly: helper
1 other paper
1 later
1905.10403 (2019-05)
Neural Jump Stochastic Differential Equations
linear
brick of this paper's assembly: helper
1 other paper
1 dated earlier
1803.03067 (2018-03)
Compositional Attention Networks for Machine Reasoning
ode_solve
brick of this paper's assembly: helper
1 other paper
1 later
1901.05761 (2019-01)
Attentive Neural Processes
odeint_adjoint 1 other paper
1 later
1905.10403 (2019-05)
Neural Jump Stochastic Differential Equations
odesolver
brick of this paper's assembly: entry
1 other paper
1 later
1902.10298 (2019-02)
ANODE: Unconditionally Accurate Memory-Efficient Gradients for Neural ODEs
rk4_step_func 1 other paper
1 later
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

More are linked than shown here.

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

Abstract

We introduce a new family of deep neural network models. Instead of specifying a discrete sequence of hidden layers, we parameterize the derivative of the hidden state using a neural network. The output of the network is computed using a blackbox differential equation solver. These continuous-depth models have constant memory cost, adapt their evaluation strategy to each input, and can explicitly trade numerical precision for speed. We demonstrate these properties in continuous-depth residual networks and continuous-time latent variable models. We also construct continuous normalizing flows, a generative model that can train by maximum likelihood, without partitioning or ordering the data dimensions. For training, we show how to scalably backpropagate through any ODE solver, without access to its internal operations. This allows end-to-end training of ODEs within larger models.

For agents

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

get_harvested_code_for_paper("1806.07366")
get_code_for_paper("1806.07366")
have("1806.07366")

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

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

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

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

Connect an agent — have() is free.