SYNTOLOGY HomeExplorerAtlasCodeMethodologyAboutDevelopersFeedPricing
Paper · 2502.01989 · ICLR · 2025

VFScale: Intrinsic Reasoning through Verifier-Free Test-time Scalable Diffusion Model

Tailin Wu, Ruiqi Feng, Tao Zhang, Jia-Shu Pan, Mcts Rollout

arXiv · PDF · Open in the Atlas

Code that ran

26 of 34 samples (functions and classes) lifted from this paper's linked repositories executed on a synthesized input in Syntology's jail (0 of them constructed an object rather than computing a result; 2 honoured the contract we drafted, 3 violated it and 13 have no contract verdict; 8 failures of our instrument; 8 no recorded run); 2 of them were also run on the host, not in the jail, by the peer-agreement lane that set their level, measured 2026-11-22; repository links from the Papers with Code archive attributed under CC BY-SA, no affiliation; bodies inline only under a permissive licence as GitHub detects it. Not a reproduction of the paper's results.

"Ran" means the function executed on a synthesized input and returned a value. It is not a reproduction of the paper's results. This record, dated, as JSON: /api/ran/2502.01989.json · badge: /api/ran/2502.01989.svg

Each repository's role is a label: a classifier's output recorded on the link, or, where no role is recorded, what the Papers with Code archive marked. The line under it names its basis. Neither says who wrote the code.

RepositoryRoleRan
ai4science-westlakeu/t_scend canonical (classifier label)
classifier basis not recorded on the link
12 ran · 1 no recorded run
ai4science-westlakeu/vfscale canonical (classifier label)
classifier basis: classifier_2025
1 ran · 0 no recorded run
AI4Science-WestlakeU/VFScale community
Papers with Code archive
13 ran · 7 no recorded run
FunctionStatusWhere it lives
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 ran

Ran 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 ran

Ran 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 ran

Ran 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 ran

Ran 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 ran

Ran 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 ran

Ran 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 ran

Ran 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 ran

Ran 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 ran

Ran 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 ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned 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 ran

Ran 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 ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned 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 ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned tuple, 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 ran

Ran 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 ran

Ran 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 ran

Ran 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 ran

Ran 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 ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned 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 ran

Ran 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 ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned 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 ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned 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 ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned tuple, 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 ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned 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 ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned 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 ran

Ran 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 ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned 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

no invocation recorded.

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

no invocation recorded.

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

no invocation recorded.

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

no invocation recorded.

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

no invocation recorded.

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

no invocation recorded.

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

no invocation recorded.

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

no invocation recorded.

Also present in other papers' code

Of 34 samples lifted from this paper's linked repositories, 34 carry a function identity and 0 do not. Of the 33 distinct functions with an identity, 8 are also present in other papers whose code we hold (8 with at least one paper dated earlier, 3 the same month, 5 later) and 25 are only here among the 52,977 papers whose code Syntology holds (as of 2026-09-26).

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

FunctionAlso present inEarliest-datedOthers named
swish
brick of this paper's assembly: helper
206 other papers
191 dated earlier, 13 later, 2 same year, order not determinable · 44 only as an assembly brick
1408.5882 (2014-08)
Convolutional Neural Networks for Sentence Classification
1805.12114 (2018-05)
Deep Reinforcement Learning in a Handful of Trials using Probabilistic Dynamics Models
1809.01357 (2018-09)
Zero Shot Learning for Code Education: Rubric Sampling with Deep Learning Inference
and 203 more not named here
exists 144 other papers
119 dated earlier, 2 the same month, 20 later, 3 same year, order not determinable · 40 only as an assembly brick
1611.07004 (2016-11)
Image-to-Image Translation with Conditional Adversarial Networks
1711.11585 (2017-11)
High-Resolution Image Synthesis and Semantic Manipulation with Conditional GANs
2006.11239 (2020-06)
Denoising Diffusion Probabilistic Models
and 141 more not named here
default 79 other papers
64 dated earlier, 2 the same month, 11 later, 2 same year, order not determinable · 15 only as an assembly brick
1611.07004 (2016-11)
Image-to-Image Translation with Conditional Adversarial Networks
2006.11239 (2020-06)
Denoising Diffusion Probabilistic Models
2010.02502 (2020-10)
Denoising Diffusion Implicit Models
and 76 more not named here
extract 77 other papers
62 dated earlier, 2 the same month, 12 later, 1 same year, order not determinable · 32 only as an assembly brick
1711.11585 (2017-11)
High-Resolution Image Synthesis and Semantic Manipulation with Conditional GANs
2006.11239 (2020-06)
Denoising Diffusion Probabilistic Models
2102.05379 (2021-02)
Argmax Flows and Multinomial Diffusion: Learning Categorical Distributions
and 74 more not named here
identity 54 other papers
47 dated earlier, 7 later · 11 only as an assembly brick
1611.07004 (2016-11)
Image-to-Image Translation with Conditional Adversarial Networks
1907.01470 (2019-07)
Augmenting Self-attention with Persistent Memory
2006.11239 (2020-06)
Denoising Diffusion Probabilistic Models
and 51 more not named here
get_time 2 other papers
2 dated earlier
2401.13171 (2024-01)
Compositional Generative Inverse Design
2407.06494 (2024-07)
DiffPhyCon: A Generative Approach to Control Complex Physical Systems
exclude_mask
brick of this paper's assembly: helper
1 other paper
1 dated earlier
2312.03682 (2023-12)
What Planning Problems Can A Relational Neural Network Solve?
mask_value
brick of this paper's assembly: helper
1 other paper
1 dated earlier
2312.03682 (2023-12)
What Planning Problems Can A Relational Neural Network Solve?

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

Repositories linked to this paper

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

Abstract

Inspired by human SYSTEM 2 thinking, LLMs excel at complex reasoning tasks via extended Chain-of-Thought. However, similar test-time scaling for diffusion models to tackle complex reasoning remains largely unexplored. From existing work, two primary challenges emerge in this setting: (i) the dependence on an external verifier indicating a notable gap from intrinsic reasoning of human intelligence without any external feedback, and (ii) the lack of an efficient search algorithm. In this paper, we introduce the Verifier-free Test-time Scalable Diffusion Model (VFScale) to achieve scalable intrinsic reasoning, which equips numberof-sample test-time scaling with the intrinsic energy function of diffusion models as the verifier. Concretely, VFScale comprises two key innovations to address the aforementioned challenges. On the training side, VFScale consists of a novel MRNCL loss and a KL regularization to improve the energy landscape, ensuring that the learned energy function itself serves as a reliable verifier. On the inference side, VFScale integrates the denoising process with a novel hybrid Monte Carlo Tree Search (hMCTS) to improve search efficiency. On challenging reasoning tasks of Maze and Sudoku, we demonstrate the effectiveness of VFScale's training objective and scalable inference method. In particular, trained with Maze sizes of up to 6 × 6, our VFScale solves 88% of Maze problems with much larger sizes of 15 × 15, while standard diffusion models completely fail. The code can be found at https://github.com/AI4Science-WestlakeU/VFScale.

For agents

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

get_harvested_code_for_paper("2502.01989")
get_code_for_paper("2502.01989")
have("2502.01989")

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

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

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

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

Connect an agent — have() is free.