SYNTOLOGY HomeExplorerAtlasCodeMethodologyAboutDevelopersFeedPricing
Paper · 2603.23016 · 2026

A Sobering Look at Tabular Data Generation via Probabilistic Circuits

Luca Bortolussi, Adrián Javaloy, Henry Gouk, Sebastiano Saccani, Antonio Vergari, Davide Scassola, Dylan Ponsford

arXiv · PDF · Open in the Atlas

Code that ran

17 of 18 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; 3 honoured the contract we drafted, 1 violated it and 1 has no contract verdict; 12 failures of our instrument; 1 no recorded run), measured 2026-11-22; 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/2603.23016.json · badge: /api/ran/2603.23016.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
april-tools/tabpc canonical (classifier label)
classifier basis: census
10 ran · 1 no recorded run
PriorLabs/tabpfn-extensions canonical (classifier label)
classifier basis: census
7 ran · 0 no recorded run
FunctionStatusWhere it lives
align_probabilities Ran
ran; our contract draft was wrong, not the code
PriorLabs/tabpfn-extensions/src/tabpfn_extensions/many_class/_utils.py
code served (permissive licence) · get_code("5ff1526ae945709c")
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 float, shape (2, 7) as a later run recorded it. The image it ran in was not recorded. If your copy returns the same type, ndim and shape on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import numpy as np

# Set random seeds for reproducibility
np.random.seed(0)

# Create probability array: shape (batch_size=2, num_classes_seen=3)
# These are predicted probabilities for 3 classes that were seen during training
proba = np.array([
    [0.1, 0.6, 0.3],
    [0.2, 0.5, 0.3]
], dtype=np.float64)

# Classes that were seen (subset of alphabet)
classes_seen = [1, 3, 5]

# Total alphabet size (should be >= max(classes_seen))
alphabet_size = 7

ARGS = {
    "proba": proba,
    "classes_seen": classes_seen,
    "alphabet_size": alphabet_size,
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
numpy — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type ndarray, ndim 2, dtype family float, shape (2, 7) — shape (2, 7) as a later run recorded it
dtype family
int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
as_numpy Ran
ran, honoured the contract we drafted
PriorLabs/tabpfn-extensions/src/tabpfn_extensions/many_class/_utils.py
code served (permissive licence) · get_code("30f2b8840fad5a2b")
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 (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 numpy as np
import torch
import pandas as pd
from scipy import sparse

torch.manual_seed(0)

# Test case 1: numpy array (direct return path)
numpy_array = np.array([[1, 2, 3, 4], [5, 6, 7, 8]])

# Test case 2: torch tensor (has to_numpy method)
torch_tensor = torch.randn(2, 4)

# Test case 3: pandas Series (has to_numpy method)
pandas_series = pd.Series([1.0, 2.0, 3.0, 4.0])

# Test case 4: scipy sparse matrix (has toarray method)
scipy_sparse = sparse.csr_matrix(np.array([[1, 0, 2], [0, 3, 0]]))

# Test case 5: list (convertible via np.asarray)
list_data = [[1, 2, 3, 4], [5, 6, 7, 8]]

# Choose one representative input for ARGS
ARGS = {
    "X": numpy_array
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
numpy, pandas, scipy, 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 (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
auto_input_layers Ran
ran; the contract check could not run (RAISES, DEP_MISSING or TIMEOUT)
april-tools/tabpc/src/circuits/hetero_tabular_data_api.py
code served (permissive licence) · get_code("9f107bdbb068e19f")
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
import pandas as pd

torch.manual_seed(0)

# Create a small tensor with shape (2, 4) - 2 samples, 4 features
x = torch.tensor([
    [1, 0, 2.5, 10],
    [2, 1, 3.2, 20]
], dtype=torch.float32)

# Create metadata dict mapping column indices to types
# We'll have: categorical, categorical, continuous, integer
metadata = {
    0: 'cat_feature',
    1: 'cat_type',
    2: 'continuous',
    3: 'int_value'
}

ARGS = {
    'x': x,
    'metadata': metadata,
    'verbose': True
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
pandas, 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
bivariate_plot Ran
ran; the contract check could not run (RAISES, DEP_MISSING or TIMEOUT)
april-tools/tabpc/src/distribution_plots.py
code served (permissive licence) · get_code("5993c72746bac21e")
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 Figure. 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 pandas as pd
import numpy as np
import matplotlib.pyplot as plt
import tempfile

# Create temporary directory for saving plots
temp_dir = tempfile.gettempdir()

# Create simple original dataframe with 2 columns (both continuous numerical)
np.random.seed(0)
df_original = pd.DataFrame({
    'feature_1': np.random.normal(0, 1, 100),
    'feature_2': np.random.normal(0, 1, 100)
})

# Create simple generated dataframe with 2 columns (both continuous numerical)
df_generated = pd.DataFrame({
    'feature_1': np.random.normal(0.1, 1, 100),
    'feature_2': np.random.normal(0.1, 1, 100)
})

# Create output path
output_path = f"{temp_dir}/bivariate_plot_test.png"

ARGS = {
    'df_original': df_original,
    'df_generated': df_generated,
    'path': output_path
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
matplotlib, numpy, pandas — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type Figure — a Figure output has no array shape of its own; none is stated — the instrument coerces any output to an array; for a Figure 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
class_vote Ran
ran; the contract check could not run (RAISES, DEP_MISSING or TIMEOUT)
PriorLabs/tabpfn-extensions/src/tabpfn_extensions/interpretability/decoder_readout.py
code served (permissive licence) · get_code("14e88beb7d75a80f")
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 numpy as np

# Set random seed for reproducibility
np.random.seed(0)

# Create small test data
n_test = 2
n_train = 5
n_classes = 3

# weights: (n_test, n_train) - readout weights from decoder
weights = np.random.rand(n_test, n_train).astype(np.float32)

# y_train: (n_train,) - training labels aligned to weight columns
y_train = np.array([0, 1, 0, 2, 1], dtype=np.int32)

# classes: class order for output columns (optional, defaults to sorted unique labels)
classes = np.array([0, 1, 2], dtype=np.int32)

ARGS = {
    "weights": weights,
    "y_train": y_train,
    "classes": classes,
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
numpy — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type tuple — a tuple output has no array shape of its own; none is stated
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
complete_y_only_data Ran
ran on a synthesized input
april-tools/tabpc/src/metrics/metrics.py
code served (permissive licence) · get_code("d753e63909b7dd0d")
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 DataFrame. 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 pandas as pd
from copy import deepcopy

# Create a mock self object (the function is a method)
class MockDataProcessor:
    pass

# Create synthetic data as a DataFrame
syn_data = pd.DataFrame({
    'col_0': [1.0, 2.0, 3.0],
    'col_1': [4.0, 5.0, 6.0],
    'col_2': [7.0, 8.0, 9.0]
})

# Create real data as a DataFrame with different values
real_data = pd.DataFrame({
    'col_0': [10.0, 20.0, 30.0],
    'col_1': [40.0, 50.0, 60.0],
    'col_2': [70.0, 80.0, 90.0]
})

# Target column index
target_col_idx = 1

# Create the self object
self_obj = MockDataProcessor()

ARGS = {
    'self': self_obj,
    'syn_data': syn_data,
    'real_data': real_data,
    'target_col_idx': target_col_idx
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
pandas, torch — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type DataFrame — a DataFrame output has no array shape of its own; none is stated — the instrument coerces any output to an array; for a DataFrame output the recorded ndim 2 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
count_matrix Ran
ran; our contract draft was wrong, not the code
april-tools/tabpc/src/distribution_plots.py
code served (permissive licence) · get_code("95b4e071a5cb5cbd")
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 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 numpy as np
import pandas as pd

# Create sample data for s_discr (discrete series)
s_discr = pd.Series([0, 1, 0, 1, 0, 1, 0, 1], name='discrete')

# Create sample data for s_real (real-valued series with some NaN)
s_real = pd.Series([1.5, 2.3, 1.8, 3.2, 2.1, 3.5, 1.9, 2.8], name='real')

# Define bin edges for histogram binning
bin_edges = np.array([1.0, 2.0, 3.0, 4.0])

# Define categories that appear in s_discr
categories = [0, 1]

# probability flag
probability = False

ARGS = {
    's_discr': s_discr,
    's_real': s_real,
    'bin_edges': bin_edges,
    'categories': categories,
    'probability': probability
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
numpy, pandas — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type ndarray, 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
file_name Ran
ran; our contract draft was wrong, not the code
april-tools/tabpc/src/util.py
code served (permissive licence) · get_code("5789cf98df5514e4")
How it ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned str. The image it ran in was not recorded. If your copy returns the same type on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

from pathlib import Path

ARGS = {
    "file": "/path/to/example.txt"
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
none outside the standard library — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type str — a str output has no array shape of its own; none is stated — the instrument coerces any output to an array; for a str output the recorded ndim 0 and dtype family float describe that coercion, not the output, and are not stated
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
filter_fit_params_for_mask Ran
ran; our contract draft was wrong, not the code
PriorLabs/tabpfn-extensions/src/tabpfn_extensions/many_class/_utils.py
code served (permissive licence) · get_code("ad50ffe87cdd75fb")
How it ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned dict. The image it ran in was not recorded. If your copy returns the same type on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import numpy as np
import pandas as pd
from typing import Mapping, Any

# Create a boolean mask for filtering
mask = np.array([True, False, True, False])

# Create fit_params with various types of values
fit_params = {
    # Array-like values that should be filtered
    'array_param': np.array([10, 20, 30, 40]),
    'list_param': [1, 2, 3, 4],
    'tuple_param': (5, 6, 7, 8),
    
    # DataFrame column (has .iloc)
    'dataframe_param': pd.DataFrame({'col': [100, 200, 300, 400]}),
    
    # Scalar values that should NOT be filtered
    'scalar_int': 42,
    'scalar_float': 3.14,
    'scalar_string': 'constant',
    
    # Array with different first dimension (should not be filtered)
    'wrong_shape': np.array([1, 2, 3]),
}

ARGS = {
    'fit_params': fit_params,
    'mask': mask,
    'n_samples': 4,
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
numpy, pandas — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type 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
float_format Ran
ran, honoured the contract we drafted
april-tools/tabpc/src/metrics/metrics.py
code served (permissive licence) · get_code("648820a4af0f1674")
How it ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned float, ndim 0, dtype family float, shape () as a later run recorded it. The image it ran in was not recorded. If your copy returns the same type, ndim and shape on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import torch
import numpy as np

torch.manual_seed(0)

ARGS = {
    "value": 3.14159265359,
    "precision_digits": 4,
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
numpy, torch — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type float, ndim 0, dtype family float, shape () — shape () as a later run recorded it
dtype family
int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
get_column_name_mapping Ran
ran; the contract check could not run (RAISES, DEP_MISSING or TIMEOUT)
april-tools/tabpc/datasets_scripts/tabdiff_process_dataset.py
code served (permissive licence) · get_code("0a6d3b3a16b9f56c")
How it ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned tuple, ndim 1, dtype family float; no output shape is stated. The image it ran in was not recorded. If your copy returns the same type and ndim on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import numpy as np
import pandas as pd

# Create a simple DataFrame with mixed column types
data_df = pd.DataFrame({
    'num_col_1': [1.0, 2.0, 3.0],
    'num_col_2': [4.0, 5.0, 6.0],
    'cat_col_1': ['a', 'b', 'c'],
    'cat_col_2': ['x', 'y', 'z'],
    'target_col': [0, 1, 0]
})

# Define indices for different column types
num_col_idx = [0, 1]  # indices of numerical columns
cat_col_idx = [2, 3]  # indices of categorical columns
target_col_idx = [4]  # indices of target columns

# Column names can be None (will use df.columns) or explicitly provided
column_names = None

ARGS = {
    'data_df': data_df,
    'num_col_idx': num_col_idx,
    'cat_col_idx': cat_col_idx,
    'target_col_idx': target_col_idx,
    'column_names': column_names
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
numpy, pandas — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type tuple, ndim 1, dtype family float — a tuple output has no array shape of its own; none is stated
dtype family
int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
get_max_num_classes Ran
ran, honoured the contract we drafted
PriorLabs/tabpfn-extensions/src/tabpfn_extensions/utils.py
code served (permissive licence) · get_code("38062913afa8e7be")
How it ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned int, ndim 0, dtype family int, shape () as a later run recorded it. The image it ran in was not recorded. If your copy returns the same type, ndim and shape on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import torch
import torch.nn as nn

# Create a mock TabPFN model with the necessary interface
class MockTabPFNModel(nn.Module):
    def __init__(self):
        super().__init__()
        self.linear = nn.Linear(4, 3)
    
    def get_inference_config(self):
        """Return a mock inference config with MAX_NUMBER_OF_CLASSES."""
        config = MockConfig()
        return config

class MockConfig:
    """Mock inference config that has MAX_NUMBER_OF_CLASSES attribute."""
    def __init__(self):
        self.MAX_NUMBER_OF_CLASSES = 100

# Create instances for testing
torch.manual_seed(0)

# Test with TabPFN model that has get_inference_config
tabpfn_model = MockTabPFNModel()

# Test with a regular model that doesn't have get_inference_config
regular_model = nn.Linear(4, 3)

ARGS = {
    "model": tabpfn_model,
}
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
is_tabpfn Ran
ran, violated the contract we drafted
PriorLabs/tabpfn-extensions/src/tabpfn_extensions/utils.py
code served (permissive licence) · get_code("3259cddd16c3bef1")
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 bool, ndim 0, dtype family float, shape () as a later run recorded it. The image it ran in was not recorded. If your copy returns the same type, ndim and shape on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import torch
import torch.nn as nn
from typing import Any

# Create a minimal stand-in class that mimics TabPFN
class TabPFNBaseModel(nn.Module):
    def __init__(self):
        super().__init__()
        self.linear = nn.Linear(4, 2)
    
    def forward(self, x):
        return self.linear(x)

# Create an instance of TabPFN model
tabpfn_model = TabPFNBaseModel()

# Create a non-TabPFN model for negative case testing
class SimpleModel(nn.Module):
    def __init__(self):
        super().__init__()
        self.linear = nn.Linear(4, 2)
    
    def forward(self, x):
        return self.linear(x)

simple_model = SimpleModel()

# Create test estimators
estimator_with_tabpfn = tabpfn_model
estimator_without_tabpfn = simple_model

# Also test with a non-model object that has TabPFN in class name
class TabPFNEstimator:
    def __init__(self):
        pass

tabpfn_estimator_obj = TabPFNEstimator()

# Test with regular object
regular_obj = {"key": "value"}

ARGS = {
    "estimator": tabpfn_model
}
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 bool, ndim 0, dtype family float, shape () — shape () as a later run recorded it
dtype family
int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
load_json Ran
ran; our contract draft was wrong, not the code
april-tools/tabpc/src/util.py
code served (permissive licence) · get_code("eb460e0605ba191e")
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 json
import tempfile
from pathlib import Path

# Create a temporary JSON file with valid content
temp_dir = tempfile.mkdtemp()
temp_file = Path(temp_dir) / "test.json"

test_data = {
    "key1": "value1",
    "key2": 42,
    "key3": [1, 2, 3],
    "key4": {"nested": "dict"}
}

with open(temp_file, 'w') as f:
    json.dump(test_data, f)

ARGS = {
    "file": temp_file
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
none outside the standard library — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type dict — a dict output has no array shape of its own; none is stated — the instrument coerces any output to an array; for a dict output the recorded ndim 0 and dtype family float describe that coercion, not the output, and are not stated
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
make_aggregator Ran
ran; our contract draft was wrong, not the code
PriorLabs/tabpfn-extensions/src/tabpfn_extensions/many_class/_strategies.py
code served (permissive licence) · get_code("6ec592d2338c75c4")
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 LogLikelihoodAggregator. The image it ran in was not recorded. If your copy returns the same type on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import numpy as np

# Set random seed for reproducibility
np.random.seed(0)

# Define constants used in the aggregators
EPS_PROBA = 1e-10
EPS_WEIGHT = 1e-10

# Create small test arrays
# P_rows: shape (n_rows, n_classes, n_vocab) - probabilities for each row, class, vocabulary item
n_rows = 2
n_classes = 3
n_vocab = 4

P_rows = np.random.dirichlet(np.ones(n_vocab), size=(n_rows, n_classes))

# codebook: shape (n_codes, n_vocab_indices) - indices into vocabulary for each code
n_codes = 3
codebook = np.random.randint(0, n_vocab, size=(n_codes, 2))

# row_weights: shape (n_rows,) - weight for each row
row_weights = np.array([0.6, 0.4])

# rest_mask: shape (n_rows, n_codes) - binary mask for which rows apply to which codes
rest_mask = np.random.randint(0, 2, size=(n_rows, n_codes)).astype(np.float32)

# Test both aggregator types with different configurations
ARGS = {
    "use_log": True,
    "mask_rest": True,
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
numpy — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type LogLikelihoodAggregator — a LogLikelihoodAggregator output has no array shape of its own; none is stated — the instrument coerces any output to an array; for a LogLikelihoodAggregator 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
pickle_load Ran
ran; our contract draft was wrong, not the code
april-tools/tabpc/src/util.py
code served (permissive licence) · get_code("c09fb22594aefb61")
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 pickle
from pathlib import Path
import tempfile
import os

# Create a temporary file with pickled data
temp_dir = tempfile.mkdtemp()
test_file = os.path.join(temp_dir, "test_data.pkl")

# Create and pickle some test data
test_data = {"key": "value", "number": 42}
with open(test_file, 'wb') as f:
    pickle.dump(test_data, f)

ARGS = {
    "file_name": test_file
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
none outside the standard library — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type dict — a dict output has no array shape of its own; none is stated — the instrument coerces any output to an array; for a dict output the recorded ndim 0 and dtype family float describe that coercion, not the output, and are not stated
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
train_val_test_split Ran
ran; our contract draft was wrong, not the code
april-tools/tabpc/datasets_scripts/tabdiff_process_dataset.py
code served (permissive licence) · get_code("e034defca8827e6c")
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 numpy as np
import pandas as pd

# Create a small dataframe with categorical columns
np.random.seed(0)
data = {
    'cat1': ['A', 'B', 'C', 'A', 'B', 'C', 'A', 'B'],
    'cat2': ['X', 'Y', 'Z', 'X', 'Y', 'Z', 'X', 'Y'],
    'num1': np.random.randn(8)
}
data_df = pd.DataFrame(data)

cat_columns = ['cat1', 'cat2']
num_train = 5
num_test = 2

ARGS = {
    'data_df': data_df,
    'cat_columns': cat_columns,
    'num_train': num_train,
    'num_test': num_test
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
numpy, pandas — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type 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
reorder Not yet run
unverified (harvested, no recorded run)
april-tools/tabpc/src/metrics/metrics.py
code served (permissive licence) · get_code("9f9ff63f9c999000")
How it ran

no invocation recorded.

Also present in other papers' code

Of 18 samples lifted from this paper's linked repositories, 18 carry a function identity and 0 do not. Of the 18 distinct functions with an identity, 2 are also present in other papers whose code we hold (2 with at least one paper dated earlier, 0 the same month, 0 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
get_column_name_mapping 1 other paper
1 dated earlier
2410.20626 (2024-10)
TabDiff: a Mixed-type Diffusion Model for Tabular Data Generation
train_val_test_split 1 other paper
1 dated earlier
2410.20626 (2024-10)
TabDiff: a Mixed-type Diffusion Model for Tabular Data Generation

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

Tabular data is more challenging to generate than text and images, due to its heterogeneous features and much lower sample sizes. On this task, diffusion-based models are the current state-of-theart (SotA) model class, achieving almost perfect performance on commonly used benchmarks. In this paper, we question the perception of progress for tabular data generation. First, we highlight the limitations of current protocols to evaluate the fidelity of generated data, and advocate for alternative ones. Next, we revisit a simple baselinehierarchical mixture models in the form of deep probabilistic circuits (PCs)-which delivers competitive or superior performance to SotA models for a fraction of the cost. PCs are the generative counterpart of decision forests, and as such can natively handle heterogeneous data as well as deliver tractable probabilistic generation and inference. Finally, in a rigorous empirical analysis we show that the apparent saturation of progress for SotA models is largely due to the use of inadequate metrics. As such, we highlight that there is still much to be done to generate realistic tabular data. Code available at https://github. com/april-tools/tabpc.

For agents

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

get_harvested_code_for_paper("2603.23016")
get_code_for_paper("2603.23016")
have("2603.23016")

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

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

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

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

Connect an agent — have() is free.