| 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 ranRan 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 ranRan 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 ranRan 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 ranRan 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 ranRan 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 ranRan 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 ranRan 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 ranRan 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 ranRan 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 ranRan 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 ranRan 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 ranRan 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 ranRan 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 ranRan 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 ranRan 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 ranRan 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 |
| 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 |
| 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 |