Agreeing on Meaning Without Seeing Each Other: Blind Semantic Matching for Private Credential Exchange

Digital identity wallets let a person hold signed credentials, such as a diploma, a vaccination record, or a driver's license, and show only the fields a website or clinic asks for. The most private version of this exchange hides information in both directions. The person reveals only the requested fields, and the requester does not reveal which fields it asked for, because that list can expose its internal decision rules. That two-way privacy has a hidden weakness: it works only if both sides use exactly the same field names. If the issuer signed given_name and the requester asks for first_name, the exchange fails. The usual machine-learning fix, a schema matcher that looks at both vocabularies together, is ruled out because neither side is allowed to see the other's list.

We propose to make each side translate its own field names, alone and on its own device, into a shared public list of concept codes. A small text encoder, trained with contrastive learning so that different names for the same concept land close together, does the translation. The private exchange then runs on concept codes instead of raw strings. The research question is not ordinary matching accuracy. It is whether two parties who never see each other's vocabulary will independently land on the same code often enough to be useful, while rarely landing on the same code for fields that differ. The second kind of agreement leaks data. We treat that agreement-versus-leakage trade-off as the main object of study and design the training and the release rule around it.

Core Claim

Self-sovereign identity, meaning identity systems where the user rather than a central provider holds the keys and credentials, has a well-documented problem with fragmented vocabularies. The survey by Mazzocca et al. describes wallets that cannot map credentials issued under different vocabularies, which leaves users to reconcile requests by hand. The strongest privacy protocol in the file, COD-ssi, assumes this problem away. It has the requester decrypt only its chosen fields through an oblivious pseudorandom function, a two-party cryptographic tool that lets one party compute a keyed hash of its input without the other party learning that input. Its correctness depends on both parties sharing a bit-exact attribute index. We keep its cryptography unchanged and replace the exact string with a concept code that each party computes locally.

The claim has two parts. First, a contrastively trained encoder that sees only field names and public context, and is optimized for code agreement rather than for ranking, gives far higher blind agreement than off-the-shelf encoders or string normalization. Second, an asymmetric release rule, under which the holder encrypts each attribute under its top few candidate codes while the requester queries only one, turns most of the remaining boundary errors into successful matches at a measurable and controllable cost in over-disclosure.

How This Differs From the Closest Work

Two schema-matching systems motivate the approach and supply parts of the method. Magneto, summarized in the GDC-SM benchmark paper, fine-tunes a small MPNet bi-encoder with triplet loss on LLM-generated synonyms of column names. It then reranks the candidates with GPT-4o-mini, and it relies on sampled cell values to resolve ambiguous names. ASTRA frames matching as sequence-to-sequence translation with mT5 or mBART, emits a <NOMAP> token for fields that have no counterpart, and also reads attribute values.

We reuse Magneto's recipe of offline synthetic synonyms plus contrastive fine-tuning, and ASTRA's idea of explicit rejection. Both systems, however, assume a single matcher with a plaintext joint view of source and target, plus access to values. Our setting forbids all three. The matcher may not see the other party's list. It may not see values, because values are what the protocol protects. It may not call a cloud model, because sending identity data to a hosted LLM recreates the central data store that self-sovereign identity exists to avoid, as Bodó et al.'s critique of decentralized data architectures argues. The output also differs. Those systems return a ranked list for a human or a downstream step to resolve. Ours returns a hard code that a cryptographic protocol will act on, with no human in the loop.

Research Program

The anchor set is a public list of concepts, each with a canonical name and a short description. It is a dictionary of concepts, not a mandated schema. Issuers keep their own field names, and the mapping happens privately on each device.

The encoder $f$ maps a field name together with its public context (credential type and the issuer's published schema description, but never values) to a unit vector. Each anchor $c$ has a learned prototype vector $p_c$. Training uses a SimCSE-style contrastive objective, following SimCSE, applied against the prototypes:

$$\ell(x) = -\log \frac{e^{f(x)^\top p_{c(x)}/\tau}}{\sum_{c'} e^{f(x)^\top p_{c'}/\tau} + \sum_{h \in H(x)} e^{f(x)^\top p_h/\tau}}$$

Here $x$ is a field name, $c(x)$ is its correct anchor, $\tau$ is a temperature, and $H(x)$ is a set of hard-negative anchors. Hard negatives are near-miss concepts such as date_of_issue for a date_of_birth field. They play the role that contradiction sentences play in supervised SimCSE, and they are where over-disclosure comes from. Training pairs come from LLM-generated paraphrases, following Magneto, but the LLM runs only offline on public schemas and never on user data. We add a margin term that pushes each $f(x)$ away from the decision boundary between its top two anchors. The aim is to make the two parties' independent top-1 choices coincide, rather than merely to rank the correct anchor high.

The release rule is asymmetric. The requester maps each queried field to its single top anchor. The holder encrypts each attribute under every anchor whose score falls within a gap $\delta$ of its top score, up to $k$ anchors. The protocol still prevents either side from learning the other's choice, but the holder's redundancy absorbs boundary disagreements. The cost is that a holder attribute might be released under an anchor the requester meant for a different concept. Sweeping $k$ and $\delta$ traces a curve of agreement against over-disclosure. An abstention rule, borrowed in spirit from ASTRA's <NOMAP>, refuses to assign any code when the top score is below a threshold. The deployed encoder is distilled to a size that fits wallet libraries such as DIDKit or Veramo, as reviewed by Mazzocca et al..

Benchmarks and Metrics

No benchmark for verifiable-credential schema matching appears in the file, so we evaluate on three tracks.

The first track uses GDC-SM (benchmark paper; data and ingestion script). Its 736 target columns serve as anchors, and the 10 source study tables act as holders. Requester queries are the target names plus held-out paraphrases. This track tests clinical records, the setting where BPDS shows patient-held keys already carry high stakes.

The second track uses ASTRA's DEn, DMulti, and DHQ sets, with standardized target attributes as anchors. DMulti tests cross-lingual blind agreement, and the reject attributes test abstention.

The third track is a new, small credential set. We will build it from published credential schemas for identity, education, and health, with paraphrased request vocabularies, and annotate it by consensus. GDC-SM uses three annotators per pair, and we will follow that practice. All splits hold out whole anchors as well as individual paraphrases, so that we measure generalization to unseen concepts rather than memorized synonyms.

The primary metric is blind agreement: the fraction of truly equivalent holder–requester pairs whose codes produce a successful match under the release rule. The paired metric is over-disclosure: the fraction of requester queries for which some non-equivalent holder attribute is decrypted. We also report correct abstention on attributes with no counterpart, encoder latency and memory on a mid-range phone, and cryptographic cost as a function of $k$.

For the cryptographic cost, COD-ssi reports claim-level operations in milliseconds and presentation-level operations in seconds for up to 128 claims, with payloads ranging from kilobytes to a few megabytes. We will report the measured overhead factor relative to those figures.

Baselines

The naive reference point is COD-ssi exactly as published: exact string equality on field names. It defines how often today's private exchange simply fails. A slightly stronger naive point lowercases names, splits tokens, and applies edit distance to the nearest anchor. This represents the lexical-matching approach that COMA-style tools embody.

The off-the-shelf neural baselines map each name to its nearest anchor using an untuned MPNet encoder, and separately using the released supervised SimCSE checkpoint (code). SimCSE reports 81.6% average Spearman correlation on seven STS benchmarks, a result found in SimCSE. These baselines test whether general-purpose sentence similarity already solves the problem.

The strongest privacy-compatible competitor is Magneto's retrieval stage, reimplemented key-only: an MPNet bi-encoder fine-tuned with triplet loss on LLM-generated synonyms, with nearest-anchor top-1 as the code. It is the strongest competitor because it is the same model family, trained on the same kind of synthetic data, and it is the method most likely to make our margin loss and release rule look unnecessary. We will run it with the same synthetic training pairs, the same encoder size, the same anchors, and an equal hyperparameter-search budget measured in GPU-hours. Magneto's reported result on GDC-SM is a "significantly higher MRR" than COMA and Unicorn, but the file contains no exact figure; no reported result found on Lacuna for Magneto's MRR scalar. We will therefore rerun it ourselves.

ASTRA is a second strong competitor on its own datasets. It reports a 15% precision and 7% recall uplift over an embedding-similarity baseline on DEn approved attributes, reject-attribute precision of at least 95% at recall of at least 40%, and precision of at least 95% with 5 shots on DHQ (ASTRA). We will fine-tune mT5-base on the same data, constrain its output to the anchor list, and run it key-only.

The privacy-violating upper bound is full Magneto, with values and an LLM reranker over a joint plaintext view. It tells us how much accuracy the privacy constraints cost.

Our method beats the key-only Magneto baseline if, at a matched over-disclosure rate of 1% or lower, its blind agreement is higher on all three tracks, with confidence intervals from bootstrapping over anchors that exclude zero. Our method beats ASTRA if it matches or exceeds ASTRA's key-only reject precision while also producing codes that both parties compute independently.

Ablations remove one ingredient at a time: the hard-negative anchors, the boundary margin, the redundant release (setting $k=1$), and the public schema context. These isolate which ingredient produces the gain.

Why not just…?

Why not just use an off-the-shelf sentence encoder? General-purpose similarity is graded and tolerant of near-misses. A protocol that releases data on a hard match needs exactly the opposite: sharp separation between date_of_birth and date_of_issue. SimCSE's own authors note that STS gains transfer only modestly to other tasks (SimCSE). The untuned MPNet and SimCSE baselines measure this directly. If they reach comparable agreement at the same over-disclosure rate, the training contribution is void, and the paper becomes a protocol-and-evaluation paper instead.

Why not just publish a crosswalk table or mandate a standard vocabulary? The survey by Mazzocca et al. documents continued fragmentation across DID methods and domain-specific schemas, and ASTRA calls manual mapping across thousands of schemas prohibitively expensive in an open set of new attributes. A crosswalk is nonetheless a real threat for the most common identity fields. We include a crosswalk baseline built from the training synonyms; on seen anchors it may tie with our method. The held-out-paraphrase and held-out-anchor splits are where the two should separate. If they do not, we will say that a curated table suffices.

Why not just let the holder see the request and match locally, or call a cloud LLM? Either choice discards the property that COD-ssi exists to provide. The first exposes the requester's decision rules to the holder. The second exposes both parties to a third party. The plaintext Magneto upper bound tells us how much accuracy privacy costs. If that gap is small, the case for privacy-preserving matching strengthens. If it is large, we report that cost honestly.

Why not just tune the requester to send several candidate codes instead of the holder? That would let the requester probe several concepts per query, which widens what it learns. Holder-side redundancy keeps the disclosure decision with the user. We will run the symmetric variant as an ablation and report its leakage.

Decisive Checks

The idea succeeds if, on held-out anchors in GDC-SM and in the credential set, the trained encoder with redundant release reaches at least 90% blind agreement at 1% or lower over-disclosure, while key-only Magneto falls clearly below that. It also requires that end-to-end presentation time with $k \le 3$ stay within a small constant factor of COD-ssi's reported seconds-scale cost, and that on-device encoding take tens of milliseconds per field.

The idea fails if the agreement–leakage curve of key-only Magneto lies on top of ours. In that case the contribution narrows to showing that existing contrastive matchers can safely feed oblivious credential protocols, which is a smaller result but still useful.

Finally, we will test whether removing values hurts most on the ambiguous names that Magneto and ASTRA single out as needing values. A large loss there would mark the limit of key-only blind matching and point to value-free public context as the next problem to solve.