| InformationDecomposition |
Ran ran; our contract draft was wrong, not the code |
priesemann-group/infomorphic_networks/im_net/im_model.py code served (permissive licence) · get_code("80273d573dbb5d3d") How it ranRan in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1) and returned Tensor, ndim 2, dtype family float; no output shape is stated. The image it ran in was not recorded. If your copy returns the same type and ndim on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.
import torch
import pickle as pkl
import os
from pathlib import Path
torch.manual_seed(0)
# Create a mock moebius.pkl file since the function tries to load it
# For n_sources=1, we need antichains and inversion_matrix
n_sources = 1
# Generate simple antichains for n_sources=1
# Antichains are tuples of tuples representing sets
antichains = [
((0,),),
((1,),),
((0, 1),),
]
# Create a simple inversion matrix (moebius function matrix)
# Shape should be (len(antichains), len(antichains))
inversion_matrix = [
[1.0, 0.0, 0.0],
[0.0, 1.0, 0.0],
[-1.0, -1.0, 1.0],
]
moebius_data = {
n_sources: (antichains, inversion_matrix)
}
# Write the pickle file
with open('moebius.pkl', 'wb') as f:
pkl.dump(moebius_data, f)
# Create a small probability tensor
# Shape: (batch_size, n_source_1, n_source_2, ..., n_target)
# For n_sources=1, we need shape (batch, source_dim, target_dim)
# Let's use batch=2, source_dim=3, target_dim=4
p_all_neurons = torch.rand(2, 3, 4)
# Normalize to be valid probabilities along the last dimension
p_all_neurons = p_all_neurons / p_all_neurons.sum(dim=-1, keepdim=True)
ARGS = {
"p_all_neurons": p_all_neurons,
}
- 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 — no output shape is stated: observe_signature.py could not observe it (fixture:OSError)
- 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
|
| acc_discrete |
Ran ran; our contract draft was wrong, not the code |
Priesemann-Group/Infomorphic_Networks/im_net/helper_functions.py code served (permissive licence) · get_code("851c1e5ab56013cb") How it ranRan in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned float, ndim 0, dtype family float, shape () as a later run recorded it. The image it ran in was not recorded. If your copy returns the same type, ndim and shape on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.
import torch
torch.manual_seed(0)
# Analyze the function:
# - acc_discrete takes pred, target, and check_inverse (with default True)
# - pred and target are compared with == operator
# - They're converted to torch.get_default_dtype() (float by default)
# - Operations: mean(axis=0), stack, max(axis=0)
# - This suggests pred and target are 2D tensors (batch_size, num_classes)
batch_size = 2
num_classes = 4
# Create pred: logits or class predictions (shape: [batch_size, num_classes])
pred = torch.randint(0, 2, (batch_size, num_classes))
# Create target: class labels (shape: [batch_size, num_classes])
# Should have same shape as pred for element-wise comparison
target = torch.randint(0, 2, (batch_size, num_classes))
ARGS = {
'pred': pred,
'target': target,
'check_inverse': 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 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
|
| activation_map |
Ran ran; the contract check could not run (RAISES, DEP_MISSING or TIMEOUT) |
Priesemann-Group/Infomorphic_Networks/im_net/helper_functions.py code served (permissive licence) · get_code("57064aa385c07040") How it ranRan in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned Tensor, ndim 2, dtype family float; no output shape is stated. The image it ran in was not recorded. If your copy returns the same type and ndim on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.
import torch
torch.manual_seed(0)
# Create small activations tensor: (n_samples=2, n_neur=4)
activations = torch.randn(2, 4)
# Create labels tensor: 2 samples with class labels (0 and 1, so n_classes=2)
labels = torch.tensor([0, 1], dtype=torch.long)
ARGS = {
"activations": activations,
"labels": labels,
}
- 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 — no output shape is stated: observe_signature.py could not observe it (read:ValueError)
- 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
|
| check_ax_and_colors |
Ran ran; the contract check could not run (RAISES, DEP_MISSING or TIMEOUT) |
Priesemann-Group/Infomorphic_Networks/im_net/plotting.py code served (permissive licence) · get_code("7977b0050b73788c") How it ranRan in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned tuple. The image it ran in was not recorded. If your copy returns the same type on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.
import seaborn as sns
import matplotlib.pyplot as plt
import matplotlib.axes
# Create a simple matplotlib axes object
fig, ax = plt.subplots()
# Create a list of colors using seaborn's color palette
colors = sns.color_palette('colorblind', 3)
# Number of plots
num_plots = 3
ARGS = {
'ax': ax,
'colors': colors,
'num_plots': num_plots
}
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
- Imports
- matplotlib, seaborn — 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
|
| compute_isx |
Ran ran, honoured the contract we drafted |
priesemann-group/infomorphic_networks/im_net/im_model.py code served (permissive licence) · get_code("73d1af8eaddb0a36") How it ranRan in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned Tensor, ndim 1, dtype family float, shape (2,) as a later run recorded it. The image it ran in was not recorded. If your copy returns the same type, ndim and shape on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.
import torch
from itertools import combinations
torch.manual_seed(0)
# Analyze the function signature and body:
# - n_sources: int, used to index tensors and create tuples
# - p_marginal: dict-like object indexed by tuples, contains tensors
# - alpha: iterable of tuples, each tuple represents a set of source indices
# Build p_marginal as a dict mapping index tuples to probability tensors
# The function indexes p_marginal with tuples like (0, 1, 2, n_sources) and (n_sources,)
# We need tensors with compatible shapes for operations
n_sources = 2
# Create a small probability tensor with shape (2, 2, 2, 2) for p_marginal values
# This represents a 4D probability distribution over 2+1 sources
prob_shape = (2, 2, 2, 2)
# Build p_marginal dictionary with all necessary index combinations
p_marginal = {}
# Generate all possible index tuples we might need
# For n_sources=2, we could have indices like (0,), (1,), (2,), (0,1), (0,2), (1,2), (0,1,2)
all_indices = list(range(n_sources + 1))
all_subsets = []
for r in range(1, n_sources + 2):
for subset in combinations(all_indices, r):
all_subsets.append(subset)
# Create tensors for each subset
for subset in all_subsets:
p_marginal[subset] = torch.rand(prob_shape)
# Ensure the special indices used in the function are present
p_marginal[tuple(range(n_sources + 1))] = torch.rand(prob_shape)
p_marginal[(n_sources,)] = torch.rand(prob_shape)
# alpha: a list of tuples, each tuple is a set of source indices
# Based on the function logic, alpha should contain tuples of indices
alpha = [(0,), (1,), (0, 1)]
# Verify alpha_t generation works
alpha_t = tuple((a + (n_sources,) for a in alpha))
ARGS = {
"n_sources": n_sources,
"p_marginal": p_marginal,
"alpha": alpha,
}
- 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 (2,) — shape (2,) as a later run recorded it
- dtype family
- int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
- Environment
- image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
|
| compute_marginals |
Ran ran; our contract draft was wrong, not the code |
priesemann-group/infomorphic_networks/im_net/im_model.py code served (permissive licence) · get_code("bcb3ea419cafa185") How it ranRan in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned 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
torch.manual_seed(0)
# The function compute_marginals takes:
# 1. n_sources: an integer
# 2. p_all_neurons: a tensor that supports .sum() with tuple and keepdim arguments
# Looking at the function:
# - n_sources is used in range(n_sources + 1) and to define set operations
# - p_all_neurons is used with .sum(tuple(...), keepdim=True)
# - The tensor needs to have dimensions matching n_sources + 1
n_sources = 2
# Create a tensor with n_sources + 1 = 3 dimensions
# Shape: (2, 3, 4) - batch=2, feature dims for marginal computation
p_all_neurons = torch.randn(2, 3, 4)
ARGS = {
"n_sources": n_sources,
"p_all_neurons": p_all_neurons,
}
- 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 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
|
| confusion_mat |
Ran ran, honoured the contract we drafted |
Priesemann-Group/Infomorphic_Networks/im_net/helper_functions.py code served (permissive licence) · get_code("505aef682aa0a2f4") How it ranRan in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned ndarray, ndim 2, dtype family int, shape (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 torch.nn as nn
from torch.utils.data import DataLoader, TensorDataset
torch.manual_seed(0)
class SimpleModel(nn.Module):
def __init__(self, num_classes=3):
super().__init__()
self.num_classes = num_classes
self.linear = nn.Linear(4, num_classes)
self.device = 'cpu'
def forward(self, x, z):
# Returns 4 outputs as expected by the function
# The function unpacks: _, theta, _, _ = model(x, z)
theta = torch.softmax(self.linear(x), dim=1)
dummy1 = torch.zeros(1)
dummy2 = torch.zeros(1)
dummy3 = torch.zeros(1)
return dummy1, theta, dummy2, dummy3
# Create a simple model
model = SimpleModel(num_classes=3)
# Create dummy data: batch_size=2, features=4, num_classes=3
x_data = torch.randn(2, 4)
y_data = torch.randint(0, 3, (2,))
# Create dataset and dataloader
dataset = TensorDataset(x_data, y_data)
loader = DataLoader(dataset, batch_size=2)
ARGS = {
'model': model,
'loader': loader,
'use_taget': False
}
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
- Imports
- sklearn, torch — import names as written, not package names to install; a name the repository itself provides is not a package
- Returned
- type ndarray, ndim 2, dtype family int, shape (3, 3) — shape (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
|
| dataset_helper |
Ran ran; our contract draft was wrong, not the code |
Priesemann-Group/Infomorphic_Networks/im_net/datasets.py code served (permissive licence) · get_code("83dcc781ebcc4017") How it ranRan in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned tuple. The image it ran in was not recorded. If your copy returns the same type on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.
import torch
import torch.nn as nn
torch.manual_seed(0)
# Create a minimal dataset class that can be instantiated with various arguments
class MinimalDataset:
def __init__(self, num_samples=10, feature_dim=4, **kwargs):
self.num_samples = num_samples
self.feature_dim = feature_dim
self.data = torch.randn(num_samples, feature_dim)
self.labels = torch.randint(0, 2, (num_samples,))
def __len__(self):
return self.num_samples
def __getitem__(self, idx):
return self.data[idx], self.labels[idx]
# Define ARGS with all parameters for dataset_helper
ARGS = {
'dataset_cls': MinimalDataset,
'creation_seed': 42,
'num_samples': [5, 10, 15],
'feature_dim': 4
}
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
- Imports
- torch — import names as written, not package names to install; a name the repository itself provides is not a package
- Returned
- type tuple — a tuple output has no array shape of its own; none is stated
- Environment
- image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
|
| get_atom_labels |
Ran ran; our contract draft was wrong, not the code |
Priesemann-Group/Infomorphic_Networks/im_net/plotting.py code served (permissive licence) · get_code("42c320e01d2ea2c2") How it ranRan in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned list, ndim 1, dtype family float; no output shape is stated. The image it ran in was not recorded. If your copy returns the same type and ndim on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.
import torch
torch.manual_seed(0)
# The function get_atom_labels takes a single parameter: num_atoms
# It returns different lists based on the value of num_atoms
# Valid inputs are 5, 19, or any other number (which prints an error)
ARGS = {
'num_atoms': 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 list, ndim 1, dtype family float — a list output has no array shape of its own; none is stated
- dtype family
- int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
- Environment
- image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
|
| get_normalization_transform |
Ran ran; our contract draft was wrong, not the code |
Priesemann-Group/Infomorphic_Networks/im_net/datasets.py code served (permissive licence) · get_code("764aa72fa73eaa6c") How it ranRan in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned Compose. 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 torchvision
from torch.utils.data import Dataset
torch.manual_seed(0)
class SimpleDataset(Dataset):
def __init__(self):
# Create small dummy image data: 2 samples, 3 channels, 4x4 images
self.data = torch.randn(2, 3, 4, 4)
self.labels = torch.tensor([0, 1])
def __len__(self):
return len(self.data)
def __getitem__(self, idx):
return self.data[idx], self.labels[idx]
trainset = SimpleDataset()
ARGS = {
"trainset": trainset
}
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
- Imports
- torch, torchvision — import names as written, not package names to install; a name the repository itself provides is not a package
- Returned
- type Compose — a Compose output has no array shape of its own; none is stated — the instrument coerces any output to an array; for a Compose 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
|
| load_reordered_moebius_function |
Ran ran; our contract draft was wrong, not the code |
priesemann-group/infomorphic_networks/im_net/im_model.py code served (permissive licence) · get_code("424f9fe7b9ff0f54") How it ranRan in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned tuple. The image it ran in was not recorded. If your copy returns the same type on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.
import torch
import pickle as pkl
import tempfile
import os
torch.manual_seed(0)
# Create a temporary directory and file for the mock moebius data
temp_dir = tempfile.mkdtemp()
moebius_file_path = os.path.join(temp_dir, 'moebius.pkl')
# Create mock data structure that matches what the function expects
# moebius_data[n] should return (antichains, inversion_matrix)
mock_inversion_matrix = [[1, 0, 0, 0], [0, 1, 0, 0], [0, 0, 1, 0], [0, 0, 0, 1]]
mock_antichains = [[0, 1], [1, 2], [2, 3]]
moebius_data = {
2: (mock_antichains, mock_inversion_matrix)
}
# Write the mock pickle file
with open(moebius_file_path, 'wb') as f:
pkl.dump(moebius_data, f)
# Change to the temp directory so the function can find moebius.pkl
original_cwd = os.getcwd()
os.chdir(temp_dir)
ARGS = {
'n': 2,
'device': 'cpu'
}
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
- Imports
- torch — import names as written, not package names to install; a name the repository itself provides is not a package
- Returned
- type tuple — a tuple output has no array shape of its own; none is stated
- Environment
- image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
|
| plot_min_max |
Ran ran; the contract check could not run (RAISES, DEP_MISSING or TIMEOUT) |
Priesemann-Group/Infomorphic_Networks/im_net/plotting.py code served (permissive licence) · get_code("4e89b96c5b758e96") How it ranRan in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned list, ndim 1, dtype family float; no output shape is stated. The image it ran in was not recorded. If your copy returns the same type and ndim on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.
import numpy as np
import matplotlib.pyplot as plt
# Create a simple matplotlib axis
fig, ax = plt.subplots()
# Create x values
x = np.array([1, 2, 3, 4, 5])
# Create data with shape (5, 8) - 5 samples, 8 values each
# Include some 1s to be filtered out, and other values
np.random.seed(0)
data = np.random.uniform(0.5, 3.0, size=(5, 8))
# Add some 1s that will be filtered by the function
data[0, 2] = 1
data[1, 5] = 1
data[2, 0] = 1
# midpoint parameter
midpoint = 'mean'
# Optional parameters
label = 'test_line'
ls = '-'
kwargs_extra = {'color': 'blue', 'alpha': 0.7}
ARGS = {
'ax': ax,
'x': x,
'data': data,
'midpoint': midpoint,
'label': label,
'ls': ls,
}
ARGS.update(kwargs_extra)
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
- Imports
- matplotlib, numpy — import names as written, not package names to install; a name the repository itself provides is not a package
- Returned
- type list, ndim 1, dtype family float — a list output has no array shape of its own; none is stated
- dtype family
- int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
- Environment
- image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
|
| powerset |
Ran ran; our contract draft was wrong, not the code |
priesemann-group/infomorphic_networks/im_net/im_model.py code served (permissive licence) · get_code("2964b884853dfa1a") How it ranRan in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned chain. 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
from itertools import chain, combinations, product
ARGS = {
"iterable": [1, 2, 3]
}
- 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 chain — a chain output has no array shape of its own; none is stated — the instrument coerces any output to an array; for a chain 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
|
| union_probability |
Ran ran; our contract draft was wrong, not the code |
priesemann-group/infomorphic_networks/im_net/im_model.py code served (permissive licence) · get_code("4777efd3ee78e1bb") How it ranRan in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned Tensor, ndim 2, dtype family float, shape (2, 4) as a later run recorded it. The image it ran in was not recorded. If your copy returns the same type, ndim and shape on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.
import torch
from itertools import combinations
torch.manual_seed(0)
# n_sources: number of sources (int)
n_sources = 2
# p_marginal: dictionary mapping tuples of indices to probability tensors
# The function accesses p_marginal[tuple(range(n_sources + 1))] and p_marginal[b_union]
# We need to create a dict with tensor values for various index combinations
p_marginal = {
(0, 1, 2): torch.randn(2, 4), # base tensor with batch=2, dim=4
(0,): torch.randn(2, 4),
(1,): torch.randn(2, 4),
(2,): torch.randn(2, 4),
(0, 1): torch.randn(2, 4),
(0, 2): torch.randn(2, 4),
(1, 2): torch.randn(2, 4),
}
# alpha: a collection of tuples representing sets
# Based on the function body, alpha is iterated over with combinations()
# Each element in alpha should be a tuple/collection of indices
alpha = [(0,), (1,), (2,)]
ARGS = {
"n_sources": n_sources,
"p_marginal": p_marginal,
"alpha": alpha,
}
- 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
|
| grab_data |
Not yet run unverified (harvested, no recorded run) |
Priesemann-Group/Infomorphic_Networks/im_net/datasets.py code served (permissive licence) · get_code("0d81c1f3e5515ea2") How it ran |