| abs |
Ran ran on a synthesized input |
twhughes/ceviche/ceviche/viz.py code served (permissive licence) · get_code("480a78607135a128") 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 Axes. 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 matplotlib.pyplot as plt
# Create a small 2D array for val
val = np.random.randn(4, 3)
# Create a small 2D array for outline
outline = np.random.randn(4, 3)
# Create a matplotlib axes object
fig, ax = plt.subplots(1, 1, constrained_layout=True)
ARGS = {
'val': val,
'outline': outline,
'ax': ax,
'cbar': False,
'cmap': 'magma',
'outline_alpha': 0.5,
'outline_val': None,
}
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
- Imports
- matplotlib, numpy — import names as written, not package names to install; a name the repository itself provides is not a package
- Returned
- type Axes — a Axes output has no array shape of its own; none is stated — the instrument coerces any output to an array; for a Axes output the recorded ndim 0 and dtype family float describe that coercion, not the output, and are not stated
- Environment
- image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
|
| adam_optimize |
Ran ran on a synthesized input |
twhughes/ceviche/ceviche/optimizers.py code served (permissive licence) · get_code("195bf3af50815188") 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
def simple_objective(params):
"""Simple quadratic objective: sum of squares"""
return np.sum(params ** 2)
def simple_jac(params):
"""Gradient of sum of squares: 2 * params"""
return 2 * params
def dummy_callback(iteration, of_list, params):
"""Dummy callback that does nothing"""
pass
ARGS = {
'objective': simple_objective,
'params': np.array([1.5, -2.3, 0.8, -1.2]),
'jac': simple_jac,
'step_size': 0.01,
'Nsteps': 5,
'bounds': None,
'direction': 'min',
'beta1': 0.9,
'beta2': 0.999,
'callback': dummy_callback,
'verbose': False
}
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
- Imports
- autograd, 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_f |
Ran ran on a synthesized input |
twhughes/ceviche/ceviche/sources.py code served (permissive licence) · get_code("175fcc923c54404c") 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 (20,) 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 autograd.numpy as npa
import numpy as np
# Analyze function signature:
# - theta: angle parameter (scalar or array)
# - lambda0: wavelength parameter (scalar)
# - dL: spacing parameter (scalar)
# - shape: tuple for array shape
# Construct valid arguments
theta = 0.3 # scalar angle in radians
lambda0 = 1.0 # scalar wavelength
dL = 0.1 # scalar spacing
shape = (4, 5) # distinct dimensions for probing
ARGS = {
"theta": theta,
"lambda0": lambda0,
"dL": dL,
"shape": shape,
}
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
- Imports
- autograd, 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 (20,) — shape (20,) 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
|
| curl_E |
Ran ran on a synthesized input |
twhughes/ceviche/ceviche/derivatives.py code served (permissive licence) · get_code("e1b020dc610f81eb") 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 3, dtype family float, shape (2, 3, 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 autograd.numpy as npa
# Set seed for reproducibility
npa.random.seed(0)
# Create small 3D arrays for the electric field components
# Using distinct dimensions: (2, 3, 4) for batch, y-axis, z-axis
batch_size = 2
dim_y = 3
dim_z = 4
Ex = npa.random.randn(batch_size, dim_y, dim_z)
Ey = npa.random.randn(batch_size, dim_y, dim_z)
Ez = npa.random.randn(batch_size, dim_y, dim_z)
# Spatial grid spacing
dL = 0.1
# Axis parameter (0, 1, or 2)
axis = 0
ARGS = {
"axis": axis,
"Ex": Ex,
"Ey": Ey,
"Ez": Ez,
"dL": dL,
}
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
- Imports
- autograd — import names as written, not package names to install; a name the repository itself provides is not a package
- Returned
- type ndarray, ndim 3, dtype family float, shape (2, 3, 4) — shape (2, 3, 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
|
| curl_H |
Ran ran on a synthesized input |
twhughes/ceviche/ceviche/derivatives.py code served (permissive licence) · get_code("c0c5035e89b60e25") 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 3, dtype family float, shape (2, 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 autograd.numpy as npa
import numpy as np
# Set seed for reproducibility
np.random.seed(0)
# Create small 3D arrays for the magnetic field components
# Shape: (2, 4, 4) - batch=2, spatial dims=4x4
Hx = npa.random.randn(2, 4, 4)
Hy = npa.random.randn(2, 4, 4)
Hz = npa.random.randn(2, 4, 4)
# Grid spacing parameter
dL = 0.1
# Axis parameter (can be 0, 1, or 2)
axis = 0
ARGS = {
"axis": axis,
"Hx": Hx,
"Hy": Hy,
"Hz": Hz,
"dL": dL,
}
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
- Imports
- autograd, numpy — import names as written, not package names to install; a name the repository itself provides is not a package
- Returned
- type ndarray, ndim 3, dtype family float, shape (2, 4, 4) — shape (2, 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
|
| get_entries_indices |
Ran ran on a synthesized input |
twhughes/ceviche/ceviche/utils.py code served (permissive licence) · get_code("8b0444e741bdb47d") 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 autograd.numpy as npa
import scipy.sparse as sp
import numpy as np
# Create a small CSR matrix for testing
# 4x3 matrix with some non-zero entries
data = np.array([1.0, 2.0, 3.0, 4.0])
row = np.array([0, 1, 2, 3])
col = np.array([0, 1, 2, 0])
csr_matrix = sp.csr_matrix((data, (row, col)), shape=(4, 3))
ARGS = {
"csr_matrix": csr_matrix
}
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
- Imports
- autograd, 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
|
| grad_sp_mult_entries_reverse |
Ran ran on a synthesized input |
twhughes/ceviche/ceviche/primitives.py code served (permissive licence) · get_code("32efd6e78703c636") 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 function. The image it ran in was not recorded. If your copy returns the same type on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.
import torch
import numpy as np
torch.manual_seed(0)
# Analyzing the function:
# - ans: appears to be unused in the function body
# - entries: unused in the function body
# - indices: tuple (ia, ja) of index arrays/tensors used to index into ans and x
# - x: tensor that gets indexed by ja
# The vjp function returns v[ia] * x[ja], so:
# - v should be indexable (tensor or array)
# - ia should be valid indices for v
# - ja should be valid indices for x
# - x should support element-wise multiplication
# Create small tensors
ans_tensor = torch.randn(2, 4) # arbitrary, unused in function
entries_tensor = torch.randn(3) # arbitrary, unused in function
x_tensor = torch.randn(4) # will be indexed by ja
# Create index arrays
# ia will index into v (which has same shape as ans output)
ia = torch.tensor([0, 1, 0], dtype=torch.long) # 3 indices, values < 2
ja = torch.tensor([0, 1, 2], dtype=torch.long) # 3 indices, values < 4
indices = (ia, ja)
ARGS = {
"ans": ans_tensor,
"entries": entries_tensor,
"indices": indices,
"x": x_tensor,
}
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
- Imports
- numpy, torch — import names as written, not package names to install; a name the repository itself provides is not a package
- Returned
- type function — a function output has no array shape of its own; none is stated — the instrument coerces any output to an array; for a function output the recorded ndim 0 and dtype family float describe that coercion, not the output, and are not stated
- Environment
- image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
|
| jacobian |
Ran ran on a synthesized input |
twhughes/ceviche/ceviche/jacobians.py code served (permissive licence) · get_code("f1957dddb0eee8e5") 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 function. 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 autograd.numpy as npa
from autograd.core import make_vjp, make_jvp
from autograd.wrap_util import unary_to_nary
from autograd.extend import vspace
def simple_function(x):
"""A simple test function: f(x) = x^2 + 2*x"""
return npa.sum(x ** 2 + 2 * x)
def vector_function(x):
"""A function that returns a vector output"""
return npa.array([x[0] ** 2, x[1] * 2, x[0] + x[1]])
# Test input - small 1D array
test_input = npa.array([1.0, 2.0, 3.0, 4.0])
ARGS = {
'fun': simple_function,
'argnum': 0,
'mode': 'reverse',
'step_size': 1e-06
}
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
- Imports
- autograd — import names as written, not package names to install; a name the repository itself provides is not a package
- Returned
- type function — a function output has no array shape of its own; none is stated — the instrument coerces any output to an array; for a function output the recorded ndim 0 and dtype family float describe that coercion, not the output, and are not stated
- Environment
- image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
|
| jacobian_forward |
Ran ran on a synthesized input |
twhughes/ceviche/ceviche/jacobians.py code served (permissive licence) · get_code("6fa0121267278eeb") 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 function. 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 autograd.numpy as npa
from autograd.core import make_vjp, make_jvp
from autograd.wrap_util import unary_to_nary
from autograd.extend import vspace
def float_2_array(x):
"""Convert float-like to array"""
if isinstance(x, (int, float, complex)):
return npa.array([x])
return npa.asarray(x)
def simple_function(x):
"""Simple test function: f(x) = x^2 + 2*x"""
return x**2 + 2*x
def simple_function_vector(x):
"""Vector function: f(x) = [x[0]^2, x[1]*x[0], x[2]+x[3]]"""
return npa.array([x[0]**2, x[1]*x[0], x[2] + x[3]])
# Test with a simple scalar function
x_scalar = npa.array(3.0)
# Test with a vector input
x_vector = npa.array([1.0, 2.0, 3.0, 4.0])
ARGS = {
"fun": simple_function_vector,
"x": x_vector
}
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
- Imports
- autograd — import names as written, not package names to install; a name the repository itself provides is not a package
- Returned
- type function — a function output has no array shape of its own; none is stated — the instrument coerces any output to an array; for a function output the recorded ndim 0 and dtype family float describe that coercion, not the output, and are not stated
- Environment
- image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
|
| jacobian_reverse |
Ran ran on a synthesized input |
twhughes/ceviche/ceviche/jacobians.py code served (permissive licence) · get_code("11d243fbf6c19486") 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 function. 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 autograd.numpy as npa
from autograd.core import make_vjp, make_jvp
from autograd.wrap_util import unary_to_nary
from autograd.extend import vspace
import numpy as np
def float_2_array(x):
"""Convert float or array to numpy array"""
if isinstance(x, (int, float)):
return npa.array([x])
return npa.asarray(x)
def simple_fun(x):
"""Simple test function: x^2 + 2*x"""
return x**2 + 2*x
def vector_fun(x):
"""Vector-valued function: [x[0]^2, x[1]*x[0], x[1]^2]"""
return npa.array([x[0]**2, x[1]*x[0], x[1]**2])
def matrix_fun(x):
"""Matrix-valued function that takes a vector and outputs a matrix"""
# Input: vector of shape (4,)
# Output: matrix of shape (3, 2)
x_flat = x.flatten()
return npa.array([
[x_flat[0]**2, x_flat[1]*x_flat[2]],
[x_flat[2] + x_flat[3], x_flat[0]*x_flat[1]],
[x_flat[3]**2, x_flat[0] + x_flat[1]]
])
# Test inputs
scalar_input = 2.5
vector_input = npa.array([1.0, 2.0, 3.0, 4.0])
matrix_input = npa.array([1.0, 2.0, 3.0, 4.0])
ARGS = {
"fun": vector_fun,
"x": vector_input
}
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
- Imports
- autograd, numpy — import names as written, not package names to install; a name the repository itself provides is not a package
- Returned
- type function — a function output has no array shape of its own; none is stated — the instrument coerces any output to an array; for a function output the recorded ndim 0 and dtype family float describe that coercion, not the output, and are not stated
- Environment
- image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
|
| real |
Ran ran on a synthesized input |
twhughes/ceviche/ceviche/viz.py code served (permissive licence) · get_code("f559c4723f95f006") 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 Axes. 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 matplotlib.pyplot as plt
# Create a small 2D array for the main value
val = np.array([[1.0 + 0.5j, 2.0 - 0.3j, -1.5 + 0.2j, 0.8 - 0.1j],
[0.5 + 1.2j, -0.7 + 0.9j, 1.1 - 0.4j, -0.3 + 0.6j],
[2.0 - 0.5j, -1.0 + 1.5j, 0.2 + 0.8j, 1.3 - 0.9j]], dtype=complex)
# Create a small 2D array for the outline
outline = np.array([[0.1, 0.2, 0.15, 0.05],
[0.3, 0.4, 0.35, 0.25],
[0.2, 0.25, 0.2, 0.15]], dtype=float)
# Create a matplotlib axes object
fig, ax = plt.subplots(1, 1, constrained_layout=True)
ARGS = {
'val': val,
'outline': outline,
'ax': ax,
'cbar': True,
'cmap': 'RdBu',
'outline_alpha': 0.5
}
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
- Imports
- matplotlib, numpy — import names as written, not package names to install; a name the repository itself provides is not a package
- Returned
- type Axes — a Axes output has no array shape of its own; none is stated — the instrument coerces any output to an array; for a Axes output the recorded ndim 0 and dtype family float describe that coercion, not the output, and are not stated
- Environment
- image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
|
| solver_eigs |
Ran ran on a synthesized input |
twhughes/ceviche/ceviche/modes.py code served (permissive licence) · get_code("90fb0f26be8ac45b") 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 torch
import numpy as np
import scipy.sparse as sp
import scipy.sparse.linalg as spl
torch.manual_seed(0)
# Create a small sparse matrix as a linear operator
# The function expects A to work with scipy.sparse.linalg.eigs
# eigs requires a square matrix or LinearOperator
# Create a small 4x4 sparse symmetric matrix (needed for eigs to work properly)
data = np.array([2.0, 3.0, 1.0, 4.0, 1.5, 2.5])
row = np.array([0, 0, 1, 1, 2, 3])
col = np.array([0, 1, 1, 2, 2, 3])
A_sparse = sp.csr_matrix((data, (row, col)), shape=(4, 4))
# Make it symmetric for eigs to work well
A_sparse = A_sparse + A_sparse.T
# Convert to a LinearOperator which is what eigs expects
A = sp.linalg.aslinearoperator(A_sparse)
# Number of eigenmodes to compute (must be less than matrix size)
Neigs = 2
# Estimate for eigenvalues (used as sigma parameter in eigs)
guess_value = 1.0
ARGS = {
"A": A,
"Neigs": Neigs,
"guess_value": guess_value
}
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
- Imports
- numpy, scipy, torch — import names as written, not package names to install; a name the repository itself provides is not a package
- Returned
- type tuple — a tuple output has no array shape of its own; none is stated
- Environment
- image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
|
| step_adam |
Ran ran on a synthesized input |
twhughes/ceviche/ceviche/optimizers.py code served (permissive licence) · get_code("e77506199877251d") 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, 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
# Set random seed for reproducibility
np.random.seed(0)
# Create small gradient array (shape 4,)
gradient = np.array([0.1, -0.2, 0.3, -0.15], dtype=np.float32)
# Create momentum term (same shape as gradient)
mopt_old = np.array([0.05, -0.1, 0.15, -0.08], dtype=np.float32)
# Create velocity term (same shape as gradient)
vopt_old = np.array([0.02, 0.03, 0.01, 0.04], dtype=np.float32)
# Iteration counter
iteration = 5
# Beta1 (exponential decay rate for first moment)
beta1 = 0.9
# Beta2 (exponential decay rate for second moment)
beta2 = 0.999
# Epsilon for numerical stability
epsilon = 1e-08
ARGS = {
"gradient": gradient,
"mopt_old": mopt_old,
"vopt_old": vopt_old,
"iteration": iteration,
"beta1": beta1,
"beta2": beta2,
"epsilon": epsilon
}
- 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
|
| transpose_indices |
Ran ran on a synthesized input |
twhughes/ceviche/ceviche/utils.py code served (permissive licence) · get_code("61e877158b641cc2") 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 int, shape (3, 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 autograd.numpy as npa
import numpy as np
def transpose_indices(indices):
return npa.flip(indices, axis=0)
# Create a small numpy array to serve as indices
# Using a 2D array with shape (3, 4) for clarity
indices = np.array([
[0, 1, 2, 3],
[4, 5, 6, 7],
[8, 9, 10, 11]
], dtype=np.int32)
ARGS = {
"indices": indices
}
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
- Imports
- autograd, 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 int, shape (3, 4) — shape (3, 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
|
| b_TFSF |
Not yet run unverified (harvested, no recorded run) |
twhughes/ceviche/ceviche/sources.py code served (permissive licence) · get_code("48d1890792d089d5") How it ran |
| compute_Q |
Not yet run unverified (harvested, no recorded run) |
twhughes/ceviche/ceviche/sources.py code served (permissive licence) · get_code("3515683a16b35b70") How it ran |
| compute_derivative_matrices |
Not yet run unverified (harvested, no recorded run) |
twhughes/ceviche/ceviche/derivatives.py code served (permissive licence) · get_code("fc7f8ba239f1a047") How it ran |
| grad_sp_mult_x_reverse |
Not yet run unverified (harvested, no recorded run) |
twhughes/ceviche/ceviche/primitives.py code served (permissive licence) · get_code("02bb35d49602cd88") How it ran |
| make_sparse |
Not yet run unverified (harvested, no recorded run) |
twhughes/ceviche/ceviche/utils.py code served (permissive licence) · get_code("e3020417beb6b8ca") How it ran |
| solve_linear |
Not yet run unverified (harvested, no recorded run) |
twhughes/ceviche/ceviche/solvers.py code served (permissive licence) · get_code("ae7d57329e86bec6") How it ran |
| sp_mult |
Not yet run unverified (harvested, no recorded run) |
twhughes/ceviche/ceviche/primitives.py code served (permissive licence) · get_code("149de24946952497") How it ran |