When a patient's care is split across several hospitals, each hospital sees a timeline with holes in it. A model at one site does not know that the patient's creatinine was measured last week elsewhere, or that their visits have been getting more frequent. It may even conclude that the patient is being dangerously undertested when the missing measurements simply sit in another database. Sharing records to close these holes is usually legally or administratively off the table. Secure multi-party computation (MPC) offers a way around this: cryptographic protocols let several parties compute a joint function of their private data while each party learns only the output. In practice the strongest MPC systems are hybrid. They do additions and multiplications cheaply on numbers split into random shares ("arithmetic secret sharing"), and switch to bit-level circuits ("Boolean" or garbled-circuit protocols) for comparisons, which are expensive.
We propose to compute longitudinal features of a patient across hospitals without any hospital revealing its records. The method rests on one design rule. Most features a clinical model needs can be computed locally in plaintext at each site and then combined with either a cheap secure sum or a handful of secure comparisons. These include counts, sums, the most recent value, and the time since the last test. Only features that depend on how events from different sites interleave in time need an oblivious merge of padded event lists, which costs many comparisons. Examples are the largest gap between tests or the effective sampling rate. The question we put to the test is whether these order-dependent features buy enough predictive accuracy to justify their cryptographic cost. If they do not, the honest result is a simpler arithmetic-only system, and the experiments are built to say so.
Core Claim
Existing hybrid MPC for health data either assumes one party holds a complete, clean feature vector or assumes the data are already harmonized and static. The first group includes Chameleon, EzPC and QUOTIENT. They evaluate two-party classifiers on UCI, MNIST or MotionSense, where the client already has its whole input. The second is SF-GWAS, which combines multiparty homomorphic encryption for linear algebra with interactive MPC for divisions and square roots across biobanks. It explicitly requires harmonized phenotypes beforehand and handles only static genotype matrices.
None of these systems reconstructs a patient's timeline when the timeline itself is split across sites. Our claim has two parts. First, cross-site features can be sorted by the cheapest secure "combiner" they admit. Second, a pipeline that sends each feature to its cheapest primitive recovers most of the accuracy of a fully pooled plaintext model, at a cost close to that of secure aggregation.
The decomposition borrows its spirit from SF-GWAS's use of the Woodbury identity, which lets each site do the heavy matrix inversion on its own unencrypted data before anything is encrypted. We apply the same idea to time series. Each site computes its own most recent value and timestamp in plaintext. The secure step is then only an argmax over $k$ site timestamps, which is $k-1$ comparisons rather than a sort.
Research Program
The setting is $k$ hospitals, plus a querying site that holds the current admission. Patients are linked by a keyed pseudonymous token. Private record linkage is out of scope and is stated as an assumption. The security model is semi-honest, the same as every hybrid system in our sources. We state this limitation plainly rather than claim malicious security.
For a patient and an index time $t$, each site holds a sorted local list of lab events. We define three feature classes by their secure combiner:
- Additive features (counts, sums, means via a secure sum and one secure division) need only arithmetic shares.
- Selection features (the last value before $t$, time since the last test, the most extreme value in a window) need $O(k)$ secure comparisons after local plaintext summarization.
- Interleaving features (the largest inter-test gap across all sites, the number of tests within volatile periods, and the cross-site sampling rate that Lasko's nonstationary Gaussian process work shows is distorted by single-site views) require merging the event lists.
For interleaving features, each site pads its list to a public cap $L$. The parties run an oblivious merge in the Boolean domain, costing on the order of $kL\log(kL)$ comparisons for a bitonic merge. They then convert back to arithmetic shares to compute gaps. Padding is how we handle the fixed-shape rigidity of MPC. The cap $L$ is the only quantity it reveals, and it is public.
The resulting features stay secret-shared and feed a model trained inside MPC: logistic regression and a small multilayer perceptron, with linear layers in arithmetic shares and the sigmoid or ReLU evaluated in Boolean form. This follows the Chameleon pattern. Missingness indicators are computed as features in their own right, not imputed away. This responds directly to the evidence that in electronic health records, the absence of a measurement carries clinical information.
We will build this on an EzPC-style compiler so that each feature's protocol choice is explicit and its cost can be logged separately.
The data come from the MIMIC-IV hospital module. We use the preprocessing of the MIMIC-IV pipeline, restricted to the chronic kidney disease cohort that paper uses, because creatinine monitoring is exactly where sampling gaps matter. Fragmentation is simulated by assigning each patient's admissions, and the labs inside them, to $k \in \{3,5\}$ virtual sites. The assignment follows a Markov mobility model with a stay probability $p$, which we sweep from 1 (no fragmentation) to $1/k$ (maximal fragmentation). The prediction targets are in-hospital mortality and readmission at the current admission. Simulation is a known weakness. Real health-information-exchange data such as the multi-source INPC records used by Thomas et al. would be the follow-up validation if access can be arranged.
Baselines
Local-only model (the "do nothing" reference). Each querying site trains on its own fragments, with local missingness indicators and the same model classes. Every proposed gain is measured against this.
Pooled plaintext oracle. An honest broker merges all records and trains the same models. This is the accuracy ceiling. It is not a privacy-preserving competitor, but it tells us how much of the fragmentation loss we recover. Its natural anchor is the MIMIC-IV pipeline, which reports ICU mortality AUROC 0.87 for a hybrid LSTM and 0.67 for logistic regression on its chronic kidney disease cohort. Our oracle uses the same cohort definition so the numbers can be checked against these. We found no reported result on Lacuna for prediction under simulated multi-site fragmentation of MIMIC-IV, so all fragmented numbers will be new.
Arithmetic-only secure pipeline. This is the strongest privacy-preserving competitor and the key ablation. It uses additive features only, computed by secure aggregation of local plaintext summaries, in the style of SF-GWAS's local-first linear algebra. It isolates what selection and interleaving features add.
Full-merge pipeline. Every feature, including the cheap ones, is computed after an oblivious merge. This isolates the value of the decomposition rule itself.
Federated averaging with local features. This is a non-cryptographic baseline for the training side.
All pipelines share the same patients, splits, feature definitions, hyperparameter search (identical grid, selected on a validation fold) and hardware. They run under both LAN and simulated WAN latency. On the cost side, the reference points are Chameleon's 11.42 ms for a 1,000-feature secure SVM query and its 2.24 s MNIST inference. Beating the field means two things together. First, the routed pipeline must close at least half of the AUROC and AUPRC gap between local-only and the oracle at $p \le 0.6$. Second, it must outperform arithmetic-only by a margin outside bootstrap confidence intervals, while costing within a small constant factor of arithmetic-only rather than of full-merge.
Why not just…?
Why not just let each site use its own data? At $p=1$ this is the oracle, so the question is how fast it degrades as $p$ falls. Lasko's analysis predicts systematic degradation. Single-site views misread undersampling, and the aliasing feeds back into lower test ordering. The $p$ sweep measures this degradation directly. If local-only stays within noise of the oracle at realistic $p$, the whole program is unnecessary, and we would report that.
Why not just securely sum local summaries? This is the real threat, because counts and means may carry most of the cross-site signal. Gupta et al.'s cancer survival work found that crude utilization counts, such as prior emergency department visits, gave large gains. The arithmetic-only baseline exists to settle the question. If it matches the routed pipeline, the conclusion is that comparisons are not worth their cost for these tasks.
Why not just use plain federated learning? Federated learning trains across sites that each hold complete local records. It does not join one patient's fragments, so at inference the querying site still sees a partial timeline. PriFFT and Weissler et al. also note that shared gradients leak information. Our federated baseline will show how much accuracy is lost to the unjoined features.
Why not just use an honest broker? This is what is done today, and it is our accuracy ceiling. The cryptographic version earns its place only where no broker is acceptable. SF-GWAS documents this situation for cross-border genomic data. The comparison then reduces to cost against the broker's zero-cost plaintext pooling.
Proposed Experiments and Decisive Checks
The main experiment crosses fragmentation level, number of sites, feature class and task. We report AUROC, AUPRC (given the imbalance that MIMIC-Extract documents), calibration error, and group-wise positive rates following the MIMIC-IV pipeline's fairness audit. On the cost side, we report wall-clock time, bytes sent and rounds per patient, split by feature class.
We also check fidelity. Secure features must match their plaintext counterparts exactly for counts and within fixed-point error for means, mirroring SF-GWAS's $r^2>0.99$ standard. Secure model predictions must match plaintext predictions closely enough that AUROC differences fall below 0.005.
There are three decisive checks. The first is whether the routed pipeline's advantage over arithmetic-only grows as $p$ decreases, specifically for creatinine-gap features, which is the trend Lasko's analysis predicts. The second is whether selection features alone capture most of that advantage. If they do, the oblivious merge can be dropped and the system becomes far cheaper. The third is whether the cost of the routed pipeline scales with $k$ rather than with $kL\log(kL)$ when interleaving features are excluded. A negative answer to the first check redirects the work toward arithmetic-only secure aggregation, and we will report it as such.
References
- Chameleon: A Hybrid Secure Computation Framework for Machine Learning Applications
- EzPC: Programmable, Efficient, and Scalable Secure Two-Party Computation
- QUOTIENT: Two-Party Secure Neural Network Training and Prediction
- Secure and federated genome-wide association studies for biobank-scale datasets
- Nonstationary Gaussian Process Regression for Evaluating Repeated Clinical Laboratory Tests
- An Extensive Data Processing Pipeline for MIMIC-IV
- Predicting onset of complications from diabetes: a graph based approach
- Machine-learning prediction of cancer survival: a retrospective study using electronic administrative records and a cancer registry
- PriFFT: Privacy-Preserving Federated Fine-Tuning of Large Language Models via Hybrid Secret Sharing
- The role of machine learning in clinical research: transforming the future of evidence generation
- MIMIC-Extract: a data extraction, preprocessing, and representation pipeline for MIMIC-III