| NCC |
Ran ran; our contract draft was wrong, not the code |
agnjason/fmhr/models/ncc_utils.py code served (permissive licence) · get_code("28a53e0f276bbbc8") 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 Tensor, ndim 2, dtype family float, shape (2, 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 torch
torch.manual_seed(0)
# Based on the function signature and usage:
# ref: shape (1, npoints, npixels)
# src: shape (nviews, npoints, npixels)
# ref_valid_mask: shape (1, npoints, npixels)
# src_valid_mask: shape (nviews, npoints, npixels)
nviews = 2
npoints = 4
npixels = 3
ref = torch.randn(1, npoints, npixels)
src = torch.randn(nviews, npoints, npixels)
ref_valid_mask = torch.randint(0, 2, (1, npoints, npixels)).float()
src_valid_mask = torch.randint(0, 2, (nviews, npoints, npixels)).float()
ARGS = {
"ref": ref,
"src": src,
"ref_valid_mask": ref_valid_mask,
"src_valid_mask": src_valid_mask,
}
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
- Imports
- torch — import names as written, not package names to install; a name the repository itself provides is not a package
- Returned
- type Tensor, ndim 2, dtype family float, shape (2, 4) — shape (2, 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
|
| add_hom |
Ran ran; our contract draft was wrong, not the code |
agnjason/fmhr/models/ncc_utils.py code served (permissive licence) · get_code("c27682ba51eb4e6f") 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 Tensor, ndim 2, dtype family float, shape (2, 5) as a later run recorded it. The image it ran in was not recorded. If your copy returns the same type, ndim and shape on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.
import torch
import numpy as np
torch.manual_seed(0)
# Test case 1: PyTorch tensor
pts_torch = torch.randn(2, 4)
# Test case 2: NumPy array
pts_numpy = np.random.randn(2, 4)
# Create ARGS dict with both test cases
# We'll use the torch tensor as the primary test
ARGS = {
"pts": pts_torch
}
- 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 Tensor, ndim 2, dtype family float, shape (2, 5) — shape (2, 5) as a later run recorded it
- dtype family
- int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
- Environment
- image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
|
| calculate_psnr |
Ran ran; the contract check could not run (RAISES, DEP_MISSING or TIMEOUT) |
agnjason/fmhr/train_unet.py code served (permissive licence) · get_code("e7c54f2a25d9ee14") 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 float, ndim 0, dtype family float, shape () as a later run recorded it. The image it ran in was not recorded. If your copy returns the same type, ndim and shape on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.
import numpy as np
import math
# Create small distinct-sized arrays for img1 and img2
# The function expects numpy arrays that can be cast to float64
img1 = np.random.randint(0, 256, size=(4, 3), dtype=np.uint8)
img2 = np.random.randint(0, 256, size=(4, 3), dtype=np.uint8)
# Create a mask with some True values
# mask.sum() is used in division, so it must be > 0
mask = np.array([[True, False, True],
[True, True, False],
[False, True, True],
[True, True, True]], dtype=bool)
ARGS = {
"img1": img1,
"img2": img2,
"mask": mask
}
- 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 float, ndim 0, dtype family float, shape () — shape () as a later run recorded it
- dtype family
- int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
- Environment
- image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
|
| compute_laplacian |
Ran ran; our contract draft was wrong, not the code |
agnjason/fmhr/mano_optim.py code served (permissive licence) · get_code("1725abb601f10ca5") 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 Tensor. The image it ran in was not recorded. If your copy returns the same type on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.
import torch
torch.manual_seed(0)
# Create a simple mesh with 4 vertices and 2 triangular faces
# verts: (V, 3) - 4 vertices with 3D coordinates
verts = torch.tensor([
[0.0, 0.0, 0.0],
[1.0, 0.0, 0.0],
[0.0, 1.0, 0.0],
[0.0, 0.0, 1.0]
], dtype=torch.float32)
# faces: (F, 3) - 2 faces, each with 3 vertex indices
faces = torch.tensor([
[0, 1, 2],
[0, 1, 3]
], dtype=torch.long)
ARGS = {
'verts': verts,
'faces': faces
}
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
- Imports
- torch — import names as written, not package names to install; a name the repository itself provides is not a package
- Returned
- type Tensor, shape (4, 4) — shape (4, 4) as a later run recorded it
- 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
|
| convert2sparse |
Ran ran; our contract draft was wrong, not the code |
agnjason/fmhr/models/gcn.py code served (permissive licence) · get_code("999ef3f8561e7b10") 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 Tensor. 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 torch
from scipy import sparse
torch.manual_seed(0)
# Create a small sparse matrix using scipy
# The function expects a scipy sparse matrix with .tocoo() method
row = np.array([0, 1, 2, 1])
col = np.array([0, 1, 2, 0])
data = np.array([1.0, 2.0, 3.0, 4.0])
scipy_sparse_matrix = sparse.coo_matrix((data, (row, col)), shape=(3, 4))
ARGS = {
"matrix": scipy_sparse_matrix
}
- 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 Tensor, shape (3, 4) — shape (3, 4) as a later run recorded it
- 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
|
| convmtx2 |
Ran ran; the contract check could not run (RAISES, DEP_MISSING or TIMEOUT) |
agnjason/fmhr/models/sfs_utils.py code served (permissive licence) · get_code("9583f37b904687d4") 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 csc_matrix. 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.sparse import csc_matrix
# Create a small kernel (square matrix)
kernel = np.array([[1.0, 2.0],
[3.0, 4.0]])
# Create a small shape (height, width)
shape = (3, 4)
ARGS = {
"kernel": kernel,
"shape": shape
}
- 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 csc_matrix — a csc_matrix output has no array shape of its own; none is stated — the instrument coerces any output to an array; for a csc_matrix 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
|
| depth2normal |
Ran ran, honoured the contract we drafted |
agnjason/fmhr/models/sfs_utils.py code served (permissive licence) · get_code("08ca1a3c5b8af575") 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 (4, 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
# Create a small depth map (2D array representing depth values)
# Using distinct dimensions: 4 height x 3 width
depth = np.array([
[1.0, 2.0, 1.5],
[1.5, 2.5, 2.0],
[2.0, 2.2, 1.8],
[1.8, 2.1, 1.9]
], dtype=np.float32)
ARGS = {
"depth": depth
}
- 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 3, dtype family float, shape (4, 3, 3) — shape (4, 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
|
| estimate_shading |
Ran ran; the contract check could not run (RAISES, DEP_MISSING or TIMEOUT) |
agnjason/fmhr/models/sfs_utils.py code served (permissive licence) · get_code("3359d23ac8fc9fd1") 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
import cv2
# Create small test data
height, width = 4, 5
# Create a small color image (h, w, 3) with values in range [0, 255]
color_im = np.random.randint(0, 256, size=(height, width, 3), dtype=np.uint8)
# Create normals (h, w, 3) - normalized direction vectors
normals = np.random.randn(height, width, 3).astype(np.float64)
# Normalize each normal vector
for i in range(height):
for j in range(width):
norm = np.linalg.norm(normals[i, j])
if norm > 0:
normals[i, j] /= norm
# Create a boolean mask (h, w) with some True values
color_mask = np.random.rand(height, width) > 0.5
# Ensure at least 4 valid pixels for the least squares solution
color_mask.flat[np.random.choice(height * width, 4, replace=False)] = True
ARGS = {
"color_im": color_im,
"normals": normals,
"color_mask": color_mask
}
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
- Imports
- cv2, 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
|
| fftfreqs |
Ran ran; the contract check could not run (RAISES, DEP_MISSING or TIMEOUT) |
agnjason/fmhr/models/sap.py code served (permissive licence) · get_code("086ad4999b6c210e") 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 Tensor, ndim 4, dtype family float, shape (4, 5, 4, 3) as a later run recorded it. The image it ran in was not recorded. If your copy returns the same type, ndim and shape on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.
import torch
import numpy as np
torch.manual_seed(0)
ARGS = {
"res": (4, 5, 6),
"dtype": torch.float32,
"exact": True
}
- 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 Tensor, ndim 4, dtype family float, shape (4, 5, 4, 3) — shape (4, 5, 4, 3) as a later run recorded it
- dtype family
- int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
- Environment
- image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
|
| get_edges |
Ran ran; our contract draft was wrong, not the code |
agnjason/fmhr/mano_optim.py code served (permissive licence) · get_code("a84f1093efd108a8") 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
torch.manual_seed(0)
# Create small test data
# verts: tensor of vertex positions, shape (V, 3) where V is number of vertices
# faces: tensor of face indices, shape (F, 3) where F is number of faces
# Each face is a triplet of vertex indices [v0, v1, v2]
V = 4 # number of vertices
F = 2 # number of faces
# Create vertices - shape (4, 3)
verts = torch.randn(V, 3)
# Create faces - shape (2, 3)
# Each row contains 3 vertex indices
faces = torch.tensor([
[0, 1, 2],
[1, 2, 3]
], dtype=torch.long)
ARGS = {
"verts": verts,
"faces": faces,
}
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
- Imports
- torch — import names as written, not package names to install; a name the repository itself provides is not a package
- Returned
- type tuple — a tuple output has no array shape of its own; none is stated
- Environment
- image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
|
| get_ray_directions |
Ran ran, honoured the contract we drafted |
agnjason/fmhr/models/get_rays.py code served (permissive licence) · get_code("e19803e9ee2c4627") 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 Tensor, ndim 3, dtype family float, shape (4, 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 torch
torch.manual_seed(0)
# These are camera intrinsic parameters
# H: image height
# W: image width
# fx, fy: focal lengths
# cx, cy: principal point (optical center)
ARGS = {
"H": 4,
"W": 3,
"fx": 500.0,
"fy": 500.0,
"cx": 1.5,
"cy": 2.0,
}
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
- Imports
- torch — import names as written, not package names to install; a name the repository itself provides is not a package
- Returned
- type Tensor, ndim 3, dtype family float, shape (4, 3, 3) — shape (4, 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
|
| get_rays |
Ran ran; the contract check could not run (RAISES, DEP_MISSING or TIMEOUT) |
agnjason/fmhr/models/get_rays.py code served (permissive licence) · get_code("f82ba403be143b44") 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 3, dtype family float; no output shape is stated. The image it ran in was not recorded. If your copy returns the same type and ndim on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.
import torch
torch.manual_seed(0)
# directions: used as left operand in matrix multiplication with c2w[:3, :3]
# c2w[:3, :3] has shape (3, 3), so directions should be broadcastable
# The function expects directions to have shape (..., 3) where ... can be any batch dimensions
# After @ operation with (3, 3), result is (..., 3)
# Then it's normalized and viewed to (-1, 3)
# Let's make directions shape (2, 4, 3) - batch of 2, spatial 4, 3D vectors
directions = torch.randn(2, 4, 3)
# c2w: camera-to-world matrix
# Used as: c2w[:3, :3] (3x3 rotation), c2w[:3, 3] (3D translation)
# Standard 4x4 homogeneous transformation matrix
c2w = torch.eye(4)
c2w[:3, :3] = torch.randn(3, 3)
c2w[:3, 3] = torch.randn(3)
ARGS = {
"directions": directions,
"c2w": c2w,
}
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
- Imports
- torch — import names as written, not package names to install; a name the repository itself provides is not a package
- Returned
- type tuple, ndim 3, dtype family float — a tuple output has no array shape of its own; none is stated
- dtype family
- int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
- Environment
- image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
|
| img |
Ran ran; the contract check could not run (RAISES, DEP_MISSING or TIMEOUT) |
agnjason/fmhr/models/sap.py code served (permissive licence) · get_code("d77c3b9fe4c2a271") How it ranRan in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1) and returned Tensor, ndim 3, dtype family float, shape (2, 4, 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 torch
torch.manual_seed(0)
# The function takes a tensor x and multiplies it by i**deg (imaginary unit powers)
# It expects x to have a last dimension of size 2 (representing complex numbers as [real, imag])
# and performs operations like swapping and negating components
x = torch.randn(2, 4, 2) # batch=2, some_dim=4, complex_dim=2
deg = 1
ARGS = {
"x": x,
"deg": deg,
}
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1
- Imports
- torch — import names as written, not package names to install; a name the repository itself provides is not a package
- Returned
- type Tensor, ndim 3, dtype family float, shape (2, 4, 2) — shape (2, 4, 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
|
| img_contrast_bright |
Ran ran; the contract check could not run (RAISES, DEP_MISSING or TIMEOUT) |
agnjason/fmhr/get_data.py code served (permissive licence) · get_code("10908dad0c9e096d") 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 int, shape (4, 5, 3) as a later run recorded it. The image it ran in was not recorded. If your copy returns the same type, ndim and shape on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.
import numpy as np
import cv2
# Create a small test image with shape (h, w, c)
# Using uint8 dtype which is standard for images
h, w, c = 4, 5, 3
img = np.random.randint(0, 256, size=(h, w, c), dtype=np.uint8)
# Parameters for cv2.addWeighted
# a: weight for the first image
a = 1.2
# b: weight for the blank image (typically 0 for simple contrast adjustment)
b = 0.0
# g: scalar added to each pixel
g = 30
ARGS = {
'img': img,
'a': a,
'b': b,
'g': g
}
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
- Imports
- cv2, 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 int, shape (4, 5, 3) — shape (4, 5, 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
|
| laplacian |
Ran ran; our contract draft was wrong, not the code |
agnjason/fmhr/models/mesh_sampling.py code served (permissive licence) · get_code("278d8710708c571f") 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 csr_matrix. The image it ran in was not recorded. If your copy returns the same type on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.
import numpy as np
import scipy.sparse as sp
# Create a small sparse adjacency matrix W
# The function expects W to be a scipy sparse matrix with .sum() method
# and to support arithmetic operations
np.random.seed(0)
# Create a small sparse adjacency matrix (4x4)
# Using a symmetric adjacency matrix for a graph
data = np.array([1.0, 1.0, 1.0, 1.0, 1.0, 1.0])
row = np.array([0, 0, 1, 1, 2, 3])
col = np.array([1, 2, 0, 3, 0, 1])
W = sp.csr_matrix((data, (row, col)), shape=(4, 4), dtype=np.float64)
ARGS = {
"W": W,
"normalized": True,
}
- 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 csr_matrix — a csr_matrix output has no array shape of its own; none is stated — the instrument coerces any output to an array; for a csr_matrix 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
|
| laplacian_cot |
Ran ran; the contract check could not run (RAISES, DEP_MISSING or TIMEOUT) |
agnjason/fmhr/mano_optim.py code served (permissive licence) · get_code("635669225b79bf5c") 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
torch.manual_seed(0)
# Create a simple mesh with 4 vertices and 2 triangular faces
verts = torch.tensor([
[0.0, 0.0, 0.0],
[1.0, 0.0, 0.0],
[0.0, 1.0, 0.0],
[0.0, 0.0, 1.0]
], dtype=torch.float32)
# Define 2 faces, each referencing 3 vertices
faces = torch.tensor([
[0, 1, 2],
[0, 1, 3]
], dtype=torch.long)
ARGS = {
"verts": verts,
"faces": faces
}
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
- Imports
- torch — import names as written, not package names to install; a name the repository itself provides is not a package
- Returned
- type tuple — a tuple output has no array shape of its own; none is stated
- Environment
- image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
|
| normalize |
Ran ran; our contract draft was wrong, not the code |
agnjason/fmhr/models/ncc_utils.py code served (permissive licence) · get_code("ee38789614e9343f") 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 Tensor, ndim 4, dtype family float, shape (2, 3, 4, 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 torch
torch.manual_seed(0)
# Create a flow tensor with shape (2, 3, 4, 2) - batch=2, height=3, width=4, channels=2
# This matches the 4D case in the function
flow = torch.randn(2, 3, 4, 2)
# Height and width parameters
h = 3
w = 4
# Optional clamp parameter
clamp = 1.0
ARGS = {
"flow": flow,
"h": h,
"w": w,
"clamp": clamp
}
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
- Imports
- torch — import names as written, not package names to install; a name the repository itself provides is not a package
- Returned
- type Tensor, ndim 4, dtype family float, shape (2, 3, 4, 2) — shape (2, 3, 4, 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
|
| poolwT |
Ran ran; the contract check could not run (RAISES, DEP_MISSING or TIMEOUT) |
agnjason/fmhr/models/gcn.py code served (permissive licence) · get_code("3adcb35add712974") 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 Tensor, ndim 3, dtype family float, shape (2, 5, 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 torch
torch.manual_seed(0)
# Analyze the function:
# - x: tensor with shape (n, m, fin), used with permute and reshape
# - L: tensor with shape (mp, ...), used with matmul and shape[0]
# The function does:
# 1. x.permute(1, 2, 0) -> (m, fin, n)
# 2. reshape(m, fin*n) -> (m, fin*n)
# 3. matmul(L, x) where L is (mp, fin*n)
# 4. reshape(mp, fin, n) and permute(2, 0, 1) -> (n, mp, fin)
# So L must be shape (mp, fin*n) to multiply with (m, fin*n)
# This means L.shape[0] = mp and L.shape[1] = fin*n
# Let's use distinct sizes:
n = 2 # batch size
m = 3 # spatial dimension
fin = 4 # input features
mp = 5 # output pooling dimension (L.shape[0])
# x shape: (n, m, fin) = (2, 3, 4)
x = torch.randn(n, m, fin)
# L shape: (mp, fin*n) - note that for matmul to work with reshaped x of (m, fin*n),
# L must be (mp, m*fin) or we need to reconsider...
# Looking at the code: x becomes (m, fin*n) after reshape
# Then matmul(L, x) means L @ x where L is (mp, ?) and x is (?, something)
# For this to work: L must be (mp, m*fin) since x is reshaped to (m, fin*n)
# Wait, let me retrace:
# x starts (n, m, fin) = (2, 3, 4)
# x.permute(1, 2, 0) = (m, fin, n) = (3, 4, 2)
# x.reshape(m, fin*n) = (3, 8)
# matmul(L, x) with x being (3, 8): L must be (mp, 3) for valid matmul output (mp, 8)
# So L.shape = (mp, m)
L = torch.randn(mp, m)
ARGS = {
"x": x,
"L": L,
}
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
- Imports
- torch — import names as written, not package names to install; a name the repository itself provides is not a package
- Returned
- type Tensor, ndim 3, dtype family float, shape (2, 5, 4) — shape (2, 5, 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
|
| rescale_L |
Ran ran; our contract draft was wrong, not the code |
agnjason/fmhr/models/mesh_sampling.py code served (permissive licence) · get_code("e331855d53ef4b5e") 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 csr_matrix. 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 scipy.sparse as sp
import numpy as np
# Create a small sparse Laplacian matrix
# The function expects L to be a sparse matrix with shape (M, M)
M = 4
L = sp.random(M, M, density=0.5, format='csr', dtype=np.float32)
# Make it symmetric to be a valid Laplacian-like matrix
L = (L + L.T) / 2
ARGS = {
'L': L,
'lmax': 2
}
- 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 csr_matrix — a csr_matrix output has no array shape of its own; none is stated — the instrument coerces any output to an array; for a csr_matrix 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
|
| sap_generate |
Ran ran; the contract check could not run (RAISES, DEP_MISSING or TIMEOUT) |
agnJason/FMHR/models/sap.py code served (permissive licence) · get_code("523ed667113feb04") How it ranRan in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1) 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 torch.nn as nn
torch.manual_seed(0)
# Build a mock DPSR model
class MockDPSR(nn.Module):
def __init__(self):
super().__init__()
self.linear = nn.Linear(3, 16)
def forward(self, points, normals):
# points: (batch, num_points, 3)
# normals: (batch, num_points, 3)
# Output should be (batch, 1, grid_size, grid_size, grid_size) or similar
batch_size = points.shape[0]
# Return a small grid tensor with batch dimension and channel dimension
return torch.randn(batch_size, 1, 4, 4, 4)
# Build a mock PSR2Mesh model
class MockPSR2Mesh(nn.Module):
def __init__(self):
super().__init__()
self.linear = nn.Linear(64, 32)
def forward(self, psr_grid):
# psr_grid: (batch, 1, 4, 4, 4) or similar
batch_size = psr_grid.shape[0]
# Return vertices (batch, num_verts, 3) and faces (batch, num_faces, 3)
num_verts = 8
num_faces = 6
vertices = torch.randn(batch_size, num_verts, 3)
faces = torch.randint(0, num_verts, (batch_size, num_faces, 3))
return vertices, faces
dpsr = MockDPSR()
psr2mesh = MockPSR2Mesh()
# Create inputs: (batch, num_points, 6) where first 3 are points, last 3 are normals
batch_size = 2
num_points = 5
inputs = torch.randn(batch_size, num_points, 6)
# Create center and scale
center = torch.tensor([0.0, 0.0, 0.0])
scale = torch.tensor([1.0, 1.0, 1.0])
ARGS = {
"dpsr": dpsr,
"psr2mesh": psr2mesh,
"inputs": inputs,
"center": center,
"scale": scale,
}
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1
- Imports
- torch — import names as written, not package names to install; a name the repository itself provides is not a package
- Returned
- type tuple — a tuple output has no array shape of its own; none is stated
- Environment
- image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
|
| sap_transform |
Ran ran; the contract check could not run (RAISES, DEP_MISSING or TIMEOUT) |
agnJason/FMHR/models/sap.py code served (permissive licence) · get_code("f3a258f73e2c917f") 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 Tensor, 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 torch
import numpy as np
torch.manual_seed(0)
# Create small tensors for the function parameters
# verts: vertices tensor, shape (2, 4) - batch of 2, 4D coordinates
verts = torch.randn(2, 4)
# center: center point for translation, shape (4,) - same dimension as verts
center = torch.randn(4)
# scale: scale factor for normalization, shape (4,) - same dimension as verts
scale = torch.randn(4).abs() + 0.1 # ensure non-zero values
# inverse: boolean flag for direction of transformation
inverse = False
ARGS = {
"verts": verts,
"center": center,
"scale": scale,
"inverse": inverse
}
- 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 Tensor, ndim 2, dtype family float — no output shape is stated: observe_signature.py could not observe it (no_result)
- 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
|
| scale_input |
Ran ran; the contract check could not run (RAISES, DEP_MISSING or TIMEOUT) |
agnjason/fmhr/models/PostionalEncoding.py code served (permissive licence) · get_code("ff4a0c727a4528a5") 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 Tensor, ndim 4, dtype family float, shape (2, 4, 5, 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 torch
torch.manual_seed(0)
# Construct a small 3D grid tensor
# Shape: (batch=2, height=4, width=5, channels=3) for a 3D coordinate grid
grid_3d = torch.randn(2, 4, 5, 3)
# Construct a transform matrix
# Shape: (4, 4) - standard homogeneous transformation matrix
# First 3 rows: rotation + translation, last row: perspective (usually [0, 0, 0, 1])
transform = torch.eye(4)
transform[:3, :3] = torch.randn(3, 3) # Random rotation-like matrix
transform[:3, 3] = torch.randn(3) # Translation component
# Construct a scale value
scale = 2.5
ARGS = {
"tensor": grid_3d,
"transform": transform,
"scale": scale,
}
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
- Imports
- torch — import names as written, not package names to install; a name the repository itself provides is not a package
- Returned
- type Tensor, ndim 4, dtype family float, shape (2, 4, 5, 3) — shape (2, 4, 5, 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
|
| spec_gaussian_filter |
Ran ran; the contract check could not run (RAISES, DEP_MISSING or TIMEOUT) |
agnjason/fmhr/models/sap.py code served (permissive licence) · get_code("656da6fdcc2cdcbf") 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 Tensor, ndim 5, dtype family float, shape (8, 6, 3, 1, 1) as a later run recorded it. The image it ran in was not recorded. If your copy returns the same type, ndim and shape on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.
import torch
import numpy as np
torch.manual_seed(0)
ARGS = {
"res": (8, 6, 4),
"sig": 1.0
}
- 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 Tensor, ndim 5, dtype family float, shape (8, 6, 3, 1, 1) — shape (8, 6, 3, 1, 1) 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
|
| transform_3D_grid |
Ran ran; the contract check could not run (RAISES, DEP_MISSING or TIMEOUT) |
agnjason/fmhr/models/PostionalEncoding.py code served (permissive licence) · get_code("1773bfa986183e62") 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 Tensor, ndim 4, dtype family float, shape (2, 4, 5, 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 torch
torch.manual_seed(0)
# Create a 3D grid with shape (batch, height, width, channels=3)
grid_3d = torch.randn(2, 4, 5, 3)
# Create a transform matrix with shape (4, 4) - 3x3 rotation + 3x1 translation
# The function expects transform[None, None, None, i, j] indexing
transform = torch.randn(4, 4)
# Scale factor
scale = 2.0
ARGS = {
"grid_3d": grid_3d,
"transform": transform,
"scale": scale,
}
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
- Imports
- torch — import names as written, not package names to install; a name the repository itself provides is not a package
- Returned
- type Tensor, ndim 4, dtype family float, shape (2, 4, 5, 3) — shape (2, 4, 5, 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
|
| vertex_quadrics |
Ran ran, honoured the contract we drafted |
agnjason/fmhr/models/mesh_sampling.py code served (permissive licence) · get_code("3129a88f8d186902") 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 (4, 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
class Mesh:
def __init__(self, v, f):
self.v = v
self.f = f
# Create a simple mesh with 4 vertices and 2 triangular faces
# vertices: 4 vertices in 3D space
vertices = np.array([
[0.0, 0.0, 0.0],
[1.0, 0.0, 0.0],
[0.0, 1.0, 0.0],
[0.0, 0.0, 1.0]
], dtype=np.float64)
# faces: 2 triangles, each defined by 3 vertex indices
faces = np.array([
[0, 1, 2],
[0, 1, 3]
], dtype=np.int32)
mesh = Mesh(v=vertices, f=faces)
ARGS = {
"mesh": mesh
}
- 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 3, dtype family float, shape (4, 4, 4) — shape (4, 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
|