SYNTOLOGY HomeExplorerAtlasCodeMethodologyAboutDevelopersFeedPricing
Paper · 2006.04292 · 2020

Achieving Equalized Odds by Resampling Sensitive Attributes

arXiv · PDF · Open in the Atlas

Code that ran

12 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; 0 honoured the contract we drafted, 0 violated it and 12 have no contract verdict; 0 failures of our instrument; 3 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/2006.04292.json · badge: /api/ran/2006.04292.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
yromano/fair_dummies canonical (classifier label)
classifier basis: census
12 ran · 3 no recorded run
FunctionStatusWhere it lives
calc_accuracy Ran
ran on a synthesized input
yromano/fair_dummies/fair_dummies/utility_functions.py
code served (permissive licence) · get_code("155d81bdb4a2fc74")
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

torch.manual_seed(0)

# outputs: tensor that will have torch.max applied along dimension 1
# Expected shape: (batch_size, num_classes)
# We use batch_size=2, num_classes=4
outputs = torch.randn(2, 4)

# Y: target labels, compared against max_indices from outputs
# Expected shape: (batch_size,) with values in range [0, num_classes)
Y = torch.tensor([0, 2])

ARGS = {
    "outputs": outputs,
    "Y": Y,
}
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 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
compute_acc Ran
ran on a synthesized input
yromano/fair_dummies/fair_dummies/utility_functions.py
code served (permissive licence) · get_code("38ec48431e45abd1")
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)

# Yhat: logits tensor with shape (batch_size, num_classes)
# The function calls torch.max(Yhat, 1) to get predicted class indices
Yhat = torch.randn(2, 4)

# Y: ground truth labels tensor with shape (batch_size,)
# The function compares predicted == Y, so Y should contain class indices (0 to num_classes-1)
Y = torch.tensor([0, 2])

ARGS = {
    "Yhat": Yhat,
    "Y": Y,
}
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
covariance_diff_biased Ran
ran on a synthesized input
yromano/fair_dummies/fair_dummies/fair_dummies_learning.py
code served (permissive licence) · get_code("593e5ed0481b0f0a")
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 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)

# Create two small tensors with distinct dimensions
# Z: batch_size=2, features=4
Z = torch.randn(2, 4)

# W: batch_size=2, features=4
W = torch.randn(2, 4)

# scale parameter
scale = 1.0

ARGS = {
    "Z": Z,
    "W": W,
    "scale": scale,
}
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 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
density_estimation Ran
ran on a synthesized input
yromano/fair_dummies/fair_dummies/utility_functions.py
code served (permissive licence) · get_code("4df32aef40d16f61")
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 sample data for Y: 1D array of continuous values
Y = np.array([0.5, 1.2, 0.3, 1.8, 2.1, 0.7, 1.5, 0.9])

# Create sample data for A: binary treatment assignment (0 or 1)
A = np.array([0, 1, 0, 1, 0, 1, 1, 0])

# Create optional test data
Y_test = np.array([0.4, 1.3, 2.0, 0.6])

ARGS = {
    'Y': Y,
    'A': A,
    'Y_test': Y_test
}
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 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
gen_synthetic_data Ran
ran on a synthesized input
yromano/fair_dummies/get_dataset.py
code served (permissive licence) · get_code("61c33a916c6ce639")
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

ARGS = {
    "n": 6000,
    "seed": 0,
}
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
get_coverage Ran
ran on a synthesized input
yromano/fair_dummies/fair_dummies/cf_classification.py
code served (permissive licence) · get_code("4fd60a8ea590875e")
How it ran

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

import torch
import numpy as np

torch.manual_seed(0)

# Y should be an integer index
Y = 1

# predicted_C should be indexable and contain boolean values
# The function does: predicted_C[int(Y)] == True
# So predicted_C needs to be a sequence/array with at least Y+1 elements
predicted_C = torch.tensor([False, True, False, True])

ARGS = {
    "Y": Y,
    "predicted_C": predicted_C
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
numpy, torch — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type int, ndim 0, dtype family int, shape () — shape () as a later run recorded it
dtype family
int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
get_length Ran
ran on a synthesized input
yromano/fair_dummies/fair_dummies/cf_classification.py
code served (permissive licence) · get_code("2ffe424106b5b1c8")
How it ran

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

import torch
import numpy as np

torch.manual_seed(0)

# Analyze the function:
# - get_length(Y, predicted_C) takes two parameters
# - It computes: length = sum(predicted_C)
# - Y is not used in the function body
# - predicted_C must be summable (list, tensor, or numpy array)

# Create small sample data
Y = torch.randn(2, 4)  # Not used but required as parameter

# predicted_C should be summable - can be a list of integers or tensor
predicted_C = [2, 3]  # Simple list of integers that sum to 5

ARGS = {
    "Y": Y,
    "predicted_C": predicted_C
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
numpy, torch — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type int, ndim 0, dtype family int, shape () — shape () as a later run recorded it
dtype family
int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
get_stat Ran
ran on a synthesized input
yromano/fair_dummies/fair_dummies/cf_classification.py
code served (permissive licence) · get_code("50b70e5728cd9316")
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 int; 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)

# Analyzing the function:
# - Y: an integer index used to access predicted_C
# - predicted_C: a sequence/array that supports indexing and boolean comparison,
#   and can be summed (needs to support sum() operation)

# Y should be a valid index into predicted_C
Y = 1

# predicted_C should be a boolean array/tensor where:
# - predicted_C[int(Y)] returns a boolean value
# - sum(predicted_C) works
# - We can check if it equals True
predicted_C = torch.tensor([False, True, False, True], dtype=torch.bool)

ARGS = {
    "Y": Y,
    "predicted_C": predicted_C
}
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 tuple, ndim 1, dtype family int — 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
pretrain_adversary Ran
ran on a synthesized input
yromano/fair_dummies/fair_dummies/fair_dummies_learning.py
code served (permissive licence) · get_code("29bbbca9a634482a")
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 SimpleDiscriminator. 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)

# Define a simple model that takes x and outputs predictions
class SimpleModel(nn.Module):
    def __init__(self, input_dim, output_dim):
        super().__init__()
        self.linear = nn.Linear(input_dim, output_dim)
    
    def forward(self, x):
        return self.linear(x)

# Define a simple discriminator
class SimpleDiscriminator(nn.Module):
    def __init__(self, input_dim):
        super().__init__()
        self.linear = nn.Linear(input_dim, 1)
    
    def forward(self, x):
        return self.linear(x)
    
    def zero_grad(self):
        super().zero_grad()

# Create model and discriminator
model = SimpleModel(input_dim=4, output_dim=3)
dis = SimpleDiscriminator(input_dim=3 + 5 + 6)  # yhat(3) + a(5) + y(6)

# Create optimizer and criterion
optimizer = torch.optim.Adam(dis.parameters(), lr=0.001)
criterion = nn.BCEWithLogitsLoss(reduction='none')

# Create data loader: list of tuples (x, y, a, at)
# x: batch of inputs (2, 4)
# y: batch of labels (2, 6)
# a: batch of attributes (2, 5)
# at: batch of true attributes (2, 5)
data_loader = [
    (torch.randn(2, 4), torch.randn(2, 6), torch.randn(2, 5), torch.randn(2, 5)),
    (torch.randn(2, 4), torch.randn(2, 6), torch.randn(2, 5), torch.randn(2, 5)),
]

# lambdas should be a tensor for weighting the loss
lambdas = torch.ones(4, 1)  # batch size 4 (2 real + 2 fake)

ARGS = {
    'dis': dis,
    'model': model,
    'data_loader': data_loader,
    'optimizer': optimizer,
    'criterion': criterion,
    'lambdas': lambdas,
}
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 SimpleDiscriminator — a SimpleDiscriminator output has no array shape of its own; none is stated — the instrument coerces any output to an array; for a SimpleDiscriminator 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
pretrain_adversary Ran
ran on a synthesized input
yromano/fair_dummies/others/adv_debiasing.py
code served (permissive licence) · get_code("f80ebdfe287d35b2")
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 MinimalAdv. 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)

# Define a minimal classifier that outputs predictions
class MinimalClf(nn.Module):
    def __init__(self):
        super().__init__()
        self.linear = nn.Linear(4, 1)
    
    def forward(self, x):
        return self.linear(x)

# Define a minimal adversary that takes concatenated input
class MinimalAdv(nn.Module):
    def __init__(self):
        super().__init__()
        self.linear = nn.Linear(3, 2)  # p_y (1) + y (2) = 3 input dims, 2 output dims
    
    def forward(self, x):
        return self.linear(x)

# Create instances
adv = MinimalAdv()
clf = MinimalClf()

# Create a minimal data loader with (x, y, z) tuples
# x: batch_size=2, features=4
# y: batch_size=2, features=2
# z: batch_size=2, features=2
data_loader = [
    (
        torch.randn(2, 4),
        torch.randn(2, 2),
        torch.randn(2, 2)
    ),
    (
        torch.randn(2, 4),
        torch.randn(2, 2),
        torch.randn(2, 2)
    )
]

# Create optimizer
optimizer = torch.optim.SGD(adv.parameters(), lr=0.01)

# Create loss criterion
criterion = nn.MSELoss(reduction='none')

# Create lambdas as a weight tensor matching the output size of adv
lambdas = torch.ones(2)

ARGS = {
    'adv': adv,
    'clf': clf,
    'data_loader': data_loader,
    'optimizer': optimizer,
    'criterion': criterion,
    'lambdas': lambdas
}
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 MinimalAdv — a MinimalAdv output has no array shape of its own; none is stated — the instrument coerces any output to an array; for a MinimalAdv 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
pretrain_adversary_fast_loader Ran
ran on a synthesized input
yromano/fair_dummies/fair_dummies/fair_dummies_learning.py
code served (permissive licence) · get_code("dd0d940686cc5d71")
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 SimpleDiscriminator. 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)

# Build a simple discriminator model
class SimpleDiscriminator(nn.Module):
    def __init__(self, input_dim):
        super().__init__()
        self.fc = nn.Linear(input_dim, 1)
    
    def forward(self, x):
        return self.fc(x)

# Build a simple model that produces predictions
class SimpleModel(nn.Module):
    def __init__(self, output_dim):
        super().__init__()
        self.fc = nn.Linear(4, output_dim)
    
    def forward(self, x):
        return self.fc(x)

# Create instances
batch_size = 2
x_dim = 4
y_dim = 3
a_dim = 5
yhat_dim = 2

x = torch.randn(batch_size, x_dim)
y = torch.randn(batch_size, y_dim)
a = torch.randn(batch_size, a_dim)
at = torch.randn(batch_size, a_dim)

model = SimpleModel(yhat_dim)
dis = SimpleDiscriminator(yhat_dim + a_dim + y_dim)

optimizer = torch.optim.SGD(dis.parameters(), lr=0.01)
criterion = nn.BCEWithLogitsLoss(reduction='none')
lambdas = torch.ones(batch_size * 2, 1)

ARGS = {
    'dis': dis,
    'model': model,
    'x': x,
    'y': y,
    'a': a,
    'at': at,
    'optimizer': optimizer,
    'criterion': criterion,
    'lambdas': lambdas
}
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 SimpleDiscriminator — a SimpleDiscriminator output has no array shape of its own; none is stated — the instrument coerces any output to an array; for a SimpleDiscriminator 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
read_crimes_data Ran
ran on a synthesized input
yromano/fair_dummies/get_dataset.py
code served (permissive licence) · get_code("e31d738cefaa827e")
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 os
import tempfile
import shutil

# Create a temporary directory for test data
test_dir = tempfile.mkdtemp()
base_path = test_dir + '/'

# Create mock communities.names file
names_content = """@attribute state numeric
@attribute county numeric
@attribute community numeric
@attribute fold numeric
@attribute communityname string
@attribute racepctblack numeric
@attribute ViolentCrimesPerPop numeric
@attribute feature1 numeric
@attribute feature2 numeric
@attribute feature3 numeric
"""

with open(base_path + 'communities.names', 'w') as f:
    f.write(names_content)

# Create mock communities.data file with sample data
import pandas as pd
import numpy as np

np.random.seed(42)
n_samples = 100
data_dict = {
    'state': np.random.randint(0, 50, n_samples),
    'county': np.random.randint(0, 200, n_samples),
    'community': np.random.randint(0, 1000, n_samples),
    'fold': np.random.randint(1, 11, n_samples),
    'communityname': ['community'] * n_samples,
    'racepctblack': np.random.uniform(0, 1, n_samples),
    'ViolentCrimesPerPop': np.random.uniform(0, 1, n_samples),
    'feature1': np.random.uniform(-10, 10, n_samples),
    'feature2': np.random.uniform(-10, 10, n_samples),
    'feature3': np.random.uniform(-10, 10, n_samples),
}

df = pd.DataFrame(data_dict)
df.to_csv(base_path + 'communities.data', header=False, index=False)

ARGS = {
    'base_path': base_path
}
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
read_meps_data Not yet run
unverified (harvested, no recorded run)
yromano/fair_dummies/get_dataset.py
code served (permissive licence) · get_code("3db0f0aa6ae485cb")
How it ran

no invocation recorded.

train Not yet run
unverified (harvested, no recorded run)
yromano/fair_dummies/others/adv_debiasing.py
code served (permissive licence) · get_code("f6d9e0317d4ec628")
How it ran

no invocation recorded.

train_regressor Not yet run
unverified (harvested, no recorded run)
yromano/fair_dummies/others/adv_debiasing.py
code served (permissive licence) · get_code("46780301e5c26af6")
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, 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 15 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

We present a flexible framework for learning predictive models that approximately satisfy the equalized odds notion of fairness. This is achieved by introducing a general discrepancy functional that rigorously quantifies violations of this criterion. This differentiable functional is used as a penalty driving the model parameters towards equalized odds. To rigorously evaluate fitted models, we develop a formal hypothesis test to detect whether a prediction rule violates this property, the first such test in the literature. Both the model fitting and hypothesis testing leverage a resampled version of the sensitive attribute obeying equalized odds, by construction. We demonstrate the applicability and validity of the proposed framework both in regression and multi-class classification problems, reporting improved performance over state-of-the-art methods. Lastly, we show how to incorporate techniques for equitable uncertainty quantification---unbiased for each group under study---to communicate the results of the data analysis in exact terms.

For agents

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

get_harvested_code_for_paper("2006.04292")
get_code_for_paper("2006.04292")
have("2006.04292")

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

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

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

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

Connect an agent — have() is free.