| identity |
Ran ran, honoured the contract we drafted |
ai4science-westlakeu/t_scend/tscend_src/model/diffusion_lib/denoising_diffusion_pytorch_1d.py code served (permissive licence) · get_code("7f1040f5e3991d5e") How it ranRan in Syntology's jail on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1) 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. The comparison behind this sample's level is a different run: the peer-agreement lane ran it again on the host, not in the jail (report dated 2026-09-05T00:37:21Z). 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 torch.nn as nn
torch.manual_seed(0)
# The identity function simply returns its first argument
# and ignores all other args and kwargs
# So we need to provide a value for t and can optionally provide other args/kwargs
t = torch.randn(2, 4)
extra_arg_1 = torch.randn(3, 5)
extra_arg_2 = "some_string"
extra_kwarg_1 = 42
extra_kwarg_2 = [1, 2, 3]
ARGS = {
"t": t,
"args": (extra_arg_1, extra_arg_2),
"kwargs": {"key1": extra_kwarg_1, "key2": extra_kwarg_2}
}
- 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 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
|
| swish |
Ran ran; our contract draft was wrong, not the code |
ai4science-westlakeu/t_scend/tscend_src/model/models.py code served (permissive licence) · get_code("0f786c407fb1ee4c") How it ranRan in Syntology's jail on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1) 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. The comparison behind this sample's level is a different run: the peer-agreement lane ran it again on the host, not in the jail (report dated 2026-09-04T22:33:52Z). 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 swish takes a single parameter 'x' which is used with:
# - torch.sigmoid(x) - requires a tensor
# - x * ... - requires a tensor that supports multiplication
# So x should be a tensor
x = torch.randn(2, 4)
ARGS = {
"x": x
}
- 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 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
|
| Expander |
Ran ran on a synthesized input |
AI4Science-WestlakeU/VFScale/vfscale_src/model/models.py code served (permissive licence) · get_code("14f0772248b45045") How it ranRan in Syntology's sandbox on this synthesized input (drafted by a language model, class construct-then-call prompt, model not recorded) and returned Tensor, ndim 4, dtype family float, shape (2, 1, 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 torch
import torch.nn as nn
from typing import Union, Tuple, List
import collections
def broadcast(tensor: torch.Tensor, dim: int, size: int) -> torch.Tensor:
"""Broadcast a specific dim for `size` times. Originally the dim size must be 1."""
if dim < 0:
dim += tensor.dim()
assert tensor.size(dim) == 1
shape = tensor.size()
return tensor.expand(concat_shape(shape[:dim], size, shape[dim + 1:]))
def concat_shape(*shapes: Union[torch.Size, Tuple[int, ...], List[int], int]) -> Tuple[int, ...]:
"""Concatenate shapes into a tuple."""
output = []
for s in shapes:
if isinstance(s, collections.abc.Sequence):
output.extend(s)
else:
output.append(int(s))
return tuple(output)
class Expander(nn.Module):
def __init__(self, dim):
super().__init__()
self.dim = dim
def forward(self, input, n=None):
if self.dim == 0:
assert n is not None
elif n is None:
n = input.size(self.dim)
dim = self.dim + 1
return broadcast(input.unsqueeze(dim), dim, n)
def get_output_dim(self, input_dim):
return input_dim
INIT_ARGS = {
'dim': 1
}
ARGS = {
'input': torch.randn(2, 1, 4),
'n': 3
}
if __name__ == '__main__':
expander = Expander(**INIT_ARGS)
output = expander(**ARGS)
print("Output shape:", output.shape)
print("Output:", output)
- Setup block drafted by
- a language model, class construct-then-call prompt, model not recorded
- 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, 1, 3, 4) — shape (2, 1, 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: torch and numpy seeded to 0 by the harness immediately before the class was constructed from INIT_ARGS (fixture_check.py)
|
| InferenceBase |
Ran ran on a synthesized input |
AI4Science-WestlakeU/VFScale/vfscale_src/model/models.py code served (permissive licence) · get_code("143b2aeff2125292") How it ranRan in Syntology's sandbox on this synthesized input (drafted by a language model, class construct-then-call prompt, model not recorded) 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
from scipy import stats
INIT_ARGS = {
'input_dim': 4,
'output_dim': 3,
'hidden_dim': [5, 6]
}
# Create input tensor with shape (2, 4) - batch_size=2, input_dim=4
input_tensor = torch.randn(2, 4)
ARGS = {
'inputs': input_tensor
}
- Setup block drafted by
- a language model, class construct-then-call prompt, model not recorded
- 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, ndim 2, dtype family float — no output shape is stated: observe_signature.py observed this class with its constructor sizes canonicalised where it could, which the node does not record, so its shape is not stated as this setup block's
- 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: torch and numpy seeded to 0 by the harness immediately before the class was constructed from INIT_ARGS (fixture_check.py)
|
| LinearLayer |
Ran ran on a synthesized input |
AI4Science-WestlakeU/VFScale/vfscale_src/model/models.py code served (permissive licence) · get_code("8d87e276de13f530") How it ranRan in Syntology's sandbox on this synthesized input (drafted by a language model, class construct-then-call prompt, model not recorded) and returned Tensor, ndim 2, dtype family float, shape (2, 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 torch.nn as nn
# Helper functions from the class definition
def get_activation(act):
if isinstance(act, nn.Module):
return act
assert type(act) is str, 'Unknown type of activation: {}.'.format(act)
act_lower = act.lower()
if act_lower == 'identity':
return nn.Identity()
elif act_lower == 'relu':
return nn.ReLU(True)
elif act_lower == 'sigmoid':
return nn.Sigmoid()
elif act_lower == 'tanh':
return nn.Tanh()
else:
try:
return getattr(nn, act)
except AttributeError:
raise ValueError('Unknown activation function: {}.'.format(act))
def get_batcnnorm(bn, nr_features=None, nr_dims=1):
if isinstance(bn, nn.Module):
return bn
assert 1 <= nr_dims <= 3
if bn in (True, 'async'):
clz_name = 'BatchNorm{}d'.format(nr_dims)
return getattr(nn, clz_name)(nr_features)
elif bn == 'sync':
raise NotImplementedError()
else:
raise ValueError('Unknown type of batch normalization: {}.'.format(bn))
def get_dropout(dropout, nr_dims=1):
if isinstance(dropout, nn.Module):
return dropout
if dropout is True:
dropout = 0.5
if nr_dims == 1:
return nn.Dropout(dropout, True)
else:
clz_name = 'Dropout{}d'.format(nr_dims)
return getattr(nn, clz_name)(dropout)
class LinearLayer(nn.Sequential):
def __init__(self, in_features, out_features, batch_norm=None, dropout=None, bias=None, activation=None):
if bias is None:
bias = batch_norm is None
modules = [nn.Linear(in_features, out_features, bias=bias)]
if batch_norm is not None and batch_norm is not False:
modules.append(get_batcnnorm(batch_norm, out_features, 1))
if dropout is not None and dropout is not False:
modules.append(get_dropout(dropout, 1))
if activation is not None and activation is not False:
modules.append(get_activation(activation))
super().__init__(*modules)
self.in_features = in_features
self.out_features = out_features
@property
def input_dim(self):
return self.in_features
@property
def output_dim(self):
return self.out_features
def reset_parameters(self):
for module in self.modules():
if isinstance(module, nn.Linear):
module.reset_parameters()
INIT_ARGS = {
'in_features': 4,
'out_features': 3,
'batch_norm': None,
'dropout': None,
'bias': None,
'activation': 'relu'
}
ARGS = {
'input': torch.randn(2, 4)
}
# Construct and call
layer = LinearLayer(**INIT_ARGS)
output = layer(**ARGS)
- Setup block drafted by
- a language model, class construct-then-call prompt, model not recorded
- 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, 3) — shape (2, 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: torch and numpy seeded to 0 by the harness immediately before the class was constructed from INIT_ARGS (fixture_check.py)
|
| LogicInference |
Ran ran on a synthesized input |
AI4Science-WestlakeU/VFScale/vfscale_src/model/models.py code served (permissive licence) · get_code("b20179518aab1891") How it ranRan in Syntology's sandbox on this synthesized input (drafted by a language model, class construct-then-call prompt, model not recorded) and returned Tensor, 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
import torch.nn as nn
# Helper functions from the class definition
def get_activation(act):
if isinstance(act, nn.Module):
return act
assert type(act) is str, 'Unknown type of activation: {}.'.format(act)
act_lower = act.lower()
if act_lower == 'identity':
return nn.Identity()
elif act_lower == 'relu':
return nn.ReLU(True)
elif act_lower == 'sigmoid':
return nn.Sigmoid()
elif act_lower == 'tanh':
return nn.Tanh()
else:
try:
return getattr(nn, act)
except AttributeError:
raise ValueError('Unknown activation function: {}.'.format(act))
def get_batcnnorm(bn, nr_features=None, nr_dims=1):
if isinstance(bn, nn.Module):
return bn
assert 1 <= nr_dims <= 3
if bn in (True, 'async'):
clz_name = 'BatchNorm{}d'.format(nr_dims)
return getattr(nn, clz_name)(nr_features)
elif bn == 'sync':
raise NotImplementedError()
else:
raise ValueError('Unknown type of batch normalization: {}.'.format(bn))
def get_dropout(dropout, nr_dims=1):
if isinstance(dropout, nn.Module):
return dropout
if dropout is True:
dropout = 0.5
if nr_dims == 1:
return nn.Dropout(dropout, True)
else:
clz_name = 'Dropout{}d'.format(nr_dims)
return getattr(nn, clz_name)(dropout)
# Class definitions
class LinearLayer(nn.Sequential):
def __init__(self, in_features, out_features, batch_norm=None, dropout=None, bias=None, activation=None):
if bias is None:
bias = batch_norm is None
modules = [nn.Linear(in_features, out_features, bias=bias)]
if batch_norm is not None and batch_norm is not False:
modules.append(get_batcnnorm(batch_norm, out_features, 1))
if dropout is not None and dropout is not False:
modules.append(get_dropout(dropout, 1))
if activation is not None and activation is not False:
modules.append(get_activation(activation))
super().__init__(*modules)
self.in_features = in_features
self.out_features = out_features
@property
def input_dim(self):
return self.in_features
@property
def output_dim(self):
return self.out_features
def reset_parameters(self):
for module in self.modules():
if isinstance(module, nn.Linear):
module.reset_parameters()
class MLPLayer(nn.Module):
def __init__(self, input_dim, output_dim, hidden_dims, batch_norm=None, dropout=None, activation='relu', flatten=True, last_activation=False):
super().__init__()
self.input_dim = input_dim
self.output_dim = output_dim
self.hidden_dims = hidden_dims
self.batch_norm = batch_norm
self.dropout = dropout
self.activation = activation
self.flatten = flatten
self.last_activation = last_activation
if hidden_dims is None:
hidden_dims = []
elif type(hidden_dims) is int:
hidden_dims = [hidden_dims]
dims = [input_dim]
dims.extend(hidden_dims)
dims.append(output_dim)
modules = []
nr_hiddens = len(hidden_dims)
for i in range(nr_hiddens):
layer = LinearLayer(dims[i], dims[i + 1], batch_norm=self.batch_norm, dropout=self.dropout, activation=self.activation)
modules.append(layer)
if self.last_activation:
layer = LinearLayer(dims[-2], dims[-1], batch_norm=self.batch_norm, dropout=self.dropout, activation=self.activation)
else:
layer = nn.Linear(dims[-2], dims[-1], bias=True)
modules.append(layer)
self.mlp = nn.Sequential(*modules)
def reset_parameters(self):
for module in self.modules():
if isinstance(module, nn.Linear):
module.reset_parameters()
def forward(self, input):
if self.flatten:
input = input.view(input.size(0), -1)
return self.mlp(input)
class InferenceBase(nn.Module):
def __init__(self, input_dim, output_dim, hidden_dim):
super().__init__()
self.input_dim = input_dim
self.output_dim = output_dim
self.hidden_dim = hidden_dim
self.layer = nn.Sequential(MLPLayer(input_dim, output_dim, hidden_dim))
def forward(self, inputs):
input_size = inputs.size()[:-1]
input_channel = inputs.size(-1)
f = inputs.view(-1, input_channel)
f = self.layer(f)
f = f.view(*input_size, -1)
return f
class LogicInference(InferenceBase):
def __init__(self, input_dim, output_dim, hidden_dim):
super().__init__(input_dim, output_dim, hidden_dim)
self.layer.add_module(str(len(self.layer)), nn.Sigmoid())
# Setup arguments
INIT_ARGS = {
'input_dim': 4,
'output_dim': 3,
'hidden_dim': 8,
}
ARGS = {
'inputs': torch.randn(2, 5, 4),
}
# Construct and call
model = LogicInference(**INIT_ARGS)
output = model(**ARGS)
- Setup block drafted by
- a language model, class construct-then-call prompt, model not recorded
- 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 — no output shape is stated: observe_signature.py observed this class with its constructor sizes canonicalised where it could, which the node does not record, so its shape is not stated as this setup block's
- 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: torch and numpy seeded to 0 by the harness immediately before the class was constructed from INIT_ARGS (fixture_check.py)
|
| MLPLayer |
Ran ran on a synthesized input |
AI4Science-WestlakeU/VFScale/vfscale_src/model/models.py code served (permissive licence) · get_code("b172f5e1fa3d4d6a") How it ranRan in Syntology's sandbox on this synthesized input (drafted by a language model, class construct-then-call prompt, model not recorded) 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 torch.nn as nn
INIT_ARGS = {
'input_dim': 6,
'output_dim': 3,
'hidden_dims': [8, 5],
'batch_norm': None,
'dropout': None,
'activation': 'relu',
'flatten': True,
'last_activation': False
}
ARGS = {
'input': torch.randn(2, 6)
}
- Setup block drafted by
- a language model, class construct-then-call prompt, model not recorded
- 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 — no output shape is stated: observe_signature.py observed this class with its constructor sizes canonicalised where it could, which the node does not record, so its shape is not stated as this setup block's
- 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: torch and numpy seeded to 0 by the harness immediately before the class was constructed from INIT_ARGS (fixture_check.py)
|
| Reducer |
Ran ran on a synthesized input |
AI4Science-WestlakeU/VFScale/vfscale_src/model/models.py code served (permissive licence) · get_code("4d7e91ea410a99e5") How it ranRan in Syntology's sandbox on this synthesized input (drafted by a language model, class construct-then-call prompt, model not recorded) and returned Tensor, ndim 3, dtype family float, shape (2, 3, 8) 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 torch.nn as nn
def exclude_mask(input, cnt=2, dim=1):
"""
Produce exclude mask. Specifically, for cnt=2, given an array a[i, j] of n * n, it produces
a mask with size n * n where only a[i, j] = 1 if and only if (i != j).
The operation is performed over [dim, dim + cnt) axes.
"""
assert cnt > 0
if dim < 0:
dim += input.dim()
n = input.size(dim)
for i in range(1, cnt):
assert n == input.size(dim + i)
rng = torch.arange(0, n, dtype=torch.long, device=input.device)
q = []
for i in range(cnt):
p = rng
for j in range(cnt):
if i != j:
p = p.unsqueeze(j)
p = p.expand((n,) * cnt)
q.append(p)
mask = q[0] == q[0]
for i in range(cnt):
for j in range(cnt):
if i != j:
mask *= q[i] != q[j]
for i in range(dim):
mask.unsqueeze_(0)
for j in range(input.dim() - dim - cnt):
mask.unsqueeze_(-1)
return mask.expand(input.size()).float()
def mask_value(input, mask, value):
assert input.size() == mask.size()
return input * mask + value * (1 - mask)
class Reducer(nn.Module):
def __init__(self, dim, exclude_self=True, exists=True):
super().__init__()
self.dim = dim
self.exclude_self = exclude_self
self.exists = exists
def forward(self, input):
shape = input.size()
inp0, inp1 = (input, input)
if self.exclude_self:
mask = exclude_mask(input, cnt=self.dim, dim=-1 - self.dim)
inp0 = mask_value(input, mask, 0.0)
inp1 = mask_value(input, mask, 1.0)
if self.exists:
shape = shape[:-2] + (shape[-1] * 2,)
exists = torch.max(inp0, dim=-2)[0]
forall = torch.min(inp1, dim=-2)[0]
return torch.stack((exists, forall), dim=-1).view(shape)
shape = shape[:-2] + (shape[-1],)
return torch.max(inp0, dim=-2)[0].view(shape)
def get_output_dim(self, input_dim):
if self.exists:
return input_dim * 2
return input_dim
INIT_ARGS = {
'dim': 2,
'exclude_self': True,
'exists': True,
}
ARGS = {
'input': torch.randn(2, 3, 3, 4),
}
if __name__ == '__main__':
reducer = Reducer(**INIT_ARGS)
output = reducer(**ARGS)
print("Output shape:", output.shape)
print("Output:", output)
- Setup block drafted by
- a language model, class construct-then-call prompt, model not recorded
- 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, 3, 8) — shape (2, 3, 8) 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: torch and numpy seeded to 0 by the harness immediately before the class was constructed from INIT_ARGS (fixture_check.py)
|
| _get_tuple_n |
Ran ran, honoured the contract we drafted |
AI4Science-WestlakeU/VFScale/vfscale_src/model/models.py code served (permissive licence) · get_code("421df320f85fd119") 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 list, ndim 1, dtype family int; 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)
# Analyze the function:
# - x: can be of type tp, or a list of elements of type tp
# - n: integer specifying the expected length
# - tp: a type (not list) that x or elements of x should match
# Test case 1: x is a single value of type tp, should be replicated n times
# Test case 2: x is already a list of n elements of type tp
# Let's use int as the type tp
x_single = 5
n = 3
tp = int
ARGS = {
"x": x_single,
"n": n,
"tp": tp
}
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1
- Imports
- numpy, torch — import names as written, not package names to install; a name the repository itself provides is not a package
- Returned
- type list, ndim 1, dtype family int — 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
|
| add_args_from_config |
Ran ran on a synthesized input |
ai4science-westlakeu/t_scend/tscend_src/utils/utils.py code served (permissive licence) · get_code("120c5b54f80e01ab") 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 ArgumentParser. 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 argparse
import yaml
import tempfile
import os
# Create a temporary YAML config file
temp_dir = tempfile.mkdtemp()
config_path = os.path.join(temp_dir, 'test_config.yaml')
config_data = {
'learning_rate': 0.001,
'batch_size': 32,
'epochs': 10,
'model_name': 'resnet50'
}
with open(config_path, 'w') as f:
yaml.dump(config_data, f)
# Create a parser with some existing arguments
parser = argparse.ArgumentParser()
parser.add_argument('--config', type=str, default=config_path)
parser.add_argument('--verbose', type=bool, default=False)
ARGS = {
'parser': parser
}
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
- Imports
- yaml — import names as written, not package names to install; a name the repository itself provides is not a package
- Returned
- type ArgumentParser — a ArgumentParser output has no array shape of its own; none is stated — the instrument coerces any output to an array; for a ArgumentParser 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
|
| broadcast |
Ran ran; the contract check could not run (RAISES, DEP_MISSING or TIMEOUT) |
AI4Science-WestlakeU/VFScale/vfscale_src/model/models.py code served (permissive licence) · get_code("a58996a6b5a75e87") 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 2, dtype family float, 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 torch
torch.manual_seed(0)
# Create a tensor with shape (1, 4) where dim 0 has size 1 (required for broadcasting)
tensor = torch.tensor([[1.0, 2.0, 3.0, 4.0]])
# dim to broadcast
dim = 0
# target size for that dimension
size = 3
ARGS = {
"tensor": tensor,
"dim": dim,
"size": size,
}
- 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 2, dtype family float, 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
|
| broadcast |
Ran ran on a synthesized input |
ai4science-westlakeu/t_scend/tscend_src/model/diffusion_lib/nlm_utils.py code served (permissive licence) · get_code("cf4d925ba3e0cd70") 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)
# Create a simple test tensor with shape (1, 4) where dim 0 has size 1
# This satisfies the assertion in broadcast that tensor.size(dim) == 1
tensor = torch.tensor([[1.0, 2.0, 3.0, 4.0]])
# dim=0 means we broadcast along the first dimension
dim = 0
# size=2 means we want to expand that dimension to size 2
size = 2
ARGS = {
"tensor": tensor,
"dim": dim,
"size": size,
}
- 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
|
| caculate_confidence_interval |
Ran ran on a synthesized input |
ai4science-westlakeu/t_scend/tscend_src/utils/utils.py code served (permissive licence) · get_code("d03ae14d2490cf24") 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 1, 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)
# Create a small tensor representing absolute differences (pred_design - pred_simu)
# Shape: (batch_size=2, feature_dim=4) to test the multi-dimensional case
data = torch.abs(torch.randn(2, 4))
ARGS = {
"data": data
}
- 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 1, 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
|
| default |
Ran ran, violated the contract we drafted |
ai4science-westlakeu/t_scend/tscend_src/model/diffusion_lib/denoising_diffusion_pytorch_1d.py code served (permissive licence) · get_code("d1ef6b8cb9a28a53") 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 str. 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)
def exists(x):
return x is not None
def default(val, d):
if exists(val):
return val
return d() if callable(d) else d
# Test case 1: val is not None, should return val
val_1 = "test_value"
d_1 = lambda: "default_value"
# Test case 2: val is None, d is callable, should return d()
val_2 = None
d_2 = lambda: "computed_default"
# Test case 3: val is None, d is not callable, should return d
val_3 = None
d_3 = "static_default"
# Test case 4: val is a number
val_4 = 42
d_4 = 100
# Test case 5: val is a tensor
val_5 = torch.tensor([1.0, 2.0, 3.0])
d_5 = lambda: torch.tensor([0.0])
ARGS = {
"val": val_1,
"d": d_1
}
- 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 str — a str output has no array shape of its own; none is stated — the instrument coerces any output to an array; for a str 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
|
| exclude_mask |
Ran ran; the contract check could not run (RAISES, DEP_MISSING or TIMEOUT) |
AI4Science-WestlakeU/VFScale/vfscale_src/model/models.py code served (permissive licence) · get_code("70af23bab509259e") 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 4, dtype family float, shape (2, 4, 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
torch.manual_seed(0)
# Create a small tensor with shape (2, 4, 4, 3)
# The function operates over [dim, dim+cnt) axes
# For dim=1, cnt=2, it will use axes 1 and 2 (both size 4)
# Batch dimension is 2, trailing dimension is 3
input_tensor = torch.randn(2, 4, 4, 3)
ARGS = {
"input": input_tensor,
"cnt": 2,
"dim": 1
}
- 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 4, dtype family float, shape (2, 4, 4, 3) — shape (2, 4, 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
|
| exists |
Ran ran, violated the contract we drafted |
ai4science-westlakeu/t_scend/tscend_src/model/diffusion_lib/denoising_diffusion_pytorch_1d.py code served (permissive licence) · get_code("608e364a9d2376a3") 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 bool, 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 torch
def exists(x):
return x is not None
ARGS = {
"x": torch.tensor([1, 2, 3, 4])
}
- 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 bool, 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
|
| get_activation |
Ran ran; our contract draft was wrong, not the code |
AI4Science-WestlakeU/VFScale/vfscale_src/model/models.py code served (permissive licence) · get_code("c608fc7d98f990e0") 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 ReLU. 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)
# Test case 1: string activation 'relu'
act_1 = 'relu'
# Test case 2: string activation 'identity'
act_2 = 'identity'
# Test case 3: string activation 'sigmoid'
act_3 = 'sigmoid'
# Test case 4: string activation 'tanh'
act_4 = 'tanh'
# Test case 5: nn.Module instance
act_5 = nn.ReLU(inplace=True)
# Test case 6: string activation that exists in nn module
act_6 = 'ELU'
# Primary test case - using 'relu' as the main argument
ARGS = {
'act': 'relu'
}
- 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 ReLU — a ReLU output has no array shape of its own; none is stated — the instrument coerces any output to an array; for a ReLU 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
|
| get_batcnnorm |
Ran ran; our contract draft was wrong, not the code |
AI4Science-WestlakeU/VFScale/vfscale_src/model/models.py code served (permissive licence) · get_code("9b9856f78988b052") 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 BatchNorm1d. 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)
# Test case 1: passing an nn.Module instance directly
bn_module = nn.BatchNorm1d(64)
# Test case 2: passing True with nr_dims and nr_features
# Test case 3: passing 'async' with nr_dims and nr_features
ARGS = {
"bn": bn_module,
"nr_features": 64,
"nr_dims": 1
}
- 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 BatchNorm1d — a BatchNorm1d output has no array shape of its own; none is stated — the instrument coerces any output to an array; for a BatchNorm1d 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
|
| get_dropout |
Ran ran; our contract draft was wrong, not the code |
AI4Science-WestlakeU/VFScale/vfscale_src/model/models.py code served (permissive licence) · get_code("3acb2b23a9bd22b9") 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 Dropout. 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)
# Test case 1: dropout as a float value with nr_dims=1
dropout_value = 0.3
nr_dims_1 = 1
# Test case 2: dropout as True with nr_dims=2
dropout_true = True
nr_dims_2 = 2
# Test case 3: dropout as an nn.Module instance
dropout_module = nn.Dropout(0.4)
nr_dims_3 = 1
# Create ARGS dict with all parameter combinations
ARGS = {
"dropout": 0.5,
"nr_dims": 1
}
- 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 Dropout — a Dropout output has no array shape of its own; none is stated — the instrument coerces any output to an array; for a Dropout 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
|
| get_time |
Ran ran; our contract draft was wrong, not the code |
ai4science-westlakeu/t_scend/tscend_src/utils/utils.py code served (permissive licence) · get_code("35d5144a8f9cae87") 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 str. 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.
from datetime import datetime
from time import localtime, strftime, time
ARGS = {
'is_bracket': True,
'return_numerical_time': False,
'precision': 'second'
}
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
- Imports
- none outside the standard library — import names as written, not package names to install; a name the repository itself provides is not a package
- Returned
- type str — a str output has no array shape of its own; none is stated — the instrument coerces any output to an array; for a str 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
|
| mask_value |
Ran ran; our contract draft was wrong, not the code |
AI4Science-WestlakeU/VFScale/vfscale_src/model/models.py code served (permissive licence) · get_code("dbb922152c1e332c") 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)
# Create small tensors with distinct sizes
# input: shape (2, 4) - batch of 2, dimension 4
input_tensor = torch.randn(2, 4)
# mask: same shape as input (2, 4), with values in [0, 1]
mask_tensor = torch.randint(0, 2, (2, 4)).float()
# value: scalar or tensor that will be broadcast
value_scalar = 0.5
ARGS = {
"input": input_tensor,
"mask": mask_tensor,
"value": value_scalar
}
- 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
|
| meshgrid |
Ran ran on a synthesized input |
ai4science-westlakeu/t_scend/tscend_src/model/diffusion_lib/nlm_utils.py code served (permissive licence) · get_code("3bd1f73dff951c9d") 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 5, 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 collections
torch.manual_seed(0)
# Create two small tensors with dimension that can be broadcasted
# The function expects tensors where the specified dim has size 1
# Let's create tensors of shape (2, 1, 4) - batch size 2, dim to broadcast is 1, feature dim is 4
input1 = torch.randn(2, 1, 4)
input2 = torch.randn(2, 1, 4)
# The dim parameter specifies which dimension to perform meshgrid on
# Using dim=-1 (or equivalently 2 for 3D tensor) to broadcast along the last dimension
dim = -1
ARGS = {
"input1": input1,
"input2": input2,
"dim": dim
}
- 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 5, 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
|
| meshgrid_exclude_self |
Ran ran on a synthesized input |
ai4science-westlakeu/t_scend/tscend_src/model/diffusion_lib/nlm_utils.py code served (permissive licence) · get_code("a8a55f19dcddf768") 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, 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
import collections
torch.manual_seed(0)
# The function meshgrid_exclude_self expects:
# - input: a tensor with at least dim+2 dimensions where dimensions dim and dim+1 are equal size
# - dim: an integer specifying which dimension to operate on (default 1)
# Let's create a tensor where:
# - We have dimensions where dim and dim+1 have equal size (e.g., 3x3)
# - Other dimensions can be different sizes to distinguish them
# Example shape: (2, 3, 3, 4) with dim=1 means dims 1 and 2 are both size 3
input_tensor = torch.randn(2, 3, 3, 4)
ARGS = {
"input": input_tensor,
"dim": 1
}
- 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, 2, 4) — shape (2, 3, 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
|
| process_tensor_sudoku |
Ran ran on a synthesized input |
ai4science-westlakeu/t_scend/tscend_src/utils/utils_maze_continuous.py code served (permissive licence) · get_code("465cda5a23bfa556") 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, 729) 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
from einops import rearrange, reduce, repeat
torch.manual_seed(0)
# The function takes a tensor x with shape [B, 9, 9, 9]
# where B is batch size. We'll create a small valid input.
# Using batch size 2 and keeping the 9x9x9 structure as required by the function
x = torch.randn(2, 9, 9, 9)
ARGS = {
"x": x
}
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
- Imports
- einops, 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, 729) — shape (2, 729) 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
|
| str2bool |
Ran ran, violated the contract we drafted |
ai4science-westlakeu/vfscale/vfscale_src/inference/inference_Maze.py code served (permissive licence) · get_code("7c54b06017e05bd2") 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 bool, 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 torch
torch.manual_seed(0)
ARGS = {
'x': 'true'
}
- 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 bool, 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
|
| sudoku_score |
Ran ran on a synthesized input |
ai4science-westlakeu/t_scend/tscend_src/utils/utils_maze_continuous.py code served (permissive licence) · get_code("bf38386f25f34c74") 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 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 torch
torch.manual_seed(0)
# The function expects a tensor with shape that can be reshaped to (-1, 3, 3, 3, 3)
# This represents a batch of sudoku grids
# For a valid sudoku, each row and column should sum to 36 (1+2+...+9)
# and each 3x3 box should sum to 36
# Create a small batch of 2 sudoku grids
# Shape: (batch_size, 9, 9) where 9=3*3
batch_size = 2
height = 9
width = 9
# Create valid sudoku values (1-9)
# For simplicity, create tensors with values that will satisfy the constraints
pred = torch.ones(batch_size, height, width, dtype=torch.float32)
# Fill with values 1-9 repeated to satisfy row/column/box sum constraints
# Each row needs to sum to 36: we can use 4 repeated (9*4 = 36)
# Let's create a pattern that works
for b in range(batch_size):
for i in range(9):
for j in range(9):
pred[b, i, j] = 4.0
ARGS = {
"pred": pred
}
- 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 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
|
| GNNConvEBM |
Not yet run unverified (harvested, no recorded run) |
AI4Science-WestlakeU/VFScale/vfscale_src/model/models.py code served (permissive licence) · get_code("36f1484dd68e104d") How it ran |
| LogicLayer |
Not yet run unverified (harvested, no recorded run) |
AI4Science-WestlakeU/VFScale/vfscale_src/model/models.py code served (permissive licence) · get_code("a5425637206e3216") How it ran |
| LogicMachine |
Not yet run unverified (harvested, no recorded run) |
AI4Science-WestlakeU/VFScale/vfscale_src/model/models.py code served (permissive licence) · get_code("6615bbe76e18ddd6") How it ran |
| NLMConv1DBlock |
Not yet run unverified (harvested, no recorded run) |
AI4Science-WestlakeU/VFScale/vfscale_src/model/models.py code served (permissive licence) · get_code("2221e5ee9ad31dc0") How it ran |
| NLMConvBlock |
Not yet run unverified (harvested, no recorded run) |
AI4Science-WestlakeU/VFScale/vfscale_src/model/models.py code served (permissive licence) · get_code("80023fe7520ff23f") How it ran |
| Permutation |
Not yet run unverified (harvested, no recorded run) |
AI4Science-WestlakeU/VFScale/vfscale_src/model/models.py code served (permissive licence) · get_code("bbedff446942642a") How it ran |
| concat_shape |
Not yet run unverified (harvested, no recorded run) |
AI4Science-WestlakeU/VFScale/vfscale_src/model/models.py code served (permissive licence) · get_code("b40432e68b551baa") How it ran |
| extract |
Not yet run unverified (harvested, no recorded run) |
ai4science-westlakeu/t_scend/tscend_src/utils/utils_maze_continuous.py code served (permissive licence) · get_code("09c8479d9a5b3e06") How it ran |