SYNTOLOGY HomeExplorerAtlasCodeMethodologyAboutDevelopersFeedPricing
Paper · 2601.09460 · 2026

SoK: Enhancing Cryptographic Collaborative Learning with Differential Privacy

Benjamin Weggenmann, Francesco Capano, Jonas Böhler

arXiv · PDF · Open in the Atlas

Code that ran

6 of 6 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; 1 honoured the contract we drafted, 0 violated it and 0 have no contract verdict; 5 failures of our instrument; 0 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/2601.09460.json · badge: /api/ran/2601.09460.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
SAP/sok-cpcl canonical (classifier label)
classifier basis: census
6 ran · 0 no recorded run
FunctionStatusWhere it lives
calculate_confidence_interval Ran
ran; our contract draft was wrong, not the code
SAP/sok-cpcl/trade_offs_evaluation/performance_eval/fl_evaluation.py
code served (permissive licence) · get_code("00081abc60a5e1a8")
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

ARGS = {
    "data": np.array([1.2, 2.3, 3.1, 2.8, 3.5]),
    "confidence": 0.95
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
numpy, scipy — 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
compute_stats Ran
ran; our contract draft was wrong, not the code
SAP/sok-cpcl/mpc_noise_sampling/utils/stats.py
code served (permissive licence) · get_code("5c4c487d8bdcc150")
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 scipy.stats as st

# Create sample data structure matching what the function expects
# The function accesses: data[experiment][protocol][f'party_{party_i}'][key][subkey]
# where key can be 'online', 'offline', or other keys
# and subkey contains lists of numeric values

data = {
    'exp_1': {
        'protocol_A': {
            'party_0': {
                'online': {
                    'metric_1': [1.2, 1.5, 1.3, 1.4, 1.6],
                    'metric_2': [2.1, 2.3, 2.2, 2.4, 2.0]
                },
                'offline': {
                    'metric_3': [3.1, 3.2, 3.3, 3.0, 3.4],
                    'metric_4': [4.5, 4.6, 4.4, 4.7, 4.3]
                },
                'other_metric': [5.0, 5.1, 5.2, 5.3, 4.9]
            },
            'party_1': {
                'online': {
                    'metric_1': [1.1, 1.4, 1.2, 1.5, 1.3],
                    'metric_2': [2.2, 2.4, 2.3, 2.5, 2.1]
                },
                'offline': {
                    'metric_3': [3.0, 3.1, 3.2, 3.3, 3.5],
                    'metric_4': [4.4, 4.5, 4.3, 4.6, 4.2]
                },
                'other_metric': [5.1, 5.2, 5.0, 5.3, 5.1]
            }
        }
    }
}

protocol = 'protocol_A'
experiment = 'exp_1'
stats = {}
n_parties = 2

ARGS = {
    'data': data,
    'protocol': protocol,
    'experiment': experiment,
    'stats': stats,
    'n_parties': n_parties
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
numpy, scipy — 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
exact_sampler Ran
ran; our contract draft was wrong, not the code
SAP/sok-cpcl/mpc_noise_sampling/src/python/dgauss_exact.py
code served (permissive licence) · get_code("9cb6a767cf01f8d9")
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 random
import fractions
from time import time

# Set seed for reproducibility
random.seed(42)

ARGS = {
    "scale": 5.0,
    "num_samples": 10,
    "seed": 12345
}
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 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
parse_log_file Ran
ran; our contract draft was wrong, not the code
SAP/sok-cpcl/mpc_noise_sampling/utils/parser.py
code served (permissive licence) · get_code("4d1aaa45bcea9a9c")
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 tempfile
import os

# Create a temporary log file with content that matches the regex patterns
temp_file = tempfile.NamedTemporaryFile(mode='w', delete=False, suffix='.log')
log_content = """
Spent 123.45 seconds (67.89 MB, 10 rounds)
Time = 456.78 seconds
CPU time = 789.01
Coordination took 12.34 seconds
Data sent = 56.78 MB
Global data sent = 90.12 MB
1000 * Triples
2000 * Bits
some other content here
3000 * Input tuples with other info 100.5
"""
temp_file.write(log_content)
temp_file.close()

filename = temp_file.name

ARGS = {
    'filename': filename
}
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
poisson_uni Ran
ran, honoured the contract we drafted
SAP/sok-cpcl/mpc_noise_sampling/src/python/skellam.py
code served (permissive licence) · get_code("7b1d40766464a7ea")
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

def poisson_uni(lambda_):
    k = -1
    p = 1.0
    lambda_exp = np.exp(-lambda_)
    while p > lambda_exp:
        k += 1
        p *= np.random.rand()
    return k

ARGS = {
    "lambda_": 3.5
}
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 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
sample_discrete_gaussian Ran
ran; our contract draft was wrong, not the code
SAP/sok-cpcl/mpc_noise_sampling/src/python/discrete_gaussian.py
code served (permissive licence) · get_code("4ae85adb8206e4fd")
How it ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned ndarray, ndim 2, dtype family int, shape (3, 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

ARGS = {
    'scale': 2.5,
    'shape': (3, 4),
    'dtype': np.int64
}
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 int, shape (3, 4) — shape (3, 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

Also present in other papers' code

Of 6 samples lifted from this paper's linked repositories, 6 carry a function identity and 0 do not. Of the 6 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 6 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

In collaborative learning (CL), multiple parties jointly train a machine learning model on their private datasets. However, data can not be shared directly due to privacy concerns. To ensure input confidentiality, cryptographic techniques, e.g., multi-party computation (MPC), enable training on encrypted data. Yet, even securely trained models are vulnerable to inference attacks aiming to extract memorized data from model outputs. To ensure output privacy and mitigate inference attacks, differential privacy (DP) injects calibrated noise during training. While cryptography and DP offer complementary guarantees, combining them efficiently for cryptographic and differentially private CL (CPCL) is challenging. Cryptography incurs performance overheads, while DP degrades accuracy, creating a privacy-accuracy-performance trade-off that needs careful design considerations. This work systematizes the CPCL landscape. We introduce a unified framework that generalizes common phases across CPCL paradigms, and identify secure noise sampling as the foundational phase to achieve CPCL. We analyze tradeoffs of different secure noise sampling techniques, noise types, and DP mechanisms discussing their implementation challenges and evaluating their accuracy and cryptographic overhead across CPCL paradigms. Additionally, we implement identified secure noise sampling options in MPC and evaluate their computation and communication costs in WAN and LAN. Finally, we propose future research directions based on identified key observations, gaps and possible enhancements in the literature. Index Terms-Differential privacy, cryptography, collaborative machine learning * Work done while he was at SAP SE. (CDP), users send raw data to a trusted third party (TTP) to add noise to the computation output. To avoid sharing raw data, in the local model (LDP), each user adds noise to its data. However, LDP yields lower accuracy than CDP. For example, Google's LDP telemetry system [6] failed to detect a common signal among 1 million users, despite billions of user reports. Enhancing cryptographic collaborative learning with DP to realize cryptographic and differentially private collaborative learning (CPCL) provides: (I) input confidentiality via cryptography, (II) output privacy via DP, and (III) high accuracy via secure sampling of CDP noise without a TTP. CPCL is an emerging topic with growing interest from academia [7]-[11] and industry [12]-[14]. For example, Google's large-scale deployment [13] enables next-word predictions for Gboard keyboards by aggregating masked noisy information from clients to satisfy DP. Apple uses DP and secure aggregation to learn popular scenes photographed by iOS users to create personalized Memories [15]. While various SoKs [16]-[18] cover cryptographic CL, the integration of DP in cryptographic CL lacks a comprehensive systematization of key techniques, design considerations, and trade-offs. This work bridges this gap by introducing a comprehensive framework for CPCL, analyzing secure noise sampling techniques, and evaluating performance-accuracy trade-offs across learning paradigms. From our systematization, we identify two main learning paradigms: federated learning (FL) and outsourced learning (OL). In FL, data-holding clients iteratively encrypt and send local model updates to servers aggregating them into a global update (Sec. IV-C). In contrast, OL clients send their encrypted data to servers to train on global encrypted data (Sec. IV-D). While cryptography and DP offer complementary guarantees, their integration is challenging since both introduce performance overhead and accuracy trade-offs: Cryptography performance overhead: cryptographic techniques incur high communication/computation costs, e.g., computation-intensive HE or communication-intensive MPC. Overhead also depends on the learning paradigm: Sec. VI shows that OL can be 10 3 × slower than plaintext, while FL is 10× faster than OL but leaks intermediate model updates. Cryptography performance-accuracy trade-off: cryptographic techniques rely on fixed-point arithmetic trading accuracy for efficiency [2], and introducing numerical errors. OL approximates non-linear operations, e.g., Softmax, affect-This work has been accepted for publication at the IEEE Conference on Secure and Trustworthy Machine Learning (SaTML 2026). The final version will be available on IEEE Xplore.

For agents

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

get_harvested_code_for_paper("2601.09460")
get_code_for_paper("2601.09460")
have("2601.09460")

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

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

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

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

Connect an agent — have() is free.