SYNTOLOGY HomeExplorerAtlasCodeMethodologyAboutDevelopersFeedPricing
Paper · 2412.02482 · ICLR · 2025

What should a neuron aim for? Designing local objective functions based on information theory

Alexander Ecker, Andreas Schneider, Valentin Neuhaus, David Ehrlich, Abdullah Makkeh, Viola Priesemann, Michael Wibral

arXiv · PDF · Open in the Atlas

Code that ran

14 of 15 samples (functions and classes) lifted from this paper's linked repositories executed on a synthesized input in Syntology's jail (0 of them constructed an object rather than computing a result; 2 honoured the contract we drafted, 0 violated it and 0 have no contract verdict; 12 failures of our instrument; 1 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/2412.02482.json · badge: /api/ran/2412.02482.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
Priesemann-Group/Infomorphic_Networks canonical (classifier label)
classifier basis: census
8 ran · 1 no recorded run
priesemann-group/infomorphic_networks canonical (classifier label)
classifier basis: classifier_2025
6 ran · 0 no recorded run
FunctionStatusWhere it lives
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 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; 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 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)

# 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 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; 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 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.

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 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 (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 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 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 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 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 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.

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 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 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 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 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 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.

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

no invocation recorded.

Also present in other papers' code

Of 15 samples lifted from this paper's linked repositories, 15 carry a function identity and 0 do not. Of the 15 distinct functions with an identity, 1 are also present in other papers whose code we hold (1 with at least one paper dated earlier, 0 the same month, 0 later) and 14 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
powerset
brick of this paper's assembly: helper
1 other paper
1 dated earlier
2308.00221 (2023-08)
Advancing Beyond Identification: Multi-bit Watermark for Large Language Models

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

In modern deep neural networks, the learning dynamics of individual neurons are often obscure, as the networks are trained via global optimization. Conversely, biological systems build on self-organized, local learning, achieving robustness and efficiency with limited global information. Here, we show how self-organization between individual artificial neurons can be achieved by designing abstract bioinspired local learning goals. These goals are parameterized using a recent extension of information theory, Partial Information Decomposition (PID), which decomposes the information that a set of information sources holds about an outcome into unique, redundant and synergistic contributions. Our framework enables neurons to locally shape the integration of information from various input classes, i.e., feedforward, feedback, and lateral, by selecting which of the three inputs should contribute uniquely, redundantly or synergistically to the output. This selection is expressed as a weighted sum of PID terms, which, for a given problem, can be directly derived from intuitive reasoning or via numerical optimization, offering a window into understanding task-relevant local information processing. Achieving neuron-level interpretability while enabling strong performance using local learning, our work advances a principled information-theoretic foundation for local learning strategies.

For agents

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

get_harvested_code_for_paper("2412.02482")
get_code_for_paper("2412.02482")
have("2412.02482")

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

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

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

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

Connect an agent — have() is free.