SYNTOLOGY HomeExplorerAtlasCodeMethodologyAboutDevelopersFeedPricing
Paper · 2603.26327 · 2026

Making Multi-Axis Models Robust to Multiplicative Noise: How, and Why?

Bailey Andrew, David Westhead, Luisa Cutillo

arXiv · PDF · Open in the Atlas

Code that ran

16 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; 4 honoured the contract we drafted, 1 violated it and 1 has no contract verdict; 10 failures of our instrument; 3 no recorded run), measured 2026-11-22; bodies inline only under a permissive licence as GitHub detects it. Not a reproduction of the paper's results.

"Ran" means the function executed on a synthesized input and returned a value. It is not a reproduction of the paper's results. This record, dated, as JSON: /api/ran/2603.26327.json · badge: /api/ran/2603.26327.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
MED-MAGMA-NeurIPS2026/MED-MAGMA-NeurIPS2026 community
Papers with Code archive
16 ran · 3 no recorded run
FunctionStatusWhere it lives
axis_curvature_final Ran
ran; our contract draft was wrong, not the code
MED-MAGMA-NeurIPS2026/MED-MAGMA-NeurIPS2026/MED_MAGMA.py
code served (permissive licence) · get_code("6bf6fa2cd8254a8f")
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 (3, 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

# Analyze the function axis_curvature_final to understand parameter requirements:
# - Omega1: used in operations like d2 * Omega1, Omega1.sum(), Omega1.sum(axis=1)
#   This suggests it's a 2D array (matrix)
# - Omega2: used in d1 * Omega2, Omega2.sum(), Omega2.sum(axis=0)
#   This suggests it's a 2D array (matrix)
# - d1, d2: used as scalars in multiplication and eye() calls

# Looking at the logic:
# - A = d2 * Omega1 + Omega2.sum() * np.eye(d1)
#   So Omega1 shape should be (d1, d1) to match eye(d1)
# - B = d1 * Omega2 + Omega1.sum() * np.eye(d2)
#   So Omega2 shape should be (d2, d2) to match eye(d2)
# - C = Omega1.sum(axis=1).reshape(-1, 1) + Omega2.sum(axis=0).reshape(1, -1)
#   Omega1.sum(axis=1) has shape (d1,), Omega2.sum(axis=0) has shape (d2,)
#   So C has shape (d1, d2)

# Then get_poptinv_final is called with (A, B, C):
# - A has shape (d1, d1)
# - B has shape (d2, d2)
# - C has shape (d1, d2)

# Let's use distinct sizes: d1=4, d2=3

d1 = 4
d2 = 3

# Create Omega1 with shape (d1, d1) = (4, 4)
Omega1 = np.random.randn(d1, d1)

# Create Omega2 with shape (d2, d2) = (3, 3)
Omega2 = np.random.randn(d2, d2)

ARGS = {
    "Omega1": Omega1,
    "Omega2": Omega2,
    "d1": d1,
    "d2": d2,
}
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 (3, 3) — shape (3, 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
blockwise_trace Ran
ran; our contract draft was wrong, not the code
MED-MAGMA-NeurIPS2026/MED-MAGMA-NeurIPS2026/MED_MAGMA.py
code served (permissive licence) · get_code("01e17b91e7a1a6ac")
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

# Construct valid arguments for blockwise_trace
# The function takes:
# - Lam: np.ndarray - a numpy array to be reshaped and summed
# - ds: tuple/list - shape to reshape Lam into
# - axis: int - which axis to keep (others are summed over)

# Create a small numpy array
Lam = np.random.randn(24)  # 24 elements

# Define the reshape dimensions (ds)
# For example, reshape to (2, 3, 4) - 2*3*4 = 24 elements
ds = (2, 3, 4)

# Define which axis to keep
axis = 1  # Keep dimension 1 (size 3), sum over dimensions 0 and 2

ARGS = {
    "Lam": Lam,
    "ds": ds,
    "axis": 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
curvatures_final Ran
ran; our contract draft was wrong, not the code
MED-MAGMA-NeurIPS2026/MED-MAGMA-NeurIPS2026/MED_MAGMA.py
code served (permissive licence) · get_code("66685aa0fe825117")
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

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

# Define dimensions
d1 = 4
d2 = 3

# Create Omega1 as a d1 x d1 matrix
Omega1 = np.random.randn(d1, d1)

# Create Omega2 as a d2 x d2 matrix
Omega2 = np.random.randn(d2, d2)

ARGS = {
    "Omega1": Omega1,
    "Omega2": Omega2,
    "d1": d1,
    "d2": d2
}
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
flip Ran
ran; the contract check could not run (RAISES, DEP_MISSING or TIMEOUT)
MED-MAGMA-NeurIPS2026/MED-MAGMA-NeurIPS2026/MED_MAGMA.py
code served (permissive licence) · get_code("966699dcc6d3cc42")
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

np.random.seed(0)

# Construct arguments for flip function
# flip(Omega1, Omega2, Y, s2, tol=1e-06, max_iter=200, step=0.001)

# Omega1: matrix used in element-wise multiplication with (YS @ YS.T)
# Shape should be compatible with YS @ YS.T
# Let's say d1 x d1 where d1 is the first dimension of Y
d1 = 4  # First dimension of Y
d2 = 3  # Second dimension of Y (and dimension of Omega2)

# Omega1: d1 x d1 matrix
Omega1 = np.random.randn(d1, d1)

# Omega2: d2 x d2 matrix
# Used in: YS @ Omega2 @ YS.T
Omega2 = np.random.randn(d2, d2)

# Y: d1 x d2 matrix
# Used in: Y * s2 (element-wise mult with s2 reshaped to (1, d2))
# and YS @ Omega2 @ YS.T and YS @ YS.T
Y = np.random.randn(d1, d2)

# s2: d2-length vector
# Used in: s2.reshape(1, d2) and Y * s2
s2 = np.random.randn(d2)

ARGS = {
    'Omega1': Omega1,
    'Omega2': Omega2,
    'Y': Y,
    's2': s2,
    'tol': 1e-06,
    'max_iter': 200,
    'step': 0.001
}
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
flipflop Ran
ran; our contract draft was wrong, not the code
MED-MAGMA-NeurIPS2026/MED-MAGMA-NeurIPS2026/MED_MAGMA.py
code served (permissive licence) · get_code("556b7148fbc0602a")
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

np.random.seed(0)

# Construct small matrices for the function
# flipflop takes: Omega1, Omega2, Y, s1, s2, max_iter, convergence_tol, zero_tol, verbose

# Omega1: d1 x d1 positive definite matrix
d1 = 4
Omega1 = np.eye(d1) + 0.1 * np.random.randn(d1, d1)
Omega1 = Omega1 @ Omega1.T  # Make it positive definite

# Omega2: d2 x d2 positive definite matrix
d2 = 3
Omega2 = np.eye(d2) + 0.1 * np.random.randn(d2, d2)
Omega2 = Omega2 @ Omega2.T  # Make it positive definite

# Y: d1 x d2 matrix
Y = np.random.randn(d1, d2)

# s1: d1-dimensional vector
s1 = np.ones(d1) / d1

# s2: d2-dimensional vector
s2 = np.ones(d2) / d2

ARGS = {
    'Omega1': Omega1,
    'Omega2': Omega2,
    'Y': Y,
    's1': s1,
    's2': s2,
    'max_iter': 20,
    'convergence_tol': 1e-10,
    'zero_tol': 0.0001,
    'verbose': False,
}
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
get_Omega_tilde Ran
ran, honoured the contract we drafted
MED-MAGMA-NeurIPS2026/MED-MAGMA-NeurIPS2026/MED_MAGMA.py
code served (permissive licence) · get_code("59609337b05fbb3e")
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

# Analyze the function:
# - Omega1: scalar or array, multiplied with (YS @ YS.T)
# - Omega2: matrix, used in YS @ Omega2 @ YS.T
# - Y: matrix, multiplied with s2
# - s2: scalar or array, multiplied with Y

# Set dimensions to be distinct:
# Y: (n, m) where n=2, m=4
# Omega2: (m, m) = (4, 4)
# Omega1: scalar
# s2: scalar

np.random.seed(0)

n = 2  # rows of Y
m = 4  # cols of Y

# Create matrices
Y = np.random.randn(n, m)  # (2, 4)
Omega2 = np.random.randn(m, m)  # (4, 4)
Omega1 = np.random.randn()  # scalar
s2 = np.random.randn()  # scalar

ARGS = {
    "Omega1": Omega1,
    "Omega2": Omega2,
    "Y": Y,
    "s2": s2
}
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
get_poptinv_final Ran
ran; our contract draft was wrong, not the code
MED-MAGMA-NeurIPS2026/MED-MAGMA-NeurIPS2026/MED_MAGMA.py
code served (permissive licence) · get_code("969e0145e36599bb")
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 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

# Construct small but valid matrices for the function
# A should be invertible and square
# B should be compatible with K for the operations
# K should have shape that allows K[:, :-1] and compatible matrix ops

# Create a small invertible square matrix for A (4x4)
A = np.array([
    [2.0, 0.5, 0.1, 0.2],
    [0.5, 2.0, 0.3, 0.1],
    [0.1, 0.3, 1.5, 0.2],
    [0.2, 0.1, 0.2, 1.8]
], dtype=np.float64)

# Create K with shape (4, 5) so that K[:, :-1] is (4, 4)
# This matches A's dimensions for KA @ K_red to work
K = np.array([
    [1.0, 0.5, 0.2, 0.1, 0.3],
    [0.3, 1.5, 0.4, 0.2, 0.1],
    [0.2, 0.1, 1.2, 0.3, 0.5],
    [0.4, 0.2, 0.1, 1.3, 0.2]
], dtype=np.float64)

# Create B with shape (5, 5) so that B[:-1, :-1] is (4, 4)
# This must be compatible with KA @ K_red (which is 4x4)
B = np.array([
    [2.0, 0.3, 0.1, 0.2, 0.4],
    [0.3, 2.5, 0.2, 0.1, 0.3],
    [0.1, 0.2, 1.8, 0.4, 0.2],
    [0.2, 0.1, 0.4, 2.0, 0.1],
    [0.4, 0.3, 0.2, 0.1, 1.5]
], dtype=np.float64)

ARGS = {
    "A": A,
    "B": B,
    "K": K
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
numpy — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type list, ndim 3, 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
get_zstar Ran
ran; our contract draft was wrong, not the code
MED-MAGMA-NeurIPS2026/MED-MAGMA-NeurIPS2026/MED_MAGMA.py
code served (permissive licence) · get_code("7b08a1e1b2c44839")
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
from scipy.optimize import minimize, Bounds, NonlinearConstraint, LinearConstraint

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

# Define small matrices and vectors for the function
# Omega1: d1 x d1 matrix
d1 = 4
Omega1 = np.array([
    [2.0, 0.5, 0.1, 0.0],
    [0.5, 2.0, 0.2, 0.1],
    [0.1, 0.2, 2.0, 0.3],
    [0.0, 0.1, 0.3, 2.0]
])

# Omega2: d2 x d2 matrix
d2 = 3
Omega2 = np.array([
    [2.0, 0.4, 0.2],
    [0.4, 2.0, 0.3],
    [0.2, 0.3, 2.0]
])

# Y: d1 x d2 matrix
Y = np.array([
    [1.0, 0.5, 0.2],
    [0.5, 1.0, 0.3],
    [0.2, 0.3, 1.0],
    [0.1, 0.2, 0.4]
])

# s1: d1-dimensional vector (initial)
s1 = np.array([1.0, 1.0, 1.0, 1.0])

# s2: d2-dimensional vector (initial)
s2 = np.array([1.0, 1.0, 1.0])

# Optional parameters with defaults
max_iter = 20
convergence_tol = 1e-10
zero_tol = 0.0001
verbose = False

ARGS = {
    'Omega1': Omega1,
    'Omega2': Omega2,
    'Y': Y,
    's1': s1,
    's2': s2,
    'max_iter': max_iter,
    'convergence_tol': convergence_tol,
    'zero_tol': zero_tol,
    'verbose': verbose
}
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
gmgm_gradient Ran
ran on a synthesized input
MED-MAGMA-NeurIPS2026/MED-MAGMA-NeurIPS2026/MED_MAGMA.py
code served (permissive licence) · get_code("b9469cc815dfded6")
How it ran

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

import numpy as np

# Analyze the function to understand what it needs:
# - es: list[np.ndarray] - used in results[axis] = left + right + reg where right = es[axis]
# - lams: list[np.ndarray] - used to get shapes and compute ks_vec
# - regularization: float - multiplied with lams[axis]

# The function processes each axis of a multi-dimensional structure
# ds = [lam.shape[0] for lam in lams] - extracts first dimension of each array
# blockwise_trace and ks_vec reshape and combine these arrays

# Create small, distinct-sized arrays for testing
# Let's use 3 dimensions with different sizes: 2, 3, 4

np.random.seed(0)

# lams: list of 1D arrays with different sizes
lam1 = np.random.randn(2)
lam2 = np.random.randn(3)
lam3 = np.random.randn(4)
lams = [lam1, lam2, lam3]

# es: list of arrays - same structure as lams for computation
# These are used as gradients/scores to add to the result
es1 = np.random.randn(2)
es2 = np.random.randn(3)
es3 = np.random.randn(4)
es = [es1, es2, es3]

# regularization: scalar float
regularization = 0.1

ARGS = {
    "es": es,
    "lams": lams,
    "regularization": regularization
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
numpy — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type list — a list output has no array shape of its own; none is stated
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
gmgm_kernel Ran
ran; our contract draft was wrong, not the code
MED-MAGMA-NeurIPS2026/MED-MAGMA-NeurIPS2026/MED_MAGMA.py
code served (permissive licence) · get_code("551f707ea980dd04")
How it ran

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

import numpy as np

# Create small test data for gmgm_kernel
np.random.seed(0)

# Create a list of small eigenvalue vectors
# Each represents eigenvalues for a different dimension
lams_init = [
    np.array([0.5, 0.7, 0.6, 0.8]),  # 4 eigenvalues
    np.array([0.4, 0.9, 0.5]),        # 3 eigenvalues
    np.array([0.6, 0.7])              # 2 eigenvalues
]

# Create corresponding gradient estimates (es)
# Each should have the same shape as the corresponding lambda
es = [
    np.array([0.1, 0.15, 0.12, 0.18]),  # 4 values
    np.array([0.08, 0.2, 0.11]),         # 3 values
    np.array([0.14, 0.16])               # 2 values
]

ARGS = {
    'es': es,
    'lams_init': lams_init,
    'max_iter': 10,
    'tol': 1e-5,
    'min_eigenvalue': 1e-6,
    'step_size': 0.1,
    'line_search_shrinkage': 0.5,
    'line_search_max_iter': 5,
    'regularization': 0.01,
    'verbose': False,
    'diagnostics': False
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
numpy — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type list — a list output has no array shape of its own; none is stated
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
gmgm_objective Ran
ran, honoured the contract we drafted
MED-MAGMA-NeurIPS2026/MED-MAGMA-NeurIPS2026/MED_MAGMA.py
code served (permissive licence) · get_code("f7597f1cab821666")
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

# Construct valid arguments for gmgm_objective
# The function expects:
# - es: list of np.ndarray
# - lams: list of np.ndarray
# - regularization: float (optional, defaults to 0.0)

# Create small numpy arrays for es and lams
# es and lams are zipped together, so they should have the same length
# Each lam is reshaped and added to build ks_vec output
# Let's use 2 arrays of different dimensions to make shapes distinct

es = [
    np.random.randn(4),  # First array: dimension 4
    np.random.randn(3),  # Second array: dimension 3
]

lams = [
    np.random.randn(4),  # First lambda: dimension 4
    np.random.randn(3),  # Second lambda: dimension 3
]

regularization = 0.1

ARGS = {
    "es": es,
    "lams": lams,
    "regularization": regularization,
}
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
interior_exp Ran
ran; the contract check could not run (RAISES, DEP_MISSING or TIMEOUT)
MED-MAGMA-NeurIPS2026/MED-MAGMA-NeurIPS2026/MED_MAGMA.py
code served (permissive licence) · get_code("16ae47a43c2351f0")
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
from scipy.optimize import minimize, Bounds, NonlinearConstraint, LinearConstraint

# Create a small positive definite matrix Q
# The function optimizes s^T Q s subject to sum(s) = 1
np.random.seed(0)
Q_base = np.random.randn(4, 4)
Q = Q_base @ Q_base.T  # Make it symmetric positive definite

# Create old_s (not used in the function body, but it's a parameter)
old_s = np.ones(4) / 4

# Define ARGS dictionary with all parameters
ARGS = {
    'Q': Q,
    'old_s': old_s,
    'tol': 1e-06,
    'max_iter': 200,
    'step': 0.001
}
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
ks_vec Ran
ran, honoured the contract we drafted
MED-MAGMA-NeurIPS2026/MED-MAGMA-NeurIPS2026/MED_MAGMA.py
code served (permissive licence) · get_code("019624fde587c1c8")
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 (24,) 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 test arrays with distinct shapes for probing
lam1 = np.array([1.0, 2.0, 3.0])  # shape (3,)
lam2 = np.array([4.0, 5.0])       # shape (2,)
lam3 = np.array([6.0, 7.0, 8.0, 9.0])  # shape (4,)

ARGS = {
    "lams": [lam1, lam2, lam3]
}
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 (24,) — shape (24,) 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
laplace_approximation Ran
ran; the contract check could not run (RAISES, DEP_MISSING or TIMEOUT)
MED-MAGMA-NeurIPS2026/MED-MAGMA-NeurIPS2026/MED_MAGMA.py
code served (permissive licence) · get_code("7d2c47d2145719ec")
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

np.random.seed(0)

# Create small test matrices
d1 = 4
d2 = 3

# Omega1: d1 x d1 positive definite matrix
Omega1 = np.random.randn(d1, d1)
Omega1 = Omega1 @ Omega1.T + np.eye(d1)

# Omega2: d2 x d2 positive definite matrix
Omega2 = np.random.randn(d2, d2)
Omega2 = Omega2 @ Omega2.T + np.eye(d2)

# Y: d1 x d2 matrix
Y = np.random.randn(d1, d2)

# s1: d1-dimensional vector (normalized)
s1 = np.random.rand(d1)
s1 = s1 / np.linalg.norm(s1)

# s2: d2-dimensional vector (normalized)
s2 = np.random.rand(d2)
s2 = s2 / np.linalg.norm(s2)

ARGS = {
    'Omega1': Omega1,
    'Omega2': Omega2,
    'Y': Y,
    's1': s1,
    's2': s2,
}
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
proximal Ran
ran, violated the contract we drafted
MED-MAGMA-NeurIPS2026/MED-MAGMA-NeurIPS2026/MED_MAGMA.py
code served (permissive licence) · get_code("72c0d51bfd33f80a")
How it ran

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

import numpy as np

# The function takes a list of arrays (lams) and clamps each to [min_eigenvalue, max_eigenvalue]
# lams should be a list of numpy arrays or array-like objects

lams = [
    np.array([0.5, 1e-7, 500000.0, 2.0]),
    np.array([1e-8, 100.0, 2000000.0, 0.1])
]

min_eigenvalue = 1e-06
max_eigenvalue = 1000000.0

ARGS = {
    "lams": lams,
    "min_eigenvalue": min_eigenvalue,
    "max_eigenvalue": max_eigenvalue
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
numpy — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type list, ndim 2, dtype family float — a list output has no array shape of its own; none is stated
dtype family
int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
trace_final Ran
ran, honoured the contract we drafted
MED-MAGMA-NeurIPS2026/MED-MAGMA-NeurIPS2026/MED_MAGMA.py
code served (permissive licence) · get_code("214d94a3b5dab46b")
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

# Analyze the function to understand parameter requirements:
# - L: used with np.trace(), so needs to be a 2D array
# - K: shape[0] accessed, K_full[:, :-1] = K, K_full.sum(axis=0) used, so needs to be 2D
# - M: shape[0] accessed, M_full[:-1, :-1] = M, so needs to be 2D

# From the logic:
# - d2 = M.shape[0] + 1
# - d1 = K.shape[0]
# - K_full is (d1, d2) where d2 = M.shape[0] + 1
# - M_full is (d2, d2)
# - K is (d1, d2-1) = (d1, M.shape[0])
# - M is (d2-1, d2-1) = (M.shape[0], M.shape[0])

# Let's use distinct sizes:
# M: 3x3 (so d2 = 4)
# K: 2x3 (so d1 = 2)
# L: 4x4 (to match d2 for trace operation)

L = np.array([
    [1.0, 0.5, 0.2, 0.1],
    [0.5, 2.0, 0.3, 0.4],
    [0.2, 0.3, 1.5, 0.6],
    [0.1, 0.4, 0.6, 2.5]
])

K = np.array([
    [1.0, 2.0, 3.0],
    [4.0, 5.0, 6.0]
])

M = np.array([
    [1.0, 0.5, 0.2],
    [0.5, 2.0, 0.3],
    [0.2, 0.3, 1.5]
])

ARGS = {
    "L": L,
    "K": K,
    "M": M
}
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
EM_algorithm Not yet run
unverified (harvested, no recorded run)
MED-MAGMA-NeurIPS2026/MED-MAGMA-NeurIPS2026/MED_MAGMA.py
code served (permissive licence) · get_code("724213aa30ec2c89")
How it ran

no invocation recorded.

EM_step Not yet run
unverified (harvested, no recorded run)
MED-MAGMA-NeurIPS2026/MED-MAGMA-NeurIPS2026/MED_MAGMA.py
code served (permissive licence) · get_code("c7e54809a2f37946")
How it ran

no invocation recorded.

flop Not yet run
unverified (harvested, no recorded run)
MED-MAGMA-NeurIPS2026/MED-MAGMA-NeurIPS2026/MED_MAGMA.py
code served (permissive licence) · get_code("944d5ecb64eb7d18")
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, 0 are also present in other papers whose code we hold (0 with at least one paper dated earlier, 0 the same month, 0 later) and 19 are only here among the 52,977 papers whose code Syntology holds (as of 2026-09-26).

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

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

Repositories linked to this paper

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

Abstract

In this paper we develop a graph-learning algorithm, MED-MAGMA, to fit multiaxis (Kronecker-sum-structured) models corrupted by multiplicative noise. This type of noise is natural in many application domains, such as that of single-cell RNA sequencing, in which it naturally captures technical biases of RNA sequencing platforms. Our work is evaluated against prior work on each and every public dataset in the Single Cell Expression Atlas under a certain size, demonstrating that our methodology learns networks with better local and global structure. MED-MAGMA is made available as a Python package (MED-MAGMA).

For agents

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

get_harvested_code_for_paper("2603.26327")
get_code_for_paper("2603.26327")
have("2603.26327")

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

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

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

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

Connect an agent — have() is free.