SYNTOLOGY HomeExplorerAtlasCodeMethodologyAboutDevelopersFeedPricing
Paper · 2006.02250 · 2020

dynoNet: a neural network architecture for learning dynamical systems

arXiv · PDF · Open in the Atlas

Code that ran

18 of 19 samples (functions and classes) lifted from this paper's linked repositories executed on a synthesized input in Syntology's jail (0 of them constructed an object rather than computing a result; 0 honoured the contract we drafted, 0 violated it and 18 have no contract verdict; 0 failures of our instrument; 1 no recorded run), measured 2026-11-22; 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/2006.02250.json · badge: /api/ran/2006.02250.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
forgi86/dynonet canonical (classifier label)
classifier basis: census
7 ran · 0 no recorded run
forgi86/rnn-adaptation community (classifier label)
classifier basis not recorded on the link
11 ran · 1 no recorded run
FunctionStatusWhere it lives
angle_between_points Ran
ran on a synthesized input
forgi86/rnn-adaptation/worlds/anglecalc2.py
code served (permissive licence) · get_code("26b80952ee33e134")
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 float, 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 math

DEGREES_360 = 2 * math.pi

def fix_angular_value(angle):
    while angle >= DEGREES_360:
        angle -= DEGREES_360
    while angle < 0:
        angle += DEGREES_360
    return angle

def atanxy(x, y):
    return math.atan2(y, x)

def angle_between_points(source_point, target_point):
    source_x, source_y = source_point
    target_x, target_y = target_point
    dx = target_x - source_x
    dy = target_y - source_y
    return fix_angular_value(atanxy(dx, dy))

# Setup valid arguments
source_point = (1.0, 2.0)
target_point = (4.0, 6.0)

ARGS = {
    "source_point": source_point,
    "target_point": target_point
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
none outside the standard library — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type float, 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
atanxy Ran
ran on a synthesized input
forgi86/rnn-adaptation/worlds/anglecalc2.py
code served (permissive licence) · get_code("380f932345a21f50")
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 float, 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 math

ARGS = {
    "x": 3.0,
    "y": 4.0,
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
none outside the standard library — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type float, 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
dkf Ran
ran on a synthesized input
forgi86/rnn-adaptation/worlds/worlds.py
code served (permissive licence) · get_code("1e0a64d14bc2f4bf")
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 numpy as np
import scipy.linalg

# Construct valid arguments for dkf function
# The function performs discrete algebraic Riccati equation solving and Kalman filtering

# Create a discrete-time system: A is the state transition matrix (n x n)
n = 4  # state dimension
A = np.array([
    [0.9, 0.1, 0.0, 0.0],
    [0.0, 0.8, 0.1, 0.0],
    [0.0, 0.0, 0.7, 0.1],
    [0.0, 0.0, 0.0, 0.6]
], dtype=float)

# C is the measurement matrix (m x n), where m is measurement dimension
m = 3  # measurement dimension (distinct from n)
C = np.array([
    [1.0, 0.5, 0.0, 0.0],
    [0.0, 1.0, 0.5, 0.0],
    [0.0, 0.0, 1.0, 0.5]
], dtype=float)

# Q is the process noise covariance (n x n)
Q = np.eye(n, dtype=float)

# R is the measurement noise covariance (m x m)
R = np.eye(m, dtype=float)

ARGS = {
    "A": A,
    "C": C,
    "Q": Q,
    "R": R
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
numpy, scipy — 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
dlqr Ran
ran on a synthesized input
forgi86/rnn-adaptation/worlds/worlds.py
code served (permissive licence) · get_code("7793f905be22ce49")
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 numpy as np
import scipy

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

# Define small matrices for a discrete LQR problem
# State dimension: 3, Control dimension: 2
# x[k+1] = A x[k] + B u[k]

# State transition matrix (3x3)
A = np.array([[1.1, 0.1, 0.0],
              [0.0, 0.9, 0.2],
              [0.1, 0.0, 1.0]], dtype=float)

# Control input matrix (3x2)
B = np.array([[1.0, 0.0],
              [0.5, 1.0],
              [0.0, 0.5]], dtype=float)

# State cost matrix (3x3) - positive definite
Q = np.array([[1.0, 0.0, 0.0],
              [0.0, 1.0, 0.0],
              [0.0, 0.0, 1.0]], dtype=float)

# Control cost matrix (2x2) - positive definite
R = np.array([[0.1, 0.0],
              [0.0, 0.1]], dtype=float)

ARGS = {
    "A": A,
    "B": B,
    "Q": Q,
    "R": R
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
numpy, scipy — 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
error_mean Ran
ran on a synthesized input
forgi86/dynonet/src/dynonet/metrics.py
code served (permissive licence) · get_code("95b9ba9c82e2d714")
How it ran

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

import numpy as np

# Create small numpy arrays for testing
np.random.seed(0)

# y_true: 2D array with shape (time_steps, channels)
# time_axis=0 means we compute mean across time for each channel
y_true = np.random.randn(5, 3)  # 5 time steps, 3 channels

# y_pred: must be compatible with y_true (same shape)
y_pred = np.random.randn(5, 3)

# time_axis: which axis represents time
time_axis = 0

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

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

import numpy as np

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

# Create small sample arrays
# y_true and y_pred must be at least 2D
# Using shape (time_steps=5, channels=3) with time_axis=0
y_true = np.random.randn(5, 3).astype(np.float32)
y_pred = y_true + np.random.randn(5, 3) * 0.1  # Add small noise

time_axis = 0

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

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

import numpy as np

# Create simple test data
np.random.seed(0)

# y_true and y_pred need to be at least 2D
# Using shape (5, 3) - 5 time steps, 3 channels
y_true = np.random.randn(5, 3).astype(np.float32)
y_pred = np.random.randn(5, 3).astype(np.float32)

# time_axis specifies which axis represents time (default 0)
time_axis = 0

ARGS = {
    'y_true': y_true,
    'y_pred': y_pred,
    'time_axis': time_axis
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
numpy — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type ndarray, ndim 1, dtype family float, shape (3,) — shape (3,) as a later run recorded it
dtype family
int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
extract_weights Ran
ran on a synthesized input
forgi86/rnn-adaptation/diffutil/jacobian.py
code served (permissive licence) · get_code("40cb6c0947e35170")
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
from torch import nn, Tensor
from typing import List, Tuple, Dict, Union, Callable

torch.manual_seed(0)

# Create a simple nn.Module with some parameters
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

mod = SimpleModel()

ARGS = {
    "mod": mod
}
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
fix_angular_value Ran
ran on a synthesized input
forgi86/rnn-adaptation/worlds/anglecalc2.py
code served (permissive licence) · get_code("c17836fe2e4d4cfc")
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 float, 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 math

DEGREES_360 = 2 * math.pi

def fix_angular_value(angle):
    while angle >= DEGREES_360:
        angle -= DEGREES_360
    while angle < 0:
        angle += DEGREES_360
    return angle

# Test cases with various angle values
ARGS = {
    "angle": 8.5  # A value greater than 2π (approximately 6.28), will be normalized
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
none outside the standard library — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type float, 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
istuple Ran
ran on a synthesized input
forgi86/dynonet/test_code/linearsiso_module_example.py
code served (permissive licence) · get_code("8a7aa318d132c7d4")
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
import torch.nn as nn

torch.manual_seed(0)

# Test case 1: Regular Python tuple
obj1 = (1, 2, 3)

# Test case 2: torch.return_types object
# Create a return_types object by using a torch function that returns one
obj2 = torch.max(torch.tensor([1.0, 2.0, 3.0]), dim=0)

# Test case 3: Non-tuple object for contrast
obj3 = [1, 2, 3]

ARGS = {
    "obj": obj1
}
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
jvp_diff Ran
ran on a synthesized input
forgi86/rnn-adaptation/diffutil/products.py
code served (permissive licence) · get_code("e4c9550af0b40a6e")
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)

# Create a simple computational graph where:
# y = f(x) for some differentiable function
# We need y, x, and v (a tangent vector)

# x: input tensor - small, 2D for simplicity
x = torch.tensor([[1.0, 2.0, 3.0, 4.0],
                   [5.0, 6.0, 7.0, 8.0]], requires_grad=True)

# Define a simple function: y = x^2 (element-wise)
y = x ** 2

# v: tangent vector with same shape as y
v = torch.tensor([[1.0, 0.0, 0.0, 0.0],
                   [0.0, 1.0, 0.0, 0.0]], requires_grad=True)

ARGS = {
    "y": y,
    "x": x,
    "v": v,
}
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
lfilter_mimo_channels_first Ran
ran on a synthesized input
forgi86/dynonet/src/dynonet/filtering.py
code served (permissive licence) · get_code("e153a6af140a7af3")
How it ran

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

import numpy as np
import scipy.signal

# Parameters for lfilter_mimo_channels_first
batch_size = 2
in_ch = 3
out_ch = 4
seq_len = 5
filter_len = 2

# Create filter coefficients b and a
# b shape: (out_ch, in_ch, filter_len)
# a shape: (out_ch, in_ch, filter_len)
b = np.random.randn(out_ch, in_ch, filter_len).astype(np.float32)
a = np.random.randn(out_ch, in_ch, filter_len).astype(np.float32)
a[:, :, 0] = 1.0  # Ensure first coefficient is non-zero for stability

# Create input signal u_in
# u_in shape: (batch_size, in_ch, seq_len)
u_in = np.random.randn(batch_size, in_ch, seq_len).astype(np.float32)

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

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

import numpy as np
import scipy.signal

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

# Define dimensions
batch_size = 2
in_ch = 3
out_ch = 4
seq_len = 5
filter_order = 2

# Create b coefficients: shape (out_ch, in_ch, filter_order)
b = np.random.randn(out_ch, in_ch, filter_order).astype(np.float64)

# Create a coefficients: shape (out_ch, in_ch, filter_order)
# Make sure a is not all zeros to avoid division issues
a = np.random.randn(out_ch, in_ch, filter_order).astype(np.float64)
a = a + 1.0  # Ensure non-zero values

# Create input signal: shape (batch_size, in_ch, seq_len)
u_in = np.random.randn(batch_size, in_ch, seq_len).astype(np.float64)

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

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

import numpy as np

# Small test case for lfiltic_vec
# The function processes batches of initial conditions for IIR filters

# Create filter coefficients (simple 2nd order filter)
b = np.array([1.0, 0.5, 0.25])  # numerator coefficients, length 3
a = np.array([1.0, -0.3, 0.1])  # denominator coefficients, length 3

# Create batch of initial output conditions
# Batch size = 2, needs at least N=len(a)-1=2 values per batch
y = np.array([[1.0, 0.5, 0.2],
              [0.3, 0.4, 0.1]], dtype=np.float64)

# Create batch of initial input conditions (optional)
# Batch size = 2, M=len(b)-1=2 values per batch
x = np.array([[2.0, 1.0],
              [0.5, 1.5]], dtype=np.float64)

ARGS = {
    'b': b,
    'a': a,
    'y': y,
    'x': x,
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
numpy — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type ndarray, ndim 2, dtype family float, shape (2, 2) — shape (2, 2) as a later run recorded it
dtype family
int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
parameter_jacobian Ran
ran on a synthesized input
forgi86/rnn-adaptation/diffutil/jacobian.py
code served (permissive licence) · get_code("cd0cf8e1e78444fa")
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, 201) 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
from torch import nn

torch.manual_seed(0)

# Create a simple model with nested parameters
class SimpleModel(nn.Module):
    def __init__(self):
        super().__init__()
        self.input_size = 4
        self.linear1 = nn.Linear(4, 8)
        self.linear2 = nn.Linear(8, 3)
    
    def forward(self, x):
        x = self.linear1(x)
        x = torch.relu(x)
        x = self.linear2(x)
        return x

# Create model instance
model = SimpleModel()

# Create 2D input: batch_size=2, input_dim=4
input_2d = torch.randn(2, 4)

# Create 3D input: batch_size=2, seq_len=3, input_dim=4
input_3d = torch.randn(2, 3, 4)

ARGS = {
    'model': model,
    'input': input_2d,
    'vectorize': True,
    'flatten': True,
}
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, 201) — shape (2, 201) 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
r_squared Ran
ran on a synthesized input
forgi86/dynonet/src/dynonet/metrics.py
code served (permissive licence) · get_code("29d31ec5ffa18d2c")
How it ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned ndarray, ndim 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 numpy as np

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

# Create small test arrays
# y_true: shape (10, 4) - 10 time steps, 4 channels
y_true = np.random.randn(10, 4)

# y_pred: same shape as y_true
y_pred = y_true + np.random.randn(10, 4) * 0.1

# time_axis: which axis represents time
time_axis = 0

ARGS = {
    "y_true": y_true,
    "y_pred": y_pred,
    "time_axis": time_axis,
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
numpy — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type ndarray, ndim 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
solve Ran
ran on a synthesized input
forgi86/rnn-adaptation/worlds/worlds.py
code served (permissive licence) · get_code("0e8cbe19b00bf520")
How it ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned ndarray, ndim 2, dtype family float, shape (1, 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 numpy as np
import scipy
from functools import partial

torch = None  # Not needed for this function

# Define a simple function that acts as the ODE system
def ode_function(t, state, input_value=None):
    """Simple ODE: dy/dt = -y + input_value"""
    return -state + input_value

# Create initial state - should be a list/array where [0] is the initial condition
# The function expects initial_state[0] to be passed to solve_ivp
initial_state = [np.array([1.0, 2.0, 3.0, 4.0])]

# Create input value - will be passed to the ODE function
input_value = np.array([0.5, 0.5, 0.5, 0.5])

# Time step
dt = 0.001

ARGS = {
    "f": ode_function,
    "initial_state": initial_state,
    "input_value": input_value,
    "dt": dt
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
numpy, scipy — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type ndarray, ndim 2, dtype family float, shape (1, 4) — shape (1, 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
vjp Ran
ran on a synthesized input
forgi86/rnn-adaptation/diffutil/products.py
code served (permissive licence) · get_code("8fa24d073ea3ade3")
How it ran

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

import torch

torch.manual_seed(0)

# Create a simple function that we'll differentiate
# Let's say y = x^2, so dy/dx = 2x
x = torch.tensor([[1.0, 2.0, 3.0, 4.0],
                   [5.0, 6.0, 7.0, 8.0]], requires_grad=True)

# Compute y = x^2 (element-wise)
y = x ** 2

# Create a vector v with same shape as y for the vjp
v = torch.ones_like(y)

ARGS = {
    "y": y,
    "x": x,
    "v": v
}
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 3, dtype family float — a tuple output has no array shape of its own; none is stated
dtype family
int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
jvp Not yet run
unverified (harvested, no recorded run)
forgi86/rnn-adaptation/diffutil/products.py
code served (permissive licence) · get_code("50a5b17ae068ea4e")
How it ran

no invocation recorded.

Also present in other papers' code

Of 19 samples lifted from this paper's linked repositories, 19 carry a function identity and 0 do not. Of the 19 distinct functions with an identity, 1 are also present in other papers whose code we hold (0 with at least one paper dated earlier, 1 the same month, 0 later) and 18 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
error_rmse 1 other paper
1 the same month
2006.02915 (2020-06)
Continuous-time system identification with neural networks: Model structures and fitting criteria

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

Repositories linked to this paper

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

Abstract

This paper introduces a network architecture, called dynoNet, utilizing linear dynamical operators as elementary building blocks. Owing to the dynamical nature of these blocks, dynoNet networks are tailored for sequence modeling and system identification purposes. The back-propagation behavior of the linear dynamical operator with respect to both its parameters and its input sequence is defined. This enables end-to-end training of structured networks containing linear dynamical operators and other differentiable units, exploiting existing deep learning software. Examples show the effectiveness of the proposed approach on well-known system identification benchmarks. Examples show the effectiveness of the proposed approach against well-known system identification benchmarks.

For agents

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

get_harvested_code_for_paper("2006.02250")
get_code_for_paper("2006.02250")
have("2006.02250")

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

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

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

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

Connect an agent — have() is free.