---
slug: persona/correlation/analyze
version: "1.0"
title: Persona Correlation — Analyze
summary: Report where the holder's identities link to one another, why, whether the link crosses a part of their life they keep separate, and what can be done about each — including the remedy a holder would not otherwise think of.
status: retired
supersededBy: persona/correlation/analyze/1.1
targetFrameworkVersion: "0.5.0"
category: identity
keywords: [persona, privacy, correlation, facet]
authors:
  - Glenn Gore (https://github.com/stormer78)
parties:
  - role: Holder
    requirement: REQUIRED
    member: issuer
  - role: Agent
    requirement: REQUIRED
    member: recipient
proofRequirement:
  requirement: REQUIRED
  rationale: The response maps the holder's personas to one another and to the verifiers that have seen them, which is the linkage the rest of the family works to prevent anyone else from assembling.
issuedAtRequirement:
  requirement: OPTIONAL
  rationale: An analysis has no durable effect; a replay returns the assessment as it stands.
sideEffects:
  level: none
  rationale: Reads only. A supplied `candidate` is analysed and MUST NOT be stored.
exposure:
  discloses: metadata
  ingests: personal
  actsAsSubject: false
  rationale: A `candidate` carries a personal value the holder is considering, so it may be analysed before it is written. The response returns the holder's own profile, context and verifier identifiers — the linkage map — and no values.
errorCodes: []
---

## Abstract

> **Retired in favour of [`persona/correlation/analyze/1.1`](../1.1).** Same analysis, three
> response members renamed: `facetId`, `facetIds` and `crossesFacets` are `worldId`,
> `worldIds` and `crossesWorlds`. This specification stays readable so documents already
> issued against it remain verifiable.

**Persona Correlation — Analyze** is the findings task behind the counts the
write tasks return.

Multiple personas exist to be unlinkable, and a composition tool is a machine for
accidentally linking them: the same value in two profiles correlates the personas
presenting them, permanently, for anyone who sees both. The holder will not notice
while composing, which is why this is a first-class output rather than a lint.

Three things distinguish it from a warning.

**It analyses candidates.** A value the holder is *considering* can be assessed
before it is written, which is the difference between a guard and a report.

**It returns identifiers, not counts.** The write tasks deliberately return only
counts, because a count is enough to warn and identifiers would disclose the
holder's other compositions to whatever tool made the write. This task is
holder-authorized and its purpose is to let the holder *act*, which they cannot do
on a number.

**It names remedies, including the non-obvious one.** `reissueCredentialToThisDid`
matters more than it looks: without it, a holder told *this links your personas*
has no action available but to abandon the attribute, and the honest fix — a
credential re-issued against the persona actually using it — stays invisible
unless the analysis names it.

**Severity is how linkable. Facets are whether the holder minds.** These are two
axes and the specification keeps them apart, because collapsing them loses
whichever one is inconvenient.

`severity` is a fact about the value and the proof beneath it: a credential
presented whole links every verifier that sees it, and that is true whatever the
holder intended. `crossesFacets` is a fact about the holder's own arrangement: a
work email appearing in every work profile is linkage they built on purpose, and
a consumer that alarms on it is teaching them to dismiss alarms — which costs
them the one that matters. The same value shared *across* facets is the finding
worth raising, and it is the reason a maintainer that implements
`persona/facet/*` can say something here that one without facets cannot.

A maintainer **MUST NOT** reduce `severity` because a linkage stays inside one
facet. The linkage is real either way: two verifiers who see both profiles link
the holder regardless of which part of their own life they filed each under, and
a severity that softened on intent would be reporting a false all-clear about
something a counterparty can still do.

One correction the analysis must encode: **a credential presented whole correlates
more than a self-asserted value**, because the issuer signature is identical at
every verifier, while a derived proof correlates less because it differs every
time. Severity is a function of value and proof rung together. An analysis that
scored on provenance alone would push holders away from the safer option.

## Status of this Document

This is a **draft** *Trust Task specification* per [SPEC.md §5.3](/SPEC.md#53-maturity-levels); the schema **MAY** change without notice. Feedback via the [issue tracker](https://github.com/trustoverip/dtgwg-trust-tasks-tf/issues).

## Conformance

[[RFC2119]](https://www.rfc-editor.org/rfc/rfc2119) and [[RFC8174]](https://www.rfc-editor.org/rfc/rfc8174) key-word conventions apply.

A conforming **producer** **MUST** emit a *Trust Task document* whose `type` is
`https://trusttasks.org/spec/persona/correlation/analyze/1.0` with a `proof` per
[SPEC.md §4.7](/SPEC.md#47-proof).

A conforming **maintainer** **MUST** reject the document unless the caller is
**holder-authorized and unscoped**; **MUST NOT** store a supplied `candidate`;
**MUST** compute matches over a keyed hash rather than a plaintext index; and
**MUST** score severity from the value and the proof rung together rather than
from provenance alone.

A maintainer that implements `persona/facet/*` **SHOULD** populate
`crossesFacets`, `facetIds` and `sharedWith[].facetId`; one that does not
**MUST** omit all three rather than emitting `false`, because `false` asserts
that the holder keeps these identities in one part of their life and an
implementation with no facets has made no such finding. A consumer **MUST**
treat an absent `crossesFacets` as *unknown* and not as *does not cross*.

A maintainer **MUST NOT** reduce `severity` because a linkage falls inside a
single facet, and **MUST NOT** omit a finding for that reason. The arrangement
is the holder's own filing and changes nothing a counterparty can do; suppressing
the finding would hide a real linkage behind a preference.

`crossesFacets` is true only where two or more **distinct** facets appear among
`sharedWith`. A profile belonging to no facet is unarranged, not a second facet,
and a maintainer **MUST NOT** count it as one — otherwise every holder who has
arranged one part of their life and not the rest sees a crossing on everything
they own.

A conforming maintainer **MUST NOT** treat a per-profile override as reducing
severity. Changing a displayed value does nothing about the credential beneath it,
and an analysis that scored on the displayed value would report a false all-clear
— which is worse than reporting nothing, because the holder would act on it.

A conforming maintainer **MUST** analyse the values a profile carries itself —
an `override`'s value and an `inline` entry's — as well as the pool attributes
it references, including in context-local profiles. Those are the two forms a
holder reaches for when they want a face to be *different*, and a throwaway face
is exactly where somebody reuses a real value; an analysis blind to them reports
a false all-clear where the holder most needs a warning. A value that no pool
attribute holds is reported as a finding **without** `attributeId`, whose
`sharedWith` names every profile carrying it. When `profileId` is supplied the
maintainer **MUST** confine the analysis to that profile: what it references and
what it carries, against everything else.

## Authorization

**Holder-authorized and unscoped.** A context-scoped caller **MUST** be refused
whatever its role. The response is the linkage map between the holder's
identities, which is precisely the artifact the family exists to keep from being
assembled by anyone else.

## Request

See the payload schema; every member carries its own rationale there.

## Response

See the payload schema.

## Security & Privacy

### Data carried

A `candidate` carries a personal value the holder has not yet written; it is
analysed and **MUST NOT** be stored. The response carries the holder's own profile,
context, persona and verifier identifiers — no values.

### The facet members carry the holder's own filing

`facetIds` and `sharedWith[].facetId` say which parts of their life the holder
considers these identities to belong to — the most correlating statement in the
persona family, and the reason `persona/facet/*` never leaves the agent scope.
Returning them here does not widen that exposure: this task is already
holder-authorized and unscoped, and already returns the linkage map itself. A
maintainer **MUST NOT** return a facet **name** in this response — the caller
holds the facet records and can resolve an identifier, and a name is the member
of a facet worth protecting.

### Correlation

This task computes correlation and therefore concentrates it: its response is the
map that says which of the holder's identities share what and who has seen it.

The computation itself is designed not to enlarge the risk it measures. Matching
is over a **keyed hash** of the value, so the maintainer can answer *does this
value appear elsewhere* without holding a plaintext index of the holder's personal
data. Exact match is the only comparison correlation requires; prefix and fuzzy
search are outside the family by construction, and that trade is deliberate.

### Retention

An analysis is a point-in-time assessment with no evidentiary value and **SHOULD
NOT** be retained. Candidates are never stored.

### Consent/purpose

The purpose is informed choice at the moment of composition: to tell a holder what
a value would link, before they commit to it, and what they could do instead.

A maintainer **MUST NOT** refuse a write on the strength of an analysis. The
holder decides; a store that substituted its judgment would be answering a
question only the holder can answer. What a producer does with a `high` severity
is the consumer's policy and is deliberately not specified here.
