Near-equivalence Mapping¶

Bridge two concepts in different controlled vocabularies with a declared correspondence that carries an explicit, typed loss-risk on the bridge itself, so consumers can route each substitution on whether their use falls in the safe zone.

Core Idea¶

A near-equivalence mapping is a declared correspondence between two concepts in different controlled vocabularies that flags them as highly similar but not safely interchangeable in all contexts — the canonical instance being SKOS closeMatch, which records that c1 in S1 and c2 in S2 are close enough to support cross-scheme browsing, retrieval, and many inference uses, but that some queries will distort if the substitution is made without context-checking. The structural commitment is declared similarity with explicit loss-risk: the bridge is real and useful, but the warning that the equivalence is incomplete is part of the bridge's specification, not a deficiency to be corrected. The work the near-equivalence relation does is to supply a third option between the two forced choices that face any cross-vocabulary integration: declare exact equivalence (and accept silent errors in edge cases where the concepts diverge) or declare no equivalence (and lose useful navigation between schemes). A close match preserves the connection while marking it for context-aware handling — a search engine can surface close-match results as expansions with a visual flag; a clinical-decision tool can warn when reasoning crosses a close-match boundary; an entity-resolution pipeline can route close-match merges to human review rather than automatic merge. What kind of loss is risked is a downstream annotation question: the gap between a close-matched pair is usually one of scope (one concept is slightly broader or narrower), context dependence (equivalence holds in one workflow but not another), or connotational register (same denotation, different usage conventions). Close-match chains degrade monotonically in fidelity: if c1 closeMatch c2 and c2 closeMatch c3, then c1-to-c3 is at most closeMatch, typically weaker, so a consumer reasoning across multiple hops must account for accumulated loss. SKOS closeMatch between LCSH and FAST subject headings where one scheme's scope is narrower, ICD-10 to SNOMED-CT pairs where one system encodes clinical attributes the other lacks, orthology mappings between species' gene catalogues where functional divergence makes one-to-one substitution context-dependent, and bilingual dictionary entries flagged as approximate equivalents (the Schadenfreude problem) all instantiate the same pattern: declared proximity with a typed warning attached.

Structural Signature¶

Sig role-phrases:

the source and target concepts — two identifiers from different controlled vocabularies declared approximately interchangeable (SKOS closeMatch)
the declared similarity assertion — the curator's judgment that the pair is close enough to support browsing, retrieval, and many inference uses
the loss-risk flag — the load-bearing element: an explicit warning, carried on the bridge, that some queries will distort under substitution — part of the specification, not a defect
the third-option role — the structural alternative to the forced binary (declare exact and accept silent error, or declare nothing and lose navigation)
the loss-kind annotation — the optional typed gap naming where fidelity fails: scope drift, context dependence, or connotational register
the consumer context-check — the runtime decision routing on the grade: use-blindly (exact), use-with-care (close: flag, warn, or human-review), or no bridge
the use-vs-loss matching — the inference matching the intended use against the declared loss-kind (aggregate counts tolerate scope drift; hierarchy-dependent reasoning does not)
the monotone chain-degradation rule — close matches compose only down to close-or-weaker, so fidelity after N hops reduces to the weakest grade on the path
the typed-uncertainty-propagation discipline — the general principle the construct embodies: the uncertainty about a correspondence is a property of the correspondence, carried with it, not reconstructed per consumer

What It Is Not¶

Not exact equivalence. A near-equivalence (closeMatch) flags two concepts as highly similar but not safely interchangeable in all contexts — some queries will distort under substitution. Unlike a declared exact equivalence, it does not license treating the pair as a single atom; the substitution is safe only for uses inside the zone the flag marks.
Not a defect to be corrected. The loss-risk warning is part of the bridge's specification, not an incomplete exactMatch awaiting repair. The whole value of the relation is that it carries the incompleteness on the bridge — "approximate" is the declared content, not a flaw to be fixed into exactness later.
Not the absence of a relationship. A near-equivalence is a real, useful connection — the structural third option between declaring exact equivalence (and accepting silent edge-case errors) and declaring no link (and losing navigation). It preserves cross-scheme browsing, retrieval, and many inference uses while marking the boundary for context-aware handling.
Not an inferred similarity score. Like its exact sibling, it is declared by a curator with authority over the schemes and carries a typed flag, not computed by a matcher returning a number. What makes it actionable is the recorded judgment plus the optional loss-kind annotation (scope drift, context dependence, connotational register), not a proximity metric.
Not safe to compose across hops. Near-equivalences degrade monotonically: a chain of closeMatch links yields at most closeMatch, typically weaker, so fidelity after N hops reduces to the weakest grade on the path. Treating a multi-step close-match route as if it were exact ignores the accumulated loss the relation is designed to flag.
Not the normalization operation. Near-equivalence is the recorded artifact of a cross-scheme similarity assertion, not the act of converting nearly-identical inputs to a canonical form (near-miss normalization, entity-resolution deduplication). One is a declared bridge between two sovereign schemes; the other is a pipeline step that collapses variants — the artifact, not the operation.

Scope of Application¶

Near-equivalence mapping lives across the knowledge-organization and interoperability subfields — a typed-uncertainty governance discipline recurring wherever sovereign vocabularies must be connected without over-claiming; its reach is within that practice. Off it, the portable move is typed-uncertainty propagation carried by the bijectivity / validation / triangulation parents (attach the loss to the bridge, match use to declared loss, account for accumulated loss across hops), so the general discipline stays off this map.

Thesaurus and subject-heading crosswalks — SKOS closeMatch between overlapping-but-not-coincident vocabularies (LCSH and FAST) where one scheme's scope is narrower, supporting browsing and retrieval with the gap flagged.
Clinical terminology mapping — ICD-10-to-SNOMED-CT pairs where one system encodes clinical attributes the other lacks, routing close-match reasoning to context-aware handling.
Comparative genomics (orthology) — ortholog mappings between species' gene catalogues where functional divergence makes one-to-one substitution context-dependent.
Bilingual lexicography — dictionary entries flagged as approximate equivalents (the Schadenfreude problem), same rough sense but different usage conventions.
Regulatory and standards recognition — equivalency declared at less-than-full recognition, where the correspondence is useful but bounded.
Data integration and ETL — field mappings flagged for schema drift, and lossy unit/precision conversions, where the declared loss travels with the mapping for downstream robustness handling.

Clarity¶

Naming the near-equivalence relation makes legible a third option that the bare vocabulary of "equivalent or not" conceals. Faced with two concepts that almost line up, an integrator without the category is forced to round: declare them the same and accept silent distortion in the edge cases, or declare no link and forfeit the navigation the proximity would have supported. The construct's clarifying force is to make the gap itself a first-class, recordable object — the bridge is real, and the warning that it is incomplete is part of the bridge's specification rather than a defect to be fixed later. That reframes the integrator's question from "are these interchangeable?" to for which uses is this substitution safe, and where will it distort? — a question that has a routable answer, because the loss-risk now travels with the mapping instead of having to be rediscovered by every consumer.

The concept also sharpens what kind of incompleteness is in play and what to do about it. Because the flag is explicit, the distinction between use blindly and use with care propagates into downstream behaviour: results can be surfaced as flagged expansions, reasoning that crosses a close-match boundary can be warned on, a merge can be routed to human review rather than performed automatically. It further makes the kind of gap nameable as a separate annotation — scope drift, context dependence, connotational register — so "close" stops being a vague hedge and becomes a typed statement about where fidelity fails. And it makes degradation across a chain legible in a way a binary cannot: since close matches compose only down to close-or-weaker, a consumer reasoning over several hops can account for accumulated loss rather than treating a multi-step path as if it were exact. The clarity is in carrying the uncertainty on the bridge, turning approximate correspondence from a liability that must be hidden into a property that can be reasoned with.

Manages Complexity¶

Cross-vocabulary similarity is a continuum: any two concepts from different schemes line up to some degree and diverge in some respects, so in principle each pair carries its own idiosyncratic profile of where it matches and where it fails, and a consumer deciding whether to substitute would have to re-assess that full profile for every pair at every use. Near-equivalence mapping compresses that continuum into a single declared grade — closeMatch — that downstream code can route on without re-inspecting the underlying concepts. The graded similarity collapses to a flag; the consumer tracks one bit (exact versus close) and reads the handling off it: an exactMatch is treated as a single atom, a closeMatch is surfaced as a flagged expansion, warned on at a reasoning boundary, or routed to human review. What would be an open assessment of partial overlap per pair reduces to a categorical lookup with a determinate behavioural consequence.

The deeper management is that the uncertainty rides on the bridge rather than being reconstructed by each consumer. Because the loss-risk is declared once and travels with the mapping, the integrator's question collapses from the unanswerable "are these really interchangeable?" to the routable "is this use inside the safe zone the flag marks?" — and the kind of gap (scope drift, context dependence, connotational register) is an optional typed annotation, so "close" stops being a vague hedge and becomes a statement of where, specifically, fidelity fails. The branch structure is correspondingly economical. A consumer routes each substitution on three reads: the grade (exact → use blindly, close → use with care, none → no bridge); the use against the declared loss-kind (aggregate counts tolerate scope drift; hierarchy-dependent reasoning does not); and, across a chain, the weakest link, since closeMatch composes only down to close-or-weaker, so "how much fidelity remains after N hops?" reduces to tracking the minimum grade on the path rather than re-deriving accumulated loss. The full, per-pair, per-use complexity of approximate correspondence thus collapses to a small graded ladder plus a typed loss-annotation, from which safe-use, flagged handling, and multi-hop degradation all read off.

Abstract Reasoning¶

The relation's foundational move is third-option reasoning that escapes a forced binary. Facing two concepts that almost line up, the integrator without the category must round — declare them the same (and accept silent distortion in edge cases) or declare no link (and forfeit the navigation the proximity would have supported). The near-equivalence relation reasons to a third position: the bridge is real and the warning that it is incomplete is part of the bridge's specification, not a defect. This re-poses the integrator's question from "are these interchangeable?" to for which uses is this substitution safe, and where will it distort? — and the answer is routable because the loss-risk now travels with the mapping rather than being rediscovered by every consumer. This is the discipline of typed-uncertainty propagation: the uncertainty about the mapping is a property of the mapping, not something the consumer must reconstruct.

From the typed flag follow two use-matching inferences. The first routes on the grade itself: an exactMatch is used blindly (treated as one atom), a closeMatch is used with care (surfaced as a flagged expansion, warned on when reasoning crosses the close-match boundary, or routed to human review instead of automatic merge), and no match is no bridge. The second, sharper move matches the intended use against the declared kind of loss — because "close" is not a vague hedge but a typed statement of where fidelity fails (scope drift, context dependence, or connotational register). The reasoning runs from the loss-kind to whether this particular use is in the safe zone: an analysis that aggregates counts tolerates scope drift and may rely on a close match, whereas one that depends on hierarchical relationships the coarser scheme lacks crosses exactly where the gap lives and must audit the boundary. This grounds a robustness-design move: knowing the substitution is approximate, the consumer designs the use to absorb the expected loss — broaden the query, log the substitution, request human review on key decisions — engineering around a named uncertainty rather than being surprised by a hidden one.

A boundary-diagnostic move reasons about why a pair is closeMatch rather than exactMatch: the answer is always a specific contextual gap — one concept slightly broader or narrower, equivalence holding in one workflow but not another, same denotation but different usage convention — and naming that gap is the inference that converts a bare grade into actionable knowledge of where the substitution will distort. Finally, a chain-degradation move accounts for accumulated loss across multiple hops: because close matches compose only down to close-or-weaker, a path c1 closeMatch c2 closeMatch c3 yields at most closeMatch (typically weaker), so the question "how much fidelity remains after N hops?" reduces to tracking the weakest grade on the path — the reasoning runs from a multi-step route to its minimum-grade link, predicting graceful (monotone) degradation rather than treating a long chain as if it were exact. These inferences stay inside the interoperability substrate: they presuppose two separately-governed vocabularies and a declared correspondence carrying a loss-flag, so the safe-use, robustness, boundary, and degradation reasoning apply to terminology crosswalks, ortholog mappings, schema-drift migrations, and approximate translation glossaries, and are not exported to settings lacking a typed bridge between sovereign schemes.

Knowledge Transfer¶

Within knowledge organization and interoperability practice the construct transfers as mechanism across a wide set of substrate-instances, because the structure — a declared correspondence carrying an explicit, typed loss-risk on the bridge itself — holds wherever sovereign vocabularies must be connected without over-claiming. SKOS closeMatch between overlapping-but-not-coincident thesauri, ICD-10-to-SNOMED-CT pairs where one system encodes clinical attributes the other lacks, orthology mappings between species' gene catalogues where functional divergence makes substitution context-dependent, regulatory equivalency at less-than-full recognition, lossy unit and precision conversions, approximate-equivalent translation glossaries (the Schadenfreude problem), and ETL field mappings flagged for schema drift all instantiate it, and the full apparatus carries: third-option reasoning out of the exact-or-nothing binary, grade-based and loss-kind-based use-matching, robustness-design around the named loss, the boundary diagnostic for why a pair is close rather than exact, and the monotone chain-degradation rule (a path of close matches yields at most close, typically weaker, so fidelity-after-N-hops reduces to the weakest link). This is genuine cross-substrate transfer, but it is transfer of a typed-uncertainty governance discipline across information systems that share the same connect-sovereign-schemes problem.

Beyond that practice the honest reading is the shared-abstract-mechanism case, and the construct's structural daylight past a few general primes is thin. The genuinely portable insight is not "near-equivalence mapping" but the deeper move it embodies — typed-uncertainty propagation: treat the uncertainty about a correspondence as a property of the correspondence, carried with it, rather than something each consumer reconstructs, so that downstream use can route on it and degrade gracefully. That move decomposes into catalog primes that already carry it at altitude: the formal correspondence is bijectivity, the fidelity-to-a-standard discipline is conformity/validation, and the cross-source verification that close matches invite is triangulation. Those parents are where any cross-domain lesson lives, and they generalize the discipline far beyond vocabularies (any approximate model, lossy conversion, or qualified credential can attach a typed loss-flag and a degradation rule). What stays home-bound is the entry's own specific cargo: the SKOS closeMatch grade and its place in the five-grade exact/close/broader/narrower/related ladder, the loss-kind annotation taxonomy (scope drift, context dependence, connotational register), and the controlled-vocabulary setting. So the disciplined move when the lesson is wanted elsewhere is to carry the typed-uncertainty-propagation discipline through its bijectivity/validation/triangulation parents — attach the uncertainty to the bridge, match use to declared loss, account for accumulated loss across hops — not to import "near-equivalence mapping" with its SKOS ladder and loss-kind taxonomy, which are the part bound to the knowledge-organization substrate. The construct's load-bearing warning generalizes even where its machinery does not: do not let a mapping be mistaken for equivalence; require the loss conditions to be stated and respected. (See Structural Core vs. Domain Accent.)

Examples¶

Canonical¶

SKOS (Simple Knowledge Organization System, a W3C standard) provides skos:closeMatch for exactly this. Suppose the Library of Congress subject concept "Cookery" and another thesaurus's concept "Cooking" denote nearly the same thing, but the two schemes scope them slightly differently. A curator asserts, in RDF, lcsh:Cookery skos:closeMatch other:Cooking rather than skos:exactMatch. The triple records that the two are close enough to support cross-catalog browsing and retrieval — a search for one can surface the other as a flagged expansion — but not that they are interchangeable in every inference. Crucially, SKOS defines closeMatch as deliberately not transitive (unlike exactMatch): a chain of close matches does not compose into an exact one, so software must not follow such links as though they asserted identity.

Mapped back: "Cookery" and "Cooking" in two schemes are the source and target concepts, and the curator's RDF triple is the declared similarity assertion. Choosing closeMatch over exactMatch is the loss-risk flag riding on the bridge and the third-option role between identity and no link. That closeMatch is non-transitive is the monotone chain-degradation rule written into the standard itself; surfacing results as flagged expansions is the consumer context-check.

Applied / In Practice¶

Healthcare interoperability runs on exactly this discipline. SNOMED International and national bodies (in the U.S., the National Library of Medicine) publish an official SNOMED CT to ICD-10-CM map, used to translate the detailed clinical terms clinicians record in an electronic health record into the coarser codes required for billing and statistics. Because SNOMED CT encodes clinical attributes ICD-10-CM lacks, most links are not exact: the map attaches explicit "map advice" — flags for context-dependence, or "consider additional codes" — and some source concepts fork to several ICD targets depending on patient specifics. Automated systems apply the unambiguous links directly and route the flagged, context-dependent ones to a human coder for review — precisely the use-with-care handling the near-equivalence relation prescribes.

Mapped back: A SNOMED clinical term and its ICD-10-CM code are the source and target concepts; the "map advice" is the loss-risk flag with the loss-kind annotation (context-dependence) named explicitly. Applying safe links but routing flagged ones to a coder is the consumer context-check and the use-vs-loss matching. That the advice travels bundled with the map, not reconstructed per consumer, is the typed-uncertainty-propagation discipline in a clinical deployment.

Structural Tensions¶

T1: Recorded bridge versus false confidence (a flag only as good as the consumer who reads it). The construct's virtue is preserving a real, useful connection while marking it for context-aware handling — better than either over-claiming exactness or losing the link. But recording a declared bridge between two schemes also makes it available to be misused as equivalence: a consumer who ignores the flag, or software that follows close-match links as if transitive, gains an authoritative-looking correspondence that silently distorts, which is exactly why SKOS has to stipulate non-transitivity. The tension is that the loss-risk protects only if it is heeded, so an unread flag is arguably worse than no bridge — it supplies a connection with the appearance of sanction but none of the safety. The relation moves the uncertainty onto the bridge, but it cannot force the consumer to look, and its whole value collapses at the point of a lazy integration. Diagnostic: Does the consuming system actually route on the close-match flag (surfacing, warning, human review), or follow the bridge as if it asserted equivalence because the link exists?

T2: Honest third option versus deferred adjudication (the curator's punt becomes the consumer's burden). Declaring closeMatch instead of forcing exact-or-nothing is honest — it refuses to over-claim where the concepts genuinely diverge. But it does not resolve the interchangeability question; it defers it, re-posing "are these the same?" as "is your use in the safe zone?" and handing that adjudication to every downstream consumer. The tension is that the curator, who best understands the two schemes, declines to rule on safety and pushes the harder, use-specific judgment to consumers who are often less equipped to make it and who must remake it for each application. The third option's honesty (don't pretend to an equivalence you can't guarantee) and its cost (distribute the unresolved judgment to everyone downstream) are the same move, so the bridge trades a false certainty at the source for a recurring burden at the edge. Diagnostic: Is the consumer positioned to judge whether its specific use falls in the safe zone, or has the curator deferred an adjudication the consumer cannot actually perform?

T3: Typed annotation versus its optionality (actionable only if the expensive step is done). What turns "close" from a vague hedge into a routable statement is the loss-kind annotation — scope drift, context dependence, or connotational register — because it tells the consumer where fidelity fails. But that annotation is optional, and it is precisely the costly curatorial step most likely to be skipped, so in practice many closeMatch links carry the bare grade without the type. The tension is that the feature which makes the relation genuinely actionable is not part of the minimal bridge, so the common case is a warning that says "something is off" without saying what — informative enough to block blind use, uninformative enough to leave the consumer unable to decide whether its use is safe. The relation's actionability and its curatorial cost pull apart, and the cheap version of the artifact retains the alarm while dropping the diagnosis. Diagnostic: Does the close-match carry a typed loss-kind that lets the consumer match use to gap, or only the bare grade, leaving "where does it distort?" unanswered?

T4: Declared authority versus computational scale (accountable but unautomatable). The relation is declared by a curator with authority over the schemes, not computed by a matcher returning a score — which gives it accountability, a named judgment, and the typed guarantee a similarity number lacks. But declaration does not scale: connecting sovereign vocabularies at realistic size involves combinatorially many concept pairs, and human curation cannot keep pace, while the computed-similarity approach that does scale is exactly what the construct defines itself against. The tension is that the property making a close-match trustworthy (a responsible human assertion with a stated loss condition) is the property that makes it scarce, so systems either accept authoritative coverage of a small fraction of pairs or fall back to unqualified automatic matching for the rest — and the discipline has no native way to bring its typed-uncertainty guarantee to the scale real interoperability demands. Diagnostic: Is the mapping a curator-declared correspondence with a stated loss condition, or an automated similarity result being treated as if it carried the declared relation's typed guarantee?

T5: Autonomy versus reduction (a knowledge-organization artifact or the instance of a typed-uncertainty parent). "Near-equivalence mapping" is a named KO construct with home-bound cargo — the SKOS closeMatch grade, its place in the exact/close/broader/narrower/related ladder, the scope-drift/context-dependence/connotational-register loss taxonomy, the controlled-vocabulary setting. Within interoperability practice it transfers as full mechanism across thesaurus crosswalks, clinical mapping, orthology, lexicography, and ETL. But the genuinely portable insight is the deeper move it embodies — typed-uncertainty propagation: attach the uncertainty to the correspondence, carried with it, so downstream use routes on it and degrades gracefully — which decomposes into bijectivity (the formal correspondence), conformity/validation (fidelity-to-standard), and triangulation (cross-source verification), and generalizes to any approximate model, lossy conversion, or qualified credential. The tension is between a well-specified KO artifact and the recognition that its cross-domain lesson belongs to the typed-uncertainty-propagation parents, with the SKOS ladder and loss taxonomy as the domain accent. Diagnostic: Resolve toward bijectivity / validation / triangulation (typed-uncertainty propagation) when carrying the attach-loss-to-the-bridge discipline beyond vocabularies; toward "near-equivalence mapping" specifically when declaring a closeMatch between two sovereign controlled vocabularies in situ.

Structural–Framed Character¶

Near-equivalence mapping sits at the framed-leaning position on the structural–framed spectrum — a curatorial governance discipline whose portable core is a genuinely structural typed-uncertainty move, but which is itself constituted by the practice of knowledge organization. The criteria lean framed, with a structural thread. On evaluative_weight it patterns structural: a closeMatch convicts nothing — it is a neutral, declared correspondence carrying a typed loss-flag, a governance artifact rather than a verdict. But human_practice_bound is high: the mapping is declared by a curator with authority over the schemes, not computed or found in nature, so it presupposes the practice of connecting sovereign controlled vocabularies — remove the curatorial practice and there is no bridge and no loss-flag to carry. Institutional_origin is pronounced: the SKOS closeMatch grade, its place in the five-grade exact/close/broader/narrower/related ladder, the loss-kind taxonomy (scope drift, context dependence, connotational register), and the W3C standard behind them are knowledge-organization furniture, artifacts of an interoperability discipline. On vocab_travels the named construct scores low, and on import_vs_recognize it patterns as recognition within KO practice (mechanism across thesaurus crosswalks, clinical mapping, orthology, ETL) but as the typed-uncertainty parents carrying the lesson beyond it.

The portable structural skeleton is typed-uncertainty propagation — attach the uncertainty about a correspondence to the correspondence itself, carried with it, so downstream use routes on it and degrades gracefully across hops. That skeleton is genuinely substrate-spanning, generalizing to any approximate model, lossy conversion, or qualified credential, which is the structural thread. But it does not lift near-equivalence mapping off the framed side, because that skeleton is exactly what the construct instantiates from its umbrella primes — bijectivity (the formal correspondence), conformity/validation (fidelity to a standard), and triangulation (the cross-source verification close matches invite) — not what makes "near-equivalence mapping" itself travel: the cross-domain reach belongs to those parents, while the SKOS ladder, the loss-kind taxonomy, and the controlled-vocabulary setting are the domain accent that stays home. Its character: an evaluatively neutral but practice-constituted, standard-born curatorial artifact whose portable core is the substrate-neutral typed-uncertainty-propagation discipline it instantiates, leaving it framed-leaning rather than a free-floating prime.

Structural Core vs. Domain Accent¶

This is the section that decides why near-equivalence mapping is a domain-specific abstraction and not a prime, separating the substrate-neutral discipline it embodies from the knowledge-organization machinery that carries it.

What is skeletal (could lift toward a cross-domain prime). Strip the controlled vocabularies and a thin relational structure survives: typed-uncertainty propagation — attach the uncertainty about a correspondence to the correspondence itself, carried with it, so downstream consumers route on it and it degrades gracefully across composition. The portable pieces are abstract — a declared correspondence, a loss-risk borne on the bridge rather than reconstructed per consumer, a use-against-loss match, and a monotone degradation rule across hops. That move genuinely generalizes to any approximate model, lossy conversion, or qualified credential, and — unusually for these entries — its skeleton is doubled several ways, which is why the construct decomposes into more than one parent: bijectivity supplies the formal correspondence, conformity / validation the fidelity-to-a-standard discipline, and triangulation the cross-source verification that close matches invite. Those three, reasoned rather than padded, are where the portable core lives — the typed-uncertainty insight the construct shares, not what makes it distinctive.

What is domain-bound. Everything that makes it near-equivalence mapping in particular is knowledge-organization furniture. The SKOS closeMatch grade and its place in the five-grade exact / close / broader / narrower / related ladder; the loss-kind annotation taxonomy (scope drift, context dependence, connotational register); the non-transitive composition rule written into the W3C standard; the curator-declared-not-computed provenance that gives the flag its accountability; and the setting of two sovereign controlled vocabularies being connected without over-claiming. The decisive test: remove the curatorial practice of bridging sovereign schemes and there is no closeMatch and no loss-flag to carry — only an abstract note that a correspondence is imperfect; strip the SKOS ladder and loss taxonomy and what remains is the bare "carry the uncertainty on the bridge," which is already the parent discipline rather than this named artifact.

Why this does not clear the prime bar. A prime's vocabulary travels and its transfer is recognition of the same mechanism, not analogy. The construct's transfer is bimodal. Within knowledge organization and interoperability — thesaurus and subject-heading crosswalks, clinical terminology mapping, comparative-genomics orthology, bilingual lexicography, ETL field mappings — it travels as full mechanism: third-option reasoning, grade- and loss-kind-based use-matching, robustness design around the named loss, the boundary diagnostic, and the monotone chain-degradation rule all carry across substrate-instances that share the connect-sovereign-schemes problem. That is genuine within-domain recognition. Beyond that practice, only the typed-uncertainty-propagation discipline travels, and it is carried by the bijectivity / validation / triangulation parents; importing "near-equivalence mapping" with its SKOS ladder and loss-kind taxonomy into a setting with no sovereign schemes borrows the shape and is analogy. When the cross-domain lesson is wanted — attach the loss to the bridge, match use to declared loss, account for accumulated loss across hops — it is those parents that bear it. The cross-domain reach belongs to them; the named construct carries controlled-vocabulary furniture that should stay home.

Relationships to Other Abstractions¶

Current abstraction Near-equivalence Mapping Domain-specific

Parents (3) — more general patterns this builds on

Near-equivalence Mapping is a kind of Schema Mapping Relation Domain-specific

Near-equivalence Mapping is the closeMatch species of Schema Mapping Relation, fixing the bridge grade at useful correspondence with explicit loss risk.
Near-equivalence Mapping is a kind of Record Reconciliation Prime

Near-equivalence Mapping is the near-match-with-stated-loss species of Record Reconciliation, specialized to controlled-vocabulary concepts and closeMatch.
Near-equivalence Mapping is a decomposition of Proxy–Target Fidelity Prime

Removing vocabulary governance leaves a stand-in relation whose explicit loss bound determines when acting on one concept remains faithful to the other.

Hierarchy paths (13) — routes to 9 parentless roots

Near-equivalence Mapping → Schema Mapping Relation → Governed Relation Vocabulary → Schema → Abstraction

Show alternative paths (12)

Not to Be Confused With¶

Exact equivalence (SKOS exactMatch). The sibling grade asserting two concepts are safely interchangeable in all contexts — treatable as a single atom, and transitive (chains compose). A near-equivalence (closeMatch) carries an explicit loss-risk and is deliberately non-transitive; it licenses substitution only inside the zone the flag marks. Tell: can the pair be substituted blindly and composed across hops (exactMatch), or only with context-checking and degrading monotonically down a chain (closeMatch)?
The other ladder grades (broaderMatch, narrowerMatch, relatedMatch). The rest of the SKOS five-grade ladder, each asserting a specific directional relation — one concept is broader than, narrower than, or merely associated with the other. A near-equivalence asserts approximate sameness with a typed loss-risk, not a hierarchical or associative direction. Tell: is the relation a directional broader/narrower/related link (the other grades), or a flagged near-identity (closeMatch)?
An inferred similarity score. A number returned by a matcher or embedding model estimating how alike two concepts are. A near-equivalence is declared by a curator with authority over the schemes and carries a typed loss-kind flag (scope drift, context dependence, connotational register), not a computed proximity metric — the accountability and the typed guarantee are exactly what a score lacks. Tell: is the correspondence a machine-computed similarity value (score), or a curator-asserted relation with a stated loss condition (near-equivalence)?
The normalization / entity-resolution operation. The act of converting near-identical inputs to a canonical form or merging duplicate records. A near-equivalence is the recorded artifact of a cross-scheme similarity assertion — a declared bridge between two sovereign schemes — not a pipeline step that collapses variants. Tell: is it a process that folds inputs together (normalization/dedup), or a standing declared correspondence between two schemes that stay distinct (near-equivalence)?
The parent primes it instantiates (bijectivity, validation, triangulation → typed-uncertainty propagation). The substrate-neutral discipline — attach the uncertainty about a correspondence to the correspondence itself, match use to declared loss, account for accumulated loss across hops — that generalizes to any approximate model, lossy conversion, or qualified credential. The cross-domain lesson belongs to these; the SKOS ladder and loss-kind taxonomy are the domain accent. Tell: strip the controlled vocabularies and what remains — loss carried on the bridge — is these parents, not near-equivalence mapping. (Treated fully in earlier sections.)

Neighborhood in Abstraction Space¶

Near-equivalence Mapping sits in a crowded region of the domain-specific corpus (10^th percentile for distinctiveness): several abstractions share nearly its structure, so a description that fits it tends to fit its neighbors too.

Family — Surface Form & Underlying Structure (23 abstractions)

Nearest neighbors

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