SYNTOLOGY HomeExplorerAtlasCodeMethodologyAboutDevelopersFeedPricing
Paper · 2110.06197 · ICLR · 2022

Crystal Diffusion Variational Autoencoder for Periodic Material Generation

Regina Barzilay, Tommi Jaakkola, Tian Xie, Xiang Fu, Octavian-Eugen Ganea

arXiv · PDF · Open in the Atlas

Code that ran

27 of 36 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; 1 honoured the contract we drafted, 0 violated it and 20 have no contract verdict; 6 failures of our instrument; 9 no recorded run), 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/2110.06197.json · badge: /api/ran/2110.06197.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
txie-93/cdvae canonical (classifier label)
classifier basis: classifier_2025
1 ran · 1 no recorded run
symmetryadvantage/wyckofftransformer community (classifier label)
classifier basis not recorded on the link
18 ran · 6 no recorded run
sparks-baird/mp-time-split community (classifier label)
classifier basis not recorded on the link
2 ran · 1 no recorded run
ixsluo/cond-cdvae extension (classifier label)
classifier basis: classifier_2025
2 ran · 1 no recorded run
knc6/cdvae community (classifier label)
classifier basis not recorded on the link
2 ran · 0 no recorded run
gabeguo/cdvae_xrd extension (classifier label)
classifier basis: classifier_2025
1 ran · 0 no recorded run
trachote/dp-cdvae extension (classifier label)
classifier basis: classifier_2025
1 ran · 0 no recorded run
FunctionStatusWhere it lives
abs_cap Ran
ran on a synthesized input
knc6/cdvae/cdvae/common/data_utils.py
code served (permissive licence) · get_code("6a946510479f2069")
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 float, ndim 0, dtype family float, shape () as a later run recorded it. The image it ran in was not recorded. If your copy returns the same type, ndim and shape on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import torch
import numpy as np

torch.manual_seed(0)

# The function abs_cap takes two parameters:
# - val (float): a numeric value to cap
# - max_abs_val (float): the maximum absolute value (defaults to 1)

# Looking at the function body:
# - It uses max() and min() built-in functions
# - It compares val against max_abs_val
# - It returns either val or sign(val) * max_abs_val
# The function works with float values

ARGS = {
    "val": 1.5,
    "max_abs_val": 1.0
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
numpy, torch — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type float, ndim 0, dtype family float, shape () — shape () as a later run recorded it
dtype family
int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
build_mlp Ran
ran; our contract draft was wrong, not the code
gabeguo/cdvae_xrd/cdvae/pl_modules/model.py
code served (permissive licence) · get_code("7a500e0992fceda5")
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 Sequential. 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)

ARGS = {
    "in_dim": 4,
    "hidden_dim": 8,
    "fc_num_layers": 3,
    "out_dim": 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 Sequential — a Sequential output has no array shape of its own; none is stated — the instrument coerces any output to an array; for a Sequential output the recorded ndim 1 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
censored_min_mae Ran
ran on a synthesized input
symmetryadvantage/wyckofftransformer/src/wyckoff_transformer/censored.py
code served (permissive licence) · get_code("32b725dbd955ba54")
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
import math
from torch import nn

torch.manual_seed(0)

# Create small tensors for the function
batch_size = 2
dim_size = 4

prediction = torch.randn(batch_size, dim_size)
target = torch.randn(batch_size, dim_size)

# Create a CensoredMinLoss criterion with predict_scale=True
criterion = nn.Module()  # This will be replaced with actual CensoredMinLoss below

class SimpleCensoredMinLoss(nn.Module):
    """Stand-in CensoredMinLoss for testing censored_min_mae"""
    def __init__(self):
        super().__init__()
        self.reduction = 'mean'
        self.noise = 0.01
        self.min_scale = 0.001
        self.predict_scale = True
        self.register_parameter('global_log_scale', None)
    
    @property
    def n_outputs(self):
        return 2 if self.predict_scale else 1
    
    def split(self, prediction):
        if self.predict_scale:
            if prediction.dim() < 2 or prediction.size(-1) != 2:
                raise ValueError(f'CensoredMinLoss with predict_scale=True needs a model with outputs=2; got shape {tuple(prediction.shape)}')
            return (prediction[..., 0], prediction[..., 1])
        location = prediction.squeeze(-1) if prediction.dim() > 1 else prediction
        return (location, self.global_log_scale.expand_as(location))
    
    def forward(self, prediction, target):
        from torch.special import log_ndtr
        location, log_scale = self.split(prediction)
        
        DEFAULT_MIN_SCALE = 0.001
        DEFAULT_NOISE = 0.01
        
        sigma = torch.as_tensor(self.noise, dtype=target.dtype, device=target.device)
        if torch.any(sigma <= 0):
            raise ValueError('noise must be positive')
        log_scale = log_scale.clamp(min=math.log(self.min_scale))
        scale = log_scale.exp()
        t = (target - location) / sigma
        a = sigma / scale
        nll = log_scale + a * t - 0.5 * a * a - log_ndtr(t - a)
        
        if self.reduction == 'mean':
            return nll.mean()
        if self.reduction == 'sum':
            return nll.sum()
        return nll

criterion = SimpleCensoredMinLoss()

# Prepare prediction with 2 outputs (location and log_scale)
prediction = torch.randn(batch_size, 2)
target = torch.randn(batch_size)

ARGS = {
    "prediction": prediction,
    "target": target,
    "criterion": criterion
}
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
censored_min_nll Ran
ran on a synthesized input
symmetryadvantage/wyckofftransformer/src/wyckoff_transformer/censored.py
code served (permissive licence) · get_code("31604f9db40cac45")
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
import math

torch.manual_seed(0)

# Create small tensors with distinct shapes
observed = torch.randn(2, 4)
location = torch.randn(2, 4)
log_scale = torch.randn(2, 4)
noise = 0.01
min_scale = 0.001

ARGS = {
    "observed": observed,
    "location": location,
    "log_scale": log_scale,
    "noise": noise,
    "min_scale": min_scale,
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
torch — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type Tensor, ndim 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
chemical_system_conditioning_dim Ran
ran on a synthesized input
symmetryadvantage/wyckofftransformer/src/wyckoff_transformer/chemical_system.py
code served (permissive licence) · get_code("52d4978b57a845eb")
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 int, ndim 0, dtype family int, 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 takes a single parameter: n_elements (int)
# It simply returns n_elements, so we need to provide a valid integer

ARGS = {
    "n_elements": 5
}
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 int, ndim 0, dtype family int, 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
chemical_system_vector Ran
ran on a synthesized input
symmetryadvantage/wyckofftransformer/src/wyckoff_transformer/chemical_system.py
code served (permissive licence) · get_code("f1aa000edc093144")
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 1, dtype family float, shape (5,) as a later run recorded it. The image it ran in was not recorded. If your copy returns the same type, ndim and shape on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import torch

torch.manual_seed(0)

ARGS = {
    "element_tokens": torch.tensor([0, 1, 2], dtype=torch.int64),
    "n_elements": 5,
    "device": None,
}
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 1, dtype family float, shape (5,) — shape (5,) as a later run recorded it
dtype family
int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
chemical_system_vectors Ran
ran on a synthesized input
symmetryadvantage/wyckofftransformer/src/wyckoff_transformer/chemical_system.py
code served (permissive licence) · get_code("f5091d700a375822")
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
from torch import Tensor

torch.manual_seed(0)

# element_tokens: Sequence[Sequence[int] | Tensor]
# This should be a sequence of sequences/tensors, each representing element tokens for a chemical system
element_tokens = [
    [0, 1, 2],           # First system with 3 elements
    [1, 3],              # Second system with 2 elements
]

# n_elements: int
# Size of the element vocabulary
n_elements = 4

# device: Optional[torch.device]
device = None

ARGS = {
    "element_tokens": element_tokens,
    "n_elements": n_elements,
    "device": device,
}
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
composition_conditioning_dim Ran
ran on a synthesized input
symmetryadvantage/wyckofftransformer/src/wyckoff_transformer/composition.py
code served (permissive licence) · get_code("c4974f8a6be0acfa")
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 int, ndim 0, dtype family int, 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
import torch.nn as nn

torch.manual_seed(0)

ARGS = {
    "n_elements": 5,
    "condition_on_cell_size": True,
}
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 int, ndim 0, dtype family int, 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
composition_vector Ran
ran on a synthesized input
symmetryadvantage/wyckofftransformer/src/wyckoff_transformer/composition.py
code served (permissive licence) · get_code("3afdb8687fc3cf98")
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 1, dtype family float, shape (11,) 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 typing import Sequence

torch.manual_seed(0)

# Define ARGS dict with all parameters for composition_vector
ARGS = {
    "element_tokens": torch.tensor([0, 2, 4], dtype=torch.int64),
    "counts": torch.tensor([2.0, 3.0, 1.0], dtype=torch.float32),
    "n_elements": 10,
    "device": None,
    "condition_on_cell_size": True,
}
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 1, dtype family float, shape (11,) — shape (11,) 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
composition_vectors Ran
ran on a synthesized input
symmetryadvantage/wyckofftransformer/src/wyckoff_transformer/composition.py
code served (permissive licence) · get_code("5a3de7c294a992b4")
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, 7) 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 typing import Sequence

torch.manual_seed(0)

# For composition_vectors, we need:
# - element_tokens: Sequence[Sequence[int] | Tensor]
# - counts: Sequence[Sequence[float] | Tensor]
# - n_elements: int
# - device: Optional[torch.device]
# - condition_on_cell_size: bool

# Create two compositions with different numbers of elements
element_tokens_1 = [0, 2, 3]  # 3 elements
counts_1 = [2.0, 1.0, 3.0]    # 3 counts

element_tokens_2 = [1, 4]     # 2 elements
counts_2 = [1.5, 2.5]         # 2 counts

# Wrap them in sequences
element_tokens = [element_tokens_1, element_tokens_2]
counts = [counts_1, counts_2]

# Vocabulary size (must be > max token index, which is 4)
n_elements = 6

# Device (CPU only)
device = torch.device('cpu')

# Conditioning flag
condition_on_cell_size = True

ARGS = {
    'element_tokens': element_tokens,
    'counts': counts,
    'n_elements': n_elements,
    'device': device,
    'condition_on_cell_size': condition_on_cell_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, 7) — shape (2, 7) 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
expected_min_bias Ran
ran on a synthesized input
symmetryadvantage/wyckofftransformer/src/wyckoff_transformer/censored.py
code served (permissive licence) · get_code("8818ca4313431c50")
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 1, dtype family float, shape (4,) as a later run recorded it. The image it ran in was not recorded. If your copy returns the same type, ndim and shape on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import torch

torch.manual_seed(0)

# Construct arguments for expected_min_bias function
scale = torch.tensor([1.5, 2.0, 0.5, 3.0], dtype=torch.float32)
n = torch.tensor([5.0, 10.0, 2.0, 8.0], dtype=torch.float32)

ARGS = {
    "scale": scale,
    "n": n,
}
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 1, dtype family float, shape (4,) — shape (4,) as a later run recorded it
dtype family
int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
fib Ran
ran, honoured the contract we drafted
sparks-baird/mp-time-split/src/mp_time_split/core.py
code served (permissive licence) · get_code("23b0f488ae6bc68e")
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 int, ndim 0, dtype family int, 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 fib function takes a single parameter n which should be a positive integer
# Reading the function body:
# - n is used in range(n - 1), so it needs to be an int > 0
# - The function returns the n-th Fibonacci number

ARGS = {
    "n": 5
}
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 int, ndim 0, dtype family int, 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
gene_representations Ran
ran on a synthesized input
symmetryadvantage/wyckofftransformer/src/wyckoff_transformer/gene_likelihood.py
code served (permissive licence) · get_code("70341785f156077f")
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. 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 collections import Counter
from math import lgamma
import numpy as np

# Construct a valid record dict for gene_representations
record = {
    'elements': ['Si', 'O', 'Al'],  # 3 elements
    'sites_enumeration_augmented': [
        (1, 2, 3),  # First enumeration variant
        (1, 2, 4),  # Second enumeration variant
    ],
    'site_symmetries_augmented': [
        ['Wyckoff_2a', 'Wyckoff_4b', 'Wyckoff_8c'],  # Symmetries for first variant
        ['Wyckoff_2a', 'Wyckoff_4b', 'Wyckoff_8c'],  # Symmetries for second variant
    ],
    'site_symmetries': ['Wyckoff_2a', 'Wyckoff_4b', 'Wyckoff_8c'],
    'sites_enumeration': (1, 2, 3),
}

ARGS = {
    'record': record,
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
numpy — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type tuple — a tuple output has no array shape of its own; none is stated
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
generation Ran
ran; our contract draft was wrong, not the code
txie-93/cdvae/scripts/evaluate.py
code served (permissive licence) · get_code("2c52dde33acf320d")
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 tuple. The image it ran in was not recorded. If your copy returns the same type on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import torch
import torch.nn as nn

torch.manual_seed(0)

# Create a minimal model that satisfies the function's requirements
class MinimalModel(nn.Module):
    def __init__(self):
        super().__init__()
        self.hparams = type('obj', (object,), {'hidden_dim': 4})()
        self.device = torch.device('cpu')
    
    def langevin_dynamics(self, z, ld_kwargs):
        batch_size = z.shape[0]
        num_atoms_val = 3
        num_atom_types = 5
        
        samples = {
            'frac_coords': torch.randn(batch_size, num_atoms_val, 3),
            'num_atoms': torch.full((batch_size,), num_atoms_val, dtype=torch.long),
            'atom_types': torch.randint(0, num_atom_types, (batch_size, num_atoms_val)),
            'lengths': torch.randn(batch_size, 3),
            'angles': torch.randn(batch_size, 3),
        }
        
        if ld_kwargs.save_traj:
            traj_steps = 6
            samples['all_frac_coords'] = torch.randn(traj_steps, batch_size, num_atoms_val, 3)
            samples['all_atom_types'] = torch.randint(0, num_atom_types, (traj_steps, batch_size, num_atoms_val))
        
        return samples

# Create a minimal ld_kwargs object
class LDKwargs:
    def __init__(self, save_traj=True):
        self.save_traj = save_traj

model = MinimalModel()
ld_kwargs = LDKwargs(save_traj=True)
num_batches_to_sample = 2
num_samples_per_z = 2
batch_size = 2
down_sample_traj_step = 1

ARGS = {
    'model': model,
    'ld_kwargs': ld_kwargs,
    'num_batches_to_sample': num_batches_to_sample,
    'num_samples_per_z': num_samples_per_z,
    'batch_size': batch_size,
    'down_sample_traj_step': down_sample_traj_step,
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1
Imports
torch — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type tuple — a tuple output has no array shape of its own; none is stated
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
get_data_home Ran
ran on a synthesized input
sparks-baird/mp-time-split/src/mp_time_split/core.py
code served (permissive licence) · get_code("d48fe570d3e210ff")
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.

import os
from os import environ, path
import tempfile

# Create a temporary directory to use as data_home
temp_dir = tempfile.mkdtemp()

# Test case 1: with explicit data_home argument
ARGS = {
    "data_home": temp_dir
}
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
get_env Ran
ran; our contract draft was wrong, not the code
knc6/cdvae/cdvae/common/utils.py
code served (permissive licence) · get_code("00e20379657c554c")
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.

import os
from typing import Optional

# Test case 1: env_name exists and has a value
os.environ['TEST_VAR'] = 'test_value'

# Test case 2: env_name does not exist but default is provided
# (no setup needed, will use default)

# Test case 3: env_name exists but is empty, with default provided
os.environ['EMPTY_VAR'] = ''

ARGS = {
    'env_name': 'TEST_VAR',
    'default': None
}
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
group_multiplicity_db Ran
ran on a synthesized input
symmetryadvantage/wyckofftransformer/src/wyckoff_transformer/csp.py
code served (permissive licence) · get_code("03f72260a9ea750c")
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 dict. The image it ran in was not recorded. If your copy returns the same type on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import torch
import numpy as np

torch.manual_seed(0)

# The function iterates over multiplicity_db.items() and unpacks each key as (sg_key, ss_token, enum_token)
# and each value as multiplicity. The sg_key is used as a dictionary key in the grouped dict.
# ss_token, enum_token, and multiplicity are collected in a list.

# Create a small multiplicity_db with the expected structure
multiplicity_db = {
    ("sg_key_1", "ss_token_1", 0): 2,
    ("sg_key_1", "ss_token_2", 1): 4,
    ("sg_key_2", "ss_token_3", 2): 3,
    ("sg_key_2", "ss_token_4", 3): 5,
    ("sg_key_3", "ss_token_5", 0): 1,
}

ARGS = {
    "multiplicity_db": multiplicity_db
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
numpy, torch — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type dict — a dict output has no array shape of its own; none is stated — the instrument coerces any output to an array; for a dict 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
log_orderings Ran
ran on a synthesized input
symmetryadvantage/wyckofftransformer/src/wyckoff_transformer/gene_likelihood.py
code served (permissive licence) · get_code("a9dc0dc92f699021")
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 float, ndim 0, dtype family float, shape () as a later run recorded it. The image it ran in was not recorded. If your copy returns the same type, ndim and shape on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

from collections import Counter
from math import lgamma
from typing import Sequence, Tuple

torch_imported = False
try:
    import torch
    torch_imported = True
except ImportError:
    pass

# Build valid arguments for log_orderings
# The function expects sites: Sequence[tuple]
# It counts occurrences of each tuple and uses lgamma to compute log orderings

# Create a multiset of sites (tuples representing element, site symmetry, enumeration)
# Example: each tuple is (element_id, symmetry_id, enumeration_id)
sites_example = [
    (1, 'A', 0),
    (1, 'A', 0),  # duplicate
    (2, 'B', 1),
    (1, 'A', 0),  # another duplicate
    (2, 'B', 1),  # duplicate
]

ARGS = {
    'sites': sites_example
}
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 float, ndim 0, dtype family float, shape () — shape () as a later run recorded it
dtype family
int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
optimization Ran
ran; our contract draft was wrong, not the code
trachote/dp-cdvae/evaluate.py
code served (permissive licence) · get_code("6bfe2286fd2a1f92")
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 dict. 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
from torch.optim import Adam

torch.manual_seed(0)

# Build a minimal model that satisfies the function's usage
class MinimalVAE(nn.Module):
    def __init__(self):
        super().__init__()
        self.device = torch.device('cpu')
        self.hparams = type('obj', (object,), {'hidden_dim': 4})()
        
        # Encoder that returns (mu, logvar, z)
        self.encoder = nn.Linear(10, 12)  # outputs 12 values (4 for mu, 4 for logvar, 4 for z)
        
        # fc_property: list of functions that take z and return scalar predictions
        self.fc_property = [
            nn.Linear(4, 1),  # property predictor for prop_idx=0
            nn.Linear(4, 1),  # property predictor for prop_idx=1
        ]
    
    def encode(self, batch):
        # Returns (mu, logvar, z)
        out = self.encoder(batch)
        mu = out[:, :4]
        logvar = out[:, 4:8]
        z = out[:, 8:12]
        return mu, logvar, z
    
    def langevin_dynamics(self, z, ld_kwargs):
        # Returns a dict with the required keys
        batch_size = z.shape[0]
        return {
            'frac_coords': torch.randn(batch_size, 3, 3),
            'atom_types': torch.randint(0, 10, (batch_size, 5)),
            'num_atoms': torch.randint(1, 6, (batch_size,)),
            'lengths': torch.randn(batch_size, 3),
            'angles': torch.randn(batch_size, 3),
        }

# Create model instance
model = MinimalVAE()

# Create a minimal data loader (list of batches)
data_loader = [torch.randn(2, 10) for _ in range(2)]

# Create ld_kwargs (can be empty dict or contain parameters for langevin_dynamics)
ld_kwargs = {}

# Define ARGS dict with all parameters
ARGS = {
    'model': model,
    'prop_idx': 0,
    'ld_kwargs': ld_kwargs,
    'data_loader': data_loader,
    'num_starting_points': 2,
    'num_gradient_steps': 10,
    'lr': 0.001,
    'num_saved_crys': 3,
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1
Imports
torch, tqdm — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type dict — a dict output has no array shape of its own; none is stated — the instrument coerces any output to an array; for a dict 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
read_config Ran
ran on a synthesized input
symmetryadvantage/wyckofftransformer/src/wyckoff_transformer/paths.py
code served (permissive licence) · get_code("278184a2cd6bed62")
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 dict. 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 os
from pathlib import Path
import tempfile

# Create a temporary config file for testing
temp_dir = tempfile.TemporaryDirectory()
temp_config_path = Path(temp_dir.name) / "paths.env"

# Write a valid config file
config_content = """# This is a comment
STORE_ROOT=/home/user/store
DATABASE_URL=postgresql://localhost/mydb
API_KEY=secret123

# Another comment
CACHE_DIR=/tmp/cache
"""
temp_config_path.write_text(config_content)

ARGS = {
    "path": temp_config_path
}
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 dict — a dict output has no array shape of its own; none is stated — the instrument coerces any output to an array; for a dict 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
replace_hydride_formula Ran
ran; our contract draft was wrong, not the code
ixsluo/cond-cdvae/scripts/evaluate.py
code served (permissive licence) · get_code("ca13c46956b131eb")
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 random

# Set seed for reproducibility
random.seed(0)

# The function takes a single parameter: string
# It iterates through each character in the string
# If the character is 'M', it replaces it with a random choice from the M tuple
# Otherwise, it keeps the character as is

# Create test strings with various patterns
test_string_1 = "MH2"  # Simple hydride formula with one M
test_string_2 = "M2MO3"  # Multiple M's
test_string_3 = "H2O"  # No M's
test_string_4 = "MMMCl"  # Multiple consecutive M's

ARGS = {
    "string": "MH2"
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1
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
repo_root Ran
ran on a synthesized input
symmetryadvantage/wyckofftransformer/src/wyckoff_transformer/paths.py
code served (permissive licence) · get_code("d04319a29ef33c57")
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 PosixPath. 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 pathlib import Path
import tempfile
import os

# Create a temporary directory structure to simulate a repo
temp_dir = tempfile.mkdtemp()
nested_dir = Path(temp_dir) / "subdir" / "nested"
nested_dir.mkdir(parents=True, exist_ok=True)

# Create a pyproject.toml marker file at the repo root
repo_marker_path = Path(temp_dir) / "pyproject.toml"
repo_marker_path.write_text("[project]\nname = 'test'\n")

# Test with a nested path that should find the repo root
test_start_path = nested_dir

ARGS = {
    "start": test_start_path
}
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 PosixPath — a PosixPath output has no array shape of its own; none is stated — the instrument coerces any output to an array; for a PosixPath 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
sample_range Ran
ran; our contract draft was wrong, not the code
ixsluo/cond-cdvae/scripts/evaluate.py
code served (permissive licence) · get_code("51f77bb8655afae1")
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 random
import re

# Set seed for reproducibility
random.seed(42)

# The function takes a single parameter: string
# It finds patterns like "m-n" in the string and replaces them with random integers between m and n

ARGS = {
    'string': 'The answer is 1-10 and the range 5-15 should work fine'
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1
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
service_ops_vectors Ran
ran on a synthesized input
symmetryadvantage/wyckofftransformer/src/wyckoff_transformer/preprocess_wychoffs.py
code served (permissive licence) · get_code("eb8846d66ef5069d")
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 dict. The image it ran in was not recorded. If your copy returns the same type on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import numpy as np

ARGS = {
    'width': 8
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
numpy — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type dict — a dict output has no array shape of its own; none is stated — the instrument coerces any output to an array; for a dict 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
start_log_prior Ran
ran on a synthesized input
symmetryadvantage/wyckofftransformer/src/wyckoff_transformer/gene_likelihood.py
code served (permissive licence) · get_code("4c607b6dfe2abca6")
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 Series. 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 logging
import numpy as np
import pandas as pd
from pathlib import Path
from unittest.mock import MagicMock

logging.basicConfig(level=logging.WARNING)

class MockTokenizer:
    """Stand-in tokenizer supporting both categorial and one_hot lookup."""
    def __init__(self, start_type='categorial'):
        self.start_type = start_type
        if start_type == 'categorial':
            self.token_map = {'P1': 0, 'P21': 1, 'C2': 2}
        else:  # one_hot
            self.np_dict = {
                'P1': np.array([1.0, 0.0, 0.0]),
                'P21': np.array([0.0, 1.0, 0.0]),
                'C2': np.array([0.0, 0.0, 1.0])
            }
    
    def __getitem__(self, key):
        if self.start_type == 'categorial':
            return self.token_map.get(key, -1)
        else:
            return self.np_dict.get(key, np.array([-1.0, -1.0, -1.0]))


class MockTrainer:
    """Stand-in trainer with required attributes and methods."""
    def __init__(self, start_type='categorial'):
        self.start_type = start_type
        self.run_path = Path('/tmp/mock_run')
        self.start_name = 'space_group'
        self.start_token_distribution = None
        self.tokenisers = {
            self.start_name: MockTokenizer(start_type=start_type)
        }
    
    def get_start_token_distribution_path(self, run_path):
        return run_path / 'start_token_distribution.pkl'
    
    def load_start_token_distribution_file(self, path):
        if self.start_type == 'categorial':
            return {
                'counts': np.array([100, 50, 25]),
                'start_type': 'categorial',
                'vectors': None
            }
        else:  # one_hot
            return {
                'counts': np.array([100, 50, 25]),
                'start_type': 'one_hot',
                'vectors': [
                    np.array([1.0, 0.0, 0.0]),
                    np.array([0.0, 1.0, 0.0]),
                    np.array([0.0, 0.0, 1.0])
                ]
            }


def make_args_categorial():
    trainer = MockTrainer(start_type='categorial')
    trainer.start_token_distribution = trainer.load_start_token_distribution_file(None)
    
    records = pd.DataFrame({
        'space_group': ['P1', 'P21', 'C2', 'P1']
    })
    
    return {
        'trainer': trainer,
        'records': records
    }


def make_args_one_hot():
    trainer = MockTrainer(start_type='one_hot')
    trainer.start_token_distribution = trainer.load_start_token_distribution_file(None)
    
    records = pd.DataFrame({
        'space_group': ['P1', 'P21', 'C2', 'P1']
    })
    
    return {
        'trainer': trainer,
        'records': records
    }


ARGS = make_args_categorial()
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
numpy, pandas — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type Series — a Series output has no array shape of its own; none is stated — the instrument coerces any output to an array; for a Series output the recorded ndim 1 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
start_to_db_key Ran
ran on a synthesized input
symmetryadvantage/wyckofftransformer/src/wyckoff_transformer/csp.py
code served (permissive licence) · get_code("dc734da5f9a66136")
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 float, ndim 0, dtype family float, shape () as a later run recorded it. The image it ran in was not recorded. If your copy returns the same type, ndim and shape on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import torch

torch.manual_seed(0)

# Test case 1: scalar tensor (1D with single element)
start_scalar = torch.tensor([5.0])

# Test case 2: 1D tensor with multiple elements
start_1d = torch.tensor([1.0, 2.0, 3.0, 4.0])

# Test case 3: 2D tensor (batch of vectors)
start_2d = torch.tensor([[1.0, 2.0, 3.0, 4.0],
                          [5.0, 6.0, 7.0, 8.0]])

# Test case 4: higher dimensional tensor
start_3d = torch.randn(2, 3, 4)

# Using a simple scalar tensor as the primary test case
ARGS = {
    "start": start_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 float, ndim 0, dtype family float, shape () — shape () as a later run recorded it
dtype family
int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
warmup_stable_decay Ran
ran on a synthesized input
symmetryadvantage/wyckofftransformer/src/wyckoff_transformer/schedules.py
code served (permissive licence) · get_code("a0fd18cdf3bb9181")
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 LambdaLR. 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
import torch.optim as optim

torch.manual_seed(0)

# Create a minimal model
model = nn.Linear(4, 3)

# Create an optimizer
optimizer = optim.SGD(model.parameters(), lr=0.1)

# Define all arguments for warmup_stable_decay
ARGS = {
    'optimizer': optimizer,
    'total_steps': 1000,
    'warmup_fraction': 0.02,
    'decay_fraction': 0.1,
    'final_lr_fraction': 0.0,
    'decay_shape': 'linear'
}
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 LambdaLR — a LambdaLR output has no array shape of its own; none is stated — the instrument coerces any output to an array; for a LambdaLR 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
build_clean_relaxation_condition Not yet run
unverified (harvested, no recorded run)
symmetryadvantage/wyckofftransformer/src/wyckoff_transformer/gene_energy.py
code served (permissive licence) · get_code("f2619508491644d0")
How it ran

no invocation recorded.

build_combinatorics Not yet run
unverified (harvested, no recorded run)
symmetryadvantage/wyckofftransformer/src/wyckoff_transformer/csp.py
code served (permissive licence) · get_code("d8cfa8a7bd164a1f")
How it ran

no invocation recorded.

build_tokenised_prediction_tensors Not yet run
unverified (harvested, no recorded run)
symmetryadvantage/wyckofftransformer/src/wyckoff_transformer/prediction.py
code served (permissive licence) · get_code("2efd8e80003f0994")
How it ran

no invocation recorded.

data_store Not yet run
unverified (harvested, no recorded run)
symmetryadvantage/wyckofftransformer/src/wyckoff_transformer/paths.py
code served (permissive licence) · get_code("6205bcf4c0b21416")
How it ran

no invocation recorded.

filter_supported_tokens Not yet run
unverified (harvested, no recorded run)
symmetryadvantage/wyckofftransformer/src/wyckoff_transformer/prediction.py
code served (permissive licence) · get_code("7682a09675335624")
How it ran

no invocation recorded.

get_file_paths Not yet run
unverified (harvested, no recorded run)
ixsluo/cond-cdvae/scripts/compute_metrics.py
code served (permissive licence) · get_code("9a6539ae57f02d7a")
How it ran

no invocation recorded.

mp_time_split Not yet run
unverified (harvested, no recorded run)
sparks-baird/mp-time-split/src/mp_time_split/utils/split.py
code served (permissive licence) · get_code("3bc0f40b2f7fd1cc")
How it ran

no invocation recorded.

optimization Not yet run
unverified (harvested, no recorded run)
txie-93/cdvae/scripts/evaluate.py
code served (permissive licence) · get_code("7d1d1bcb15f1fefe")
How it ran

no invocation recorded.

tokeniser_key Not yet run
unverified (harvested, no recorded run)
symmetryadvantage/wyckofftransformer/src/wyckoff_transformer/prediction.py
code served (permissive licence) · get_code("e28290d6a95905bf")
How it ran

no invocation recorded.

Also present in other papers' code

Of 36 samples lifted from this paper's linked repositories, 36 carry a function identity and 0 do not. Of the 36 distinct functions with an identity, 6 are also present in other papers whose code we hold (0 with at least one paper dated earlier, 0 the same month, 6 later) and 30 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
build_mlp 3 other papers
3 later
2310.10732 (2023-10)
MOFDiff: Coarse-grained Diffusion for Metal-Organic Framework Design
2403.12478 (2024-03)
Con-CDVAE: A method for the conditional generation of crystal structures
2512.07289 (2025-12)
Equivariant Diffusion for Crystal Structure Prediction
get_env 2 other papers
2 later
2204.10348 (2022-04)
Simulate Time-integrated Coarse-grained Molecular Dynamics with Multi-Scale Graph Networks
2405.02797 (2024-05)
Adapting to Distribution Shift by Visual Domain Prompt Generation
fib 1 other paper
1 later
2503.17138 (2025-03)
Workshop on Neural Network Weights as a New Data Modality 2025 STRUCTURE IS NOT ENOUGH: LEVERAGING BEHAVIOR FOR NEURAL NETWORK WEIGHT RECONSTRUCTION
generation 1 other paper
1 later
2308.02165 (2023-08)
Diffusion probabilistic models enhance variational autoencoder for crystal structure generative modeling
get_file_paths 1 other paper
1 later
2308.02165 (2023-08)
Diffusion probabilistic models enhance variational autoencoder for crystal structure generative modeling
optimization 1 other paper
1 later
2308.02165 (2023-08)
Diffusion probabilistic models enhance variational autoencoder for crystal structure generative modeling

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

Generating the periodic structure of stable materials is a long-standing challenge for the material design community. This task is difficult because stable materials only exist in a low-dimensional subspace of all possible periodic arrangements of atoms: 1) the coordinates must lie in the local energy minimum defined by quantum mechanics, and 2) global stability also requires the structure to follow the complex, yet specific bonding preferences between different atom types. Existing methods fail to incorporate these factors and often lack proper invariances. We propose a Crystal Diffusion Variational Autoencoder (CDVAE) that captures the physical inductive bias of material stability. By learning from the data distribution of stable materials, the decoder generates materials in a diffusion process that moves atomic coordinates towards a lower energy state and updates atom types to satisfy bonding preferences between neighbors. Our model also explicitly encodes interactions across periodic boundaries and respects permutation, translation, rotation, and periodic invariances. We significantly outperform past methods in three tasks: 1) reconstructing the input structure, 2) generating valid, diverse, and realistic materials, and 3) generating materials that optimize a specific property. We also provide several standard datasets and evaluation metrics for the broader machine learning community. 1

For agents

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

get_harvested_code_for_paper("2110.06197")
get_code_for_paper("2110.06197")
have("2110.06197")

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

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

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

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

Connect an agent — have() is free.