Declared Equivalence Mapping¶

An explicit, authoritative, versioned assertion that two concepts from different vocabularies are interchangeable for stated purposes — collapsing a cross-scheme distinction to zero for consumers who trust the declaration rather than re-verifying at use-time.

Core Idea¶

A declared equivalence mapping is an explicit, authoritative assertion that two concepts from different controlled vocabularies or identifier schemes are interchangeable for stated purposes — the canonical instance being SKOS exactMatch, which records that concept c1 in scheme S1 and concept c2 in scheme S2 may be substituted for one another in downstream use without loss. The mapping is declared (recorded as a versioned artifact, not inferred by algorithm), symmetric (the interchangeability runs in both directions), and purpose-bounded (it asserts substitutability within a defined context, not ontological identity across all possible queries). The structural work the declaration does is to collapse a cross-scheme distinction to zero for a defined consumer: any system that respects the mapping treats c1 and c2 as a single atom, routing, aggregating, or inferring without re-verifying the equivalence at use-time. Authority is the load-bearing element — the substitution is valid by virtue of the declarer's judgment, so consumers who rely on it are trusting the declarer's scope assessment. That trust relation makes the declaration a governed artifact with a full lifecycle: it has an author, a stated purpose, a version, and a retraction channel through which the declarer can downgrade or revoke it if review reveals a mismatch. The governance complexity the declaration manages is the N-vocabulary integration problem: rather than requiring each consumer to re-match schemes at use-time (O(N²) comparisons for N schemes), declared equivalences centralise the matching as a maintained mapping table that consumers consult (O(N) maintenance). SKOS exactMatch between LCSH and FAST headings in library cataloguing, ICD-10 to SNOMED-CT code pairs in clinical coding, Ensembl to HGNC gene-identifier crosswalks in bioinformatics, and CRM-to-ERP customer entity reconciliation in master-data management all instantiate the same structure: an authority declares two sovereign identifiers interchangeable, downstream systems rely on the declaration, and fidelity depends on the declaration remaining accurate.

Structural Signature¶

Sig role-phrases:

the source and target concepts — two identifiers from different controlled vocabularies or schemes being declared interchangeable (c1 in S1, c2 in S2)
the declarer — the party with naming-authority over the schemes whose judgment makes the substitution valid (cataloguer, curator, regulator)
the declaration record — the versioned, revocable artifact carrying the assertion, recorded not inferred
the symmetry commitment — interchangeability running in both directions
the purpose-scope bound — the stated context the substitution holds within: substitutability for defined use, not ontological identity across all queries
the delegated-trust route — the path by which downstream consumers rely on the declaration without re-verifying at use-time, collapsing the cross-scheme distinction to zero
the retraction channel — the lifecycle mechanism letting the declarer downgrade or revoke the equivalence if review reveals a mismatch, relocating failure from data to governance
the weakest-link composition rule — transitive chains compose along grades: all-exactMatch yields exactMatch, but any closeMatch link caps the whole chain, so fidelity tracks the weakest grade on the path
the O(N)-vs-O(N²) consolidation — centralising matching as one maintained table consulted by all consumers, replacing per-consumer use-time re-matching

What It Is Not¶

Not ontological identity. A declared equivalence asserts substitutability within a stated purpose, not that the two concepts are the same across all possible queries. Two codes can be an exact match for routing and reporting while still differing in hierarchical parents and attribute slots — "they are mapped" does not mean "they are the same in every respect."
Not an inferred or computed match. The equivalence is declared — recorded as a versioned artifact by a party with authority over the schemes — not produced by an algorithm matching similarity scores. Its validity rests on the declarer's judgment, so the question is "who declared it, for what purpose, is it current?", not "how high did the matcher score?"
Not a proven bijection. Although it often asserts a one-to-one pairing, the declaration is an institutional act, frequently made without the bijection being formally established. It is authority-backed interchangeability, not a mathematically verified one-to-one mapping.
Not unconditional or permanent. The substitution holds only within its declared scope and only while the declaration is current; it carries an author, a version, and a retraction channel. A consumer who carries the equivalence outside its purpose, or relies on a stale or revoked declaration, is committing a nameable governance error — fidelity degrades the moment the declaration drifts.
Not transitively safe at full fidelity. Declared equivalences are composable but fidelity-fragile: a chain of exactMatch links yields exactMatch, but a single closeMatch (near-equivalence) link caps the entire chain at closeMatch. Reachability between two concepts inherits the weakest grade on the path, so one weak link silently degrades a long chain of otherwise-exact mappings.

Scope of Application¶

Declared equivalence mapping lives across the knowledge-organization and interoperability subfields — a governance practice recurring wherever distinct naming authorities must interoperate over the same N-sovereign-scheme integration problem; its reach is within that practice. Off it, the portable core is the bijectivity + certification/authority parents (validity-by-declaration with scope, version, and revocation), so the general trust-bridging pattern stays off this map.

Library and knowledge-organization systems — SKOS exactMatch between LCSH and FAST subject headings, thesaurus reconciliation across national libraries, and museum-vocabulary equivalences across institutions.
Healthcare terminology — ICD-10-to-SNOMED-CT code pairs declared interchangeable for internal routing and reporting, while the codes still differ in their hierarchical parents and attribute slots.
Bioinformatics — Ensembl-to-HGNC gene-identifier crosswalks declaring two sovereign identifiers the same gene for a given assembly.
Data engineering and master-data management — CRM-to-ERP customer-entity reconciliation declaring two records the same customer across systems.
Regulatory equivalency — a regulator declaring a foreign auditor's or framework's report equivalent to the domestic one for cross-border listing purposes.
Standards harmonisation — ISO and similar bodies declaring two national standards equivalent for certification recognition.

Clarity¶

Naming a correspondence a declared equivalence locates the source of its authority, which is exactly what use-time intuition leaves ambiguous. When a system treats two identifiers as interchangeable, three very different things could be underwriting that — a computed similarity score, a metaphysical claim that the concepts are the same, or someone's recorded judgment that they may be substituted. The construct forces the third reading into view and keeps it apart from the other two: the equivalence holds because a party with authority over the schemes put their name on it, not because an algorithm matched them and not because they are ontologically identical. That distinction makes the right question askable — not "are these two concepts the same?" but who declared them interchangeable, for what purpose, and is that declaration still current? — and it relocates the failure mode from the data to the governance, since a wrong substitution is now a wrong or stale declaration with an author and a retraction channel, rather than an inscrutable mismatch.

The framing also makes the bounded-purpose qualifier legible, dissolving a confusion that silently corrupts integrations. Because the declaration asserts substitutability only within a stated context, two codes can be an exact match for routing and reporting while still differing in their hierarchical parents and attribute slots — so "they are mapped" stops meaning "they are the same in every respect," and a consumer who carries the equivalence outside its declared scope is making an error the construct can name. Equally, it clarifies that relying on such a mapping is delegated trust: the consumer is trusting the declarer's scope assessment rather than re-verifying, which turns an invisible dependency into a visible one and explains why the artifact needs an author, a version, and a way to be revoked. The sharper handle this gives an integrator is that the cost of interoperating is not the matching but the maintenance of a trusted, scope-stamped declaration — and that fidelity degrades the moment the declaration drifts from the purpose it was made for.

Manages Complexity¶

Integrating N sovereign vocabularies is, in its raw form, a combinatorial sprawl: every consumer that wants to route, aggregate, or infer across schemes confronts the cross-scheme matching problem afresh, re-deciding at use-time whether each pair of identifiers may be substituted — an O(N²) tangle of ad-hoc comparisons, re-derived per consumer and per query, with no shared answer and no record of how any given match was reached. The declared equivalence mapping collapses that sprawl by externalising each substitution decision into one maintained artifact. The matching is performed once, by an authority, and recorded; thereafter every consumer that respects the mapping treats the two identifiers as a single atom, reading the substitution off the table rather than re-establishing it. The quadratic field of use-time comparisons reduces to a linear set of maintained correspondences that the whole consumer population shares.

What the integrator then tracks is small and fixed: for any cross-scheme substitution, four parameters off the declaration — who declared it, for what purpose, at what version, and whether it is still current — from which the validity of relying on it follows. This is the deeper compression: it converts an open, data-level question ("are these two concepts really the same?", which has no determinate answer and would have to be re-litigated everywhere) into a closed, governance-level lookup ("is there a live, in-scope declaration by a trusted authority?"). The branch structure is correspondingly tight. A consumer routes on three checks: does an exactMatch exist (treat as one atom) or only a weaker grade (degrade fidelity accordingly); is the intended use inside the declared purpose-scope (rely) or outside it (do not carry the equivalence across); and is the declaration current (use) or retracted/stale (fall back). Failures relocate from inscrutable data mismatches to a named, versioned, revocable declaration with an author and a retraction channel — so a bad substitution is a traceable governance event, not a needle in the data. Transitive chains compose along the same rails: a path of exactMatch links yields exactMatch, but any closeMatch link caps the whole chain at closeMatch, so reasoning about reachability between two concepts reduces to tracking the weakest grade on the declaration path. The unbounded problem of "how does everyone keep all these vocabularies interoperating?" thus collapses to maintaining a linear table of scope-stamped, versioned declarations and consulting four fields per use.

Abstract Reasoning¶

The construct's first move is a source-of-authority diagnosis. When a system treats two identifiers as a single atom, the analyst reasons to what underwrites the substitution — a computed similarity score, a metaphysical claim that the concepts are the same, or a recorded judgment that they may be substituted — and the construct forces the third reading and holds it apart from the other two: the equivalence is valid because a party with authority over the schemes put their name on it, not because an algorithm matched them and not because they are ontologically identical. This relocates the well-posed question from "are these two concepts the same?" (which has no determinate answer and would be re-litigated everywhere) to "who declared them interchangeable, for what purpose, and is that declaration still current?" — a closed governance lookup with an answer.

From that re-posing follow two tightly coupled boundary and trust inferences. The boundary move reasons from the declaration's stated purpose-scope to whether a given use may rely on it: because the assertion is substitutability within a defined context, two codes can be an exact match for routing and reporting while still differing in hierarchical parents and attribute slots, so a consumer who carries the equivalence outside its declared scope is committing a nameable error rather than a data mismatch. The reasoning runs from "is the intended use inside the declared purpose?" to "rely" or "do not carry across." The trust move makes the dependency explicit: relying on a mapping is delegated trust — the consumer is trusting the declarer's scope assessment instead of re-verifying — so an invisible dependency becomes a visible one, and this is exactly why the artifact must carry an author, a version, and a retraction channel. The interventionist corollary is that the cost of interoperating is not the matching but the maintenance of a trusted, scope-stamped declaration, and the prescription when a mismatch is found is to downgrade or revoke the declaration through its retraction channel.

Two further moves govern failure attribution and composition. Failure relocates from the data to the governance: a wrong substitution is inferred to be a wrong or stale declaration with an author and a version, a traceable governance event, not an inscrutable needle in the data — so on detecting a bad substitution the analyst reasons back to "which declaration, made by whom, for what now-drifted purpose?" rather than auditing the records. The composition move reasons about reachability between two concepts along a path of declarations: a chain of exactMatch links yields exactMatch, but a single closeMatch (near-equivalence) link caps the entire chain at closeMatch, so inferring the fidelity grade between two concepts reduces to tracking the weakest grade on the declaration path — and the prediction that follows is fidelity-fragility, that one weak link silently degrades a long chain of otherwise-exact mappings. Finally, a boundary-on-options move places declared equivalence among its alternatives: when two systems with sovereign naming authority must interoperate, declaring equivalences is one structural option alongside adopting a common name or building a translation layer, and the analyst reasons about the constant trade-off — declarations preserve each scheme's autonomy at the cost of an additional artifact to maintain — selecting the declaration route precisely when scheme sovereignty must be kept.

Knowledge Transfer¶

Within knowledge organization and interoperability practice the construct transfers as mechanism across a strikingly wide set of substrate-instances, because the structure — an authority declares two sovereign identifiers interchangeable, downstream relies without re-verifying, and fidelity rides on the declaration staying accurate — holds wherever distinct naming authorities must interoperate. SKOS exactMatch between LCSH and FAST headings, ICD-10-to-SNOMED-CT pairs in clinical coding, Ensembl-to-HGNC gene-identifier crosswalks in bioinformatics, CRM-to-ERP entity reconciliation in master-data management, regulatory equivalency declarations across jurisdictions, and ISO standards harmonisation all instantiate it, and the full apparatus carries without change: the source-of-authority diagnosis, the purpose-scope boundary, the delegated-trust framing, the failure-relocation to a versioned retraction channel, and the weakest-link composition rule for transitive chains. The discipline that an assertion carries an author, a purpose, a scope, a version, and a retraction route ports intact from SKOS to entity resolution to standards recognition. This is genuine cross-substrate transfer, but note it is transfer of a governance practice across information systems, all of which share the same N-sovereign-scheme integration problem.

Characterising what travels as mechanism off that practice requires care, because the construct's structural daylight beyond a few general primes is thin, and the honest reading is the shared-abstract-mechanism case. The portable core decomposes: the formal one-to-one pairing is bijectivity (often asserted here without the bijection being formally established), the act of pairing-by-evaluation is comparison/function-mapping, and the declared layer — validity by authority rather than by use-time matching, with scope, version, and revocation — is the generic trust-bridging already carried by certification, naming/authority, conformity, and validation. Those parents are what genuinely recur across domains and what should carry any cross-domain lesson: whenever the question is how two systems with sovereign naming authority interoperate, the general options are adopt-a-common-name, build-a-translation-layer, or declare-equivalences, and the declared-equivalence route is the certification/bijectivity pattern applied to preserve scheme autonomy at the cost of a maintained artifact. What stays home-bound is the entry's own specific cargo: the SKOS exactMatch/closeMatch fidelity grades, the controlled-vocabulary and identifier-scheme setting, and its position as the highest-fidelity slot in the broader schema-mapping-relation family (exact/close/broader/narrower/related). So the disciplined move when the lesson is wanted elsewhere is to invoke the bijectivity-plus-certification/authority parents and the general declared-mapping practice, not to import "declared equivalence mapping" with its SKOS grade system, which is the part bound to the knowledge-organization substrate — while keeping the construct's load-bearing warning, that the equivalence holds only for its stated purpose and degrades the moment a consumer carries it out of scope or the declaration drifts. (See Structural Core vs. Domain Accent.)

Examples¶

Canonical¶

The defining instance is a SKOS exactMatch triple linking a Library of Congress Subject Heading to its counterpart in FAST (Faceted Application of Subject Terminology), the OCLC-maintained scheme derived from LCSH. Both schemes have sovereign concept identifiers — an LCSH authority URI and a FAST URI — and a cataloguer records, as a versioned RDF statement, that the two may be substituted in downstream discovery. The assertion takes the literal form of a triple: <LCSH-concept> skos:exactMatch <FAST-concept>. Because SKOS defines exactMatch as a symmetric, transitive sub-property signalling "high confidence [the] concepts can be used interchangeably... across a wide range of information retrieval applications," any catalog or discovery layer that respects the statement now routes and aggregates both identifiers as one atom, without recomputing the correspondence per query. Nothing about the two concepts changed; a party with authority over the schemes recorded a judgment, and consumers rely on it.

Mapped back: The LCSH and FAST URIs are the source and target concepts; the cataloguer is the declarer and the RDF triple is the declaration record. skos:exactMatch's symmetric definition is the symmetry commitment, and its "range of retrieval applications" wording is the purpose-scope bound. Discovery systems consuming the triple without re-verifying take the delegated-trust route, and closeMatch versus exactMatch supplies the fidelity grades behind the weakest-link composition rule.

Applied / In Practice¶

Clinical informatics runs this at national scale through the ICD-10-CM to SNOMED CT map maintained by the U.S. National Library of Medicine. ICD-10-CM (a billing and reporting classification) and SNOMED CT (a clinical reference terminology) are independently governed schemes, and the NLM publishes a versioned crosswalk asserting which codes correspond for stated use cases such as translating recorded clinical findings into reimbursement codes. Hospital systems consult the released map rather than re-matching terminologies per patient encounter, and when a mapping is found wrong it is corrected in the next published version rather than debugged inside each hospital's data. Crucially the correspondence is purpose-bounded: two codes may map for reporting while still sitting under different hierarchical parents, so carrying the equivalence into a clinical-inference context the map was not built for is an out-of-scope error.

Mapped back: ICD-10-CM and SNOMED codes are the source and target concepts; the NLM is the declarer and the released crosswalk is the versioned declaration record. Hospitals consuming it without re-matching are on the delegated-trust route, achieving the O(N)-vs-O(N²) consolidation. Fixing a bad pair in the next release is the retraction channel, and "maps for reporting but not for inference" is the purpose-scope bound in force.

Structural Tensions¶

T1: Validity by authority versus validity by fact (a declaration can be authoritative and wrong). The construct's defining move is to underwrite substitutability by the declarer's judgment rather than by any use-time verification or ontological truth — validity is conferred by a party putting their name on it. This is what makes interoperability tractable: it converts an open, undecidable "are these the same?" into a closed governance lookup with an answer. But it also decouples validity from correctness, so a declaration can be fully authoritative — current, in-scope, by a trusted party — and simply mistaken, and every consumer on the delegated-trust route propagates the error with confidence precisely because they declined to re-verify. The tension is that authority-backing is at once the source of the construct's operability and the reason a wrong equivalence circulates unchecked: the very trust that removes the O(N²) verification burden also removes the checks that would catch a bad pairing. Diagnostic: Is reliance here justified by the declarer's demonstrated accuracy, or only by their authority to declare — and what would surface a valid-but-wrong mapping?

T2: Collapse-to-one-atom versus loss of scope metadata (the benefit that discards its own guardrail). The structural payoff is that respecting systems treat c1 and c2 as a single atom, routing and aggregating without re-checking. But the purpose-scope bound — the qualifier that keeps the substitution honest ("interchangeable for reporting, not for hierarchical inference") — is exactly the information the collapse throws away: once two codes are one atom, the atom no longer carries the stated context, and a downstream consumer several hops from the declaration cannot see the scope it was valid within. The convenience of zeroing the distinction and the safety of honoring its boundary pull against each other, because the more thoroughly a pipeline treats the pair as identical, the less able it is to notice when it has carried the equivalence out of scope. The tension is that collapsing the distinction to zero is both the point and the mechanism by which scope violations become invisible. Diagnostic: Does the system that treats these as one atom still have access to the declaration's purpose-scope, or has the collapse erased the boundary that governs safe use?

T3: Centralized O(N) efficiency versus concentrated failure (the maintained table as single point of corruption). Externalizing each match into one shared, maintained artifact replaces per-consumer O(N²) re-matching with an O(N) table the whole population consults — the construct's headline efficiency. But the same centralization concentrates risk: in the O(N²) world a mistaken match is local to one consumer, while in the centralized world a single wrong or drifted declaration is inherited simultaneously by every system that respects it. Consolidating the judgment consolidates the blast radius. The retraction channel and versioning exist to manage exactly this, but they make correction a governance event that must propagate to all consumers, and a stale copy anywhere reintroduces the retracted error. The tension is that the shared table which eliminates redundant matching also eliminates the redundancy that once contained mistakes, trading many small independent risks for one large correlated one. Diagnostic: If this declaration is wrong or retracted, does the correction reach every consumer — or does centralization mean one error, or one stale copy, corrupts them all at once?

T4: Transitive composability versus fidelity fragility (the weakest link caps the chain). Declared equivalences compose along paths, which lets an integrator infer reachability between concepts that were never directly mapped — a genuine reasoning affordance. But composition is fidelity-fragile: a chain of exactMatch links yields exactMatch, while a single closeMatch link caps the entire chain at closeMatch, so a long path of otherwise-exact mappings inherits the grade of its one weak link. The affordance that makes distant concepts reachable is the same one that silently degrades fidelity across the reach, and because the collapsed atom does not advertise the grade of the path behind it, a consumer using the endpoint may treat as exact a correspondence that a buried near-equivalence has already downgraded. The tension is that composability extends the mapping's reach and dilutes its fidelity by the same transitive step. Diagnostic: Along the declaration path connecting these two concepts, what is the weakest grade — and does the consuming system know the reachable pair is only as strong as that link?

T5: Scheme sovereignty preserved versus perpetual maintenance burden (the cost of not merging). Faced with N sovereign vocabularies, declaring equivalences is one structural option beside adopting a common name or building a translation layer, and its distinctive virtue is that it preserves each scheme's autonomy — no vocabulary must surrender its identifiers. But that autonomy is bought with a standing artifact that must be maintained against drift in either scheme forever: every time a source or target vocabulary evolves, the declaration can silently fall out of accuracy, and fidelity degrades the moment it drifts from the purpose it was made for. A common-name merge would eliminate the artifact but destroy the sovereignty; the declaration keeps the sovereignty by accepting an unbounded maintenance liability. The tension is that preserving each scheme's independence is exactly what makes the equivalence a perpetual governance obligation rather than a one-time fix. Diagnostic: Is preserving both schemes' sovereignty worth a declaration that must be maintained against drift indefinitely — or would a common name or translation layer better fit a stable, long-lived integration?

T6: Autonomy versus reduction (declared equivalence mapping or the bijectivity-plus-certification parents it composes). Declared equivalence mapping is a named knowledge-organization construct with real home cargo — the SKOS exactMatch/closeMatch fidelity grades, the controlled-vocabulary setting, its slot as the highest-fidelity relation in the schema-mapping family. Yet its portable core decomposes into parents already in the catalog: the one-to-one pairing is bijectivity (often asserted without being formally established), the pairing act is comparison/function-mapping, and the declared layer — validity by authority with scope, version, and revocation — is the generic trust-bridging of certification, naming-authority, conformity, and validation. Those parents carry the cross-domain lesson: how two systems with sovereign naming interoperate (adopt-a-common-name, build-a-translation-layer, or declare-equivalences), with the declared route being certification-plus-bijectivity applied to preserve autonomy. The tension is between a SKOS-specific construct and the flatter authority-backed-mapping structure that is what actually generalizes. Diagnostic: Resolve toward the bijectivity+certification/authority parents when the lesson is wanted outside knowledge organization; toward declared equivalence mapping when governing interchangeable identifiers across controlled vocabularies in situ.

Structural–Framed Character¶

Declared equivalence mapping sits at the framed-leaning position — a neutral, well-behaved interoperability construct that is nonetheless constituted entirely by an authority-backed governance practice, so it lands well short of a structural mechanism while carrying no evaluative charge.

On evaluative weight it reads structural, which keeps it off the framed pole: a declared equivalence convicts and praises nothing — it asserts substitutability, rendering no judgment. The remaining four criteria pull firmly framed. On human_practice_bound it is maximal, and the entry makes the point unusually explicit: validity is conferred by authority — "a party with authority over the schemes put their name on it" — so the equivalence is constituted by a declaring act, and with the naming-authority practice and its trusting consumers removed there is no declaration, no scope, no retraction channel, nothing for the concept to be. T1 drives it home: a declaration can be authoritative and wrong, because validity here is a governance fact, not a fact of the world. Its institutional_origin is total: SKOS exactMatch/closeMatch, controlled vocabularies, identifier schemes, and the declarers (cataloguers, the NLM, regulators, ISO) are all artifacts of specific knowledge-organization standards and institutions. On vocab_travels it scores low: the exactMatch/closeMatch fidelity grades, the SKOS setting, and the controlled-vocabulary framing lose their referents off the substrate. And import_vs_recognize is bimodal in the entry's own terms — across libraries, clinical coding, bioinformatics, MDM, regulatory equivalency, and standards harmonisation the identical governance practice is recognized as the same mechanism, but off that practice only the general trust-bridging parents travel, and importing "declared equivalence mapping" with its SKOS grades elsewhere would carry the substrate-bound part.

The one portable structural skeleton is an authority-backed, scope-bounded bijective mapping — a validity-by-declaration correspondence between two identifiers, carrying scope, version, and a revocation channel. This decomposes cleanly into bijectivity (the one-to-one pairing, often asserted without being formally established), comparison/function-mapping (the pairing act), and certification/naming-authority (validity by authority with scope and revocation). That skeleton genuinely recurs wherever two systems with sovereign naming must interoperate, which tempts a structural reading. But it does not lift declared equivalence mapping off framed-leaning, because that authority-backed-mapping structure is exactly what the entry instantiates from those parents, not what makes "declared equivalence mapping" itself portable: the cross-domain reach belongs to bijectivity+certification/authority, while the SKOS fidelity grades, the weakest-link composition rule, and the controlled-vocabulary setting — the distinctive layer — stay home as the knowledge-organization implementation. Its character: an evaluatively neutral but wholly authority-constituted interoperability construct whose only substrate-spanning content is the scope-bounded bijective-mapping-by-declaration it borrows from the bijectivity/certification parents, everything distinctive to it being the SKOS-graded knowledge-organization instance of that borrowed pattern.

Structural Core vs. Domain Accent¶

This section decides why declared equivalence mapping is a domain-specific abstraction and not a prime, and it carries the case for its domain-specificity — there is no separate section for that. Its skeleton is genuinely doubled: a formal pairing and an authority layer, which is why it decomposes into two families of parent at once.

What is skeletal (could lift toward a cross-domain prime). Strip the knowledge-organization setting and a thin relational structure survives, in two parts. First, a scope-bounded bijective correspondence: two identifiers from sovereign systems paired one-to-one for a stated purpose, so that consumers may substitute one for the other within that scope. Second, an authority-backed validity layer: the correspondence holds not because it was verified at use-time but because a party with naming-authority declared it, carrying scope, version, and a revocation route, with downstream consumers relying on the declaration rather than re-checking. Both pieces are abstract and substrate-portable — a one-to-one pairing that lets two things be treated as one atom, and validity conferred by declaration rather than by computation. That is exactly why the construct instantiates bijectivity and comparison/function-mapping (the pairing) together with certification, conformity, and validation (validity-by-authority with scope and revocation) rather than one clean parent. This is the core it shares, not what makes it distinctive.

What is domain-bound. Almost everything that makes it declared equivalence mapping in particular is knowledge-organization furniture, and none survives extraction intact. The SKOS exactMatch/closeMatch fidelity grades; the weakest-link composition rule that caps a transitive chain at its lowest grade; the controlled-vocabulary and identifier-scheme setting; its slot as the highest-fidelity relation in the schema-mapping family (exact/close/broader/narrower/related); and the worked instruments and cases (SKOS triples between LCSH and FAST, the NLM's ICD-10-to-SNOMED crosswalk, Ensembl-to-HGNC, CRM-to-ERP reconciliation) are all specific to the interoperability substrate. The decisive test: remove the controlled-vocabulary schemes and the SKOS grade system and what remains is a plain authority-backed pairing — the general trust-bridge — with no exactMatch/closeMatch distinction to compose, no N-sovereign-scheme integration problem to consolidate, nothing left that is this construct rather than its parents.

Why this does not clear the prime bar. A prime's vocabulary travels and its transfer is recognition of the same mechanism, not analogy. Declared equivalence mapping's transfer is bimodal. Within knowledge-organization and interoperability practice it travels intact as full mechanism across a wide substrate set — libraries, clinical coding, bioinformatics, master-data management, regulatory equivalency, standards harmonisation — because every instance is the same governance practice over the same N-sovereign-scheme problem: an authority declares two identifiers interchangeable, downstream relies without re-verifying, and fidelity rides on the declaration staying accurate, with the source-of-authority diagnosis, purpose-scope boundary, delegated-trust framing, retraction channel, and weakest-link rule all carrying without change. Beyond that practice it travels only by decomposition into its parents: the substrate-spanning lesson is carried by bijectivity+comparison (the pairing) and certification/conformity/validation (validity by authority), which is the general trust-bridging pattern — adopt-a-common-name, build-a-translation-layer, or declare-equivalences — of which this is the SKOS-graded instance. Importing "declared equivalence mapping" itself elsewhere would drag the fidelity-grade system and controlled-vocabulary cargo that belong home. The cross-domain reach belongs to those parents; the named construct carries knowledge-organization baggage that should stay home.

Relationships to Other Abstractions¶

Current abstraction Declared Equivalence Mapping Domain-specific

Parents (3) — more general patterns this builds on

Declared Equivalence Mapping is a kind of Schema Mapping Relation Domain-specific

Declared Equivalence Mapping is the exactMatch species of Schema Mapping Relation, fixing the bridge grade at purpose-bounded loss-free substitution.
Declared Equivalence Mapping is a kind of Record Reconciliation Prime

Declared Equivalence Mapping is the equivalent-verdict species of Record Reconciliation, made authoritative and purpose-bounded for controlled schemes.
Declared Equivalence Mapping is a decomposition of Equivalence Relation Prime

Removing declaration governance leaves sameness under a stated criterion, with symmetric substitution and exact-only transitive closure.

Hierarchy paths (13) — routes to 9 parentless roots

Declared Equivalence Mapping → Schema Mapping Relation → Governed Relation Vocabulary → Schema → Abstraction

Show alternative paths (12)

Not to Be Confused With¶

SKOS closeMatch (near-equivalence). The lower-fidelity sibling in the same mapping family: an assertion that two concepts are similar enough to substitute in some applications but not fully interchangeable. Declared equivalence proper (exactMatch) is the highest-fidelity slot; the grade difference is load-bearing, because a single closeMatch link caps a whole transitive chain at closeMatch (the weakest-link rule). Tell: is the declaration high-confidence full interchangeability (exactMatch, this entry) or approximate, application-limited similarity (closeMatch)? Same act, weaker grade.
Ontological identity (owl:sameAs). The assertion that two identifiers denote the very same individual in all contexts — a metaphysical sameness claim that licenses unrestricted substitution and inference. Declared equivalence asserts only purpose-bounded substitutability: two codes can be an exact match for routing while differing in hierarchical parents and attribute slots. Tell: does the assertion claim the referents are identical everywhere (owl:sameAs) or interchangeable within a stated purpose (declared equivalence)? Identity versus scoped substitutability.
Inferred / computed match (record linkage, entity resolution). A correspondence produced by an algorithm scoring similarity between records or concepts. Declared equivalence is recorded by an authority, valid by the declarer's judgment, not by a matcher's confidence. Tell: is the right question "how high did the matcher score?" (computed match) or "who declared it, for what purpose, is it current?" (declared equivalence)? A similarity output versus a governed assertion. (A computed match may be promoted into a declaration — but then its validity shifts to the declarer.)
Crosswalk / schema-mapping relation (the broader family). A crosswalk is the whole translation table between two schemes, containing relations of several grades — exactMatch, closeMatch, broadMatch/narrowMatch (hierarchical), relatedMatch (associative). Declared equivalence mapping is the highest-fidelity relation type within that family, not the family itself. Tell: is the referent the entire cross-scheme mapping with its mixed relation types (crosswalk) or specifically the exact-interchangeability assertions inside it (declared equivalence)?
Cross-reference relation (intra-scheme). The thesaural pointers (USE/UF/BT/NT/RT) that route or nest terms within a single controlled vocabulary. Declared equivalence runs across two sovereign vocabularies, asserting correspondence between schemes. The cousin entry flags the same boundary: cross-referencing navigates inside one scheme; equivalence mapping bridges two. Tell: do the two endpoints live in one vocabulary (cross-reference) or in different vocabularies asserted interchangeable (declared equivalence)? Intra-scheme routing versus inter-scheme correspondence.
The bijectivity + certification/authority parents (umbrella). The substrate-neutral primes the construct composes — bijectivity (the one-to-one pairing, often asserted without formal proof), comparison/function-mapping (the pairing act), and certification/naming-authority (validity by declaration with scope and revocation). Not confusable peers but the generalization: the general trust-bridging pattern (adopt-a-common-name, build-a-translation-layer, or declare-equivalences). Tell: the parents carry the lesson off the knowledge-organization substrate; "declared equivalence mapping," treated more fully in a later section, is the SKOS-graded instance with its fidelity grades and weakest-link rule.

Neighborhood in Abstraction Space¶

Declared Equivalence Mapping sits in a moderately populated region (40^th percentile for distinctiveness): it has near-neighbors but no dense thicket of look-alikes.

Family — Trust Infrastructure for Shared Knowledge (6 abstractions)

Nearest neighbors

Computed from structural-signature embeddings · 2026-07-12