SYNTOLOGY HomeExplorerAtlasCodeMethodologyAboutDevelopersFeedPricing
Paper · 2305.14749 · ICML · 2023

gRNAde: Geometric Deep Learning for 3D RNA inverse design

Pietro Liò, Alex Morehead, Chaitanya Joshi, Simon Mathis, Arian Jamasb, Ramon Viñas, Charles Harris, Rishabh Anand

arXiv · PDF · Open in the Atlas

Code that ran

17 of 29 samples (functions and classes) lifted from this paper's linked repositories executed on a synthesized input in Syntology's jail (1 of them constructed an object rather than computing a result; 1 honoured the contract we drafted, 2 violated it and 1 has no contract verdict; 13 failures of our instrument; 12 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/2305.14749.json · badge: /api/ran/2305.14749.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
chaitjo/geometric-rna-design canonical (classifier label)
classifier basis: classifier_2025
1 ran · 1 no recorded run
rish-16/rna-backbone-design community
Papers with Code archive
16 ran · 11 no recorded run
FunctionStatusWhere it lives
Linear Ran
ran on a synthesized input · constructed an object; no result was computed
rish-16/rna-backbone-design/rna_backbone_design/models/ipa_pytorch.py
code served (permissive licence) · get_code("d3ad22a7f9c56f53")
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 an instance of its own class, Linear: the run constructed the object and did not call it, so no result was computed. 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 typing import Optional, Callable

torch.manual_seed(0)

def custom_init_fn(weight, bias):
    """A simple custom initializer for testing"""
    weight.fill_(0.5)
    if bias is not None:
        bias.fill_(0.1)

ARGS = {
    'in_dim': 4,
    'out_dim': 3,
    'bias': True,
    'init': 'default',
    'init_fn': None,
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
numpy, scipy, torch — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type Linear — the run constructed an instance of its own class and did not call it; no shape is stated — the instrument coerces any output to an array; for a Linear 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
_calculate_fan Ran
ran; the contract check could not run (RAISES, DEP_MISSING or TIMEOUT)
rish-16/rna-backbone-design/rna_backbone_design/models/ipa_pytorch.py
code served (permissive licence) · get_code("e6c1f4ae2bdfd63e")
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 expects:
# - linear_weight_shape: a tuple of (fan_out, fan_in) dimensions
# - fan: a string specifying which fan to return ('fan_in', 'fan_out', or 'fan_avg')

ARGS = {
    'linear_weight_shape': (4, 3),
    'fan': 'fan_in'
}
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
_prod Ran
ran, violated the contract we drafted
rish-16/rna-backbone-design/rna_backbone_design/models/ipa_pytorch.py
code served (permissive licence) · get_code("5fcde0d4e5ddc285")
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 numpy as np

torch.manual_seed(0)

# The function _prod takes a single parameter 'nums' which is an iterable
# of numbers to multiply together. The function iterates through each element
# and multiplies them.

ARGS = {
    "nums": [2, 3, 4, 5]
}
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 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
create_partial_seq_logit_bias Ran
ran, honoured the contract we drafted
chaitjo/geometric-rna-design/design.py
code served (permissive licence) · get_code("0315e2c91a9c7304")
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 (6, 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.functional as F

torch.manual_seed(0)

# Create a minimal featurizer class with the required letter_to_num mapping
class MockFeaturizer:
    def __init__(self):
        self.letter_to_num = {
            'A': 0,
            'G': 1,
            'C': 2,
            'U': 3
        }

# Instantiate the featurizer
featurizer = MockFeaturizer()

# Define the arguments dictionary
ARGS = {
    'partial_seq': 'A_G_CU',
    'featurizer': featurizer,
    'device': torch.device('cpu'),
    'model_out_dim': 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 Tensor, ndim 2, dtype family float, shape (6, 4) — shape (6, 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
flatten_final_dims Ran
ran; our contract draft was wrong, not the code
rish-16/rna-backbone-design/rna_backbone_design/models/ipa_pytorch.py
code served (permissive licence) · get_code("706bd906bbbd5b15")
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 3, dtype family float, shape (2, 4, 15) 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 that allows flattening final dimensions
# Using distinct sizes: batch=2, dim1=4, dim2=3, dim3=5
t = torch.randn(2, 4, 3, 5)

# no_dims specifies how many final dimensions to flatten
no_dims = 2

ARGS = {
    "t": t,
    "no_dims": no_dims,
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
torch — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type Tensor, ndim 3, dtype family float, shape (2, 4, 15) — shape (2, 4, 15) 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
identity_quats Ran
ran; our contract draft was wrong, not the code
rish-16/rna-backbone-design/rna_backbone_design/models/ipa_pytorch.py
code served (permissive licence) · get_code("e74d067a4b8cbfa9")
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 3, dtype family float, shape (2, 3, 4) as a later run recorded it. The image it ran in was not recorded. If your copy returns the same type, ndim and shape on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import torch
import numpy as np

torch.manual_seed(0)

# The function creates identity quaternions with shape (*batch_dims, 4)
# Parameters:
# - batch_dims: tuple or torch.Size specifying batch dimensions
# - dtype: torch dtype (optional)
# - device: torch device (optional)
# - requires_grad: bool for gradient tracking

ARGS = {
    "batch_dims": (2, 3),  # batch dimensions as tuple
    "dtype": torch.float32,
    "device": torch.device("cpu"),
    "requires_grad": True,
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
beartype, jaxtyping, numpy, torch — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type Tensor, ndim 3, dtype family float, shape (2, 3, 4) — shape (2, 3, 4) as a later run recorded it
dtype family
int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
identity_rot_mats Ran
ran; our contract draft was wrong, not the code
rish-16/rna-backbone-design/rna_backbone_design/models/ipa_pytorch.py
code served (permissive licence) · get_code("f4eab26d444aca71")
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, 4, 3, 3) as a later run recorded it. The image it ran in was not recorded. If your copy returns the same type, ndim and shape on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import torch
import numpy as np

torch.manual_seed(0)

ARGS = {
    "batch_dims": (2, 4),
    "dtype": torch.float32,
    "device": torch.device("cpu"),
    "requires_grad": True,
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
beartype, jaxtyping, numpy, torch — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type Tensor, ndim 4, dtype family float, shape (2, 4, 3, 3) — shape (2, 4, 3, 3) as a later run recorded it
dtype family
int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
identity_trans Ran
ran; our contract draft was wrong, not the code
rish-16/rna-backbone-design/rna_backbone_design/models/ipa_pytorch.py
code served (permissive licence) · get_code("30509afaa8397557")
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 3, dtype family float, shape (2, 4, 3) as a later run recorded it. The image it ran in was not recorded. If your copy returns the same type, ndim and shape on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import torch
import numpy as np
from typing import Union, Tuple, Optional

torch.manual_seed(0)

# Construct arguments for identity_trans function
batch_dims = (2, 4)  # Tuple of batch dimensions
dtype = torch.float32  # Optional dtype
device = torch.device('cpu')  # CPU only
requires_grad = True  # Boolean flag

ARGS = {
    'batch_dims': batch_dims,
    'dtype': dtype,
    'device': device,
    'requires_grad': requires_grad
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
beartype, jaxtyping, numpy, torch — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type Tensor, ndim 3, dtype family float, shape (2, 4, 3) — shape (2, 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
invert_quat Ran
ran; our contract draft was wrong, not the code
rish-16/rna-backbone-design/rna_backbone_design/models/ipa_pytorch.py
code served (permissive licence) · get_code("84e835457291ffe0")
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 3, dtype family float, shape (2, 3, 4) as a later run recorded it. The image it ran in was not recorded. If your copy returns the same type, ndim and shape on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import torch
from typing import Optional

torch.manual_seed(0)

# Create a quaternion tensor with shape (batch=2, num_nodes=3, quaternion_dims=4)
quat = torch.randn(2, 3, 4)

# Create a mask tensor with shape (batch=2, num_nodes=3)
mask = torch.tensor([[True, False, True], [False, True, False]], dtype=torch.float32)

ARGS = {
    "quat": quat,
    "mask": mask,
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
jaxtyping, 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, 4) — shape (2, 3, 4) as a later run recorded it
dtype family
int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
invert_rot_mat Ran
ran, violated the contract we drafted
rish-16/rna-backbone-design/rna_backbone_design/models/ipa_pytorch.py
code served (permissive licence) · get_code("cae0c69acc790c0e")
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 3, dtype family float, shape (2, 3, 3) as a later run recorded it. The image it ran in was not recorded. If your copy returns the same type, ndim and shape on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import torch

torch.manual_seed(0)

# Create a valid rotation matrix with shape (2, 3, 3)
# Batch size 2, each element is a 3x3 rotation matrix
rot_mat = torch.randn(2, 3, 3)

# Make them orthogonal by doing QR decomposition
# This ensures they're valid rotation matrices
q, r = torch.linalg.qr(rot_mat)
rot_mat = q

ARGS = {
    "rot_mat": rot_mat
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
jaxtyping, 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, 3) — shape (2, 3, 3) as a later run recorded it
dtype family
int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
permute_final_dims Ran
ran; our contract draft was wrong, not the code
rish-16/rna-backbone-design/rna_backbone_design/models/ipa_pytorch.py
code served (permissive licence) · get_code("c653d7a1bb820cd6")
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, 5, 4) as a later run recorded it. The image it ran in was not recorded. If your copy returns the same type, ndim and shape on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import torch
from typing import List

torch.manual_seed(0)

# Create a small tensor with distinct dimensions for probing
# Shape: (2, 3, 4, 5) - batch=2, some intermediate dims, final dims that will be permuted
tensor = torch.randn(2, 3, 4, 5)

# Create a permutation of the final dimensions
# If we want to permute the last 2 dimensions [4, 5], we can reverse them
inds = [1, 0]

ARGS = {
    "tensor": tensor,
    "inds": inds,
}
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, 5, 4) — shape (2, 3, 5, 4) as a later run recorded it
dtype family
int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
quat_multiply Ran
ran; our contract draft was wrong, not the code
rish-16/rna-backbone-design/rna_backbone_design/models/ipa_pytorch.py
code served (permissive licence) · get_code("8c6e2bf356f1172c")
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 3, dtype family float, shape (2, 3, 4) as a later run recorded it. The image it ran in was not recorded. If your copy returns the same type, ndim and shape on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import torch
import numpy as np

torch.manual_seed(0)

# Create two quaternion tensors
# Shape: (batch_size, num_nodes, 4) where 4 is for quaternion components
quat1 = torch.randn(2, 3, 4)
quat2 = torch.randn(2, 3, 4)

ARGS = {
    'quat1': quat1,
    'quat2': quat2,
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
jaxtyping, numpy, torch — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type Tensor, ndim 3, dtype family float, shape (2, 3, 4) — shape (2, 3, 4) as a later run recorded it
dtype family
int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
quat_multiply_by_vec Ran
ran; our contract draft was wrong, not the code
rish-16/rna-backbone-design/rna_backbone_design/models/ipa_pytorch.py
code served (permissive licence) · get_code("be492de7f5f316a1")
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 3, dtype family float, shape (2, 3, 4) as a later run recorded it. The image it ran in was not recorded. If your copy returns the same type, ndim and shape on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import torch
import numpy as np

torch.manual_seed(0)

# Create small tensors matching the type signatures
# quat: QUATERNION_TENSOR_TYPE = Float[torch.Tensor, '... num_nodes 4']
# vec: COORDINATES_TENSOR_TYPE = Float[torch.Tensor, '... num_nodes 3']

batch_size = 2
num_nodes = 3

# Create quaternion tensor with shape (batch_size, num_nodes, 4)
quat = torch.randn(batch_size, num_nodes, 4, dtype=torch.float32)

# Create coordinate/vector tensor with shape (batch_size, num_nodes, 3)
vec = torch.randn(batch_size, num_nodes, 3, dtype=torch.float32)

ARGS = {
    'quat': quat,
    'vec': vec,
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
jaxtyping, numpy, torch — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type Tensor, ndim 3, dtype family float, shape (2, 3, 4) — shape (2, 3, 4) as a later run recorded it
dtype family
int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
quat_to_rot Ran
ran; our contract draft was wrong, not the code
rish-16/rna-backbone-design/rna_backbone_design/models/ipa_pytorch.py
code served (permissive licence) · get_code("862c50f1ae9bc345")
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 3, dtype family float, shape (2, 3, 3) as a later run recorded it. The image it ran in was not recorded. If your copy returns the same type, ndim and shape on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import torch
import numpy as np

torch.manual_seed(0)

# Create a small quaternion tensor
# Shape: [2, 4] - batch of 2 quaternions, each with 4 components
quat = torch.randn(2, 4)

ARGS = {
    'quat': quat
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
jaxtyping, numpy, torch — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type Tensor, ndim 3, dtype family float, shape (2, 3, 3) — shape (2, 3, 3) as a later run recorded it
dtype family
int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
rot_matmul Ran
ran; our contract draft was wrong, not the code
rish-16/rna-backbone-design/rna_backbone_design/models/ipa_pytorch.py
code served (permissive licence) · get_code("a8ce422107f24555")
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 3, dtype family float, shape (2, 3, 3) as a later run recorded it. The image it ran in was not recorded. If your copy returns the same type, ndim and shape on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import torch

torch.manual_seed(0)

# Create two random rotation matrix tensors with shape [2, 3, 3]
# Using batch size 2 to test batched operations
a = torch.randn(2, 3, 3)
b = torch.randn(2, 3, 3)

ARGS = {
    "a": a,
    "b": b,
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
jaxtyping, 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, 3) — shape (2, 3, 3) as a later run recorded it
dtype family
int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
rot_to_quat Ran
ran; the contract check could not run (RAISES, DEP_MISSING or TIMEOUT)
rish-16/rna-backbone-design/rna_backbone_design/models/ipa_pytorch.py
code served (permissive licence) · get_code("228c042a185c679a")
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 jaxtyping import Float

torch.manual_seed(0)

# Create a valid rotation matrix (3x3)
# For testing, we'll create a simple rotation matrix
# A valid rotation matrix should be orthogonal with determinant 1
def create_rotation_matrix():
    """Create a valid 3x3 rotation matrix."""
    # Simple rotation around z-axis by 45 degrees
    angle = torch.tensor(3.14159 / 4)  # 45 degrees
    cos_a = torch.cos(angle)
    sin_a = torch.sin(angle)
    rot = torch.tensor([
        [cos_a, -sin_a, 0.0],
        [sin_a, cos_a, 0.0],
        [0.0, 0.0, 1.0]
    ])
    return rot

# Create a batch of rotation matrices with shape (2, 3, 3)
rot = torch.stack([create_rotation_matrix(), create_rotation_matrix()], dim=0)

ARGS = {
    "rot": rot
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
jaxtyping, 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
rot_vec_mul Ran
ran; our contract draft was wrong, not the code
rish-16/rna-backbone-design/rna_backbone_design/models/ipa_pytorch.py
code served (permissive licence) · get_code("118e30173a0c8cea")
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 (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

torch.manual_seed(0)

# Create rotation matrices [*, 3, 3]
# Using batch size 2 for the * dimension
r = torch.randn(2, 3, 3)

# Create coordinate tensors [*, 3]
# The function expects coordinates with shape [*, 3] where * matches the batch dimension
t = torch.randn(2, 3)

ARGS = {
    "r": r,
    "t": t,
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1
Imports
jaxtyping, 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: none by the harness; any seed is in the setup block
InvariantPointAttention Not yet run
unverified (harvested, no recorded run)
rish-16/rna-backbone-design/rna_backbone_design/models/ipa_pytorch.py
code served (permissive licence) · get_code("0898b773881cf4c6")
How it ran

no invocation recorded.

Rigid Not yet run
unverified (harvested, no recorded run)
rish-16/rna-backbone-design/rna_backbone_design/models/ipa_pytorch.py
code served (permissive licence) · get_code("da4aaa284430aebf")
How it ran

no invocation recorded.

Rotation Not yet run
unverified (harvested, no recorded run)
rish-16/rna-backbone-design/rna_backbone_design/models/ipa_pytorch.py
code served (permissive licence) · get_code("64aa702cd0e421b0")
How it ran

no invocation recorded.

final_init_ Not yet run
unverified (harvested, no recorded run)
rish-16/rna-backbone-design/rna_backbone_design/models/ipa_pytorch.py
code served (permissive licence) · get_code("a10b543dd71d1e5b")
How it ran

no invocation recorded.

gRNAde Not yet run
unverified (harvested, no recorded run)
chaitjo/geometric-rna-design/src/models.py
code served (permissive licence) · get_code("4c10ab57adb8b449")
How it ran

no invocation recorded.

gating_init_ Not yet run
unverified (harvested, no recorded run)
rish-16/rna-backbone-design/rna_backbone_design/models/ipa_pytorch.py
code served (permissive licence) · get_code("1336281a5bb9480a")
How it ran

no invocation recorded.

glorot_uniform_init_ Not yet run
unverified (harvested, no recorded run)
rish-16/rna-backbone-design/rna_backbone_design/models/ipa_pytorch.py
code served (permissive licence) · get_code("50401de5c99d7396")
How it ran

no invocation recorded.

he_normal_init_ Not yet run
unverified (harvested, no recorded run)
rish-16/rna-backbone-design/rna_backbone_design/models/ipa_pytorch.py
code served (permissive licence) · get_code("8a0d47ceb85c9840")
How it ran

no invocation recorded.

ipa_point_weights_init_ Not yet run
unverified (harvested, no recorded run)
rish-16/rna-backbone-design/rna_backbone_design/models/ipa_pytorch.py
code served (permissive licence) · get_code("fcb2f4de473c1b1f")
How it ran

no invocation recorded.

lecun_normal_init_ Not yet run
unverified (harvested, no recorded run)
rish-16/rna-backbone-design/rna_backbone_design/models/ipa_pytorch.py
code served (permissive licence) · get_code("3569de993ea5cde4")
How it ran

no invocation recorded.

normal_init_ Not yet run
unverified (harvested, no recorded run)
rish-16/rna-backbone-design/rna_backbone_design/models/ipa_pytorch.py
code served (permissive licence) · get_code("b026377d7b0a114f")
How it ran

no invocation recorded.

trunc_normal_init_ Not yet run
unverified (harvested, no recorded run)
rish-16/rna-backbone-design/rna_backbone_design/models/ipa_pytorch.py
code served (permissive licence) · get_code("54e19d7f047b2518")
How it ran

no invocation recorded.

Also present in other papers' code

Of 29 samples lifted from this paper's linked repositories, 29 carry a function identity and 0 do not. Of the 29 distinct functions with an identity, 13 are also present in other papers whose code we hold (0 with at least one paper dated earlier, 0 the same month, 13 later) and 16 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
flatten_final_dims
brick of this paper's assembly: helper
10 other papers
10 later · 1 only as an assembly brick
2401.04082 (2024-01)
Improved motif-scaffolding with SE(3) flow matching
2405.20313 (2024-05)
Sequence-Augmented SE(3)-Flow Matching For Conditional Protein Backbone Generation
2406.00735 (2024-06)
Full-Atom Peptide Design based on Multi-modal Flow Matching
and 7 more not named here
permute_final_dims
brick of this paper's assembly: helper
10 other papers
10 later · 1 only as an assembly brick
2401.04082 (2024-01)
Improved motif-scaffolding with SE(3) flow matching
2405.20313 (2024-05)
Sequence-Augmented SE(3)-Flow Matching For Conditional Protein Backbone Generation
2406.00735 (2024-06)
Full-Atom Peptide Design based on Multi-modal Flow Matching
and 7 more not named here
Linear
brick of this paper's assembly: model
2 other papers
2 later · 1 only as an assembly brick
2502.02513 (2025-02)
Diffusion Generative Modeling on Lie Group Representations
2504.09374 (2025-04)
Hierarchical protein backbone generation with latent and structure diffusion
final_init_
brick of this paper's assembly: helper
2 other papers
2 later · 2 only as an assembly brick
2502.02513 (2025-02)
Diffusion Generative Modeling on Lie Group Representations
2504.09374 (2025-04)
Hierarchical protein backbone generation with latent and structure diffusion
gating_init_
brick of this paper's assembly: helper
2 other papers
2 later · 2 only as an assembly brick
2502.02513 (2025-02)
Diffusion Generative Modeling on Lie Group Representations
2504.09374 (2025-04)
Hierarchical protein backbone generation with latent and structure diffusion
glorot_uniform_init_
brick of this paper's assembly: helper
2 other papers
2 later · 1 only as an assembly brick
2502.02513 (2025-02)
Diffusion Generative Modeling on Lie Group Representations
2504.09374 (2025-04)
Hierarchical protein backbone generation with latent and structure diffusion
he_normal_init_
brick of this paper's assembly: helper
2 other papers
2 later · 1 only as an assembly brick
2502.02513 (2025-02)
Diffusion Generative Modeling on Lie Group Representations
2504.09374 (2025-04)
Hierarchical protein backbone generation with latent and structure diffusion
ipa_point_weights_init_
brick of this paper's assembly: helper
2 other papers
2 later · 2 only as an assembly brick
2502.02513 (2025-02)
Diffusion Generative Modeling on Lie Group Representations
2504.09374 (2025-04)
Hierarchical protein backbone generation with latent and structure diffusion
lecun_normal_init_
brick of this paper's assembly: helper
2 other papers
2 later · 1 only as an assembly brick
2502.02513 (2025-02)
Diffusion Generative Modeling on Lie Group Representations
2504.09374 (2025-04)
Hierarchical protein backbone generation with latent and structure diffusion
normal_init_
brick of this paper's assembly: helper
2 other papers
2 later · 2 only as an assembly brick
2502.02513 (2025-02)
Diffusion Generative Modeling on Lie Group Representations
2504.09374 (2025-04)
Hierarchical protein backbone generation with latent and structure diffusion
_calculate_fan
brick of this paper's assembly: helper
1 other paper
1 later · 1 only as an assembly brick
2502.02513 (2025-02)
Diffusion Generative Modeling on Lie Group Representations
_prod
brick of this paper's assembly: helper
1 other paper
1 later · 1 only as an assembly brick
2502.02513 (2025-02)
Diffusion Generative Modeling on Lie Group Representations
trunc_normal_init_
brick of this paper's assembly: helper
1 other paper
1 later · 1 only as an assembly brick
2502.02513 (2025-02)
Diffusion Generative Modeling on Lie Group Representations

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

Computational RNA design tasks are often posed as inverse problems, where sequences are designed based on adopting a single desired secondary structure without considering 3D conformational diversity. We introduce gRNAde, a geometric RNA design pipeline operating on 3D RNA backbones to design sequences that explicitly account for structure and dynamics. gRNAde uses a multi-state Graph Neural Network and autoregressive decoding to generates candidate RNA sequences conditioned on one or more 3D backbone structures where the identities of the bases are unknown. On a single-state fixed backbone re-design benchmark of 14 RNA structures from the PDB identified by Das et al. (2010), gRNAde obtains higher

For agents

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

get_harvested_code_for_paper("2305.14749")
get_code_for_paper("2305.14749")
have("2305.14749")

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

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

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

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

Connect an agent — have() is free.