SYNTOLOGY HomeExplorerAtlasCodeMethodologyAboutDevelopersFeedPricing
Paper · 2605.28068 · ICML · 2026

PINE: Pruning Boosted Tree Ensembles with Conformal In-Distribution Prediction Equivalence

Yusuke Matsui, Haruki Yajima

arXiv · PDF · Open in the Atlas

Code that ran

19 of 20 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; 17 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/2605.28068.json · badge: /api/ran/2605.28068.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
sbuschjaeger/PyPruning canonical (classifier label)
classifier basis: census
14 ran · 1 no recorded run
mazumder-lab/ForestPrune community
Papers with Code archive
5 ran · 0 no recorded run
FunctionStatusWhere it lives
agglomerative Ran
ran; the contract check could not run (RAISES, DEP_MISSING or TIMEOUT)
sbuschjaeger/PyPruning/PyPruning/ClusterPruningClassifier.py
code served (permissive licence) · get_code("49d91813a36e50fc")
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 1, dtype family int, shape (8,) 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
from sklearn.cluster import AgglomerativeClustering

# Create sample data for agglomerative clustering
# X should be a 2D array of shape (n_samples, n_features)
np.random.seed(0)
X = np.random.randn(8, 4)

# n_estimators determines the number of clusters
n_estimators = 3

# Build the ARGS dictionary with all parameters
ARGS = {
    "X": X,
    "n_estimators": n_estimators,
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
numpy, sklearn — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type ndarray, ndim 1, dtype family int, shape (8,) — shape (8,) 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
avg_path_len_regularizer Ran
ran, honoured the contract we drafted
sbuschjaeger/PyPruning/PyPruning/ProxPruningClassifier.py
code served (permissive licence) · get_code("293a20e9664c873c")
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 float64, ndim 0, 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
from sklearn.tree import DecisionTreeClassifier

# Create a simple decision tree classifier
X = np.array([[0, 0], [1, 1], [2, 2], [3, 3]], dtype=np.float64)
y = np.array([0, 1, 0, 1], dtype=np.int64)

# Train a simple decision tree
est = DecisionTreeClassifier(max_depth=2, random_state=42)
est.fit(X, y)

ARGS = {
    "est": est
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
numpy, sklearn — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type float64, ndim 0, dtype family float — no output shape is stated: observe_signature.py recorded float ndim 0, which disagrees with the fixture run
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
centroid_selector Ran
ran; the contract check could not run (RAISES, DEP_MISSING or TIMEOUT)
sbuschjaeger/PyPruning/PyPruning/ClusterPruningClassifier.py
code served (permissive licence) · get_code("73d7d0974f761271")
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 1, dtype family int, shape (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
from sklearn.neighbors import NearestCentroid
from sklearn.metrics import pairwise_distances, pairwise_distances_argmin_min

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

# Create small sample data
# X: feature matrix with 5 samples and 4 features
X = np.array([
    [1.0, 2.0, 3.0, 4.0],
    [1.5, 2.5, 3.5, 4.5],
    [5.0, 6.0, 7.0, 8.0],
    [5.5, 6.5, 7.5, 8.5],
    [9.0, 10.0, 11.0, 12.0]
], dtype=np.float64)

# assignments: cluster label for each sample (3 clusters)
assignments = np.array([0, 0, 1, 1, 2], dtype=int)

# target: dummy parameter (not used in function body, but required by signature)
target = np.array([0, 0, 1, 1, 2], dtype=int)

ARGS = {
    "X": X,
    "assignments": assignments,
    "target": target
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
numpy, sklearn — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type ndarray, ndim 1, dtype family int, shape (3,) — shape (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
combined Ran
ran; the contract check could not run (RAISES, DEP_MISSING or TIMEOUT)
sbuschjaeger/PyPruning/PyPruning/MIQPPruningClassifier.py
code served (permissive licence) · get_code("158dd95388c39f7c")
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 float64, ndim 0, 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

# Create small ensemble predictions
# Shape: (num_classifiers, num_samples, num_classes)
# 5 classifiers, 2 samples, 4 classes
ensemble_proba = np.random.rand(5, 2, 4)

# Normalize to make valid probabilities
ensemble_proba = ensemble_proba / ensemble_proba.sum(axis=2, keepdims=True)

# Create target labels for 2 samples
target = np.array([0, 2])

# Indices for pair of classifiers
i = 0
j = 1

# Default weights (equal weights for 5 measures)
weights = [1.0 / 5.0 for _ in range(5)]

ARGS = {
    "i": i,
    "j": j,
    "ensemble_proba": ensemble_proba,
    "target": target,
    "weights": weights,
}
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 float64, ndim 0, dtype family float — no output shape is stated: observe_signature.py recorded float ndim 0, which disagrees with the fixture run
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
combined_error Ran
ran; the contract check could not run (RAISES, DEP_MISSING or TIMEOUT)
sbuschjaeger/PyPruning/PyPruning/MIQPPruningClassifier.py
code served (permissive licence) · get_code("c91bb2cdbf547c37")
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 float64, ndim 0, 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

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

# Create small ensemble predictions: shape (num_classifiers, num_samples, num_classes)
# 5 classifiers, 2 samples, 4 classes
ensemble_proba = np.random.rand(5, 2, 4)

# Normalize to make valid probabilities
ensemble_proba = ensemble_proba / ensemble_proba.sum(axis=2, keepdims=True)

# Create target labels: shape (num_samples,)
target = np.array([0, 2])

# Define arguments for combined_error function
ARGS = {
    "i": 0,
    "j": 1,
    "ensemble_proba": ensemble_proba,
    "target": target
}
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 float64, ndim 0, dtype family float — no output shape is stated: observe_signature.py recorded float ndim 0, which disagrees with the fixture run
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
complementariness Ran
ran; the contract check could not run (RAISES, DEP_MISSING or TIMEOUT)
sbuschjaeger/PyPruning/PyPruning/GreedyPruningClassifier.py
code served (permissive licence) · get_code("fbba0ad234a0641b")
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 float64, ndim 0, 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

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

# Create sample probability predictions from an ensemble of classifiers
# Shape: (n_classifiers, n_samples, n_classes)
# - n_classifiers: 5 classifiers in the ensemble
# - n_samples: 2 samples
# - n_classes: 4 classes
ensemble_proba = np.random.rand(5, 2, 4)

# Normalize to make valid probabilities (sum to 1 across classes for each sample)
ensemble_proba = ensemble_proba / ensemble_proba.sum(axis=2, keepdims=True)

# Target labels for the 2 samples
# Shape: (n_samples,)
target = np.array([1, 2])

# Index of the current classifier being evaluated
i = 0

# Indices of selected models already in the sub-ensemble
# These are indices into the first dimension of ensemble_proba
selected_models = np.array([1, 3])

ARGS = {
    "i": i,
    "ensemble_proba": ensemble_proba,
    "selected_models": selected_models,
    "target": target,
}
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 float64, ndim 0, dtype family float — no output shape is stated: observe_signature.py recorded float ndim 0, which disagrees with the fixture run
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
converge_test Ran
ran; the contract check could not run (RAISES, DEP_MISSING or TIMEOUT)
mazumder-lab/ForestPrune/code/ForestPrune.py
code served (permissive licence) · get_code("7ecd0604b4d5e6a7")
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 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 numpy as np
from numba import jit

@jit(nopython=True)
def converge_test(sequence, threshold, tail_length):
    diff = np.diff(sequence)
    if len(diff) < tail_length + 1:
        return False
    else:
        return np.max(np.abs(diff[-tail_length:])) < threshold

# Create a sequence that demonstrates convergence
# The function computes differences and checks if the last tail_length differences
# are all below the threshold
sequence = np.array([1.0, 1.5, 1.7, 1.8, 1.85, 1.87, 1.88, 1.89], dtype=np.float64)
threshold = 0.1
tail_length = 3

ARGS = {
    "sequence": sequence,
    "threshold": threshold,
    "tail_length": tail_length
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1
Imports
numba, numpy — 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
eval_obj Ran
ran; the contract check could not run (RAISES, DEP_MISSING or TIMEOUT)
mazumder-lab/ForestPrune/code/ForestPrune.py
code served (permissive licence) · get_code("489bce2e5ea9c859")
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 numpy as np
from numba import jit

@jit(nopython=True)
def eval_obj(Y, diff_array_list, vars_z, learning_rate, alpha, W_array, normalization):
    pred = np.zeros(len(Y))
    regularization = 0
    for i in range(len(vars_z)):
        pred += learning_rate * np.dot(diff_array_list[i], vars_z[i])
        regularization += np.sum(np.dot(W_array[i], vars_z[i]))
    bias = np.sum((Y - pred) ** 2) / len(Y)
    return bias + regularization * alpha / normalization

# Setup code to construct valid arguments
np.random.seed(0)

# Y: target vector
Y = np.array([1.0, 2.0, 3.0, 4.0])

# diff_array_list: list of 2D arrays for dot products
diff_array_list = [
    np.random.randn(4, 5),
    np.random.randn(4, 6),
    np.random.randn(4, 7)
]

# vars_z: list of 1D arrays (variables for each layer)
vars_z = [
    np.random.randn(5),
    np.random.randn(6),
    np.random.randn(7)
]

# learning_rate: scalar
learning_rate = 0.01

# alpha: regularization coefficient
alpha = 0.1

# W_array: list of 2D weight matrices
W_array = [
    np.random.randn(3, 5),
    np.random.randn(3, 6),
    np.random.randn(3, 7)
]

# normalization: scalar for normalization
normalization = 1.5

ARGS = {
    "Y": Y,
    "diff_array_list": diff_array_list,
    "vars_z": vars_z,
    "learning_rate": learning_rate,
    "alpha": alpha,
    "W_array": W_array,
    "normalization": normalization
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
numba, numpy — 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
evaluate_candidates Ran
ran; the contract check could not run (RAISES, DEP_MISSING or TIMEOUT)
mazumder-lab/ForestPrune/code/ForestPrune.py
code served (permissive licence) · get_code("cfa03aa05bb54fd6")
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
from numba import jit

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

# Define parameters based on function signature
cycle_ind = 0
num_cycles = 2
candidate_dim = 4
num_candidates = 3
batch_size = 2

# Create diff_array_list: list of arrays for each cycle
diff_array_list = [
    np.random.randn(batch_size, candidate_dim).astype(np.float64),
    np.random.randn(batch_size, candidate_dim).astype(np.float64)
]

# Create temp_vars: array to store candidate values for each cycle
temp_vars = np.zeros((num_cycles, candidate_dim), dtype=np.float64)

# Create learning_rate
learning_rate = 0.01

# Create candidates: list of candidate vectors to evaluate
candidates = [
    np.random.randn(candidate_dim).astype(np.float64),
    np.random.randn(candidate_dim).astype(np.float64),
    np.random.randn(candidate_dim).astype(np.float64)
]

# Create precompute_pred: precomputed predictions
precompute_pred = np.random.randn(batch_size).astype(np.float64)

# Create Y: target values
Y = np.random.randn(batch_size).astype(np.float64)

# Create alpha: regularization parameter
alpha = 0.001

# Create W_array: weight arrays for each cycle
W_array = [
    np.random.randn(candidate_dim, candidate_dim).astype(np.float64),
    np.random.randn(candidate_dim, candidate_dim).astype(np.float64)
]

# Create normalization: normalization factor
normalization = 1.0

ARGS = {
    'diff_array_list': diff_array_list,
    'temp_vars': temp_vars,
    'learning_rate': learning_rate,
    'cycle_ind': cycle_ind,
    'candidates': candidates,
    'precompute_pred': precompute_pred,
    'Y': Y,
    'alpha': alpha,
    'W_array': W_array,
    'normalization': normalization
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
numba, 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
individual_contribution Ran
ran; the contract check could not run (RAISES, DEP_MISSING or TIMEOUT)
sbuschjaeger/PyPruning/PyPruning/RankPruningClassifier.py
code served (permissive licence) · get_code("c9719411110ef7bd")
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 float64, ndim 0, 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

# Analyze the function to understand parameter requirements:
# - i: integer index into first dimension of ensemble_proba
# - ensemble_proba: 3D numpy array with shape (num_classifiers, num_samples, num_classes)
# - target: 1D numpy array of true labels with length num_samples

# Set small dimensions: 
# - num_classifiers = 3 (ensemble size)
# - num_samples = 2 (batch size)
# - num_classes = 4 (number of classes)

np.random.seed(42)

# Create ensemble_proba: shape (3, 2, 4)
# Each classifier makes predictions over 2 samples with probabilities for 4 classes
ensemble_proba = np.random.dirichlet(np.ones(4), size=(3, 2))

# Create target: shape (2,) with class labels in range [0, 3]
target = np.array([1, 2])

# i: index of classifier to evaluate (must be in range [0, 2])
i = 0

ARGS = {
    "i": i,
    "ensemble_proba": ensemble_proba,
    "target": target,
}
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 float64, ndim 0, dtype family float — no output shape is stated: observe_signature.py recorded float ndim 0, which disagrees with the fixture run
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
individual_error Ran
ran; the contract check could not run (RAISES, DEP_MISSING or TIMEOUT)
sbuschjaeger/PyPruning/PyPruning/RankPruningClassifier.py
code served (permissive licence) · get_code("3ff27b63774f30c4")
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 float64, ndim 0, 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 numpy as np

torch.manual_seed(0)

# The function expects:
# - i: an integer index
# - ensemble_proba: a 3D array/tensor with shape (num_classifiers, batch_size, num_classes)
# - target: a 1D array/tensor with class labels for each sample in the batch

# Create small example data
num_classifiers = 3
batch_size = 2
num_classes = 4

# ensemble_proba: shape (3, 2, 4) - 3 classifiers, 2 samples, 4 classes
# Each value should be a probability (though the function only uses argmax)
ensemble_proba = np.random.rand(num_classifiers, batch_size, num_classes)

# target: shape (2,) - ground truth labels for 2 samples
target = np.array([0, 2])

# i: index of the individual classifier to evaluate
i = 0

ARGS = {
    "i": i,
    "ensemble_proba": ensemble_proba,
    "target": target,
}
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 float64, ndim 0, dtype family float — no output shape is stated: observe_signature.py recorded float ndim 0, which disagrees with the fixture run
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
individual_margin_diversity Ran
ran; the contract check could not run (RAISES, DEP_MISSING or TIMEOUT)
sbuschjaeger/PyPruning/PyPruning/RankPruningClassifier.py
code served (permissive licence) · get_code("2fc44664a5e0cd59")
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 float64, ndim 0, 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

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

# Create a small ensemble probability array
# Shape: (num_classifiers, num_samples, num_classes)
# Using 3 classifiers, 2 samples, 4 classes
ensemble_proba = np.random.dirichlet(np.ones(4), size=(3, 2)).astype(np.float32)

# Create target labels (one per sample)
# Must match the number of samples in ensemble_proba
target = np.array([1, 2], dtype=np.int32)

# Index i selects which classifier we're evaluating
i = 0

# Alpha parameter controlling trade-off between margin and diversity
alpha = 0.2

ARGS = {
    "i": i,
    "ensemble_proba": ensemble_proba,
    "target": target,
    "alpha": alpha,
}
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 float64, ndim 0, dtype family float — no output shape is stated: observe_signature.py recorded float ndim 0, which disagrees with the fixture run
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
kmeans Ran
ran; the contract check could not run (RAISES, DEP_MISSING or TIMEOUT)
sbuschjaeger/PyPruning/PyPruning/ClusterPruningClassifier.py
code served (permissive licence) · get_code("d0cc5e799e877245")
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 1, dtype family int, shape (10,) 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
from sklearn.cluster import KMeans

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

# Create small sample data for clustering
# X should be a 2D array of shape (n_samples, n_features)
X = np.random.randn(10, 4)

# Number of clusters to form
n_estimators = 3

# Additional kwargs for KMeans
kwargs = {
    'random_state': 0,
    'n_init': 10
}

ARGS = {
    'X': X,
    'n_estimators': n_estimators,
    **kwargs
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
numpy, sklearn — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type ndarray, ndim 1, dtype family int, shape (10,) — shape (10,) 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
neg_auc Ran
ran; the contract check could not run (RAISES, DEP_MISSING or TIMEOUT)
sbuschjaeger/PyPruning/PyPruning/GreedyPruningClassifier.py
code served (permissive licence) · get_code("f5a275d965e3fc5d")
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 numpy as np
from sklearn.metrics import roc_auc_score

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

# Create small test data
batch_size = 2
num_models = 3
num_classes = 2

# ensemble_proba: shape (num_models, batch_size, num_classes)
# Contains probability predictions from each model
ensemble_proba = np.random.rand(num_models, batch_size, num_classes)
# Normalize to make valid probabilities
ensemble_proba = ensemble_proba / ensemble_proba.sum(axis=2, keepdims=True)

# selected_models: array of indices of already selected models
# Should be a subset of model indices (0 to num_models-1)
selected_models = np.array([0, 1])

# target: binary labels for the batch
target = np.array([0, 1])

# i: index of the model to evaluate
i = 2

ARGS = {
    "i": i,
    "ensemble_proba": ensemble_proba,
    "selected_models": selected_models,
    "target": target,
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
numpy, sklearn — 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
node_regularizer Ran
ran, honoured the contract we drafted
sbuschjaeger/PyPruning/PyPruning/ProxPruningClassifier.py
code served (permissive licence) · get_code("e8d4fc73133e000e")
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 numpy as np
from sklearn.tree import DecisionTreeClassifier

# Create a simple decision tree estimator
X = np.array([[0, 0], [1, 1], [2, 2], [3, 3]])
y = np.array([0, 1, 0, 1])

est = DecisionTreeClassifier(random_state=42)
est.fit(X, y)

ARGS = {
    "est": est
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
numpy, sklearn — 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
precompute_predictions Ran
ran; the contract check could not run (RAISES, DEP_MISSING or TIMEOUT)
mazumder-lab/ForestPrune/code/ForestPrune.py
code served (permissive licence) · get_code("1cb5f080c0095329")
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 ndarray, ndim 1, dtype family float, shape (4,) as a later run recorded it. The image it ran in was not recorded. If your copy returns the same type, ndim and shape on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import numpy as np

# Construct arguments for precompute_predictions
# The function expects:
# - diff_array_list: list of arrays that will be indexed and used in np.dot
# - temp_vars: list of arrays that will be indexed and used in np.dot
# - learning_rate: scalar float
# - cycle_ind: integer index to skip

# Create small diff_array_list - list of 1D arrays
# Each array should have the same length (they're dotted with temp_vars)
diff_array_list = [
    np.array([1.0, 2.0, 3.0, 4.0]),
    np.array([0.5, 1.5, 2.5, 3.5]),
    np.array([2.0, 3.0, 4.0, 5.0])
]

# Create temp_vars - list of 1D arrays matching the length of diff_array_list elements
temp_vars = [
    np.array([0.1, 0.2, 0.3, 0.4]),
    np.array([0.2, 0.3, 0.4, 0.5]),
    np.array([0.15, 0.25, 0.35, 0.45])
]

# learning_rate is a scalar
learning_rate = 0.01

# cycle_ind is an integer index to skip (should be valid index in range)
cycle_ind = 1

ARGS = {
    "diff_array_list": diff_array_list,
    "temp_vars": temp_vars,
    "learning_rate": learning_rate,
    "cycle_ind": cycle_ind
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1
Imports
numba, numpy — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type ndarray, ndim 1, dtype family float, shape (4,) — shape (4,) as a later run recorded it
dtype family
int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
reduced_error Ran
ran; the contract check could not run (RAISES, DEP_MISSING or TIMEOUT)
sbuschjaeger/PyPruning/PyPruning/GreedyPruningClassifier.py
code served (permissive licence) · get_code("45e1e406f2c60ddf")
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 float64, ndim 0, 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 numpy as np

torch.manual_seed(0)

# Build valid arguments for reduced_error function
# Parameters: i, ensemble_proba, selected_models, target

# i: index of a classifier (int)
i = 0

# ensemble_proba: numpy array of shape (num_models, num_samples, num_classes)
# The function indexes it as [i, :, :], [selected_models, :, :], and calls .sum(axis=0), .argmax(axis=1)
# So it needs at least 3 dimensions
num_models = 5
num_samples = 2
num_classes = 4
ensemble_proba = np.random.rand(num_models, num_samples, num_classes).astype(np.float32)

# selected_models: array-like of model indices to select from ensemble_proba
# Used as ensemble_proba[selected_models, :, :] for fancy indexing
selected_models = np.array([0, 1, 3])

# target: array of true labels for comparison
# Used in pred.argmax(axis=1) != target, so should be shape (num_samples,)
target = np.array([0, 2])

ARGS = {
    "i": i,
    "ensemble_proba": ensemble_proba,
    "selected_models": selected_models,
    "target": target
}
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 float64, ndim 0, dtype family float — no output shape is stated: observe_signature.py recorded float ndim 0, which disagrees with the fixture run
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
solve_weighted Ran
ran; our contract draft was wrong, not the code
mazumder-lab/ForestPrune/code/ForestPrune.py
code served (permissive licence) · get_code("23c4bb0f8d5ff1eb")
How it ran

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

import numpy as np
import pandas as pd
import random

class SimpleTree:
    def __init__(self, max_depth):
        self.max_depth = max_depth

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

# Create small test data
max_depth = 3
num_trees = 2
num_samples = 5

# Y: pandas Series with numeric values
Y = pd.Series([1.0, 2.0, 3.0, 4.0, 5.0])

# tree_list: list of tree objects with max_depth attribute
tree_list = [SimpleTree(max_depth) for _ in range(num_trees)]

# diff_array_list: list of numpy arrays, each of shape (num_samples, max_depth)
diff_array_list = [
    np.random.randn(num_samples, max_depth),
    np.random.randn(num_samples, max_depth)
]

# alpha: regularization parameter
alpha = 0.1

# learning_rate: float
learning_rate = 0.01

# W_array: list of numpy arrays for regularization weights, each of shape (max_depth,)
W_array = [
    np.ones(max_depth),
    np.ones(max_depth)
]

# normalization: float for normalization factor
normalization = 1.0

# warm_start: optional list of initial variables (empty list means no warm start)
warm_start = []

ARGS = {
    'Y': Y,
    'tree_list': tree_list,
    'diff_array_list': diff_array_list,
    'alpha': alpha,
    'learning_rate': learning_rate,
    'W_array': W_array,
    'normalization': normalization,
    'warm_start': warm_start
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1
Imports
numba, 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
to_prob_simplex Ran
ran; the contract check could not run (RAISES, DEP_MISSING or TIMEOUT)
sbuschjaeger/PyPruning/PyPruning/ProxPruningClassifier.py
code served (permissive licence) · get_code("bda31a34b0d8761f")
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

# The function to_prob_simplex takes a vector x and projects it onto the probability simplex
# It uses: len(x), np.sort(), indexing, arithmetic operations, and max()
# x should be array-like (list or numpy array)

# Create a simple test vector with some values
x = np.array([2.0, 1.5, 0.5, -1.0])

ARGS = {
    "x": x
}
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 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
create_pruner Not yet run
unverified (harvested, no recorded run)
sbuschjaeger/PyPruning/PyPruning/Papers.py
code served (permissive licence) · get_code("65ba38df5792e260")
How it ran

no invocation recorded.

Also present in other papers' code

Of 20 samples lifted from this paper's linked repositories, 20 carry a function identity and 0 do not. Of the 20 distinct functions with an identity, 0 are also present in other papers whose code we hold (0 with at least one paper dated earlier, 0 the same month, 0 later) and 20 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.

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

Tree ensembles are machine learning models with strong predictive performance and interpretability, and remain widely used for tabular data. Standard pruning methods for tree ensembles typically optimize an accuracy-compression trade-off and may change a subset of predictions, potentially compromising decision consistency. Faithful pruning methods address this issue by preserving prediction equivalence over the entire input space, but this requirement leads to lower compression ratios. We propose PINE, a pruning method that provides strong guarantees within an in-distribution region. PINE preserves prediction equivalence within this region and controls the region size using a single parameter α via conformal calibration. Experiments on 12 public tabular datasets show that PINE improves the compression ratio by up to 30% while preserving predictions at a comparable level to existing faithful pruning methods.

For agents

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

get_harvested_code_for_paper("2605.28068")
get_code_for_paper("2605.28068")
have("2605.28068")

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

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

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

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

Connect an agent — have() is free.