SYNTOLOGY HomeExplorerAtlasCodeMethodologyAboutDevelopersFeedPricing
Paper · 2302.02004 · NeurIPS · 2023

Sharp Spectral Rates for Koopman Operator Learning

Massimiliano Pontil, Pietro Novelli, Vladimir Kostic, Karim Lounici

arXiv · PDF · Open in the Atlas

Code that ran

15 of 16 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 15 have no contract verdict; 0 failures of our instrument; 1 no recorded run), measured 2026-11-21; repository links from the Papers with Code archive attributed under CC BY-SA, no affiliation; bodies inline only under a permissive licence as GitHub detects it. Not a reproduction of the paper's results.

"Ran" means the function executed on a synthesized input and returned a value. It is not a reproduction of the paper's results. This record, dated, as JSON: /api/ran/2302.02004.json · badge: /api/ran/2302.02004.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
Machine-Learning-Dynamical-Systems/kooplearn canonical (classifier label)
classifier basis not recorded on the link
15 ran · 1 no recorded run
FunctionStatusWhere it lives
assemble_operators_1d Ran
ran on a synthesized input
Machine-Learning-Dynamical-Systems/kooplearn/src/kooplearn/datasets/_overdamped_langevin_generator.py
code served (permissive licence) · get_code("c2199443c77a8fa1")
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 numpy as np

# Define a simple potential gradient function
def potential_gradient(x):
    """Simple quadratic potential: V(x) = x^2, so V'(x) = 2x"""
    return 2 * x

# Set up parameters
domain_min = 0.0
domain_max = 1.0
num_basis = 3
gamma = 1.0
sigma = 0.5
num_quad_points = 8

ARGS = {
    "domain_min": domain_min,
    "domain_max": domain_max,
    "num_basis": num_basis,
    "potential_gradient": potential_gradient,
    "gamma": gamma,
    "sigma": sigma,
    "num_quad_points": num_quad_points,
}
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 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
build_cosine_basis_1d Ran
ran on a synthesized input
Machine-Learning-Dynamical-Systems/kooplearn/src/kooplearn/datasets/_overdamped_langevin_generator.py
code served (permissive licence) · get_code("68ad10e8ef37d022")
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

ARGS = {
    "domain_min": 0.0,
    "domain_max": 1.0,
    "num_basis": 5,
    "num_quad_points": 12,
}
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 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_transition_matrix Ran
ran on a synthesized input
Machine-Learning-Dynamical-Systems/kooplearn/src/kooplearn/datasets/_logistic_map.py
code served (permissive licence) · get_code("fad015dcf69a86cf")
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 (11, 11) 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.special
import scipy.integrate

# Construct valid arguments for compute_transition_matrix
ARGS = {
    "M": 5  # Small positive integer for efficient computation
}
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 (11, 11) — shape (11, 11) 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
covariance Ran
ran on a synthesized input
Machine-Learning-Dynamical-Systems/kooplearn/src/kooplearn/_linalg.py
code served (permissive licence) · get_code("29532cdf3f0299d4")
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 (4, 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 test arrays
# X: (n=2, d_x=4) - 2 observations, 4 features
X = np.random.randn(2, 4)

# Y: (n=2, d_y=3) - 2 observations, 3 features
Y = np.random.randn(2, 3)

ARGS = {
    "X": X,
    "Y": Y,
}
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 (4, 3) — shape (4, 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
directed_hausdorff_distance Ran
ran on a synthesized input
Machine-Learning-Dynamical-Systems/kooplearn/src/kooplearn/metrics.py
code served (permissive licence) · get_code("fc5e0c22ee0c97e4")
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 float64, ndim 0, 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 numpy as np

# Create sample 1D arrays for pred and reference
pred = np.array([1.0, 5.0, 6.0])
reference = np.array([2.0, 4.0, 7.0])

ARGS = {
    "pred": pred,
    "reference": reference,
}
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 float64, ndim 0, dtype family float — no output shape is stated: observe_signature.py recorded float ndim 0, which disagrees with the fixture run
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
find_complex_conjugates Ran
ran on a synthesized input
Machine-Learning-Dynamical-Systems/kooplearn/src/kooplearn/_utils.py
code served (permissive licence) · get_code("21ca10017842e559")
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

# Create a 1D array of complex numbers with some conjugate pairs and real values
complex_vec = np.array([
    1.0 + 2.0j,      # index 0
    1.0 - 2.0j,      # index 1 (conjugate of 0)
    3.0 + 0.0j,      # index 2 (real)
    4.0 + 1.0j,      # index 3
    4.0 - 1.0j,      # index 4 (conjugate of 3)
    5.0 + 0.0j,      # index 5 (real)
], dtype=np.complex128)

ARGS = {
    'complex_vec': complex_vec,
    'tol': 10.0,
}
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
fuzzy_parse_complex Ran
ran on a synthesized input
Machine-Learning-Dynamical-Systems/kooplearn/src/kooplearn/_utils.py
code served (permissive licence) · get_code("9e63dcf31d16723c")
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 a complex vector with some elements whose real parts are close to each other
# This will allow the function to test its fuzzy matching logic
vec = np.array([
    1.0 + 0.5j,
    1.0 + 1e-12j,  # Real part close to first element
    3.0 + 2.0j,
    3.0 + 1e-13j,  # Real part close to third element
], dtype=np.complex128)

# Define the arguments dictionary
ARGS = {
    'vec': vec,
    'tol': 10.0,
}
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 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
logistic_map Ran
ran on a synthesized input
Machine-Learning-Dynamical-Systems/kooplearn/src/kooplearn/datasets/_logistic_map.py
code served (permissive licence) · get_code("144f7c9df1753a93")
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

# Create a small numpy array with values in the domain [0, 1]
x_scalar = np.array(0.5)
x_array = np.array([0.1, 0.3, 0.7, 0.9])
x_2d = np.array([[0.2, 0.4], [0.6, 0.8]])

ARGS = {
    "x": x_array
}
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
make_duffing Ran
ran on a synthesized input
Machine-Learning-Dynamical-Systems/kooplearn/src/kooplearn/datasets/_samples_generator.py
code served (permissive licence) · get_code("7e5917ad9b7d91d6")
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 DataFrame. 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 pandas as pd
import scipy.integrate

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

# Create initial conditions: [position, velocity]
X0 = np.array([0.1, 0.0])

# Define ARGS dict with all parameters
ARGS = {
    'X0': X0,
    'n_steps': 100,
    'dt': 0.01,
    'alpha': 0.5,
    'beta': 0.0625,
    'gamma': 0.1,
    'delta': 2.5,
    'omega': 2.0,
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
numpy, pandas, scipy — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type DataFrame — a DataFrame output has no array shape of its own; none is stated — the instrument coerces any output to an array; for a DataFrame output the recorded ndim 2 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
make_linear_system Ran
ran on a synthesized input
Machine-Learning-Dynamical-Systems/kooplearn/src/kooplearn/datasets/_samples_generator.py
code served (permissive licence) · get_code("eb5b8263066395a5")
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 DataFrame. 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 pandas as pd

# Define the arguments for make_linear_system
X0 = np.array([1.0, 0.0])

# 2D stable linear system
A = np.array([[0.9, 0.1], [-0.1, 0.9]])

n_steps = 100
noise = 0.1
dt = 1.0
random_state = 42

ARGS = {
    'X0': X0,
    'A': A,
    'n_steps': n_steps,
    'noise': noise,
    'dt': dt,
    'random_state': random_state
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
numpy, pandas — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type DataFrame — a DataFrame output has no array shape of its own; none is stated — the instrument coerces any output to an array; for a DataFrame output the recorded ndim 2 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
make_lorenz63 Ran
ran on a synthesized input
Machine-Learning-Dynamical-Systems/kooplearn/src/kooplearn/datasets/_samples_generator.py
code served (permissive licence) · get_code("b59e7e8dc93e917e")
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 DataFrame. 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 pandas as pd

ARGS = {
    'X0': np.array([1.0, 0.0, 0.0]),
    'n_steps': 100,
    'dt': 0.01,
    'sigma': 10.0,
    'mu': 28.0,
    'beta': 2.667
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
numpy, pandas, scipy — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type DataFrame — a DataFrame output has no array shape of its own; none is stated — the instrument coerces any output to an array; for a DataFrame output the recorded ndim 2 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
noise_features Ran
ran on a synthesized input
Machine-Learning-Dynamical-Systems/kooplearn/src/kooplearn/datasets/_logistic_map.py
code served (permissive licence) · get_code("38721ec99a7c41f6")
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
import scipy.special

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

# Create arguments for noise_features function
x = np.array([0.2, 0.5, 0.8])  # scalar or array of values in [0, 1]
i = 3  # feature index
M = 10  # order of trigonometric noise distribution (default is 10)

ARGS = {
    "x": x,
    "i": i,
    "M": M,
}
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 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
spd_neg_pow Ran
ran on a synthesized input
Machine-Learning-Dynamical-Systems/kooplearn/src/kooplearn/_linalg.py
code served (permissive licence) · get_code("a92bd87a7d27826d")
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 (4, 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

# Create a small symmetric positive definite (SPD) matrix
# For a 4x4 matrix, we can construct it as A @ A.T where A is random
np.random.seed(0)
A = np.random.randn(4, 4)
M = A @ A.T

# Ensure it's symmetric and positive definite
M = (M + M.T) / 2
M = M + np.eye(4) * 5  # Add to diagonal to ensure positive definiteness

ARGS = {
    'M': M,
    'exponent': -1.0,
    'cutoff': None,
    'strategy': 'trunc'
}
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 (4, 4) — shape (4, 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
stable_topk Ran
ran on a synthesized input
Machine-Learning-Dynamical-Systems/kooplearn/src/kooplearn/_utils.py
code served (permissive licence) · get_code("fc4666aeadf8fcdb")
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 numpy as np

# Create a simple 1D vector with some values
# Mix of larger and smaller values to test the rcond filtering
vec = np.array([5.2, 3.1, 1.8, 0.5, 0.001, 2.3], dtype=np.float64)

# Number of top-k indices to extract
k_max = 4

# Optional rcond threshold (None will use machine precision-based default)
rcond = None

# Whether to ignore warnings about discarded elements
ignore_warnings = True

ARGS = {
    "vec": vec,
    "k_max": k_max,
    "rcond": rcond,
    "ignore_warnings": ignore_warnings,
}
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 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
weighted_norm Ran
ran on a synthesized input
Machine-Learning-Dynamical-Systems/kooplearn/src/kooplearn/_linalg.py
code served (permissive licence) · get_code("bd99f93761bae48d")
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 float64, ndim 0, 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 numpy as np

# Case 1: 1D array (vector) without weighting matrix
A_1d = np.array([1.0, 2.0, 3.0, 4.0])
M_none = None

ARGS = {
    "A": A_1d,
    "M": M_none,
}

# Alternative test case: 2D array with weighting matrix
A_2d = np.array([[1.0, 2.0, 3.0],
                  [4.0, 5.0, 6.0],
                  [7.0, 8.0, 9.0],
                  [10.0, 11.0, 12.0]])
M_weighted = np.array([[2.0, 0.1, 0.0, 0.0],
                       [0.1, 2.0, 0.1, 0.0],
                       [0.0, 0.1, 2.0, 0.1],
                       [0.0, 0.0, 0.1, 2.0]])

# Use the simpler case without M for ARGS
ARGS = {
    "A": A_1d,
    "M": M_none,
}
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 float64, ndim 0, dtype family float — no output shape is stated: observe_signature.py recorded float ndim 0, which disagrees with the fixture run
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
assemble_operators_2d Not yet run
unverified (harvested, no recorded run)
Machine-Learning-Dynamical-Systems/kooplearn/src/kooplearn/datasets/_overdamped_langevin_generator.py
code served (permissive licence) · get_code("3108d99f4689babb")
How it ran

no invocation recorded.

Also present in other papers' code

Of 16 samples lifted from this paper's linked repositories, 16 carry a function identity and 0 do not. Of the 16 distinct functions with an identity, 16 are also present in other papers whose code we hold (16 with at least one paper dated earlier, 0 the same month, 0 later) and 0 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
assemble_operators_1d 1 other paper
1 dated earlier
2211.06678 (2022-11)
Learning dynamical systems: an example from open quantum system dynamics
assemble_operators_2d 1 other paper
1 dated earlier
2211.06678 (2022-11)
Learning dynamical systems: an example from open quantum system dynamics
build_cosine_basis_1d 1 other paper
1 dated earlier
2211.06678 (2022-11)
Learning dynamical systems: an example from open quantum system dynamics
compute_transition_matrix 1 other paper
1 dated earlier
2211.06678 (2022-11)
Learning dynamical systems: an example from open quantum system dynamics
covariance 1 other paper
1 dated earlier
2211.06678 (2022-11)
Learning dynamical systems: an example from open quantum system dynamics
directed_hausdorff_distance 1 other paper
1 dated earlier
2211.06678 (2022-11)
Learning dynamical systems: an example from open quantum system dynamics
find_complex_conjugates 1 other paper
1 dated earlier
2211.06678 (2022-11)
Learning dynamical systems: an example from open quantum system dynamics
fuzzy_parse_complex 1 other paper
1 dated earlier
2211.06678 (2022-11)
Learning dynamical systems: an example from open quantum system dynamics
logistic_map 1 other paper
1 dated earlier
2211.06678 (2022-11)
Learning dynamical systems: an example from open quantum system dynamics
make_duffing 1 other paper
1 dated earlier
2211.06678 (2022-11)
Learning dynamical systems: an example from open quantum system dynamics
make_linear_system 1 other paper
1 dated earlier
2211.06678 (2022-11)
Learning dynamical systems: an example from open quantum system dynamics
make_lorenz63 1 other paper
1 dated earlier
2211.06678 (2022-11)
Learning dynamical systems: an example from open quantum system dynamics
noise_features 1 other paper
1 dated earlier
2211.06678 (2022-11)
Learning dynamical systems: an example from open quantum system dynamics
spd_neg_pow 1 other paper
1 dated earlier
2211.06678 (2022-11)
Learning dynamical systems: an example from open quantum system dynamics
stable_topk 1 other paper
1 dated earlier
2211.06678 (2022-11)
Learning dynamical systems: an example from open quantum system dynamics
weighted_norm 1 other paper
1 dated earlier
2211.06678 (2022-11)
Learning dynamical systems: an example from open quantum system dynamics

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

Repositories linked to this paper

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

Abstract

Nonlinear dynamical systems can be handily described by the associated Koopman operator, whose action evolves every observable of the system forward in time. Learning the Koopman operator and its spectral decomposition from data is enabled by a number of algorithms. In this work we present for the first time non-asymptotic learning bounds for the Koopman eigenvalues and eigenfunctions. We focus on time-reversal-invariant stochastic dynamical systems, including the important example of Langevin dynamics. We analyze two popular estimators: Extended Dynamic Mode Decomposition (EDMD) and Reduced Rank Regression (RRR). Our results critically hinge on novel minimax estimation bounds for the operator norm error, that may be of independent interest. Our spectral learning bounds are driven by the simultaneous control of the operator norm error and a novel metric distortion functional of the estimated eigenfunctions. The bounds indicates that both EDMD and RRR have similar variance, but EDMD suffers from a larger bias which might be detrimental to its learning rate. Our results shed new light on the emergence of spurious eigenvalues, an issue which is well known empirically. Numerical experiments illustrate the implications of the bounds in practice.

For agents

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

get_harvested_code_for_paper("2302.02004")
get_code_for_paper("2302.02004")
have("2302.02004")

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

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

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

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

Connect an agent — have() is free.