Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
The 705111002 |Map to SNOMED CT with correlation and origin type reference set| is used to meet the requirements for representation of maps from codes in another code system (other-codes) to a SNOMED CT concept, where the following requirements apply.
A requirement to indicate the degree of correlation between the SNOMED CT concept and the other-codes.
A requirement to indicate whether a concept or code was added to either code system as a result of the mapping process and, in this case, to indicate in which code system the concept or code originated.
A requirement to represent the SNOMED CT attribute to which the other-code should be applied in order to capture the full specificity of the value represented by the other-code.
No requirements for mapping rules or advice to be included with each map.
Map to SNOMED CT with Correlation and Origin Reference Set - Data structure
The following metadata hierarchy supports this reference set:
Map to SNOMED CT with correlation and origin type reference set in the Metadata Hierarchy
The tables below show the descriptors that define examples of reference sets that follow the pattern.
Refset Descriptor rows for Map to SNOMED CT with correlation and origin type reference set
Sample Content from a Map to SNOMED CT with correlation and origin type reference set
effectiveTime
Time
The inclusive date or time at which this version of the identified reference set member became the current version.
Note: In distribution files the effectiveTime should follow the short ISO date format (YYYYMMDD) and should not include the hours, minutes, seconds or timezone indicator.
The current version of this reference set member at time T is the version with the most recent effectiveTime prior to or equal to time T.
YES
YES (Full)
Optional (Snapshot)
active
Boolean
The state of the identified reference set member as at the specified effectiveTime .
If active = 1 (true) the reference set member is part of the current version of the set, if active = 0 (false) the reference set member is not part of the current version of the set.
YES
NO
moduleId
SCTID
Identifies the SNOMED CT module that contains this reference set member as at the specified effectiveTime.
The value must be a subtype of within the metadata hierarchy.
YES
NO
refsetId
SCTID
Identifies the reference set to which this reference set member belongs.
In this case, a subtype descendant of:
NO
NO
referencedComponentId
SCTID
A reference to the SNOMED CT component to be included in the reference set.
The SNOMED CT concept to which the code in the other terminology or code system is mapped.
NO
NO
mapSource
String
The other-code which maps to the SNOMED CT concept specified as the referencedComponentId.
NO
NO
attributeId
SCTID
A reference to the SNOMED CT concept representing the attribute to which the referencedComponentId (other-code) applies. In some cases, other-codes may be overloaded with a meaning that combines the meaning of a specific attribute with a value applied to it in the SNOMED CT concept model , in these cases accurate mapping needs to specify both aspects of the meaning. The attributeId provides effective disambiguation in these cases. Values of attributeId are restricted to subtypes of .
YES
NO
correlationId
SCTID
The correlation from the other-code to the SNOMED CT concept. Possible values are the following subtypes of :
YES
NO
contentOriginId
SCTID
An indication of whether the concept was initially in one of the terminologies (SNOMED CT or other-codes) and added to the other as part of mapping or was in both terminologies at the outset. Values are subtypes of .
YES
NO
0
1
2
3
4
TBC
LP16246-8
TBC
LP148077-3
TBC
LP15149-5
TBC
LP14492-0
TBC
id
UUID
A 128 bit unsigned Integer, uniquely identifying this reference set member.
Different versions of a reference set member share the same id but have different effectiveTime. This allows a reference set member to be modified or made inactive (i.e. removed from the active set) at a specified time.
NO
LP16063-7
YES (Full /Snapshot)
To check the validity of a SNOMED CT Identifier, please visit the SNOMED International Component Identifier Service, which can do this check for you - https://cis.ihtsdotools.org/info
This section describes SNOMED CT Release Format 2 (RF2), to be used for official production releases of SNOMED CT. This format is not mandated for internal terminology development usage or as an interchange mechanism between terminology development systems. RF2 provides a format that is flexible, unambiguous and useful. It was designed to strengthen SNOMED CT by providing a simple and stable format that enables innovation through adaptations to cater for changing requirements.
The component release files are defined in the following sections:
This subsection provides illustrated notes on the contents of the SNOMED CT International release package used to distribute the SNOMED International Edition. Similar folder structures should be present in other release packages. However, the files included may be limited to those required to represent the components and/or reference set members in that particular release package.
This Figure shows the overall structure of a release package. The top level folder is named according to the Release Package Naming Conventions. It contains one subfolder for each of the Release Types (Delta, Full and Snapshot). Each release type folder contains a Terminology folder and a Refset folder. The Refset folders contains separate folders for different groups of reference sets (Content, Language, Map and Metadata).
This Figure shows the contents of the Terminology folder. In this case, the files shown are those for the Full release type. Details of most of these files are shown in section Component Release Files Specification, while the OWL refsets follow the specification of the OWL Expression Reference Set.
This Figure shows the contents of the Refset subfolders. In this case, the files shown are those for the Full release type. The names of the reference set files correspond the reference set types and the structure of each reference set type is specified in section .
This section outlines the logical model at the heart of the design of SNOMED CT. It then provides a summary of the ways in which different elements of this logical model are represented in release files. Finally, it provides an overview of the concept definitions that provide the semantic foundation for meaningful processing of clinical information.
This Figure provides a high-level view that illustrates the concept-centric design of SNOMED CT. The subsections below describe the different elements illustrated here.
A concept is defined as a clinical idea to which a unique concept identifier has been assigned.
SNOMED CT concepts are distributed in the concept file.
SNOMED CT is the most comprehensive and precise clinical health terminology product in the world. It has been developed collaboratively to ensure it meets the diverse needs and expectations of clinicians worldwide and is accepted as a common global language for health terms. SNOMED CT enables meaning-based retrieval and processing of clinical data because it applies description logic techniques to represent the meaning of clinical concepts. As a result, patients and healthcare professionals benefit from improved health records, clinical decisions and analysis, leading to higher quality, consistency and safety in healthcare delivery.
SNOMED International distributes SNOMED CT to its licensees as a package of release files that can be loaded into software applications that enable and optimize access to the terminology.
This document provides the formal specification of the file structures in which SNOMED CT is distributed. The specified file structures apply to the releases of the SNOMED CT International Edition, and to SNOMED CT extensions distributed by Members and Affiliates .
The intended audiences for this guide are those involved in the creating or consuming SNOMED CT release files. This includes:
SNOMED International staff involved in creating or quality assuring SNOMED CT release files.
A Boolean field that specifies whether an identified component or is an active from the point in time specified by the effectiveTime .
Note: Field name in SNOMED CT Release Format 2.
A field in a 900000000000506000 |Language type reference set| that indicates the acceptability of a Description in the language or dialect specified by that Reference Set . Values include "preferred" and "acceptable".
Note: Field name in a 900000000000506000 |Language type reference set|
The string of digits to the left of the partition-identifier (in a short format SCTID) or to the left of the namespace-identifier (in a long format SCTID) is referred to as the item-identifier.
These values are available to uniquely identify an individual entity within the specified partition or namespace. The same item-identifier can be allocated in each partition of each namespace as the SCTID is rendered unique by the partition-identifier and the namespace-identifier. For components in the International Release of SNOMED CT, item-identifiers will usually be issued in the arbitrary order in which components are added to SNOMED Clinical Terms. However, due to management of the editing process the sequence of issued item-identifiers may be discontinuous.
The SCTID data type is a 64-bit positive integer.
When rendered as a string an SCTID must always be represented using decimal digits and when rendered as a string has a maximum permitted length of 18 digits and a minimum length of 6 digits.
Note : Leading zeros are always omitted from the string rendering of an SCTID. For example the value "101291009" must not be rendered as "0101291009".
Concepts are associated with descriptions that contain human-readable terms describing the concept.
Concepts are related to one another by relationships and OWL axioms that provide a formal logical definition of the concept.
Authors create a new SNOMED CT concept for each distinct clinical meaning added to the terminology. Every concept is uniquely identified and this identifier allows the concept to be unambiguously recorded in a clinical record. The concept identifier also allow other related information to be linked to a specific concept. This linked information includes human-readable terms and formal concept definitions.
A description is defined as an association between a human-readable phrase (term) and a particular SNOMED CT concept.
Each description is represented by a separate row in the Description File.
Each description has a unique identifier and connects a concept with a term of a specified description type. All concepts have descriptions with description types fully specified name and synonym. Other description type can be defined and may be applied to some concepts.
Terminology authors create a set of descriptions each of which links a term to an identified concept. The linked terms must all be legitimate ways to label or refer to the concept to which they are linked. Translators also create descriptions to link appropriate terms in other languages or dialects to the same concepts. Since usage of terms varies depending on languages and dialects, the design also support addition of information about which descriptions contain terms that are preferred or acceptable in each language or dialect.
Terminology authors associate each concept with a formal stated definition. This stated concept definition consists of description logic axioms that are known to be true for that concept (for example stating that appendectomy is a procedure that applies the method excision to the appendix structure). Because these axioms are stated in a formal way, a description logic classifier can be applied to all the axioms in the terminology to generate additional logical inferences. Therefore, the overall model is designed to enable representation of both the original stated concept definition and the inferred view of the concept definition.
In practice, a description logic classifier can generate more than one inferred view, depending on whether all logically inferred axioms are retained and on whether some types of redundant axioms are omitted from the inferred view.
The SNOMED CT design also enables a wide range of customizable information to be linked to the concepts and descriptions mentioned above. The extensible design of SNOMED CT enables consistent representation and distribution of:
subsets of concepts or descriptions
ordered lists of concepts or descriptions
language preferences associated with different descriptions
ordered or unordered associations between concepts
coded or plain text annotations linked to specific concepts
maps from concepts to codes in other code systems
representation of queries and expressions

National Release Centers and Affiliates that create, maintain and distribute SNOMED CT extensions.
Software designers and developers responsible for SNOMED CT enabled software applications that need to access data provided in SNOMED CT release files.
Anyone interested in a detailed understanding of the logical design of SNOMED CT and way that logical design is represented in release files.
Notes



These files provide standardized ways of providing users with Metadata regarding the Release Package and the SNOMED CT components contained therein.
These files are located in the top-level directory of the SNOMED CT Release packages, and contain various information related to the specific Release package in which they reside.
release-package-information-.json file - Detailed Specification
National Release Centres and others may create additional reference sets. A namespace is required to create a new reference set, as each reference set is defined by a concept. The concept's FSN and a synonym are used to name the reference set. Where a new reference set is created against an existing pattern, then the following naming convention should be used (where the text "Specific name " is to be replaced by the specific name of the reference set).
FSN = Specific name attribute value reference set (foundation metadata concept )
PT = Specific name attribute value map
For a Language:
FSN = Language name [International Organization for Standardization 639-1 code Language code] language reference set (foundation metadata concept )
Example: English [International Organization for Standardization 639-1 code en] language reference set (foundation metadata concept)
PT = Language name
Example: English
For a Dialect:
FSN = Dialect name Language name language reference set (foundation metadata concept )
Example: Great Britain English language reference set (foundation metadata concept)
PT = Dialect code Language name
FSN = Specific name annotation reference set (foundation metadata concept )
PT = Specific name annotation reference set
FSN = Specific name association reference set (foundation metadata concept )
PT = Specific name association reference set
The active field of each component version indicates whether a component is active or inactive. However, it does not provide any information about why a concept or description has been inactivated. The reason why a concept or description has been inactivated is indicated by a row in a component Inactivation reference set. The reason for inactivation may determine the appropriate way to deal with data in existing records, protocols or queries that use a concept or description after it has been inactivated.
The two component inactivation Reference Sets are shown in the table below.
Component Inactivation Reference Sets
The reason for inactivation is specified by a concept enumeration.
The permitted values for this enumeration for a concept are documented in the Editorial Guide pages on Concept Inactivation, and the type of historical association that should be applied is also provided.
Additionally, the inactivation reasons that may be stated for description inactivation are documented in this page: Description Inactivation
Related Links
See also the formal specification of .
This section covers several general topics related to SNOMED CT release packages and release files including:
The following two sections provide detailed specifications of the release files.
Section contains details of release files that represent the main SNOMED CT components:
Concepts
Descriptions
Relationships
Several description logic features, which would improve the completeness and precision of classification, cannot be represented in individual concept definitions.
If particular characteristics of the attributes used to define concepts are identified, this can enhance classification. For example, knowing that an attribute like 123005000 |Part of| is transitive would allow the classifier to make infer that an entire finger is part of the entire upper limb.
Property chains are in some ways similar to transitivity but involve more than one attribute. For example, 127489000 |Has active ingredient| can be declared to chain with 738774007 |Is modification of|. In that case, suppose the definition of 387307005 |Calcium carbonate| includes 738774007 |Is modification of| of 5540006 |Calcium|, a DL classifier can determine that a tablet that 127489000 |Has active ingredient| = 387307005 |Calcium carbonate| by definition has a modification of 5540006 |Calcium| as its active ingredient. Thus in the example shown the classifier can determine that |calcium carbonate tablet| is a subtype of |calcium tablet|.
Each SNOMED CT component is managed and maintained in a module identified by its moduleId field.
A SNOMED CT module is defined as a group of SNOMED CT components and/or reference set members managed, maintained, and distributed as a unit.
Components and reference set members that are part of the same module share the same moduleId value.
All modules , except the , have dependencies on other modules specified by the .
This section summarizes the ways in which SNOMED CT concept definitions are represented. It outlines the rationale for changes to the way in which the stated view of concept definitions is represented. The changes are occurring during a transitional period that started in July 2018 and is due to be completed in 2019.
A field in the Identifier file containing the representation of an Identifier in another code system that is irrevocably linked to a SNOMED CT identifier .
effectiveTime
String
Specifies the inclusive date at which the package has been versioned
Note : In distribution files the effectiveTime should follow the short ISO date format (YYYYMMDD)
previousPublishedPackage
String
The name of the last Release package to have been published for this specific SNOMED CT Product
licenceStatement
String
The licence statement that applies to this particular version of the Product, and which must be adhered to when using the package.
languageRefsets
String
Details of all language refsets included within the package (eg) { "id": "900000000000508004", "term": "Great Britain English language reference set" }, { "id": "900000000000509007", "term": "United States of America English language reference set" }
packageComposition
String
essentialComponents
String
Any information useful to the users, regarding components that are a mandatory part of each version of the package.
optionalComponents
String
Bespoke fields can be created in this section in order to provide users with any additional information that may be specific about this particular Product, especially in regard to components that might (but don't have to) be included in each version of the package. See below for examples:
MapDirectionality
String
States which direction each map file is mapped in (eg) SNOMED to external product, or external product to SNOMED
SNOMEDMapSource
String
The version of SNOMED CT that the map is based upon (eg) SNOMED CT version 20250701, released July 2025
externalMapSource
String
The version of the external product upon which the map is based (eg) Orphanet version July 2025
dependency
String
The external product version upon which this package is dependent
Indicates the reason that a concept has been made inactive.
Indicates the reason that a description has been made inactive.
components and reference set members, that are part of the same module, share the same moduleId value.
components and reference set members are part of only one module , at any given time.
The organization responsible for maintaining an extension must:
create and maintain at least one module identified by a moduleId that it has created;
apply a moduleId that it has created to all components and reference set members in its extension ;
manage and distribute information about the dependencies of its modules in accordance with SNOMED CT specifications.
The organization responsible for maintaining an extension may:
create and maintain multiple modules ;
organize its components and reference set members within the modules it manages in a way that best meets its business needs;
move a component or reference set member between its modules by creating a revised version of that component or reference set member with a different moduleId (It is then part of the new module from the effectiveTime of the revised version).
Components and reference set members may be moved between modules maintained by different organizations. However, such moves must only be made:
with the consent of the organizations responsible for both the source and target modules; and
in accordance with rules specified by SNOMED International.


Example: GB English
Section Reference Set Release Files Specification contains details of release files that customize and enhance SNOMED CT by representing:
Subsets of concepts and descriptions
Maps to other code systems
Language and dialect preferences for different terms
Annotation of components
Associations between components
Other forms of configuration and extensibility
A SNOMED CT International Release includes three distinct release types. Table 3.2-1 describes the release types and the differences between them.
SNOMED CT Release Types
Release type
Description
Full
A full release is a release type in which the release files contain every version of every component and reference set member ever released.
There are practical use cases for each Release Type.
The full release allows access to all versions of the release. This is valuable for reviewing data entered using earlier versions and more generally supporting change management.
The snapshot release only includes the latest version of each component. This can be useful to optimize access to the current version but does not provide access to earlier versions.
The delta release only includes changes made between one version and the next. This provides a simple way to identify new and changed components to support change management and can also be used to update the previous version of the full release to the new version of the full release. However, the delta release cannot be used as a stand alone resource.
When considering which release type to use, it is worth noting that delta and snapshot views can be readily generated from the full release type. For this reason organizations that maintain SNOMED CT extensions are required to provide the full release type, while distribution of the other release types are optional.
The final digit of the SCTID is a check-digit.
Users should be required to type SCTID values but in some case during design and development it may be necessary to copy or paste identifiers. The objective of the check-digit is to detect the commonest types of error that may occur due to typographical errors on those situations or in other cases where transcription or communication mechanisms may introduce error. Examples may include high-level development such as creating or modifying protocols or pre-specified queries.
An SCTID is checked by using the Verhoeff check, which is a Dihedral D 5 Check. This detects a higher proportion of common typographical errors than either the IBM or Modulus 11 check. Unlike the Modulus 11 check it is effective on decimal strings longer than ten-digits. Furthermore its value can always be represented as a decimal digit without excluding any values.
See Check-Digit Computation for detailed information about the Verhoeff check-digit algorithm and links to sample program code.
A live site to check a SNOMED CT Identifier can be found here -
This section outlines some of the features of concept definitions and the impact of different ways of representing concept definitions on the precision and completeness of those definitions. This section has been kept as brief as possible and is only intended to raise awareness of the changes. For those interested in understanding more about each of the topics mentioned, a more detailed appendix is provided which illustrates each of the points made in this section.
The first four columns in all release files are shown in Table 3.1.3-1. The next three sections of the specification explain the ways in which these fields are used to support identification, versioning and modularization.
Fields present in all release files
This Figure shows how SNOMED CT release files represent the logical model.
The following figure shows how SNOMED CT release files represent the logical model.
Release file representation of the logical model
The following examples conform to the SNOMED CT identifier specification and illustrate a range of possible Identifiers within different partitions and namespaces.
The release file naming convention specified in this section applies to all SNOMED International release files starting with the January 2010 International release. The release package naming convention specified was added subsequently to provide additional clarity through a structured name applied to the folder (and zip archive name) containing a set of release files. This package naming convention first applied to releases by SNOMED International during 2017.
These naming specifications provide the following benefits:
A consistent naming convention across the International edition and each National edition.
Predictable file naming, providing a stable structure for naming over time between releases.
As a stated view represented by axioms that conform to the OWL Functional Syntax distributed in the OWL Expression Reference Set file.
As an inferred view represented by defining relationships that are distributed in the relationship file. The inferred view is generated by applying description logic classification to the stated view.
Concept definitions include two distinct elements
Axioms that assert that a concept is a subtype of one or more other concepts. In the inferred view these are represented as subtype relationships.
Axioms that assert characteristics of a concept that distinguish it from its supertypes. In the inferred view these are represented as attribute relationships.
An Annotation Reference Set field containing additional information linked to a SNOMED CT component .
Note: Field name in SNOMED CT Release Format 2.
Annotation Reference Set (Deprecated)
id
SCTID
Uniquely identifies a component.
NO
YES (Full/Snapshot)
id
UUID
Uniquely identifies a reference set member.
NO
YES (Full/Snapshot)
effectiveTime
Time
Specifies the inclusive date at which this rows state became the then current valid state of the identified component or reference set member.
YES
YES (Full) Optional (Snapshot)
active
Boolean
Specifies whether the state of the component or reference set member was active or inactive from the nominal release date specified by the effectiveTime.
YES
NO
moduleId
SCTID
Identifies the module this component or reference set member is currently maintained in. Set to a child of 900000000000443000
|Module| within the metadata hierarchy.
YES
NO
Field
Data type
Purpose
Mutable
Part of Primary Key
5
The Item identifier digits 100 are the lowest permitted value. Therefore this is the lowest SctId that can be allocated to a concept.
100014
01= description, using short format
4
This is the lowest SctId that can be allocated to a description.
100022
02= relationship, using short format
2
This is the lowest SctId that can be allocated to a relationship.
1290023401004
00= concept, using short format
4
A valid SctId for a concept.
1290023401015
01= description, using short format
5
A valid SctId for a description.
9940000001029
02= relationship, using short format
9
A valid SctId for a relationship.
11000001102
10= concept, using long format
2
A valid long format SctId for a concept in the 1000001 namespace.
10989121108
10= concept, using long format
8
A valid long format SctId for a concept in the 0989121 namespace.
1290989121103
10= concept, using long format
3
A valid long format SctId for a concept in the 0989121 namespace.
1290000001117
11= description, using long format
7
A valid long format SctId for a description in the 0000001 namespace.
9940000001126
12= relationship, using long format
6
A valid long format SctId for a relationship in the 0000001 namespace.
999999990989121104
10= concept, using long format
4
The maximum valid SctId for a concept in the 0989121 namespace.
100005
00 = concept, using short format
A standard way to identify the source country and namespace of the organization responsible for a release file.
A consistent mechanism for representing version of release files and packages of release files.
An human readable way to identify the content of a file, at a summary level.
A mechanism for identifying the type of information stored in a release file (e.g. documentation, tooling, etc.).
Guidance on file naming for release files in non-English extensions.
Assurance that file names will be unique across the International release and releases from individual National release centers and across separate releases from each center over time.
Quality Assurance checks, performed during the International release process, ensure that this naming convention is enforced. Equivalent checks should also be performed as part of each National Release Center's release process.
Concepts
Each concept is represented by a row in the concept release file.
Descriptions
Each description is represented by a row in the description release file.
Stated Concept Definitions
Each stated concept definition is represented by a set of rows in the OWL axiom reference set file, which follows the format of an OWL Expression Reference Set. Each row contains an axiom that forms part of the definition of the concept identified by the referencedComponentId.
Notes:
As well as representing the definitions of individual concepts, the OWL axiom reference set represents characteristics of attributes including transitivity, reflexivity and property chains.
The OWL Ontology Reference Set also follows the OWL Expression Reference Set pattern. It contains general information about the terminology, which is required by a description logic classifier but is not subject to significant changes between release versions.
Change Note
This representation was introduced in July 2018 and, following a transitional period, now fully represents all stated concept definitions.

Snapshot
A snapshot release is a release type in which the release files contain only the most recent version of every component and reference set member released, as at the release date.
Delta
A delta release is a release type in which the release files contain only rows that represent component versions and reference set member versions created since the previous release date.
Notes
Each row in a delta release file represents either a new component or reference set member, or a change to an existing component or reference set member since the previous release date.
A delta release identifies differences between two versions of the same release package.
A delta release added to the previous full release is identical to the full release of the new version.
The previous release date, on which a delta release is based, is usually the date of the most recent previous release. However, that may not always be the case. For example, where interim releases are made between two major releases there may be a combined delta release covering a period since a previous major release.
Delta files have been removed from the SNOMED International release package, Managed Service Extensions and Derivative packages. However a Delta Generation Tool is available for those who need it. The Delta Generation Tool allows users to create their own Delta between two fixed release dates - you can find it here:
The Figure below shows how SNOMED CT release files prior to July 2018 represented the various elements in the logical model. The revised representation of these elements are shown on in Representation of the Logical Model.
Release file representation of the logical model (before update)
The , was used to represent the stated view of relationships prior to a transition process between July 2018 and July 2019. In July 2019 this file became obsolete and was completely replaced by two (the OWL axiom reference set file and the OWL ontology reference set file).
Figure 1 shows the associations between files that represent the stated and inferred views prior to the transition. It shows the associations between the release files that following these changes.
The stated relationship file is now obsolete as it has been completely replaced by two (the OWL axiom reference set file and the OWL ontology reference set file).
During the transitional period the stated relationship file continued to be distributed, but the OWL axiom reference set introduced advanced aspects to concept definitions which could not be represented in the stated relationship file.
In January 2012 the SNOMED International switched from the original Release Format (used for SNOMED CT distribution since 2002), to the more flexible and consistent Release Format 2 (RF2). This means that from that date onward the primary source data for the SNOMED CT International Release is maintained and distributed in the RF2 format.
The SNOMED International recognizes that, while implementers will which to benefit from the features of the new format, there is inevitably a transitional period during which both format are in use. Therefore, the SNOMED International provides the following resources to support users whose system do not yet support SNOMED CT Release Format 2:
Release Format 1 files will continue to be included in the International Release for a limited period
These files are not the authoritative version of SNOMED CT but are generated from the authoritative RF2 data using a software utility developed for this purpose.
The resulting RF1 data retains the functionality of the original release data but does not support any of the features of RF2. While all the clinically relevant SNOMED CT hierarchies are identical in both releases, the additional "Metadata Hierarchy" added as part of the RF2 upgrade is not included in the RF1 converted data. In addition there are some cases where Cross Maps
The "RF2 to RF1 Conversion Tool" and the "RF1 Compatibility Package" are available for Members and Affiliates to download in the same way as the SNOMED CT International Release.
SNOMED CT core release files include metadata concepts that represent each of the allocated namespace-identifiers.
A namespace concept has the following characteristics:
It is a subtype child of 370136006 |Namespace concept|
The fully specified name of the concept has the term
Extension Namespace {nnnnnnn}(namespace concept)
A synonym associated with each concept has the term
Extension Namespace {nnnnnnn}
Where appropriate further synonyms may be included to identify the nature of the responsible organization.
As the release file formats contain a number of concept enumerations, it is necessary to define sets of concepts that represent the allowed values. As well as the enumerated values, other metadata supporting the extensibility mechanism and the concept model is required.
The concept is a subtype of the root concept (138875005 |SNOMED CT Concept|), and contains the metadata, supporting the release.
The subtypes of |SNOMED CT Model Component (metadata)| are described in the following table and the top three levels of the hierarchy are shown in the figure below this.
SNOMED CT Model Component (metadata)
This section briefly outlines two distinct types of views of SNOMED CT concept definitions. More detailed illustrations of some of the points on this page are provided in .
SNOMED CT concepts are defined by assertions made by SNOMED CT authors. The concept definitions asserted by SNOMED CT authors are known as the stated view.
The stated view is a representation of concept definitions consisting only of assertions made or revised by SNOMED CT authors.
A description logic classifier can apply logical rules to the stated view to create inferences. The end result of this process is an inferred view of concept definitions.
The inferred view is a representation of concept definitions that is logically derived by applying a description logic classifier to the stated view.
The decision on whether you need access to the stated view and/or inferred view depends on your answers to the following questions.
The RF2 to RF1 Conversion Tool used for generating the RF1 files is also available to all Members and Affiliate Licensees
The "RF2 Conversion Tool" is an open source, Java-based, software tool to facilitate the conversion of SNOMED CT files released in RF2 format into RF1 format. The tool provides both a command line utility and a Graphical User Interface (GUI) to facilitate configuration, progress tracking and the maintenance of additional data whenever it is not available as part of an RF2 release.
The limitations of RF2 to RF1 conversion (noted above) will also apply to conversion undertaken using this tool. To enable the conversion to be completed successfully in a way that retains and replaces Identifiers consistently for the RF1 environment a set of auxiliary files (the "RF1 Compatibility Package") is also required.
Concepts
Each concept is represented by a row in the concept release file.
Descriptions
Each description is represented by a row in the description release file.
Stated Concept Definitions
Each stated concept definition is represented by a set of rows in the stated relationship release file. Each row in the set that set defines a concept, represents a defining relationship with another concept. The definitionStatusId column in the concept file row indicates whether the set of defining relationships is sufficient to define the concept.The stated relationship file has the same format as the relationship file.
Inferred Concept Definitions
Each inferred concept definition is represented by a set of rows in the relationship release file. Each row in the set that set defines a concept, represents a defining relationship with another concept. The definitionStatusId column in the concept file row indicates whether the set of defining relationships is sufficient to define the concept.
Other Related Information
Represented by a range of reference set release files that conform to the extensible reference set file format. Each row in a reference set refers to a concept or description as a member of the set. The extensible structure allows different types of related information to be associated with the referenced component.


106237007
|Linkage concept (linkage concept)|
Concepts that specify
Semantic Relationships between concepts (246061005 |Attribute|); and
Asserted associations between statements in a record (416698001 |Link assertion|).
370136006
|Namespace concept (namespace concept)|
Concepts that specify the Extension Namespaces allocated by the SNOMED International.
900000000000442005
|Core metadata concept (core metadata concept)|
Concepts that are referenced from enumerated fields within the International Release files (the Concept, Description, Relationship, Identifier).
SNOMED CT Metadata Hierarchy (2018-01-31) - Core metadata concepts (top 3 levels only)
900000000000441003 |SNOMED CT Model Component| 900000000000442005 |Core metadata concept| 900000000000447004 |Case significance| 900000000000448009 |Case insensitive| 900000000000017005 |Case sensitive| 900000000000020002 |Initial character case insensitive| 900000000000449001 |Characteristic type| 900000000000227009 |Additional relationship| 900000000000006009 |Defining relationship| 900000000000225001 |Qualifying relationship| 900000000000444006 |Definition status| 900000000000073002 |Defined| 900000000000074008 |Primitive| 900000000000446008 |Description type| 900000000000550004 |Definition| 900000000000003001 |Fully specified name| 900000000000013009 |Synonym| 900000000000453004 |Identifier scheme| 900000000000294009 |SNOMED CT integer ID| 900000000000002006 |SNOMED CT UUID| 900000000000450001 |Modifier| 900000000000452009 |All| 900000000000451002 |Some| 900000000000443000 |Module| 900000000000445007 |IHTSDO maintained module| 466707005 |SNOMED CT Medical Devices module| 900000000000454005 |Foundation metadata concept| ... (see next table)
SNOMED CT Metadata Hierarchy (2018-01-31) - Foundation metadata concepts (top 3 levels only - some long lists replaced by ...)
900000000000441003 |SNOMED CT Model Component| 900000000000442005 |Core metadata concept| ... (see previous table) 900000000000454005 |Foundation metadata concept| 900000000000455006 |Reference set| 900000000000516008 |Annotation type| 900000000000521006 |Association type| 900000000000480006 |Attribute value type| 705109006 |Code to expression type reference set| 447250001 |Complex map type reference set| 609430003 |Concept model reference set| 900000000000538005 |Description format| 733614007 |Expansion history reference set| 609331003 |Extended map type reference set| 733613001 |Intensional definition reference set| 900000000000506000 |Language type| 705111002 |Map correlation and origin type reference set| 900000000000534007 |Module dependency| 723564002 |MRCM reference set| 733618005 |Ordered association type reference set| 733619002 |Ordered component type reference set| 447258008 |Ordered type reference set| 900000000000512005 |Query specification type| 900000000000456007 |Reference set descriptor| 900000000000496009 |Simple map| 446609009 |Simple type reference set| 900000000000457003 |Reference set attribute| 447257003 |"Linked to" reference set attribute| 900000000000511003 |Acceptability| ... 723569007 |Template| 106237007 |Linkage concept| 246061005 |Attribute| 410663007 |Concept history attribute| 410662002 |Concept model attribute| 116680003 |Is a| 408739003 |Unapproved attribute| 416698001 |Link assertion| 417151001 |Has explanation| ... 416872009 |Is etiology for| 417318003 |Is manifestation of| 370136006 |Namespace concept| 373872000 |Core Namespace| 370137002 |Extension Namespace 1000000| ... 713754005 |Extension Namespace 1000999|
Inferred Concept Definitions
Each inferred concept definition is represented by a set of rows in the relationship release file. Each row in the set that defines a concept, represents a necessary, defining relationship with another concept. The definitionStatusId column in the concept file row indicates whether the set of defining relationships is sufficient to define the concept.
Other Related Information
Represented by a range of reference set release files that conform to the extensible reference set file format.
Each row in a reference set refers to a concept or description as a member of the set.The extensible structure allows different types of related information to be associated with the referenced component.
A 900000000000512005 | Query specification type reference set| allows a serialised query to represent the membership of a subset of SNOMED CT components. A query contained in the reference set is run against the content of SNOMED CT to produce a subset of concepts, descriptions or relationships. The query is referred to an intensional definition of the subset. It can be run against future releases of SNOMED CT to generate an updated set of subset members.
The members of the resulting subset may also be represented in an enumerated form as a Simple reference set. An enumerated representation of a subset is referred to as an extensional definition.
A Query Specification Reference Set is a String reference set containing query that represent intensional definitions of subsets of components. The result of running the query is an extensional representation of the subset of components which can be represented as a Simple Reference Set. Its structure is shown in the following table.
Query specification reference set - Data structure
The following metadata in the "Foundation metadata concept " hierarchy supports this reference set :
Hierarchy of Foundation metadata concept
The table below shows the descriptor that defines the structure of the pattern.
Descriptor Template for Query Specification Reference Sets
In the example below, "serialised query 1" is a text string that can be used to generate members for Reference set 1 , which is a simple member reference set (without any additional fields within its member records).
Example rows from Query Specification Reference Set
See for details of the language used to specify intensional definitions of concept subsets.
A provides a standardized way to represent postcoordinated expressions. This representation is useful for the implementation of a postcoordinated expression repository.
A is a type of .
Postcoordinated expression type reference set reference set - Data structure
900000000000454005
|Foundation metadata concept (foundation metadata concept)|
The metadata that supports the extensibility mechanism, and is discussed in more detail in the Reference Sets Guide.
762947003
|OWL metadata concept (OWL metadata concept)|
The OWL metadata concept has subtypes that are used in the OWL reference sets to provide a referencedComponent for some of the definitions or axioms that are required.
Boolean
The state of the identified reference set member as at the specified effectiveTime. If active = 1 (true) the reference set member is part of the current version of the set, if active = 0 (false) the reference set member is not part of the current version of the set.
YES
NO
moduleId
SCTID
Identifies the SNOMED CT module that contains this reference set member as at the specified effectiveTime .
The value must be a subtype of within the metadata hierarchy.
YES
NO
refsetId
SCTID
Identifies the reference set to which this reference set member belongs.
A subtype descendant of:
NO
NO
referencedComponentId
SCTID
A reference to the SNOMED CT component to be included in the reference set.
NO
NO
query
String
The serialised query that can be used to (re-)generate the reference set members.
The syntax for specifying the intensional definitions of concept subsets is specified in the
YES
NO
1
id
UUID
A 128 bit unsigned Integer, uniquely identifying this reference set member.Different versions of a reference set member share the same id but have different effectiveTime. This allows a reference set member to be modified or made inactive (i.e. removed from the active set) at a specified time.
NO
YES (Full/Snapshot)
effectiveTime
Time
The inclusive date or time at which this version of the identified reference set member became the current version.
Note : In distribution files the effectiveTime should follow the short ISO date format (YYYYMM DD) and should not include the hours, minutes, seconds or timezone indicator.The current version of this reference set member at time T is the version with the most recent effectiveTime prior to or equal to time T.
YES
YES (Full) Optional (Snapshot)
|Target reference set|
active
0
id
UUID
A 128 bit unsigned Integer, uniquely identifying this reference set member.
Different versions of a reference set member share the same id but have different effectiveTime. This allows a reference set member to be modified or made inactive (i.e. removed from the active set) at a specified time.
NO
YES (Full /Snapshot)
effectiveTime
Time
The inclusive date or time at which this version of the identified reference set member became the current version.
Note: In distribution files the effectiveTime should follow the short ISO date format (YYYYMMDD) and should not include the hours, minutes, seconds or timezone indicator.
The current version of this reference set member at time T is the version with the most recent effectiveTime prior to or equal to time T.
YES
YES (Full)
Optional (Snapshot)
The following metadata hierarchy supports this reference set:
Postcoordinated expression type reference set reference set in the Metadata Hierarchy
900000000000454005 |Foundation metadata concept| 900000000000455006 |Reference set| 1119417006 |Postcoordinated expression type reference set|
The tables below show the descriptor that defines the reference sets that follows the data structure of the |Postcoordinated expression type reference set (foundation metadata concept)| .
Refset Descriptor rows for the postcoordinated expression type reference set.
The International Edition of SNOMED CT includes two different types of the |Postcoordinated expression type reference set| . These are the |Canonical close to user form expression reference set (foundation metadata concept)| and |Classifiable form expression reference set (foundation metadata concept)| . Both of these reference sets provide a standardized way of representing different types of SNOMED CT expressions, and are useful for the implementation of a postcoordinated expression repository.
The |Canonical close to user form expression reference set (foundation metadata concept)| provides a standardized way to represent postcoordinated expressions as they were captured by the users, but in a canonical form. The 1119468009 | Classifiable form expression reference set (foundation metadata concept)| provides a standardized way to represent postcoordinated expressions in a classifiable form. The classifiable form is a syntactically valid and concept model compliant representation of the close-to-user form expression, and serves as the input to the classifier, enabling compositional expressions to be classified with SNOMED CT content.
active
Boolean
The state of the identified reference set member as at the specified effectiveTime .
If active = 1 (true) the reference set member is part of the current version of the set, if active = 0 (false) the reference set member is not part of the current version of the set.
YES
NO
moduleId
SCTID
Identifies the SNOMED CT module that contains this reference set member as at the specified effectiveTime.
The value must be a subtype of 900000000000443000 |Module (core metadata concept)| within the metadata hierarchy.
YES
NO
refsetId
SCTID
Identifies the reference set to which this reference set member belongs.
In this case, a subtype descendant of: 900000000000455006| Reference set|
NO
NO
referencedComponentId
SCTID
A reference to the SNOMED CT component to be included in the reference set.
NO
NO
expression
String
A SNOMED CT expression that conforms to the compositional grammar.
YES
NO
substrate
Uniform Resource Identifier
The SNOMED CT content by which the expression is authored.
YES
NO
0
1
2
The logical model of associations between the components in the release files is shown in the Figure below The component class represents columns present in all three component files. The individual classes (description, concept and relationship) only show the additional columns present in those files. The colored lines between descriptions and concepts and between relationships and concepts represent the link between the foreign keys (shown in bold) and the id of the concept. These provide the functional connections between components described in this document. The grey lines indicate additional links between columns that are populated with concept identifiers that provide enumerated values.
The below Figure provides an extended view of the associations between release files following changes complete in July 2019 release of SNOMED CT. These changes enable SNOMED CT to use enhanced description logic features and resulted in a significant change to the way in which the stated view of concept definitions are represented. However the changes did not significantly affect the structure and associations between the main component files shown in the Figure above.
The following diagram provides an extended view of the associations between release files following changes complete in July 2019 release of SNOMED CT . These changes enable SNOMED CT to use enhanced description logic features and resulted in a significant change to the way in which the stated view of concept definitions are represented. However, the changes did not significantly affect the structure and associations between the main component files shown in the diagram above.
Each concept is represented by a row in the Concept and the concept is identified by the id column in that row. There can be more than one row with the same id but with different effectiveTime values, in which case each of these rows represents a version of that same concept. Thus each row represents a version of a clinical concept.
Each concept has two or more descriptions associated with it:
At least one Fully Specified Name; and
At least one synonym.
Each description is represented by a row in the description file and is identified by the id column in that row. There can be more than one row with the same id but with different effectiveTime values, in which case each of these rows represents a version of that same description. Thus each row represents a version of a description. Each description applies to one concept to which it is linked by the conceptId. All versions of a description must relate to exactly the same identified concept (i.e. the conceptId must not change between versions).
Each relationship, from a source concept to a destination concept, is represented by a row in the relationship file. There can be more than one row with the same id but with different effectiveTime values, in which case each of these rows represents a version of that same relationship. Thus each row represents a version of a relationship. The source, destination and type each relationship are identified respectively by the sourceId, destinationId and typeId columns. All versions of a relationship must have the same sourceId, destinationId and typeId. The typeId refers to concept, that is also held within the concept file. The only concepts that can be used as the relationship typeId are or concepts that are subtypes of .
The most basic form of relationship is the |is a| relationship. This relationship states that one concept is a subtype of another concept. Each subtype concept is connected to its parent subtype(s) by relationships with the typeId 116680003 |is a| and this form the main SNOMED CT hierarchy. In this hierarchy, a child concept may have more than one parent concept. The root of the hierarchy is , which has a set of top level children, each forming its own sub-hierarchy.Relationships with typeid values that are subtypes of |Concept model attribute| are referred to as attribute relationship and contribute to the formal definition of the source concept.
The includes a check-digit, which is generated using Verhoeff's dihedral check. This section explains the algorithm used and includes sample source code for generating and checking the check-digit in Java Script and Microsoft Visual Basic.
The mathematical description of this technique may appear complex but in practice it can be reduced to a pair of two-dimensional arrays, a single dimensional inverse array and a simple computational procedure. These three arrays are shown in the following tables.
The first array contains the result of "Dihedral D5" multiplication;
The second array consists of 8 rows of which two are defined while the rest are derived by applying the following formula: F(i, j) = F(i - 1, F(1, j)) ;
The Description holds descriptionsthat describe SNOMED CT concepts. A description is used to give meaning to a concept and provide well-understood and standard ways of referring to a concept.
Description file - Detailed Specification
The third array consists of a single row containing the inverse of the Dihedral D5 array it identifies the location of all the zero values in the first array.
Table 6.4.2-1: Results of Dihedral D5 multiplication
Table 6.4.2-2: The full array for Function F
Table 6.4.2-3: The Inverse D5 array
The identifier is checked by starting at the rightmost digit of the identifier (the check-digit itself) and proceeding to the left processing each digit as follows:
Check = ArrayDihedralD5 ( Check, ArrayFunctionF(( Position Modulus 8), Digit ))
Check = the running value of the check-sum (starts at zero and modified by each step).
Position = the position of the digit (counted from the right starting at zero).
Digit = the value of the digit.
The final value of Check should be zero. Otherwise the check has failed.
When calculating the check-digit the same process is applied with a minor variation:
Position is the position that the digit will have when the check-digit has been appended.
The final value of Check is applied to the Inverse D5 array to find the correct check-digit.
Check-digit= ArrayInverseD5 ( Check ).
Although a user should rarely type the SCTID, experience suggests that from time to time this will happen. A user may also copy and paste an SCTID. There is a significant risk of errors in these processes and inclusion of a check-digit is intended to reduce the risk of such errors passing undetected. The choice of check-digit algorithm has been made to maximize the detection of common typographical errors. These have been analyzed by in a paper by J. Verhoeff ("Error Detecting Decimal Codes", Mathematical Center Tract 29 , The Mathematical Center, Amsterdam, 1969) and subsequently cited in Wagner and Putter, ("Error Detecting Decimal Digits", CACM , Vol 32, No. 1, January 1989). These papers give a detailed categorization of the sorts of errors humans make in dealing with decimal numbers, based on a study of 12000 errors:
single errors: a becomes b (60% to 95% of all errors).
omitting or adding a digit (10% to 20%).
adjacent transpositions: ab becomes ba (10% to 20%).
twin errors: aa becomes bb (0.5% to 1.5%).
jump transpositions: acb becomes bca (0.5% to 1.5%).
jump twin errors: aca becomes bcb (below 1%).
phonetic errors: a0 becomes 1a -similar pronunciation e.g. thirty or thirteen (0.5% to 1.5%).
In the explanations above, a is not equal to b, but c can be any decimal digit.
The check-sums used for credit cards (the IBM check) picks up the most common errors but miss some adjacent transpositions and many jump transpositions. Assuming the pattern of errors described above, on average it will miss between 4% and 5% of expected errors.
The ISBN modulus 11 (used for UK NHS number) picks up more errors than the IBM checksum. Leaving 2% to 3% of errors undetected. However, it generates a check-sum value of 0 to 10 and thus cannot be represented as a single check-digit in about 9% of cases. The ISBN convention is to use "X" to represent the check-digit value 10 but this is incompatible with an Integer representation. The UK NHS number uses this check-sum but regards and number generating a check-sum of 10 as an invalid identifier. This approach could be applied to the SCTID but this would render 9% of possible values unusable in each partition and namespace. This would prevent a simple sequence of values from being allocated as the item identifier within any namespace. More significantly the unusable item identifier would differ in each namespace or partition and this would prevent simple transpositions of item identifiers between partitions and namespaces.
Partitions could be a useful way of distinguishing developmental and released components and revising the partition and recalculating the check-digit would then be an elegant way to activate these components for a distribution version. It seems unwise to prevent future development and maintenance by using a check-sum that will prevent this.
Verhoeff's check catches all single errors, all adjacent transpositions, over 95% of twin errors, over 94% of jump transpositions and jump twin errors, and most phonetic errors. Therefore, like modulus 11, the Verhoeff check reduces the undetected error rate to 2% or 3%. Unlike modulus 11, it does this using a single decimal check-digit and without limiting the range of valid numbers.
The majority of the undetected errors with both modulus 11 and Verhoeff result from additions or omissions of digits. Any check-digit method is likely to miss 10% of such errors and since these comprise 10% to 20%. The Verhoeff scheme also misses four jump twin errors involving digits with a difference of 5 (i.e. 050 vs. 505, 161 vs. 616, 272 vs. 727, and 494 vs. 949).
id
SCTID
Uniquely identifies the description.
NO
YES (Full/Snapshot)
effectiveTime
Time
Specifies the inclusive date at which the component version's state became the then current valid state of the component
Note : In distribution files the effectiveTime should follow the short ISO date format (YYYYMM DD) and should not include the hours, minutes, seconds or timezone indicator.
YES
YES
(Full)
Optional (Snapshot)
active
Boolean
Specifies whether the state of the description was active or inactive from the nominal release date specified by the effectiveTime .
YES
NO
moduleId
SCTID
Identifies the description version's module. Set to a child of within the metadata hierarchy.
YES
NO
conceptId
SCTID
Identifies the concept to which this description applies. Set to the identifier of a concept in the |SNOMED CT Concept| hierarchy within the Concept. Note that a specific version of a description is not directly bound to a specific version of the concept to which it applies. Which version of a description applies to a concept depends on its effectiveTime and the point in time at which it is accessed.
NO
NO
languageCode
String
Specifies the language of the description text using the two character ISO-639-1 code. Note that this specifies a language level only, not a dialect or country code.
NO
NO
typeId
SCTID
Identifies whether the description is fully specified name a synonym or other description type. This field is set to a child of in the Metadata hierarchy.
NO
NO
term
String
The description version's text value, represented in UTF-8 encoding
YES
NO
caseSignificanceId
SCTID
Identifies the concept enumeration value that represents the case significance of this description version. For example, the term may be completely case sensitive, case insensitive or initial letter case insensitive. This field will be set to a child of within the metadata hierarchy.
YES
NO
Only one description record with the same id field will be current at any point in time. The current record will be the one with the most recent effectiveTime before or equal to the point in time under consideration.
If the active field of this record is false ('0'), then the description is inactive at that point in time. If the activefield is true ('1'), then the description is associated with the concept identified by the conceptId field.
The conceptId field, the languageCode field and the typeId field will not change between two rows with the same id, in other words they are immutable. Where a change is required to one of these fields, then the component will be inactivated (by appending a row with the same id and the active field set to false) and a another row will be added representing a new component with a new id. Only limited changes may be made to the term field, as defined by editorial rules.
Each concept will have at least one active description with a typeId of |synonym| and at least one active description with a typeId of |Fully specified name|.
Where a concept only has one active description with a typeId of |Fully specified name| across all language codes within a release, then that Description can be taken as the Fully Specified Name for all languages and dialects, and need not be explicitly included in every language reference set associated with that release.
The term field will be restricted as follows:
to an overall maximum length of 32Kb;
to a maximum length, configurable for each description type as defined in the 900000000000538005 | Description format reference set| member associated with that description type- see the Description Format Reference Set specifications document for more details.
The Description Format Reference Set also defined the format of the term field (plain text, limited HTML, XHTML) for each description type.
Control characters (including TABs, CRs and LFs) will not appear in 900000000000540000 | Plain text| or format types.


The is a reference set that is used to specify the format of all reference sets included in a release. The data type and meaning of the referenced component and each additional field within each reference set is described by this reference set .
Reference set descriptor can be used to define
The order of appearance of additional attributes (other than those mandatory for all reference sets);
The name and purpose of the additional attributes;
An allows a value from a specified range to be associated with a component. This type of reference set can be used for a range of purposes where there is a requirement to provide additional information about particular concepts, descriptions or relationships. For example, an |Attribute value type reference set| is used to indicate the reason why a concept has been inactivated.
An Attribute value reference set is a component reference set used to apply a tagged value to a SNOMED CT component. Its structure is shown in the following table.
Attribute Value Reference Set - Data Structure
A supports the representation of language and dialects preferences for the use of particular descriptions. The most common use case for this type of reference set is to specify the acceptable and preferred terms for use within a particular country or region. However, the same type of reference set can also be used to represent preferences for use of descriptions in a more specific context such as a clinical specialty, organization or department.
A Language reference set is a Component reference set that is used to indicate which descriptions contain terms that are acceptable or preferred in a particular language or dialect. Its structure is shown in the following table.
Reference Set Types in the Metadata Hierarchy (2018-01-31)
A supports the representation of simple maps from values in other code systems to SNOMED CT concepts. No constraints are put on the number of SNOMED CT concepts mapping to by a particular code. However, this type of reference set is usually only appropriate where there is a close "one-to-one" mapping between the coded values in another code system and SNOMED CT concepts.
A is a String Reference Set used to represent maps from codes in another terminology, classification or code system to SNOMED CT concepts. Its structure is shown in the following table.
Simple map to SNOMED CT reference set - Data structure



<style>
p.p1 {
margin: 0.0px 0.0px 0.0px 0.0px;
font: 12.0px Helvetica
}
span.s1 {
color: #021da7
}
span.s2 {
color: #f9975e
}
span.s3 {
color: #ff9450
}
span.s4 {
color: #ab4500
}
span.s5 {
color: #a7a400
}
table {
border-width: 6px;
border-color: #0080ff;
border-collapse: collapse;
border-style: ridge;
}
td {
border-width: 3px;
border-color: #0080ff;
border-collapse: collapse;
padding: 6px;
border-style: ridge;
}
</style>
<form action="" name="form">
<table width="441">
<tr>
<td width="212" height="25"> Partial Identifier <br />(without check-digit)
</td>
<td width="115" height="25">
<input name="num" size="18" />
</td>
<td width="92" height="25">
<input onclick="VerhoeffCompute()" type="button" value="Compute" />
</td>
</tr>
<tr>
<td width="212" height="35"> SNOMED CT Identifier </td>
<td width="115" height="35"> <input name="numcd" size="18" />
</td>
<td width="92" height="35"> <input onclick="VerhoeffCheck()" type="button" value="Check" />
</td>
</tr>
<tr>
<td width="212" height="23"> Result of check </td>
<td width="115" height="23" colspan="2" id="out"> </td>
</tr>
<tr>
<td width="212" height="23"> Component type </td>
<td width="115" height="23" colspan="2" id="component"> </td>
</tr>
<tr>
<td width="212" height="23"> Namespace </td>
<td width="115" height="23" colspan="2" id="extnamespace"> </td>
</tr>
</table>
<p style="margin-left: 0; margin-right: 0"> This Verhoeff checking part of this code was based on a webpage at: </p>
<ul>
<li>
<a href="http://www.augustana.ab.ca/~mohrj/algorithms/checkdigit.html">
http://www.augustana.ab.ca/~mohrj/algorithms/checkdigit.html </a>
</li>
</ul>
</form>var FnF = new Array();
FnF[0] = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9];
FnF[1] = [1, 5, 7, 6, 2, 8, 3, 0, 9, 4];
for (var i = 2; i < 8; i++) {
FnF[i] = [, , , , , , , , ,];
for (var j = 0; j < 10; j++)
FnF[i][j] = FnF[i - 1][FnF[1][j]];
}
var Dihedral = new Array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9], [1, 2, 3, 4, 0, 6, 7, 8, 9, 5], [2, 3, 4, 0, 1, 7, 8, 9, 5, 6], [3, 4, 0, 1, 2, 8, 9, 5, 6, 7], [4, 0, 1, 2, 3, 9, 5, 6, 7, 8], [5, 9, 8, 7, 6, 0, 4, 3, 2, 1], [6, 5, 9, 8, 7, 1, 0, 4, 3, 2], [7, 6, 5, 9, 8, 2, 1, 0, 4, 3], [8, 7, 6, 5, 9, 3, 2, 1, 0, 4], [9, 8, 7, 6, 5, 4, 3, 2, 1, 0]);
var InverseD5 = new Array(0, 4, 3, 2, 1, 5, 6, 7, 8, 9);
function VerhoeffCheck() {
var check = 0;
var IdValue = document.form.numcd.value;
document.getElementById("out").innerText = "";
document.getElementById("out").setAttribute("style", "color:red;");
document.getElementById("component").innerText = "Invalid partition";
document.getElementById("component").setAttribute("style", "color:green;");
document.getElementById("extnamespace").innerText = "No namespace";
document.getElementById("extnamespace").setAttribute("style", "color:red;");
for (var i = IdValue.length - 1; i >= 0; i--)
check = Dihedral[check][FnF[(IdValue.length - i - 1) % 8][IdValue.charAt(i)]];
if (check != 0) { document.getElementById("out").innerText = "Check-digit ERROR"; }
else if (IdValue.length < 6) { document.getElementById("out").innerText = "SCTID too short"; }
else if (IdValue.length > 18) { document.getElementById("out").innerText = "SCTID too long"; }
else {
document.getElementById("out").innerText = "Check-digit OK";
document.getElementById("out").setAttribute("style", "color:green;");
switch (IdValue.substr(IdValue.length - 3, 2)) {
case "00":
document.getElementById("component").innerText = "Concept"; document.getElementById("extnamespace").innerText = "International";
break;
case "01":
document.getElementById("component").innerText = "Description";
document.getElementById("extnamespace").innerText = "International";
break;
case "02":
document.getElementById("component").innerText = "Relationship";
document.getElementById("extnamespace").innerText = "International";
break;
case "03":
document.getElementById("component").innerText = "Subset (RF1)";
document.getElementById("extnamespace").innerText = "International";
break;
case "04":
document.getElementById("component").innerText = "Cross Map Set (RF1)";
document.getElementById("extnamespace").innerText = "International";
break;
case "05":
document.getElementById("component").innerText = "Cross Map Target (RF1)";
document.getElementById("extnamespace").innerText = "International";
break;
case "10":
document.getElementById("component").innerText = "Concept"; document.getElementById("extnamespace").innerText = IdValue.substr(IdValue.length - 10, 7);
break;
case "11":
document.getElementById("component").innerText = "Description";
document.getElementById("extnamespace").innerText = IdValue.substr(IdValue.length - 10, 7);
break;
case "12":
document.getElementById("component").innerText = "Relationship";
document.getElementById("extnamespace").innerText = IdValue.substr(IdValue.length - 10, 7);
break;
case "13":
document.getElementById("component").innerText = "Subset (RF1)";
document.getElementById("extnamespace").innerText = IdValue.substr(IdValue.length - 10, 7);
break;
case "14":
document.getElementById("component").innerText = "Cross Map Set (RF1)";
document.getElementById("extnamespace").innerText = IdValue.substr(IdValue.length - 10, 7);
break;
case "15":
document.getElementById("component").innerText = "Cross Map Target (RF1)";
document.getElementById("extnamespace").innerText = IdValue.substr(IdValue.length - 10, 7);
break;
default:
document.getElementById("component").setAttribute("style", "color:red;");
}
if (document.getElementById("extnamespace").innerText == 'International') { document.getElementById("extnamespace").setAttribute("style", "color:green;"); } else if (IdValue.length > 10) { document.getElementById("extnamespace").setAttribute("style", "color:green;"); } else {
document.getElementById("extnamespace").innerText = "Invalid Namespace";
}
}
}
function VerhoeffCompute() {
var IdValue = document.form.num.value; var check = 0;
document.form.numcd.value = "";
for (var i = IdValue.length - 1; i >= 0; i--)
check = Dihedral[check][FnF[(IdValue.length - i) % 8][IdValue.charAt(i)]];
document.form.numcd.value = document.form.num.value + InverseD5[check];
VerhoeffCheck();
document.getElementById("out").innerText = "Computed check-digit";
}This allows for a reference set to be validated using the metadata embedded within the reference set descriptor in the following ways:
the data type of its attributes may be validated against the data type declared in the reference set descriptor;
the column order can be checked against the reference set descriptor.
The Reference set descriptor reference set is a Component - Component - Integer reference set that specifies the structure of reference sets. Its structure is shown in the following table.
id
UUID
A 128 bit unsigned Integer, uniquely identifying this reference set member.
Different versions of a reference set member share the same id but have different effectiveTime. This allows a reference set member to be modified or made inactive (i.e. removed from the active set) at a specified time.
NO
At least one row must exist for each reference set included in a release. This row must have an attributeOrder value of '0' and an attributeType of ' component type' (or one of its descendants). The referencedComponentId identifies the reference set defined by the descriptor.
There is one additional row for each additional column present in the specified reference set .
Creation of Reference set descriptor data is mandatory when creating a new reference set in the International Release or in a National Extension.
Creation of a Reference set descriptor is optional when creating a reference set in another Extension. If a descriptor is not created, the descriptor of the closest ancestor of the reference set is used when validating reference set member records.
The following metadata in the |Foundation metadata concept| hierarchy supports the reference set descriptor reference set.
The Reference Set Descriptor Reference Set is specified by the 900000000000456007 |Reference set descriptor| concept in the metadata hierarchy.
900000000000441003 | SNOMED CT Model Component| 900000000000454005 | Foundation metadata concept| 900000000000455006 | Reference set| 900000000000456007 | Reference set descriptor|
Values in the Reference Set are populated from:
The table below shows the descriptor that defines the structure of the 900000000000456007 |Reference set descriptor| . Note that this descriptor is itself part of the 900000000000456007 |Reference set descriptor| that it describes!
id
UUID
A 128 bit unsigned Integer, uniquely identifying this reference set member.Different versions of a reference set member share the same id but have different effectiveTime. This allows a reference set member to be modified or made inactive (i.e. removed from the active set) at a specified time.
NO
YES (Full/Snapshot)
effectiveTime
Time
The inclusive date or time at which this version of the identified reference set member became the current version.
Note : In distribution files the effectiveTime should follow the short ISO date format (YYYYMM DD) and should not include the hours, minutes, seconds or timezone indicator.The current version of this reference set member at time T is the version with the most recent effectiveTime prior to or equal to time T.
YES
YES (Full) Optional (Snapshot)
The metadata concepts shown below are examples of concepts that identify attribute value reference sets.
Attribute Value Reference Sets in the Metadata Hierarchy
900000000000454005 |Foundation metadata concept| 900000000000455006 |Reference set| 900000000000480006 |Attribute value type| 900000000000489007 |Concept inactivation indicator reference set| 900000000000490003 |Description inactivation indicator reference set| 900000000000547002 |Relationship inactivation indicator reference set| < Not currently used
Concept Inactivation Values (with usage notes referring to the International Release)
900000000001043018 |Concept inactivation value| 723277005 |Nonconformance to editorial policy component| < New introduced 2017-07-31 900000000000482003 |Duplicate| 900000000000483008 |Outdated| 900000000000484002 |Ambiguous| 900000000000485001 |Erroneous| 900000000000486000 |Limited| 900000000000487009 |Moved elsewhere| 900000000000492006 |Pending move| < NEVER used for descriptions in the International Release - may have been used in extensions
Description Inactivation Values (with usage notes referring to the International Release)
900000000001077011 |Description inactivation value| 723277005 |Nonconformance to editorial policy component| < New introduced 2017-07-31 723278000 |Not semantically equivalent component| < New introduced 2017-07-31 900000000000483008 |Outdated| 900000000000485001 |Erroneous| 900000000000495008 |Concept non-current| 900000000000486000 |Limited| < NOT used for description inactivations after 2010-07-31 900000000000487009 |Moved elsewhere| < NOT used for description inactivations before 2016-07-31 or after 2017-07-31 900000000000482003 |Duplicate| < NOT used for description inactivations before 2016-07-31 or after 2017-07-31 900000000000494007 |Inappropriate| < NOT used for description inactivations before 2008-07-31 or after 2017-07-31 900000000000492006 |Pending move| < NEVER used for descriptions in the International Release - may have been used in extensions
The tables below show the descriptors that define examples of reference sets that follow the |Attribute value type reference set| pattern.
Refset Descriptor Rows for the Concept Inactivation Indicator Reference Set
Refset Descriptor Rows for the Description Inactivation Indicator Reference Set
Sample Rows from the Concept Inactivation Indicator Reference Set
id
UUID
A 128 bit unsigned Integer, uniquely identifying this reference set member.
Different versions of a reference set member share the same id but have different effectiveTime. This allows a reference set member to be modified or made inactive (i.e. removed from the active set) at a specified time.
NO
YES (Full /Snapshot)
effectiveTime
Time
The inclusive date or time at which this version of the identified reference set member became the current version.
Note: In distribution files the effectiveTime should follow the short ISO date format (YYYYMMDD) and should not include the hours, minutes, seconds or timezone indicator.
The current version of this reference set member at time T is the version with the most recent effectiveTime prior to or equal to time T.
YES
YES (Full)
Optional (Snapshot)
In a Language reference set:
No more than one description of a specific description type associated with a single concept may have the acceptabilityId value 900000000000548007 |Preferred| .
Every active concept should have one preferred synonym in each language.
This means that a language reference set should assign the acceptabilityId 900000000000548007 |Preferred| to one synonym (a description with typeId value 900000000000013009 | synonym| ) associated with each concept .
This description is the preferred term for that concept in the specified language or dialect.
Any description which is not referenced by an active row in the reference set is regarded as unacceptable (i.e. not a valid synonym in the language or dialect ).
If a description becomes unacceptable, the relevant language reference set member is inactivated by adding a new row with the same id, the effectiveTime of the change and the value active=0.
For this reason there is no requirement for an "unacceptable" value.
The following metadata supports this reference set :
Language References Sets in the Metadata Hierarchy
900000000000454005 |Foundation metadata concept| 900000000000506000 |Language type| 900000000000507009 |English| 900000000000508004 |GB English| 900000000000509007 |US English|
The immediate children of |Language type| will represent languages. This level may be used to represent the "formal approved" language, where a language authority is formally recognized. In most cases, this level will not identify a specific reference set. Subtype of the language level are used to represent different dialects, national or regional variants.
The table below shows an example of the descriptor for a specific reference sets that follows the |Language type reference set| pattern.
Refset Descriptor rows for a language reference set
Sample content from the US English language reference set
Sample content from the GB English language reference set
id
UUID
A 128 bit unsigned Integer, uniquely identifying this reference set member.
Different versions of a reference set member share the same id but have different effectiveTime. This allows a reference set member to be modified or made inactive (i.e. removed from the active set) at a specified time.
NO
YES (Full /Snapshot)
effectiveTime
Time
The inclusive date or time at which this version of the identified reference set member became the current version.
Note: In distribution files the effectiveTime should follow the short ISO date format (YYYYMMDD) and should not include the hours, minutes, seconds or timezone indicator.
The current version of this reference set member at time T is the version with the most recent effectiveTime prior to or equal to time T.
YES
YES (Full)
Optional (Snapshot)
The following metadata hierarchy supports this reference set:
Simple Map to SNOMED CT Reference Sets in the Metadata Hierarchy
900000000000454005 |Foundation metadata concept| 900000000000455006 |Reference set| 1187636009 |Simple map to SNOMED CT type reference set|
The tables below show the descriptors that define examples of reference sets that follow the 1187636009 |Simple map to SNOMED CT type reference set (foundation metadata concept)| pattern.
Refset Descriptor rows for Simple map to SNOMED CT type reference set
Sample Content from a Simple Map to SNOMED CT Reference Set
10078111
An allows attributes to be associated with a valid value range for a given SNOMED CT content type and rule strength. The range of each attribute is defined using an Expression Constraint. This expression constraint represents the set of concepts, expressions, or concrete values that may be used as the value of the given attribute. The also provides a summary of the concept model rule associated with each attribute (including all valid domains and the given range) using an Expression Constraint representation. This attribute rule can be completely auto-generated by combining information from the and the .
An is structured as shown in the following table.
A Component Annotation Refset will be created to support annotations on components (concepts, descriptions, relationships, etc) of SNOMED CT.
The SNOMED CT International Release contains Annotations content in two reference sets:
The Member Annotation String Value reference set, in which annotations are held on members of any reference set(s).
The Component Annotation String Value reference set, in which annotations are assigned to any SNOMED CT component.
A Component Annotation String Value reference set is structured as shown in the following table:
active
Boolean
The state of the identified reference set member as at the specified effectiveTime. If active = 1 (true) the reference set member is part of the current version of the set, if active = 0 (false) the reference set member is not part of the current version of the set.
YES
NO
moduleId
SCTID
Identifies the SNOMED CT module that contains this reference set member as at the specified effectiveTime .
The value must be a subtype of 900000000000443000 |Module (core metadata concept)| within the metadata hierarchy.
YES
NO
refsetId
SCTID
Identifies the reference set to which this reference set member belongs.
In this case, a subtype descendant of: 900000000000480006 |Attribute value type reference set|
NO
NO
referencedComponentId
SCTID
A reference to the SNOMED CT component to be included in the reference set.
NO
NO
valueId
SCTID
The tagged value applied to the referencedComponentId. A subtype of 900000000000491004 | Attribute value| .
YES
NO
0
1
0
1
active
Boolean
The state of the identified reference set member as at the specified effectiveTime .
If active = 1 (true) the reference set member is part of the current version of the set, if active = 0 (false) the reference set member is not part of the current version of the set.
YES
NO
moduleId
SCTID
Identifies the SNOMED CT module that contains this reference set member as at the specified effectiveTime.
The value must be a subtype of 900000000000443000 |Module (core metadata concept)| within the metadata hierarchy.
YES
NO
refsetId
SCTID
Identifies the reference set to which this reference set member belongs.
In this case, a subtype descendant of: 1187636009 |Simple map to SNOMED CT type reference set|
NO
NO
referencedComponentId
SCTID
A reference to the SNOMED CT component to be included in the reference set.
Refers to the SNOMED CT concept to which the mapSource is mapped (i.e. the map target).
NO
NO
mapSource
String
The equivalent code in the other terminology, classification or code system, from which the referencedComponentId is mapped.
YES
NO
0
1
10058899
10058683
10036000
10068719
active
Boolean
The state of the identified reference set member as at the specified effectiveTime .
If active = 1 (true) the reference set member is part of the current version of the set, if active = 0 (false) the reference set member is not part of the current version of the set.
YES
NO
moduleId
SCTID
Identifies the SNOMED CT module that contains this reference set member as at the specified effectiveTime.
The value must be a subtype of 900000000000443000 |Module (core metadata concept)| within the metadata hierarchy.
YES
NO
refsetId
SCTID
Identifies the reference set to which this reference set member belongs.
In this case, a subtype descendant of: 900000000000506000 |Language type|
NO
NO
referencedComponentId
SCTID
A reference to the SNOMED CT component to be included in the reference set. Refers to the description to which the acceptability value is being applied.
NO
NO
acceptabilityId
SCTID
A subtype of 900000000000511003 |Acceptability| indicating whether the description is acceptable or preferred for use in the specified language or dialect .
YES
NO
0
1
If the partition-identifier indicates a long format SCTID, the seven-digits immediately to the left of the partition-digit are a namespace-identifier. The namespace-identifier is an integer value, left padded with 0 s as necessary to ensure there are always seven digits in the value. The namespace-identifier does not hold meaning.
Each organization that is authorized to generate SCTID is allocated a namespace-identifier by the SNOMED International. Each allocated namespace is represented in the Namespace Concept metadata sub-hierarchy, released as part of the International release (see details in The Namespace hierarchy ).
YES (Full /Snapshot)
effectiveTime
Time
The inclusive date or time at which this version of the identified reference set member became the current version.
Note: In distribution files the effectiveTime should follow the short ISO date format (YYYYMMDD) and should not include the hours, minutes, seconds or timezone indicator.
The current version of this reference set member at time T is the version with the most recent effectiveTime prior to or equal to time T.
YES
YES (Full)
Optional (Snapshot)
active
Boolean
The state of the identified reference set member as at the specified effectiveTime .
If active = 1 (true) the reference set member is part of the current version of the set, if active = 0 (false) the reference set member is not part of the current version of the set.
YES
NO
moduleId
SCTID
Identifies the SNOMED CT module that contains this reference set member as at the specified effectiveTime.
The value must be a subtype of 900000000000443000 |Module (core metadata concept)| within the metadata hierarchy.
YES
NO
refsetId
SCTID
Identifies the reference set to which this reference set member belongs.
In this case, the refsetId is always 900000000000456007 |Reference set descriptor| as there is only one reference set of this type.
NO
NO
referencedComponentId
SCTID
A reference to the SNOMED CT component to be included in the reference set.
Refers to the concept that identifies the reference set (or reference set type) defined by this descriptor.
NO
NO
attributeDescription
SCTID
Specifies the name of an attribute that is used in the reference set to which this descriptor applies.
Set to a descendant of 900000000000457003 |Reference set attribute (foundation metadata concept)| in the metadata hierarchy, that describes the additional attribute extending the reference set .
NO
NO
attributeType
SCTID
Specifies the data type of this attribute in the reference set to which this descriptor applies.
Set to a descendant of 900000000000459000 |attribute type (foundation metadata concept)| in the metadata hierarchy, that describes the type of the additional attribute extending the reference set .
NO
NO
attributeOrder
integer
Specifies the position of this attribute in the reference set to which this descriptor applies. A zero value identifies the referencedComponentId within the reference set. Other values specify an additional attributes by its position relative to the referencedComponentId. Within a particular descriptor, attributeOrder values for a particular referencedComponentId must be contiguous.
An unsigned Integer, providing an ordering for the additional attributes extending the reference set .
NO
NO
0
1
2
3
id
UUID
A 128 bit unsigned Integer, uniquely identifying this reference set member.
Different versions of a reference set member share the same id but have different effectiveTime. This allows a reference set member to be modified or made inactive (i.e. removed from the active set) at a specified time.
NO
YES (Full /Snapshot)
effectiveTime
Time
The inclusive date or time at which this version of the identified reference set member became the current version.
Note: In distribution files the effectiveTime should follow the short ISO date format (YYYYMMDD) and should not include the hours, minutes, seconds or timezone indicator.
The current version of this reference set member at time T is the version with the most recent effectiveTime prior to or equal to time T.
YES
YES (Full)
Optional (Snapshot)
The following metadata hierarchy supports this reference set:
The table below shows the reference set descriptor for a reference set that follows the 723592007 |MRCM attribute range reference set| pattern.
refsetId
referencedComponentId
attributeDescription
attributeType
attribute Order
The table below shows some example rows from a reference set that follows the format of the 723592007 |MRCM attribute range reference set|.
refsetId
referencedComponentId
rangeConstraint
attributeRule
ruleStrengthId
contentTypeId
id
UUID
A 128 bit unsigned Integer, uniquely identifying this reference set member.
Different versions of a reference set member share the same id but have different effectiveTime. This allows a reference set member to be modified or made inactive (i.e. removed from the active set) at a specified time.
NO
YES (Full /Snapshot)
A Component Annotation String Value reference set should be named along the lines of the following convention:
der2_scsRefset_ComponentAnnotationStringValueSnapshot__[Product]_ __[date]_.txt
For example, for an International Release on 1st December 2023:
der2_scsRefset_ComponentAnnotationStringValueSnapshot_INT_20231201.txt
The reference set example tables on this page have been revised as follows to aid clarity and understanding:
The first four columns which are present in all release files are not shown. The omitted columns ( id, effectiveTime, active) are used in the same way in all referenced sets to support identification, versioning and packaging. They do not directly affect the specific features of a particular reference set or reference set type.
Reference set columns that contain SNOMED CT identifiers are expanded to show details of the concept or description referenced by that identifier. In some cases, the term is shown in the same column using the expression syntax, in other cases an additional column with a name suffix '_term' has been added. In the standard reference set files only the identifier is present in the column and there is no added column for the term. When using reference sets, the term and other details of the component are looked up from the relevant component release files.
The table below shows the descriptors that define the structure of the 1292992004 |Component annotation with string value reference set (foundation metadata concept)| pattern and examples of the descriptors for specific reference sets that follow this pattern.
Descriptor templates for Component Annotation String Value reference sets
1292992004 |Component annotation with string value reference set (foundation metadata concept) |
900000000000460005 |Component type (foundation metadata concept)|
excluding the postcoordinated expression and rerfset member type components
An 733618005 | Ordered association type reference set (foundation metadata concept)| can be used to specify ordered associations between different components. These can be used to specify several interrelated subsets of components and to define alternative hierarchies for navigation while searching for an appropriate concept or description.
An Ordered association reference set is a component integer reference set that is used to represent ordered lists of associations and alternative hierarchies. Its structure is shown in the following table.
Ordered association reference set - Data structure
The following metadata in the "Foundation metadata concept" hierarchy supports this reference set:
Ordered Association References Set in the Metadata Hierarchy
The tables below show the descriptor that defines the structure of the pattern and an example of descriptor for a specific reference set that follows this pattern.
Refset Descriptor rows for an ordered association type reference set
can be used to specify and display a customized navigation hierarchy. Alternative hierarchical representations of SNOMED CT can support data entry by satisfying the requirements of a specific use case, and addressing some of the challenges of displaying an unordered polyhierarchy (as defined by SNOMED CT's subtype structure).
The figure below shows the way a navigation hierarchy is represented. The example reference set contains a set of description components used to describe finger structures.
The |All fingers| components is linked to the |Hand|, and the |Thumb| is linked to the |All fingers| component. The |Thumb| is placed first because it has the order value 1. Similarly, the components for |Second finger|, |Third finger|, |Fourth finger| and |Fifth finger| are also linked to the |All finger| component in the order specified by the order value. As shown in the figure the direction of the associations goes from the referenceComponentId to the targetComponentId so the components referenced by the targetComponentId are used to form the groups specified in the hierarchy
Navigation hierarchy example.
This file provides a standardized way of associating alternative Identifiers from various schemes with SNOMED CT components.
At any point in time , an alternativeIdentifier within a particular scheme will be associated with one and only one SNOMED CT component. A SNOMED CT component may be associated with zero or mor e alternativeIdentifiers within a single scheme.
It is important to note that the SNOMED CT component and it' s alternativeIdentifiers all identify precisely the same real-world object.
Note: The Identifier file is not currently used in the SNOMED CT International Release as use of the more flexible Simple map type references set structure is preferred for links to alternative codes. The only known current use of this file is for internal identification of components during the content development process.
Identifier file - Detailed Specification
Only one record with the same identifierSchemeId and alternateIdentifier fields will be current at any point in time. The current record will be the one with the most recent effectiveTime before or equal to the point in time under consideration.
If the active field of this record is false ('0'), then the association is inactive at that point in time. If the active field is true ('1'), then there is an identity at that point in time between the referencedComponentId (a SNOMED CT component) and the alternateIdentifier in the scheme identified by identifierSchemeId.
effectiveTime
Time
The inclusive date or time at which this version of the identified reference set member became the current version.
Note: In distribution files the effectiveTime should follow the short ISO date format (YYYYMMDD) and should not include the hours, minutes, seconds or timezone indicator.
The current version of this reference set member at time T is the version with the most recent effectiveTime prior to or equal to time T.
YES
YES (Full)
Optional (Snapshot)
active
Boolean
The state of the identified reference set member as at the specified effectiveTime .
If active = 1 (true) the reference set member is part of the current version of the set, if active = 0 (false) the reference set member is not part of the current version of the set.
YES
NO
moduleId
SCTID
Identifies the SNOMED CT module that contains this reference set member as at the specified effectiveTime .
The value must be a subtype of 900000000000443000 |Module (core metadata concept)| within the metadata hierarchy.
YES
NO
refsetId
SCTID
Identifies the reference set to which this reference set member belongs.
In this case, a subtype descendant of: 1292992004 |Component annotation with string value reference set (foundation metadata concept)|
NO
NO
referencedComponentId
SCTID
A reference to the SNOMED CT component to be included in the reference set.
The component (concept, description, relationship) to which the annotation applies.
NO
NO
languageDialectCode
String
Specifies the language of the Annotation text using the two character ISO-639-1 code. Note that this specifies a language level only, not a country code. However, a dialect can also be included by following the standard RFC 5646, although this is an optional inclusion. The new concept 1304275002 |Language or dialect code (foundation metadata concept)| has been added for the metadata for this refset.
NOTE: This field should be blank wherever a language code is not applicable, but never NULL.
YES
NO
typeId
SCTID
Any descendant of 1295447006 |Annotation attribute (attribute)| minus 1295449009 |Additional relationship attribute (attribute)| and its descendant in the attribute hierarchy.
NO
NO
value
String
The Annotation text itself, with a maximum size of 32Kb, represented in UTF-8 encoding.
YES
NO
0
1292992004 |Component annotation with string value reference set (foundation metadata concept) |
1304275002 |Language or dialect code (foundation metadata concept)|
900000000000465000 |String (foundation metadata concept)|
1
1292992004 |Component annotation with string value reference set (foundation metadata concept) |
1296892000 |Annotation type (foundation metadata concept)|
900000000000461009 |Concept type component|
2
1292992004 |Component annotation with string value reference set (foundation metadata concept) |
900000000000519001 |Annotation value (foundation metadata concept)|
900000000000465000 |String (foundation metadata concept)|
3
00000000-1111-2222-3333-444444444444
20240131
1
1292992004 | Component annotation with string value reference set (foundation metadata concept) |
784371009 |Huntington disease-like 1 (disorder)|
en
|Attribution (attribute)|
"Inserm Orphanet"
00000000-1111-2222-3333-444444444444
20240131
1
1292992004 | Component annotation with string value reference set (foundation metadata concept) |
103741018 |Radius, NOS|
en
|Inactivation note (attribute)|
"Non-conformance to the description convention for structure concept. The suffix NOS for classification should not be used."
00000000-1111-2222-3333-444444444444
20240131
1
1292992004 | Component annotation with string value reference set (foundation metadata concept) |
425523004 |Entire bone organ of spine (body structure)|
en
|Inactivation note (attribute)|
"No suitable replacement concept identified"
00000000-1111-2222-3333-444444444444
20240131
1
1292992004 | Component annotation with string value reference set (foundation metadata concept) |
370137002 |Extension Namespace {1000000} (namespace concept)|
en
|Namespace owner (attribute)|
NHS Digital (UK)
SNOMED Clinical Terms Components are identified and referenced using numeric identifiers. These identifiers have the data type SCTID (SNOMED CT Identifier).
The SCTID data type is 64-bit integer which is allocated and represented in accordance with a set of rules. These rules enable each SCTID to refer unambiguously to a unique component. They also support separate partitions for allocation of Identifiers for particular types of component. In the case of components that originate in an Extension, the SCTID also supports separate namespaces that distinguish between different issuing organizations.
Boolean
The state of the identified reference set member as at the specified effectiveTime. If active = 1 (true) the reference set member is part of the current version of the set, if active = 0 (false) the reference set member is not part of the current version of the set.
YES
NO
moduleId
SCTID
Identifies the SNOMED CT module that contains this reference set member as at the specified effectiveTime .
The value must be a subtype of within the metadata hierarchy.
YES
NO
refsetId
SCTID
Identifies the reference set to which this reference set member belongs.
A subtype descendant of:
NO
NO
referencedComponentId
SCTID
A reference to the SNOMED CT component to be included in the reference set.
NO
NO
targetComponentId
SCTID
The identifier of the target component of the association that acts as a grouper or hierarchy node, collecting together a subgroup from within the list.
This field either enables reference set member linked into a number of subgroups. These subgroups can be nested allowing representation of alternative hierarchies.
To link members into a subgroup, all components in the same subgroup should reference the same component. This can either be a component that represents the name of that subgroup or the first member of the subgroup. In the latter case, the first row of each subgroup will contain the same identifier in referencedComponentId and targetComponentId and with order =1.
To link a number of children concepts to a single parent concept, one member record should exist per child, with the referencedComponentId field referencing the parent and this field referencing the child concept. The order field is then used to order the children concepts under the parent concept.
YES
NO
order
integer
Specifies the sort order of the list. The list is ordered by applying an ascending sort of the order value.
The value of order =1 represents the highest priority. A value of '0' is not allowed. Duplicate values are permitted and the sort order between two members with the same order value is not defined.
If the targetComponentId value is not 0, sorting occurs within subgroups that share the same targetComponentId.
Note: The name "order" is a reserved word in some database environments. Please consider this when using this column.
YES
NO
1
2
…
20160731
1
19999999103
159999999105
Associations as ordered reference set
70327001
All fingers
141819019
Hand
1
id
UUID
A 128 bit unsigned Integer, uniquely identifying this reference set member.Different versions of a reference set member share the same id but have different effectiveTime. This allows a reference set member to be modified or made inactive (i.e. removed from the active set) at a specified time.
NO
YES (Full/Snapshot)
effectiveTime
Time
The inclusive date or time at which this version of the identified reference set member became the current version.
Note : In distribution files the effectiveTime should follow the short ISO date format (YYYYMM DD) and should not include the hours, minutes, seconds or timezone indicator.The current version of this reference set member at time T is the version with the most recent effectiveTime prior to or equal to time T.
YES
YES (Full) Optional (Snapshot)
0

active
Boolean
Specifies whether the association was active or inactive from the point in time specified by the effectiveTime .
YES
NO
moduleId
SCTID
Identifies the source module that this association was created in.
Set to a child of within the metadata hierarchy.
YES
NO
identifierSchemeId
SCTID
Identifier of the concept enumeration value from the Metadata hierarchy that represents the scheme to which the Identifier value belongs. Set to a descendant of within the metadata hierarchy.
NO
YES (Full/Snapshot)
referencedComponentId
SCTID
Uniquely identifies the SNOMED CT component with which the alternative Identifier is associated.
YES
NO
alternateIdentifier
String
String representation of the alternative Identifier in its native scheme.
NO
YES (Full/Snapshot)
effectiveTime
Time
Specifies the inclusive date at which the alternative Identifier was associated with the SNOMED CT component.
YES
YES
(Full)
Optional (Snapshot)
active
active
Boolean
The state of the identified reference set member as at the specified effectiveTime .
If active = 1 (true) the reference set member is part of the current version of the set, if active = 0 (false) the reference set member is not part of the current version of the set.
YES
NO
moduleId
SCTID
Identifies the SNOMED CT module that contains this reference set member as at the specified effectiveTime .
The value must be a subtype of 900000000000443000 |Module (core metadata concept)| within the metadata hierarchy.
YES
NO
refsetId
SCTID
Identifies the reference set to which this reference set member belongs.
In this case, a subtype descendant of: 723592007 |MRCM attribute range reference set|
NO
NO
referencedComponentId
SCTID
A reference to the SNOMED CT component to be included in the reference set. A reference to the SNOMED CT attribute concept to which the range defined by this member applies.
NO
NO
rangeConstraint
String
A parsable string, which defines the valid set of values that may be used for the given attribute (identified by the referencedComponentId).
If the attribute in the referencedComponentId is a subtype of 762705008 |Concept model object attribute (attribute)| then the rangeConstraint must be an expression constraint, which can be parsed using the ABNF rules defined by the Expression Constraint Language.
If the attribute in the referencedComponentId is a subtype of 762706009 |Concept model data attribute (attribute)| then the rangeConstraint must be parsable using the concreteValueReplacement ABNF rule specified in the . For example, the following rangeConstraint includes the set of all positive integers: int (>#0..)
YES
NO
attributeRule
String
An Expression Constraint that captures the domain, range and cardinality constraints for the given attribute, rule strength and content type. This string can be parsed using the ABNF syntax defined for the Expression Constraint Language. If ranges with concrete values are required, the Expression Constraint Language can be extended as described above (for rangeConstraint).
YES
NO
ruleStrengthId
SCTID
A subtype of 723573005 |Concept model rule strength| which specifies whether the given rule is mandatory (resulting in an error) or optional (resulting in a warning).
YES
NO
contentTypeId
SCTID
A subtype of 723574004 |Content type| which indicates the type of SNOMED CT content over which this rule applies.
YES
NO
0
1
2
3
4
(<< 404684003 |Clinical finding (finding)| OR << 272379006 |Event (event)| ): [0..*] { [0..*] 255234002 |After| = (<< 404684003 |Clinical finding (finding)| OR << 71388002 |Procedure (procedure)| )}
An 723604009 |MRCM attribute domain reference set| allows attributes to be associated with the domains in which they may be applied. It also allows grouping and cardinality constraints to be specified for each attribute and domain combination. For each attribute-domain rule, the strength of the rule (e.g. 723597001 |Mandatory concept model rule| or 723598006 |Optional concept model rule| ) and the content type over which this rule applies (e.g. 723596005 |All SNOMED CT content| , 723594008 |All precoordinated SNOMED CT content| ) is also specified.
Each attribute is identified by its concept id, while each domain is identified by the same concept id used in the referencedComponentId of the 723589008 |MRCM domain reference set|
An 723604009 |MRCM attribute domain reference set| is structured as shown in the following table.
The following metadata hierarchy supports this reference set:
The table below shows the reference set descriptor for a reference set that follows the pattern.
The table below shows some example rows from a reference set that follows the format of the .
The |Module dependency reference set| represents dependencies between different SNOMED CT release modules. In each case, the dependency indicates which targetEffectiveTime of each particular module a given sourceEffectiveTime of the dependent module requires.
The 900000000000534007 |Module dependency reference set| is a String - String reference set which is used to represent dependencies between modules, taking account of module versioning. Its structure is shown in the following table.
Each row in the release files for components and reference set members has a . This refers to the module that the component is maintained in. Each module is either part of the SNOMED International Release or part of a single SNOMED CT Extension. The has a partition-id which indicates whether it is part of the SNOMED International Release and, if not, its namespace identifier indicates the SNOMED CT Extension that it belongs to.
A module is simply a collection of SNOMED CT components maintained as a unit by a single organization. It is the organization 's responsibility to organize the components in each extension that it is responsible for into one or more modules, in a way that best fits its business needs.
A module is represented by a descendant of in the metadata hierarchy. The immediate subtype descendants of represent groups of modules maintained by an organization and subtypes of these can be used to arrange that organizations modules into a number of groups. For example, all modules maintained by SNOMED International will be children of .
At any point in time a component must be in one, and only one module. It is possible for components and reference set members to be moved between modules (subject to constraints explained elsewhere). In this case, a new row is added to the release file with the same but with a new and a new .
Each extension must include one or more modules. Each module must be part of either the SNOMED International Release or one and only one extension. A module may not move from one extension to another over time. If components or reference set members in a module are to be moved from an extension to the SNOMED International Release or to another extension, they must either be added to an existing or newly created module maintained by the destination organization.
The does NOT represent dependencies between module. Instead, module dependencies are modeled using the .
At the point of release, if any component within a module has changed, then a new row must be added to the for each dependency of that module. The of the added rows must set to the date of the new release. The updated records indicate that some components within the module have been updated in this release. If there have been no additions, updates or inactivations of components or reference set members within a module, then a new records need not be added unless there is a requirement to declare that the unchanged module is compatible with a later release of the module(s) on which it dependents.
The recommended practice is for the column to contain the same identifier for all versions of the dependencies between the same pair of modules. This approach means that at any given time only one version of each module has effective dependencies. The dependencies of earlier versions can be reviewed by reviewing a snapshot for the effectiveTime of the earlier release.
The effectiveTime of at least one row for each pair of modules should be the same as the sourceEffectiveTime. Otherwise, there will be a period of time when a snapshot view will not show the dependencies. However, it is theoretically possible for an additional row to be added with a later effectiveTime in cases where an otherwise unchanged release of an extension, declares itself to be compatible with an updated release of the target module (in this case the effectiveTime and targetEffectiveTime are changed but the sourceEffectiveTime remains unchanged.
A module dependency only needs to be inactivated if the dependency is found to be erroneous. This is because, the module dependency is specific to a particular version of the source and target module. Therefore, if that dependency was valid at the outset it remains valid indefinitely in respect of those specified module versions, even if the dependencies between subsequent versions differ.
Module version dependencies are represented using a single . Thus all module dependency rows have the same refsetId ().
It is the responsibility of the organization owning and maintaining a dependent module to identify all modules on which it depends. They do this by adding rows to the within the dependent module. Because these added member must be in the dependent module, the moduleId of the reference set member record is also the identifier of the dependent (source) module.
The column not only indicates that this reference set member is in the specified module, it also indicates that this is the module that is the source of the dependency. As a result, in this reference set the moduleId column is immutable (i.e Mutable=NO). This is an exception to the usual rule and implies that a member of this reference set cannot move from one module to another.
The target module on which the source module depends is identified by the . Like the source module this is also immutable and this implies that if a module ceases to be dependent on another module, a new row inactivating the dependency can be added but the same member cannot be used to represent a different dependency (even if that dependency is a direct replacement of the inactivated dependency). However as noted above,
A module version may depend on one or more other module versions, and many module versions may have a dependency on a single module version. Cyclic module version dependencies are not allowed. If module-A depends on module-B, then module-B cannot depend on module-A.
Dependencies are not transitive and this means that dependencies cannot be inferred from a chain of dependencies. If module-A depends on module-B and module-B depends on module-C, the dependency of module-A on module-C must still be stated explicitly.
Any release should consist of a set of module versions that are certified as being compatible. Each release should also identify other module versions that it is dependent on even when these are outside the scope of the release. For example, the dependencies of modules in an Extension on the International Release must be stated.
Dependencies are specified between module versions, not just dependencies between modules. Therefore, it is possible to specify a dependency from a module released on one date to an earlier version of another module. The version of the dependent module is specified by the and the version of the module on which it depends is specified by the .
The following metadata in the "Foundation metadata concept " hierarchy supports this reference set
The table below shows the descriptor that defines the structure of the .
Example : The table below holds example entries for the in a snapshot view of the January 2014 SNOMED CT International Release .
This SNOMED CT International Release contains three modules:
which has no dependencies;
which depends on the ; and
which depends on both the other modules.
In this case all the 2014-01-31 modules depend on 2014-01-31 versions of the other modules. However, in some case a module may depend on an earlier version of another model (e.g. an extension module may be releases after the SNOMED CT International Release to which it applies).
Dependencies are not transitive. The fact that is dependent on may seem to imply a dependency on . However, in practice all dependencies must be explicitly specified, not just immediate dependencies.
An associates description logic statements with SNOMED CT concept in the OWL functional syntax.
The SNOMED CT International Release contains content in two reference sets that follow the |OWL expression type reference set| pattern:
The , in which the OWL expressions represent axioms that form the logical definition of the concept identified by the referencedComponentId.
The , in which the OWL expressions represent essential information about an ontology. This information includes, namespaces, ontology URI, ontology version URI, and import statements. The |OWL ontology reference set (foundation metadata concept)|
Each component has an associated active field, which can take values of true (1) or false (0). The meaning of this flag is described by component type in the following table:
Behavior of Active and Inactive Components
SnomedCT_[Product][Scope(optional)][Format(optional)]_[ReleaseStatus]_[ReleaseDate]T[ReleaseTime][TimeZone]
e.g. SnomedCT_InternationalRF2_PRODUCTION_20250701T120000Z.zip
True
The concept is intended for active use.
All active descriptions for which the conceptId refers to this concept are valid. Visibility of these active descriptions depends on information contained in applicable refset members (for example, whether the description is in a language dialect reference set that is currently enabled in the vendor's system).
All active relationships of which it is the sourceId or destinationId are applicable.
Concept
False
The concept is not intended for active use. However, it remains a valid concept for historical purposes as part of the SNOMED CT commitment to the principle of ' concept permanence'.
Valid descriptions of the concept remain active allowing it to be appropriately viewed in human-readable form.
An inactive concept cannot be the sourceId, destinationId or typeId of an active relationship.
Description
True
The description contains a term that is a valid description of the concept referred to by the conceptId.
An active description may refer to an inactive concept, in which case the term provides a valid description of that inactive concept. Text based searches should (by default) include only active descriptions that refer to active concepts.
Description
False
The description is not a valid and the associated term should no longer be regarded as being associated with the concept referred to by conceptId.
Relationship
True
The relationship represents a valid association of the type specified by the typeId, between two concepts referred to by the sourceId and destinationId ;
An inactive concept cannot be the sourceId, destinationId or typeId of an active relationship.
Relationship
False
The relationship is not valid. An inactive relationship should be ignored as it does not apply.
This does not necessarily mean that the association indicated by the relationship does not apply. The relationship may be inactive because it is redundant and inferable based on other active relationships.
An inactive relationship may refer to either active or inactive components.
Refset member
True
The refset member contains valid information applicable to the component referred to by the referencedComponentId .
The component referred to by the referencedComponentId may be active or inactive. An active refset member cannot make an inactive component active but may provide related information that continues to be relevant (e.g. the reason for inactivation).
Refset member
False
The refset member is not valid. An inactive refset member should be ignored. The information it contains is not applicable to the component referred to by referencedComponentId.
Component Type
Active value
Component behavior when the most recent row representing a component has the specified active value
Concept
Boolean
The state of the identified reference set member as at the specified effectiveTime .
If active = 1 (true) the reference set member is part of the current version of the set, if active = 0 (false) the reference set member is not part of the current version of the set.
Note: A module dependency should only be inactivated if it is found to be erroneous.
YES
NO
moduleId
SCTID
Identifies the SNOMED CT module that contains this reference set member as at the specified effectiveTime .
The value must be a subtype of within the metadata hierarchy.
YES
NO
refsetId
SCTID
Identifies the reference set to which this reference set member belongs.
In this case, a subtype descendant of:
NO
NO
referencedComponentId
SCTID
A reference to the SNOMED CA reference to the SNOMED CT component to be included in the reference set. A reference to the SNOMED CT attribute concept to which the attribute-domain rule defined by this member applies.
NO
NO
domainId
SCTID
A reference to the SNOMED CT concept that identifies the relevant concept domain.
NO
NO
grouped
Boolean
Whether or not the given attribute (identified by referencedComponentId) is treated by a Description Logic reasoner as belonging to a relationship group, when applied to a concept in the given domain.
If grouped = 1 (true) then the given attribute (identified by referencedComponentId) is treated by a Description Logic reasoner as belonging to a relationship group.
If grouped = 0 (false) then the given attribute (identified by referencedComponentId) is treated by a Description Logic reasoner as not belonging to a relationship group.
YES
NO
attributeCardinality
String
The number of times the given attribute can be assigned a distinct (non-redundant) value within the definition of each concept or expression.
This string can be parsed using the following ABNF rule (together with the subrules defined in the ):
attributeCardinality = minimum to maximum
YES
NO
attributeInGroupCardinality
String
The number of times the given attribute can be assigned a distinct (non-redundant) value within a single relationship group as part of the definition of a concept or expression.
This string can be parsed using the following ABNF rule (together with the subrules defined in the ):
attributeCardinality = minimum to maximum
YES
NO
ruleStrengthId
SCTID
A subtype of which specifies whether the given rule is mandatory (resulting in an error) or optional (resulting in a warning
YES
NO
contentTypeId
SCTID
A subtype of which indicates the type of SNOMED CT content over which this rule applies. In many cases, this will be set to .
YES
NO
0
1
2
3
4
5
6
1
0..*
0..*
1
0..*
0..*
1
0..*
0..1
0
0..1
0..0
id
UUID
A 128 bit unsigned Integer, uniquely identifying this reference set member.
Different versions of a reference set member share the same id but have different effectiveTime. This allows a reference set member to be modified or made inactive (i.e. removed from the active set) at a specified time.
NO
YES (Full /Snapshot)
effectiveTime
Time
The inclusive date or time at which this version of the identified reference set member became the current version.
Note: In distribution files the effectiveTime should follow the short ISO date format (YYYYMMDD) and should not include the hours, minutes, seconds or timezone indicator.
The current version of this reference set member at time T is the version with the most recent effectiveTime prior to or equal to time T.
YES
YES (Full)
Optional (Snapshot)
active
0
1
2
20140131
20140131
20140131
20140131
20140131
id
UUID
A 128 bit unsigned Integer, uniquely identifying this reference set member.
Different versions of a reference set member share the same id but have different effectiveTime. This allows a reference set member to be modified or made inactive (i.e. removed from the active set) at a specified time.
NO
YES (Full /Snapshot)
effectiveTime
Time
The inclusive date or time at which this version of the identified reference set member became the current version.
Note: In distribution files the effectiveTime should follow the short ISO date format (YYYYMMDD) and should not include the hours, minutes, seconds or timezone indicator.
The current version of this reference set member at time T is the version with the most recent effectiveTime prior to or equal to time T.
YES
YES (Full)
Optional (Snapshot)
active
Boolean
The state of the identified reference set member as at the specified effectiveTime .
If active = 1 (true) the reference set member is part of the current version of the set, if active = 0 (false) the reference set member is not part of the current version of the set.
Note: A module dependency should only be inactivated if it is found to be erroneous.
YES
NO
moduleId
SCTID
Identifies the SNOMED CT module that contains this reference set member as at the specified effectiveTime .
The value must be a subtype of 900000000000443000 |Module (core metadata concept)| within the metadata hierarchy.
The moduleId for in the Module Dependency Reference Set represents the source module (i.e. the module declaring a dependency on another module).
Note: In all other situations moduleId is mutable. However, in the Module Dependency Reference Set a change to the moduleId would also change the source of the dependency. Therefore, it should not be treated as mutable.
YES
NO
refsetId
SCTID
Identifies the reference set to which this reference set member belongs.
In this case, always 900000000000534007 |Module dependency reference set| as there is only one Module Dependency Reference set.
NO
NO
referencedComponentId
SCTID
A reference to the SNOMED CT component to be included in the reference set. This refers to the target of the dependency (i.e. the module on which the module identified by moduleId depends).
NO
NO
sourceEffectiveTime
Time
The effective time of the dependent source module (identified by moduleId). This specifies a version of that module, consisting of all components that have the same moduleId as this refset member in their states as at the specified targetEffectiveTime .
YES
NO
targetEffectiveTime
Time
The effective time of the target module required to satisfy the dependency (identified by referencedComponentId). This specifies a version of that module, consisting of all components with the moduleId specified by referencedComponentId in their states as at the specified targetEffectiveTime .
YES
NO
20140131
An 762676003 |OWL expression type reference set| is structured as shown in the following table.
id
UUID
A 128 bit unsigned Integer, uniquely identifying this reference set member.
Different versions of a reference set member share the same id but have different effectiveTime. This allows a reference set member to be modified or made inactive (i.e. removed from the active set) at a specified time.
NO
The following metadata supports this reference set:
900000000000454005 |Foundation metadata concept| 900000000000455006 |Reference set| 762676003 |OWL expression type reference set| 762103008 |OWL ontology reference set| 733073007 |OWL axiom reference set| 900000000000457003 |Reference set attribute| 706999006 |Expression| 762677007 |OWL expression| 900000000000459000 |Attribute type| 900000000000465000 |String| 762678002 |OWL 2 language syntax|
The reference set example tables on this page have been revised as follows to aid clarity and understanding:
The first four columns which are present in all release files are not shown. The omitted columns (id, effectiveTime, active) are used in the same way in all referenced sets to support identification, versioning and packaging. They do not directly affect the specific features of a particular reference set or reference set type.
Reference set columns that contain SNOMED CT identifiers are expanded to show details of the concept or description referenced by that identifier. In some cases, the term is shown in the same column using the expression syntax, in other cases an additional column with a name suffix '_term' has been added. In the standard reference set files only the identifier is present in the column and there is no added column for the term. When using reference sets, the term and other details of the component are looked up from the relevant component release files.
The table below shows the descriptors that define the structure of the 762676003 | OWL expression type reference set| pattern and examples of the descriptors for specific reference sets that follow this pattern.
Descriptor templates for OWL expression reference rets
OWL ontology reference set example
Prefix(:=<>)
OWL axiom reference set example
SubClassOf(:404684003 :138875005)
Values
Description
Product
<any>
Camel case short title sufficient to identify the product.
Scope (optional)
Edition
The release files included in the package fully resolve all dependencies of all modules included in the package.
Scope (optional)
Extension
The release files included in the package needs to be combined with the International Edition release package and any other packages required to resolve the dependencies declared by the Module Dependency Reference Set.
Format (optional)
RF1
Required for any release packages containing Release Format 1 files.
Format (optional)
RF2
Current value for all release packages.
Format (optional)
<other>
Other values may be specified in future.
ReleaseStatus
ALPHA
The package is an alpha release package, which is defined as a SNOMED CT release package made available only for initial review and testing by implementers and other stakeholders.
Notes
An alpha release package must not be used in production clinical systems or in clinical settings. This includes Affiliate Licensees or any third parties, except those who have formally committed to test it.
An alpha release is used to test the format and content of the SNOMED CT release. Feedback is elicited and changes are made prior to publication of the beta release.
ReleaseStatus
BETA
The package is a beta release package, which is defined as a SNOMED CT release package made available for review and testing only.
Notes
Implementers and other stakeholders review and test the beta release.
The beta release package is made available prior to the production release. It must not be used in production clinical systems or in clinical settings. This includes Affiliate Licensees or any third parties, except those who have formally committed to test it.
The
ReleaseStatus
PRODUCTION
The package is a production release package, which is defined as a final, formally endorsed SNOMED CT release package intended for live use in appropriately licensed operational systems.
Notes
A production release package represents the authoritative release of the product. Implementers can use it in operational clinical systems.
The production release status indicates that the releasing party (SNOMED International or the owner of the extension) commits to maintain the release history. Thus the historical audit trail is maintained through the product's lifetime.
ReleaseDate
YYYYMMDD
The package release date formatted in accordance with ISO-8601.
ReleaseTime
HHMMSS
The package release time formatted in accordance with ISO-8601.
TimeZone
Z
The package timezone formatted in accordance with ISO-8601.
Element
…
20160731
1
19999999103
159999999105
Associations as ordered reference set
127053016
Thumb
70327001
All fingers
1
…
20160731
1
19999999103
159999999105
Associations as ordered reference set
138873019
Second finger
70327001
All fingers
2
…
20160731
1
19999999103
159999999105
Associations as ordered reference set
108884010
Third finger
70327001
All fingers
3
…
20160731
1
19999999103
159999999105
Associations as ordered reference set
136021011
Fourth finger
70327001
All fingers
4
…
20160731
1
19999999103
159999999105
Associations as ordered reference set
21356012
Fifth finger
70327001
All fingers
5
This section of the SNOMED CT Release Files Specification provides details of the structure and content of reference set files distributed by SNOMED International as part of the SNOMED CT International Release. This is also the standard format in which producers of SNOMED CT extension are required to distribute any reference sets that they produce to their sublicensees.
The files specified by this section form part of SNOMED CT Release Format 2 (RF2) - the standard release format for SNOMED CT since 2012. RF2 is a flexible, simple stable format with support for robust versioning. It enables innovation through adaptations to cater for changing requirements. This format is only mandated as the standard distribution format for SNOMED CT International and SNOMED CT Extensions. Internal representations of SNOMED CT resources within an application may vary provided such representations faithfully retain the information represented in the release files.
Reference set data structures provide a generic mechanism for configuration and extensibility of SNOMED CT to a wide range of different requirements. Reference sets act as building blocks that provide a common foundation that enables those developing SNOMED CT extensions to customize the way their users interact with SNOMED CT. The flexibility offered by reference sets also enables adaptation of existing system to support changing requirements.
Please note thar for more detail of the purposes for which reference sets can be used and the ways in which the design of different reference set types meet practical requirements, please refer to the .
The following subsections provide details of the format of the SNOMED CT component release files.
The following rules apply to all SNOMED CT Release Files.
SNOMED CT Release Files are UTF-8 encoded, tab delimited text files.
Each line, including the final line, ends with a carriage return character (hex 0D) followed by a line feed character (hex 0A).
The first line of each file, contains the names of each column (also know more generally as a field).
Beta releases were formerly known as candidate baseline releases.
A reference to a concept that specifies the name and/or usage of an additional attribute in a Refset. If the attributeType is component reference, the values applied to this additional attribute are restricted to subtypes of this concept .
Note: Field name in a SNOMED CT Release Format 2 Reference Set Descriptor.
Field names are represented using lower-camel-case
First letter of name is lower case
First letter of each words apart from the first word in the name is upper case
All other letters are lower case.
For example:
id
term
typeId
relationshipGroup
The name, datatype and usage of the fields in each file are specified in the following sections of this guide
.
YES (Full /Snapshot)
effectiveTime
Time
The inclusive date or time at which this version of the identified reference set member became the current version.
Note: In distribution files the effectiveTime should follow the short ISO date format (YYYYMMDD) and should not include the hours, minutes, seconds or timezone indicator.
The current version of this reference set member at time T is the version with the most recent effectiveTime prior to or equal to time T.
YES
YES (Full)
Optional (Snapshot)
active
Boolean
The state of the identified reference set member as at the specified effectiveTime .
If active = 1 (true) the reference set member is part of the current version of the set, if active = 0 (false) the reference set member is not part of the current version of the set.
YES
NO
moduleId
SCTID
Identifies the SNOMED CT module that contains this reference set member as at the specified effectiveTime.
The value must be a subtype of 900000000000443000 |Module (core metadata concept)| within the metadata hierarchy.
YES
NO
refsetId
SCTID
Identifies the reference set to which this reference set member belongs.
In this case, a subtype descendant of: 762676003 |OWL expression type reference set (foundation metadata concept)|
NO
NO
referencedComponentId
SCTID
A reference to the SNOMED CT component to be included in the reference set.
The concept to which the OWL expression applies. In the case of the 733073007 |OWL axiom reference set (foundation metadata concept)|, the axiom contributes to the definition of the identified concept.
NO
NO
owlExpression
String
The text of OWL expression to attach to the component identified by referencedComponentId.
YES
NO
0
1
0
1
0
1
Prefix(owl:=<http://www.w3.org/2002/07/owl#>)
Prefix(rdf:=<http://www.w3.org/1999/02/22-rdf-syntax-ns#>)
Prefix(xml:=<http://www.w3.org/XML/1998/namespace>)
Prefix(xsd:=<http://www.w3.org/2001/XMLSchema#>)
Prefix(rdfs:=<http://www.w3.org/2000/01/rdf-schema#>)
Ontology(<http://snomed.info/sct/900000000000207008>)
Example of SubClassOf, which is equivalent to an |Is a| relationship between most SNOMED CT concepts.
A different OWL expression is used to represent |Is a| relationships between attributes. This is shown in the row below.
SubObjectPropertyOf(:774081006 :733928003)
Example of SubObjectPropertyOf, which is equivalent to an |Is a| relationship between attributes.
EquivalentClasses(:90708001 ObjectIntersectionOf(:64572001 ObjectSomeValuesFrom(:609096000 ObjectSomeValuesFrom(:363698007 :64033007))))
Example of EquivalentClasses. which is equivalent to stating that a concept is sufficiently defined by a set of necessary relationships.
EquivalentClasses(:126516008 ObjectIntersectionOf(:64572001 ObjectSomeValuesFrom(:609096000 ObjectIntersectionOf(ObjectSomeValuesFrom(:116676008 :108369006) ObjectSomeValuesFrom(:363698007 :371311000)))))
Example of a role group with a conjunction of two relationships as its value.
TransitiveObjectProperty(:774081006)
Example of a transitive object property.
SubObjectPropertyOf(ObjectPropertyChain(:127489000 :738774007) :127489000))
Example of a property chain.
SubClassOf(ObjectIntersectionOf(:64859006 ObjectSomeValuesFrom(:609096000 ObjectSomeValuesFrom(:255234002 :387713003)) ObjectSomeValuesFrom(:609096000 ObjectSomeValuesFrom(:363698007 :272673000))) :703264005)
Example of a general concept inclusion (GCI).
This subsection explains features that apply to all SNOMED CT release files.
The SNOMED CT Release File Specification formally defines the format in which SNOMED CT is provided to licensees (Affiliates). For information about SNOMED CT licensing and availability of release files please refer to the Member Licensing and Distribution Service (MLDS) - http://snomed.org/licensing.
Each SCTID identifies a SNOMED CT component. The identifier itself does not contain information related to the meaning of a concept or description. This means it is not possible to infer anything about the meaning of a concept from the numeric value of the identifier or from the sequence of digits. The meaning of a concept can be determined from relationships to other concepts and from associated descriptions that include human readable terms.
The SCTID does however have a structure which includes valuable information about the nature and source of the identified component and the validity of the identifier. This structure supports the following features:
Check-digit validation of the identifier.
The check-digit is the final digit in the decimal rendering of the identifier. This can be checked to minimize errors from transcription or incomplete copy-paste actions.
Partitioning between identifiers for different types of SNOMED CT component.
A two-digit partition identifier distinguishes the identifiers of different component types and prevents the same identifier from being allocated to both a concept and a description. As a result, when an SCTID is read from a record or other resource, it is possible to determine whether it represents a concept, a relationship or a description, before searching for the identified component.
Namespaces to separate component identifiers originated by different organizations.
Organizations are only permitted to issue identifiers which fall within a specified namespace of potential identifier values. This prevents collisions between identifiers issues by different organizations which would otherwise result in ambiguity and errors when sharing data.
There are two formats used for representing namespaces.
The effectiveTime and active fields in the release file enable the use of a "log style" append-only data model to track all changes to each component, providing full traceability. Once released, a row in any of these files will always remain unchanged. Historic data is supplied in the RF2 release files, dating back to the first release in RF1 format in 2002.
In order to change the properties of a current component a new version of that component is created with the same identifier. This done by adding a new row to the relevant release file, with the column values updated to represent the changes. The active field must be set to true and the timestamp in the effectiveTime field indicating the nominal date on which the new version was released. Note that the existing row is not changed in any way.
To inactivate a component, a new row is added, containing the same data as the final valid version of the component, but with the active field set to false and the timestamp in the effectiveTime fi eld indicating the nominal date of the release in which the final version ceased being valid. Note again that the existing row is not changed in any way.
Where editorial policy does not allow a particular property of a component to be changed whilst keeping the same Identifier, the component as a whole is inactivated (as described above), and a new row added with a new id, the effectiveTime set to the nominal date of the release in which this version of the component became valid, and the active field set to true.
It is thus possible to see both the current values and any historical values of a component at any point in time.
New content, changes and inactivations must have the effectiveTime for the release that it appears in. Pre-releases for testing may set the effectiveTime as the date of the future scheduled release but in general the effectiveTime must not be later that the scheduled release data, Where there is a business requirement for specifying a future activation date for some components, this may be represented using reference sets.
The following data types are used in the release files:
Data Types Used in Release Files
The Concept File holds the clinical concepts that make up SNOMED CT. A concept is given meaning by its Fully Specified Name, which is held in the Description. A concept may be distinguished from or refined by association with other concepts using relationships, which are held in the Relationship.
Long format in which the partition identifier value indicates that a separate namespace identifier is required to distinguish between components originated as part of an extension created by an appropriately authorized organization .


The following example demonstrates how the history mechanism works on the Concept, but the same rules apply equally well to the Description, Relationship and Reference set member files. In this example, the descriptions associated with the moduleId and definitionStatusId have been shown in place of their SCTID values.
A new concept (101291009) is added on the 1st July 2007:
History Example - Concept Added
Id
effectiveTime
active
moduleId
definitionStatusId
101291009
20070701
1
In the following release (on 1st January 2008), the concept is moved from |Module 1| to |Module 2|. Because the moduleId field is not immutable, the concept may be updated simply by adding a new record with the same Id.
History Example - Module Change
Id
effectiveTime
active
moduleId
definitionStatusId
101291009
20070701
1
In the following release (on 1st July 2008), the concept is changed from being Primitive to being Fully defined.
History Example - Definition Status Changed
Id
effectiveTime
active
moduleId
definitionStatusId
101291009
20070701
1
In the following release (on 1st January 2009), the concept is inactivated:
History Example - Concept Made Inactive
Id
effectiveTime
active
moduleId
definitionStatusId
101291009
20070701
1
A Universally Unique Identifier is a 128-bit unsigned generated using a standard algorithm.
UUIDs are represented as strings of hexadecimal characters split by - characters as points specified by the .
Integer
A 32-bit signed integer.
String
UTF-8 text of a specified length.
Boolean
A Boolean value, represented as one of two possible integer values (1 = true, 0 = false).
Time
A date and time format expressed as a text string in line the basic representation specified in the .
Where only date is required the format is YYYYMMDD (e.g. 20180125 refers to 25th January 2018)
Where a time is also required the YYYYMMDDThhmmssZ (e.g. 20180125T123000Z refers to 12:30 UTC on 25th January 2018)
The time should be expressed as UTC, as indicated by the trailing "Z".
Concept enumeration is the a set of SNOMED CT concept identifiers used to represent values for a property of a SNOMED CT component or reference set member.
Notes
Concept enumeration serves the same purpose as more general approaches to providing enumerated lists of values (i.e. assigning a number to a value). However, the use of SNOMED CT concept identifier allows access to the human readable meaning of each enumeration using descriptions in the same way for other concepts.
The SNOMED CT concepts used to represent concept enumerations are usually subtype children (or descendants) of concepts in the SNOMED CT metadata hierarchy. Each possible value is represented by a single child concept. This allows updates to the permitted values to be tracked using the component history mechanism.
Example
Concept enumerations for description.typeId:
900000000000446008 |Description type (core metadata concept)|
900000000000003001 |Fully specified name (core metadata concept)|
900000000000013009 |Synonym (core metadata concept)|
900000000000550004 |Definition (core metadata concept)|
Concept enumeration values (subtypes of 900000000000442005 |Core metadata concept|
Concept
Comment
900000000000443000
|Module (core metadata concept)|
Each subtype of this concept represents a development module. These concepts provide values to the moduleId field that is present in all SNOMED CT component file. The value indicates the module within which a component was created and is being maintained.
900000000000444006
|Definition status (core metadata concept)|
Each subtype of this concept represents a value that can be applied to the concept. definitionStatusId field. This is used to indicate whether the current set of defining Relationships applied to a concept are sufficient to fully-define it relative to its supertypes.
900000000000446008 |Description type (core metadata concept)|
Data Type
Description
SCTID
A SNOMED CT identifier, between 6 and 18 digits long, as described in SCTID Representation.
This data type is used to identify SNOMED components, to refer to a component from another component or from a reference set, and also to represent the values for concept enumerations.
UUID
Uniquely identifies the concept.
NO
YES (Full/Snapshot)
effectiveTime
Time
Specifies the inclusive date at which the component version's state became the then current valid state of the component.
Note : In distribution files the effectiveTime should follow the short ISO date format (YYYYMM DD) and should not include the hours, minutes, seconds or timezone indicator.
YES
YES
(Full) Optional (Snapshot)
active
Boolean
Specifies whether the concept was active or inactive from the nominal release date specified by the effectiveTime.
YES
NO
moduleId
SCTID
Identifies the concept version's module. Set to a descendant of within the metadata hierarchy.
YES
NO
definitionStatusId
SCTID
Specifies if the concept version is primitive or defined. Set to a descendant of in the metadata hierarchy.
YES
NO
Only one concept record with the same id field is current at any point in time. The current record will be the one with the most recent effectiveTime before or equal to the date under consideration. If the active field of this record is false ('0'), then the concept is inactive at that point in time.
When a concept is made inactive, the following operations take place:
A new row is added to the Concepts file for the concept, with the active flag set to inactive and the definitionStatusId set to primitive;
All relationships that have as source the concept to be inactivated will themselves be inactivated by adding a new row to the Relationship for each relationship, with the active flag set to inactive;
All active descriptions associated with the concept will remain unchanged unless incorrect for the concept;
Rows will be added as needed to the Historical Association Reference Sets, to model associations from the inactive concept to other concepts;
Active descriptions that are still associated with the inactive concept will be added to the , with an associated value of
id
SCTID
This section describes four categories of reference set types, each of which contain several sub-types.
Each reference set type follows a pattern and that pattern is also represented in a machine readable form using a set of members (known as a Descriptor Template, for short). In most case, the same pattern may be used to define a number of different reference sets to serve a variety of purposes. However, there are also some highly specific reference set types that exist for a single specified purpose. These are the , and .
In each subsection, a reference set type is described under the following subheadings:
The purpose of the reference set;
The format of the reference set member record is detailed in a table;
The metadata supporting the reference set;
The machine readable reference set descriptor member records for the reference set type;
Related Links
This section briefly outlines different aspects of assertions made about concepts and the extent to which they are necessarily true or form part of a sufficient definition of the concept. More detailed illustrations of some of the points on this page are provided in Necessary and Sufficient - Examples.
The stated view of concept definition consists of one or more assertions made by SNOMED CT authors.
Each time an assertion is made about a concept, an author must decide if that assertion is a necessary condition. If the assertion is always true for that concept and its subtypes, it is a necessary condition.
This implies that for all instances of that concept or its subtypes, the assertion must be true, even if it has not been explicitly stated.
A necessary condition is defined as a characteristic that is always true of a concept.
Example
If you have a , the morphological abnormality 72704001 |fracture| must be present. Therefore, 116676008 |morphology| = 72704001 |fracture| is a necessary condition of |fracture of femur|.
For each concept an author must decide if there are one or more sets of assertions that form a sufficient definition of that concept. A set of assertions is a sufficient definition if it distinguishes a concept and its subtypes from other concepts.
This implies that if all assertions in the set are true for a concept, it must be an instance of the defined concept or a subtype of that concept.
A sufficient definition is a set of characteristics which distinguish a concept and its subtypes from all other concepts.
Examples
The following set of assertions is a sufficient definition for because any concept for which this set of assertions is true must either be the disorder appendicitis or a subtype of appendicitis.
Both the following sets of assertions are sufficient definitions for the concept
While each of the assertions |Causative agent| = |Substance| and |Due to| = |Disease| form part of a sufficient definition, neither of these assertions are necessary conditions because only one of them needs to be true. This illustrates that an assertion that is part of a sufficient definition need not be a necessary condition.
A concept that has no sufficient definitions is a primitive concept.
Because primitive concepts have no sufficient definitions it is not possible for a description logic classifier to determine if other concepts are subtypes of this concept. Similarly, it is not possible to automatically determine whether an expression is a subtype of a primitive concept. Therefore, only concepts or expressions that explicitly state they are subtypes of primitive concepts will be treated as subtypes when applying expression constraints or undertaking analysis.
However, note that this does not prevent a primitive concept being classified as a subtype of a sufficiently defined concept.
A concept that has at least one sufficient definition is a sufficiently defined concept.
A description logic classifier can determine whether the stated definitions of other concepts meet at least one of the sufficient definitions and if so will classify these concepts as its subtypes. Similarly, it is possible to determine whether an expression is equivalent to or a subtype of a sufficiently defined concept. Therefore, where expression constraints or queries refer to sufficiently defined concepts the results will include the inferred subtypes of these concepts.
If a sufficiently defined concept has one or more additional necessary conditions then any concept or expression that satisfies one of its sufficient definitions will also inherit any necessary conditions.
For example one sufficient definition of is an ulcer in a stomach structure:
However, another definition could be created with a more specific site gastric mucosa:
In both cases these definition are equivalent to |Gastric ulcer (disorder)|. The more general definition is flexible when it comes to allowing refinement to a specific location of the ulcer within the stomach, which is actually useful information. It also avoids requiring an expression to refer specifically to the mucosa (stomach lining), which is where all gastric ulcers occur.
For example, an expression including the specific location could look like this
This satisfies the sufficient definition because the finding site is a subtype of stomach structure. This will therefore classify as a type of |Gastric ulcer (disorder)| located in the anterior wall of the gastric fundus. The problem is that a query for disorders of the gastric mucosa will not find this expression.
However, adding the definition that refers to the gastric mucosa as an additional necessary condition can solve this problem. The expression satisfies the sufficient definition implying this is a type of |Gastric ulcer (disorder)|. The fact that it is a type of gastric ulcer causes it to inherit |finding site| = |gastric mucosa| so it will now be included in the query for disease in the gastric mucosa.
The Transitive Closure is the complete set of relationships between every concept and each of its super-type concepts, in other words both its parents and ancestors.
A transitive closure table is one of the most efficient ways to test for subsumption between concepts.
Transitive Closure Perl scripts can be used to generate a snapshot view of the transitive closure from the snapshot release of the Relationship. The output of such a script would usually adhere to the following file structure. Note that the primary key for this table consists of both columns.
Transitive Closure File - Detailed Specification
A versioned view of the Transitive Closure can also be generated by combining the snapshot views for different effective times and removing redundant rows (e.g. where the transitive closure has not changed between release versions). The generated file could then be represented using the example specification below. Note that the unique key for this file would consist of the subtypeId, supertypeId and effectiveTime.
Versioned Transitive Closure File - Example Specification
The permissible value for the SCTIDs are limited by the following rules:
Only positive integer values that are greater than 105 and less than 1018 are permitted.
The only valid string renderings of the identifier value are String of decimal digits (0-9), commencing with a non zero digit.
The second and third digits from the right hand end of the string rendering of the identifier must match one of the partition-identifier values specified in this guide.
The rightmost digit of the string rendering is a check-digit and must match the value calculated using the specified check-digit computation.
In the last example, as well as inactivating the concept (active=0), the definitionStatusId is changed from 900000000000073002 |Defined| to 900000000000074008 |Primitive|. In practice this change is not essential since the value of data columns is ignored when a component is inactive. Although the change is unnecessary and insignificant, it typically occurs since all the relationships of an inactive concept must also be inactive, and as a result, from the perspective of the authoring environment the concept cannot be regarded as 900000000000073002 |Defined|.
|Module 1|
900000000000074008 |Primitive|
|Module 1|
900000000000074008 |Primitive|
101291009
20080101
1
|Module 2|
900000000000074008 |Primitive|
|Module 1|
900000000000074008 |Primitive|
101291009
20080101
1
|Module 2|
900000000000074008 |Primitive|
101291009
20080701
1
|Module 2|
900000000000073002 |Defined|
|Module 1|
900000000000074008 |Primitive|
101291009
20080101
1
|Module 2|
900000000000074008 |Primitive|
101291009
20080701
1
|Module 2|
900000000000073002 |Defined|
101291009
20090101
0
|Module 2|
900000000000074008 |Primitive|
Each subtype of this concept represents a value that can be applied to the Description. typeId field. This is used to indicate whether the Description represents a Fully Specified Name, a synonymous term, a definition or some other symbolic or textual representation of the associated concept.
900000000000449001
|Characteristic type (core metadata concept)|
Each subtype of this concept represents a value that can be applied to the Description. caseSignificanceId field. This is used to indicate whether the text of the term can be modified to by switching characters from upper to lower case (or vice-versa).
900000000000449001 |Characteristic type (core metadata concept)|
Each subtype of this concept represents a value that can be applied to the Relationship. characteristicTypeId field. This is used to indicate whether a Relationship forms part of the definition of the source concept.
900000000000450001
|Modifier (core metadata concept)|
Each subtype of this concept represents a value that can be applied to the Relationship. modifierId field. This is used to indicate the type of Description Logic (DL) restriction (some, all, etc.) that applies to the Relationship.
900000000000453004 |Identifier scheme (core metadata concept)|
Each subtype of this concept represents a value that can be applied to the Identifier. identifierSchemeId field. This is used to indicate the scheme to which the Identifier value belongs.
Examples of the reference set type;
SCTID
Id of the concept playing the supertype role. Set to an Identifier of a concept.
YES
effectiveTime
Time
Specifies the inclusive date at which the transitive closure record was added or changed its active state.
YES
active
Boolean
Specifies whether at the transitive closure represented by the subtypeId and supertypeId became valid (active) or invalid (inactive) from the point in time specified by the effectiveTime.
NO
subtypeId
SCTID
Id of the concept playing the subtype role. Set to an Identifier of a concept.
YES
supertypeId
SCTID
Id of the concept playing the supertype role. Set to an Identifier of a concept.
YES
subtypeId
SCTID
Id of the concept playing the subtype role. Set to an Identifier of a concept.
YES
supertypeId
18526009 |disorder of appendix| + 302168000 |inflammation of large intestine| :
116676008 |associated morphology| = 23583003 |inflammation|,
63698007 |finding site| = 66754008 |appendix structure|73211009 |Diabetes mellitus| : 246075003 |Causative agent| = 105590001 |Substance|
73211009 |Diabetes mellitus| : 42752001 |Due to| = 64572001 |Disease|=== 64572001 |disease| :
{116676008 |associated morphology| = 56208002 |ulcer|,
363698007 |finding site| = 69695003 |stomach structure|}=== 64572001 |disease| :
{116676008 |associated morphology| = 56208002 |ulcer|,
363698007 |finding site| = 78653002 |gastric mucosa|}=== 64572001 |disease| :
{116676008 |associated morphology| = 56208002 |ulcer|,
363698007 |finding site| = 127869006 |Anterior wall of fundus of stomach|}<< 64572001 |disease| : 363698007 |finding site| = 78653002 |gastric mucosa|A 447250001 |Complex map from SNOMED CT type reference set| supports the representation of maps where each SNOMED CT concept may map to one or more codes in a target scheme. This type of reference set supports the general set of mapping data required to enable a target code to be selected at run-time from a number of alternate codes. It supports target code selection by accommodating the inclusion of machine readable rules and/or human readable advice. An 609331003 |Extended map from SNOMED CT type reference set| adds an additional field to allow the categorization of maps.
A 447250001 |Complex map from SNOMED CT type reference set| is an Integer - Integer - String - String - String - Component reference set. The pattern is currently used for the map to ICD-9-CM. Its structure is as shown in the following table, with one exception - the table below includes an additional field (mapCategoryId) which is not used for this type of map.
An 609331003 |Extended map type reference set (foundation metadata concept)| follows the same pattern but adds one additional column. It is an Integer - Integer - String - String - String - Component - Component reference set and this pattern is currently used for maps to ICD-10. Its structure is shown in the following table, and includes the mapCategoryId.
Table: Complex and Extended map from SNOMED CT type reference sets - Data structures
Values for are allocated on a sequential basis (for each refsetId and referencedComponentId combination) during authoring starting at 1. However, distributed mapGroup are not necessarily sequential, as some mapGroup may be created and removed during a mapping process between releases. For maps where each SNOMED CT concept only maps to at most one of a group of alternate target codes, the mapGroup field are usually be set to '1'.
Values for will be allocated on a sequential basis (within each map group) starting from '1'. For maps that do not require run - time alternatives, the mapPriority field is set to '1'.
The and fields enable run-time selection (within vendor's software) from a number of alternative map records within a mapGroup. Where there are no alternatives maps these columns of the release files will be empty (zero length string). Where alternative maps exist one or both of columns will be populated where relevant information is available.
Where both fields are populated, and a vendor's system is capable of processing a machine readable rule, this should take priority over the human readable advice. Where neither field is populated, a vendor's system should allow the end-user to select the appropriate target code from the alternates.
For more details on this topic in relation to the ICD-10 maps released as part of the SNOMED CT International Edition please see the .
The specific grammar and content of the rules for resolving complex mapping cases depends on the nature of the target code system or classification. In general, each map is accompanied by a rule which is tested against other data and can be evaluated to return one of the following values:
True - in which case the map target applies;
False - in which case the map target does not apply;
Indeterminate - in cases where there is insufficient accessible data to determine whether the map target applies. In this case manual resolution of the map using the map advice provided will be required.
The mapping rules assume access to a number of variables, that can be bound to appropriate attributes in the vendor's system information model. These include the age and gender of the patient and information about coexisting situations (e.g. records of other disorders, procedures or events in the same patient record).
Detailed definitions of the mapping rules used forms part of individual specifications for maps to particular target code systems and classifications. This will initially be provided separately and will accompany the release of the relevant mapping files. For example, the set of rules used for mapping to ICD-10 are included in the .
The following metadata supports this reference set:
List: Complex and Extended Map from SNOMED CT References Sets in the Metadata Hierarchy
The tables below examples of the descriptors for specific reference sets that follow the and patterns.
Table: Refset Descriptor Rows for a Complex Map from SNOMED CT Reference Set
Refset Descriptor Rows for an Extended Map from SNOMED CT type Reference Set
Sample Content from an Extended Map from SNOMED CT Reference Set
The basic reference set data structure consists of the following fields:
Basic Reference Set Data Structure
Each reference set is identified and named by a concept in the metadata hierarchy. Therefore the reference set is identified by a concept identifier (an SCTID).
Each row in a reference set file represents a reference set member.
Individual reference set members are uniquely identified by a identifier represented as a UUID.
Each reference set member belongs to a single reference set, and it is linked to that reference set by the refsetId field.
Each reference set member is also associated with a single referenced component by its referencedComponentId field. The referenced component may be a concept, description, relationship. If the referenced component is a concept that identifies another reference set, that reference set may be considered to be the target of the reference.
The refsetId and referencedComponentId fields will not change between two rows with the same id, in other words they are immutable. Where a change is required to one of these fields, the current row will be inactivated (by appending a row with the same id and the active field set to false). Another row with a new id will be appended to reference another component.
A component may belong to any number of reference sets. A component may also be referenced by more that one member of the same reference set. This is not useful in the case of a simple reference set but is relevant for some reference sets. For example, a SNOMED CT concept may map to or from more than on codes in another code system.
An 900000000000521006 |Association type reference set| represents a set of unordered associations of a particular type between components.
An Association reference set is a reference set used to represent associations between components. Its structure is shown in the following table.
Association Reference Set - Data Structure
The following metadata supports this reference set:
Association Reference Sets in the Metadata Hierarchy
- this has many subtypes
See for an example of the reference set description and data representation in an association type reference set.
An allows a collection of components to be defined with a specified order. This type of reference set is therefore useful for creating ordered lists and to specify groups where the components that belong to the same group share the same order.
An Ordered component reference set (an Integer Component reference set) is used to represent ordered lists and alternative hierarchies. Its structure is shown in the following table.
Ordered component reference set - Data structure
This section outlines the rationale for distributing an OWL representation of the stated view of concept definitions and provides an overview of the way OWL axioms are represented in SNOMED CT release files. More detailed information is published separately in the and the .
The mismatch between the requirements for representing enhanced concept definitions and the capabilities of the current stated relationship file might in theory be addressed by addition of columns to the file or adding additional information in reference sets. However, in practice this would create a more complex solution able to support a specific set of enhanced features.
Adopting the well-established OWL standards formats offers a more flexible solution that can represent the full range of description logic features. This approach enables SNOMED Internation to specify a particular logic profile to be applied to current releases of SNOMED CT, with the option to extend that profile in the future. Future revisions of the logic profile would not require a change in the distribution file structure provided these were supported by an OWL syntax.
OWL axioms can be represented using several different syntaxes. SNOMED International has chose the OWL Functional Syntax as its standard representation.
The OWL Functional Syntax is a formal representation of the web ontology language (OWL) as a simple text base syntax that is used as a bridge between the structural specification and various concrete syntaxes.
Reference sets types are identified by concepts that are subtypes of the metadata concept . Individual reference sets of a particular type are identified and named by concepts that are subtype descendants of the concept that identifies the reference set type.
Reference Set Types in the Metadata Hierarchy (2018-01-31)
Reference Set Attributes in Metadata Hierarchy (2018-01-31) (some omitted)
id
UUID
A 128 bit unsigned Integer, uniquely identifying this reference set member.
Different versions of a reference set member share the same id but have different effectiveTime. This allows a reference set member to be modified or made inactive (i.e. removed from the active set) at a specified time.
NO
YES
(Full/Snapshot)
effectiveTime
Time
The inclusive date or time at which this version of the identified reference set member became the current version.
Note: In distribution files the effectiveTime should follow the short ISO date format (YYYYMMDD) and should not include the hours, minutes, seconds or timezone indicator.
The current version of this reference set member at time T is the version with the most recent effectiveTime prior to or equal to time T .
YES
YES
(Full) Optional (Snapshot)
active
Boolean
The state of the identified reference set member as at the specified effectiveTime .
If active = 1 (true) the reference set member is part of the current version of the set, if active = 0 (false) the reference set member is not part of the current version of the set.
YES
NO
moduleId
SCTID
Identifies the SNOMED CT module that contains this reference set member as at the specified effectiveTime .
The value must be a subtype of |Module (core metadata concept)| within the metadata hierarchy.
YES
NO
refsetId
SCTID
Identifies the reference set to which this reference set member belongs.
NO
NO
referencedComponentId
SCTID
A reference to the SNOMED CT component to be included in the reference set.
NO
NO
Zero or more other fields dependent on reference set type
SCTID, String, or Integer
Optional field(s) serving purposes specific to the reference set type. For details see Reference Set Types.
YES
NO
id
UUID
A 128 bit unsigned Integer, uniquely identifying this reference set member.Different versions of a reference set member share the same id but have different effectiveTime. This allows a reference set member to be modified or made inactive (i.e. removed from the active set) at a specified time.
NO
YES (Full/Snapshot)
effectiveTime
Time
The inclusive date or time at which this version of the identified reference set member became the current version.
Note : In distribution files the effectiveTime should follow the short ISO date format (YYYYMM DD) and should not include the hours, minutes, seconds or timezone indicator.The current version of this reference set member at time T is the version with the most recent effectiveTime prior to or equal to time T.
YES
YES (Full) Optional (Snapshot)
active
Boolean
The state of the identified reference set member as at the specified effectiveTime. If active = 1 (true) the reference set member is part of the current version of the set, if active = 0 (false) the reference set member is not part of the current version of the set.
YES
NO
moduleId
SCTID
Identifies the SNOMED CT module that contains this reference set member as at the specified effectiveTime .
The value must be a subtype of 900000000000443000 |Module (core metadata concept)| within the metadata hierarchy.
YES
NO
refsetId
SCTID
Identifies the reference set to which this reference set member belongs.
In this case, a subtype descendant of: 900000000000521006 |Association type|.
NO
NO
referencedComponentId
SCTID
A reference to the SNOMED CT component to be included in the reference set. The source component of the association.
NO
NO
targetComponentId
SCTID
The identifier of the target component of the association. Note. An inconsistency in this specification was resolved by the Modeling Advisory Group 2018-10-15 decision that this field should be mutable.
YES
NO
Time
The inclusive date or time at which this version of the identified reference set member became the current version.
Note: In distribution files the effectiveTime should follow the short ISO date format (YYYYMMDD) and should not include the hours, minutes, seconds or timezone indicator.
The current version of this reference set member at time T is the version with the most recent effectiveTime prior to or equal to time T.
YES
YES (Full)
Optional (Snapshot)
active
Boolean
The state of the identified reference set member as at the specified effectiveTime .
If active = 1 (true) the reference set member is part of the current version of the set, if active = 0 (false) the reference set member is not part of the current version of the set.
YES
NO
moduleId
SCTID
Identifies the SNOMED CT module that contains this reference set member as at the specified effectiveTime.
The value must be a subtype of within the metadata hierarchy.
YES
NO
refsetId
SCTID
Identifies the reference set to which this reference set member belongs.
In this case, a subtype descendant of: or
NO
NO
referencedComponentId
SCTID
A reference to the SNOMED CT component to be included in the reference set.
Refers to the SNOMED CT concept that is mapped to the other terminology or code system (i.e. the map source).
NO
NO
mapGroup
Integer
An Integer, grouping a set of complex map records from which one may be selected as a target code. Where a SNOMED CT concept maps onto 'n' target codes, there will be 'n' groups, each containing one or more complex map records.
YES
NO
mapPriority
Integer
Within a mapGroup, the mapPriority specifies the order in which complex map records should be checked. Only the first map record meeting the run - time selection criteria will be taken as the target code within the group of alternate codes.
YES
NO
mapRule
String
A machine-readable rule, (evaluating to either 'true' or 'false' at run-time) that indicates whether this map record should be selected within its mapGroup.
YES
NO
mapAdvice
String
Human-readable advice, that may be employed by the software vendor to give an end-user advice on selection of the appropriate target code from the alternatives presented to him within the group.
YES
NO
mapTarget
String
The target code in the target terminology, classification or code system.
YES
NO
correlationId
SCTID
A child of in the metadata hierarchy, identifying the correlation between the SNOMED CT concept and the target code.
YES
NO
The following additional field only applies to
mapCategoryId
SCTID
Identifies the SNOMED CT concept in the metadata hierarchy which represents the MapCategory for the associated map member. The categories vary for different target code systems, each set of categories is represented by a subtype of .
In the case of ICD-10 the individual category values are of: .
YES
NO
0
1
2
3
4
5
6
0
1
2
3
4
5
6
7
1
1
TRUE
ALWAYS O03.8
O03.8
2
1
TRUE
ALWAYS O08.6
O08.6
1
1
IFA 90979004 |Chronic tonsillitis (disorder)|
IF CHRONIC TONSILLITIS CHOOSE J35.0 MAP OF SOURCE CONCEPT IS CONTEXT DEPENDENT
J35.0
1
2
IFA 232406009 |Chronic pharyngeal candidiasis (disorder)|
IF CHRONIC PHARYNGEAL CANDIDIASIS CHOOSE B37.8 MAP OF SOURCE CONCEPT IS CONTEXT DEPENDENT
B37.8
1
3
OTHERWISE TRUE
ALWAYS J31.2
J31.2
1
1
TRUE
ALWAYS F31.1
F31.1
1
1
TRUE
ALWAYS T63.4
T63.4
2
1
TRUE
ALWAYS X25
X25
1
1
TRUE
ALWAYS J18.0
J18.0
1
1
TRUE
ALWAYS D61.8
D61.8
id
UUID
A 128 bit unsigned Integer, uniquely identifying this reference set member.
Different versions of a reference set member share the same id but have different effectiveTime. This allows a reference set member to be modified or made inactive (i.e. removed from the active set) at a specified time.
NO
YES (Full /Snapshot)
effectiveTime
id
UUID
A 128 bit unsigned Integer, uniquely identifying this reference set member.
Different versions of a reference set member share the same id but have different effectiveTime. This allows a reference set member to be modified or made inactive (i.e. removed from the active set) at a specified time.
NO
YES (Full /Snapshot)
effectiveTime
Time
The inclusive date or time at which this version of the identified reference set member became the current version.
Note: In distribution files the effectiveTime should follow the short ISO date format (YYYYMMDD) and should not include the hours, minutes, seconds or timezone indicator.
The current version of this reference set member at time T is the version with the most recent effectiveTime prior to or equal to time T.
YES
YES (Full)
Optional (Snapshot)
The following metadata in the "Foundation metadata concept" hierarchy supports this reference set:
Ordered Component Reference Sets in the Metadata Hierarchy
900000000000454005 |Foundation metadata concept| 900000000000455006 |Reference set| 733619002 |Ordered component type reference set|
The tables below show the descriptor that defines the structure of the Ordered component type reference set pattern and an example of descriptor for a specific reference set that follows this pattern.
Refset Descriptor rows for an ordered reference set
Rational ordering of finger concepts using an ordered component reference set
733619002
|Fingers ordered component reference set|
1
733619002
|Fingers ordered component reference set|
OWL axioms are distributed in a reference set that follows the OWL Expression Reference Set specification. The axiom itself is contained in a string field and the concept whose definition it contributes to is referenced by the the referencedComponentId. Although a single row in the reference set can provide a sufficient definition, the definition of a single concept can also include several axioms each represented by a row in the reference set.
Figure 2.3.4.2-1 shows the diagrammatic representation of the stated view of the definition of 80146002 |Excision of appendix|. Table 2.3.4.2-1 shows the same definition as represented by three rows in the stated relationship file together with the definitionStatusId in the concept file.
Stated relationships and definition status for the sufficiently defined concept 80146002 |Excision of appendix|
id
effective Time
active
..
sourceId
destinationId
relationship Group
typeId
..
Example of OWL axiom refset representation of the definition of |Excision of appendix|.
id
effectiveTime
active
moduleId
refsetId
referencedComponentId
owlExpression
..
The above table shows a row in the OWL axiom reference set file representing the same definition. As shown by this example, a single sufficient definition is represented by a single row in the reference set. However, some concept definitions may require multiple rows in the reference set. Situations in which multiple row are required include:
Concepts with multiple sufficient definitions, each of which requires a separate row in the reference set.
Concepts with additional necessary conditions that are not part of a sufficient definition, each of which requires a separate row in the reference set.
The use of this reference set structure is now discouraged as it requires implementers to create a new refset concept for every new annotation type. New RF2 specifications have been created for annotations, please refer to these for future use:
An 900000000000516008 |Annotation type reference set| allows String to be associated with components for any specified purpose.
An annotation reference set is a String reference set used to apply text annotation to selected SNOMED CT components.
Annotation reference set - Data structure
The following metadata in supports this reference set :
Annotation References Sets in the Metadata Hierarchy
The tables below show the descriptors that define the structure of the pattern and examples of the descriptors for specific reference sets that follow this pattern.
Table: Descriptor Template for Annotation Reference Sets
The attributeType for the Annotation field can be any descendant of the " string " concept in the metadata hierarchy. This hierarchy is described in more detail under the section.
Descriptor for the Associated Image Annotation Reference set
Note that in the table above, the 900000000000469006 |URL| concept is a descendant of |string| concept in the metadata.
As no annotation reference sets are included in the International Release, these sample rows are for illustration only.
Example of Associated image Annotation Reference Set
In the above example, the two URLs have been used to annotate two SNOMED CT concepts with images on the web. It is not recommended that this mechanism be used to annotate concepts with text that may require translation to other languages. Instead, such text should be included under an appropriate description type within the Description.
The Relationship file holds one relationship per row. Each relationship is of a particular type, and has a source concept and a destination concept.
An example of a relationship is given below for: |Outpatient procedure| where:
371883000 |Outpatient procedure| is the source concept;
116680003 |Is a| is the relationship type concept and;
is the destination concept.
Only one relationship record with the same id field will be current at any point in time. The current record will be the one with the most recent effectiveTime before or equal to the point in time under consideration.
If the active field of this record is false ('0'), then the relationship is inactive at that point in time. If the active field is true ('1'), then there is a relationship between the SNOMED CT concepts identified by sourceId and destinationId.
The sourceId, destinationId, relationshipGroup, typeId, characteristicTypeId and modifierId will not change between two rows with the same id, in other words they are immutable. Where a change is required to one of these fields, then the current row will be de-activated (by appending a row with the same id and the active field set to false) and a new row with a new id will be appended.
The relationshipGroup field is used to group relationships with the same sourceId field into one or more logical sets. A relationship with a relationshipGroup field value of '0' is considered not to be grouped. All relationships with the same sourceId and non-zero relationshipGroup are considered to be logically grouped.
The relationshipGroup field will be an unsigned Integer, and will not be limited to a single digit value. There is no guarantee that they will be assigned sequentially, and the values will not be unique across concepts.
.
A supports the representation of simple maps from SNOMED CT concepts to values in other code systems. No constraints are put on the number of codes mapped from a single SNOMED CT concept.
A is a String - Component reference set used to represent maps from SNOMED CT concepts to codes in another terminology, classification or code system, with the correlation between these codes. Its structure is shown in the following table.
Simple map with correlation from SNOMED CT type reference set - Data structure
The specifies the text format and maximum length of each supported description type. This permits additional description types to be specified in future in addition to the three existing description types ( synonym, fully specified name and textual definition).
The is a C-I ( component- Integer) reference set which is used to specify the length and format of the terms in descriptions of this description type. Its structure is shown in the following table.
Description format reference set - Data structure
An specifies the set of MRCM reference sets that should be applied to the content in each module. Within a SNOMED CT Edition, the MRCM rules applied to the included modules must be consistent, to ensure data integrity within an edition is maintained.
An is structured as shown in the following table.
As illustrated in Figure 2.3.4.1-1, each defining relationship is represented by a row in the relationship file. The concept being defined is referenced by the sourceId, the concept that represents the type of relationship (attribute) is referenced by the typeId and the destinationId refers to the concept that represents the value of that attribute.
The relationship file also has a relationshipGroup which allows two or more defining relationships to be grouped together.
The definitionStatusId of the source concept, indicates whether the combination of defining relationships provide provides sufficient definition of that concept.
Example of stated view of |Excision of stomach structure| represented by stated relationships
active
Boolean
The state of the identified reference set member as at the specified effectiveTime .
If active = 1 (true) the reference set member is part of the current version of the set, if active = 0 (false) the reference set member is not part of the current version of the set.
YES
NO
moduleId
SCTID
Identifies the SNOMED CT module that contains this reference set member as at the specified effectiveTime.
The value must be a subtype of 900000000000443000 |Module (core metadata concept)| within the metadata hierarchy.
YES
NO
refsetId
SCTID
Identifies the reference set to which this reference set member belongs.
In this case, a subtype descendant of: 733619002 |Ordered component type reference set (foundation metadata concept)|
NO
NO
referencedComponentId
SCTID
A reference to the SNOMED CT component to be included in the reference set.
NO
NO
order
Integer
Specifies the sort order of the list. The list is ordered by applying an ascending sort of the order value.
The value of order =1 represents the highest priority. A value of '0' is not allowed. Duplicate values are permitted and the sort order between two members with the same order value is not defined.
Note: The name "order" is a reserved word in some database environments. Please consider this when using this column.
YES
NO
0
1
2
733619002
|Fingers ordered component reference set|
3
733619002
|Fingers ordered component reference set|
4
733619002
|Fingers ordered component reference set|
5

..
..
20180731
1
..
80146002
|Excision of appendix|
71388002 |Procedure|
0
116680003
|Is a|
..
..
..
20080731
1
..
80146002
|Excision of appendix|
129304002 |Excision - action|
1
260686004 |Method|
..
..
..
20080731
1
..
80146002
|Excision of appendix|
66754008 |Appendix structure|
1
405813007 |Procedure site - Direct|
..
..
..
1
..
733073007 |OWL axiom reference set|
80146002
|Excision of appendix|
EquivalentClasses(:80146002 ObjectIntersectionOf(:71388002 ObjectSomeValuesFrom(:609096000 ObjectIntersectionOf(ObjectSomeValuesFrom
(:260686004 :129304002)ObjectSomeValuesFrom
(:405813007 :66754008)))))


effectiveTime
Time
The inclusive date or time at which this version of the identified reference set member became the current version.
Note : In distribution files the effectiveTime should follow the short ISO date format (YYYYMM DD) and should not include the hours, minutes, seconds or timezone indicator.The current version of this reference set member at time T is the version with the most recent effectiveTime prior to or equal to time T.
YES
YES (Full) Optional (Snapshot)
active
Boolean
The state of the identified reference set member as at the specified effectiveTime. If active = 1 (true) the reference set member is part of the current version of the set, if active = 0 (false) the reference set member is not part of the current version of the set.
YES
NO
moduleId
SCTID
Identifies the SNOMED CT module that contains this reference set member as at the specified effectiveTime .
The value must be a subtype of within the metadata hierarchy.
YES
NO
refsetId
SCTID
Identifies the reference set to which this reference set member belongs.
A subtype descendant of:
NO
NO
referencedComponentId
SCTID
A reference to the SNOMED CT component to be included in the reference set.
NO
NO
annotation
String
The text annotation to attach to the component identified by referencedComponentId.
YES
NO
1
1
id
UUID
A 128 bit unsigned Integer, uniquely identifying this reference set member.Different versions of a reference set member share the same id but have different effectiveTime. This allows a reference set member to be modified or made inactive (i.e. removed from the active set) at a specified time.
NO
YES (Full/Snapshot)
0
0
effectiveTime
Time
Specifies the inclusive date at which the component version's state became the then current valid state of the component.
Note : In distribution files the effectiveTime should follow the short ISO date format (YYYYMM DD) and should not include the hours, minutes, seconds or timezone indicator.
YES
YES
(Full)
Optional (Snapshot)
active
Boolean
Specifies whether the state of the relationship was active or inactive from the nominal release date specified by the effectiveTime field.
YES
NO
moduleId
SCTID
Identifies the relationship version's module. Set to a child of within the metadata hierarchy.
YES
NO
sourceId
SCTID
Identifies the source concept of the relationship version. That is the concept defined by this relationship. Set to the identifier of a concept.
NO
NO
destinationId
SCTID
Identifies the concept that is the destination of the relationship version.That is the concept representing the value of the attribute represented by the typeId column. Set to the identifier of a concept. Note that the values that can be applied to particular attributes are formally defined by the .
NO
NO
relationshipGroup
Integer
Groups together relationship versions that are part of a logically associated relationshipGroup. All active Relationship records with the same relationshipGroup number and sourceId are grouped in this way.
YES
NO
typeId
SCTID
Identifies the concept that represent the defining attribute (or relationship type) represented by this relationship version.
That is the concept representing the value of the attribute represented by the typeId column.
Set to the identifier of a concept. The concept identified must be either 116680003 |Is a| or a subtype of 410662002 |Concept model attribute|. The concepts that can be used as in the typeId column are formally defined as follows:
OR <
Note that the attributes that can be applied to particular concepts are formally defined by the .
NO
NO
characteristicTypeId
SCTID
A concept enumeration value that identifies the characteristic type of the relationship version (i.e. whether the relationship version is defining, qualifying, etc.) This field is set to a descendant of in the metadata hierarchy.
YES
NO
modifierId
SCTID
A concept enumeration value that identifies the type of Description Logic (DL) restriction (some, all, etc.). Set to a child of in the metadata hierarchy.
Currently the only value used in this column is and thus in practical terms this column can be ignored. For further clarification please see .
YES
NO
id
SCTID
Uniquely identifies the relationship.
NO
YES
(Full/
Snapshot)
id
UUID
A 128 bit unsigned Integer, uniquely identifying this reference set member.
Different versions of a reference set member share the same id but have different effectiveTime. This allows a reference set member to be modified or made inactive (i.e. removed from the active set) at a specified time.
NO
YES (Full /Snapshot)
effectiveTime
Time
The inclusive date or time at which this version of the identified reference set member became the current version.
Note: In distribution files the effectiveTime should follow the short ISO date format (YYYYMMDD) and should not include the hours, minutes, seconds or timezone indicator.
The current version of this reference set member at time T is the version with the most recent effectiveTime prior to or equal to time T.
YES
YES (Full)
Optional (Snapshot)
The following metadata hierarchy supports this reference set:
Simple map with correlation from SNOMED CT type reference sets in the Metadata Hierarchy
900000000000454005 |Foundation metadata concept| 900000000000455006 |Reference set| 1193542003 |Simple map with correlation from SNOMED CT type reference set|
The tables below show the descriptors that define examples of reference sets that follow the 1193546000 |Map source to map target correlation (foundation metadata concept)| pattern.
Refset Descriptor rows for Simple map with correlation from SNOMED CT type reference set
Sample Content from a Simple map with correlation from SNOMED CT type reference set
10228000
id
UUID
A 128 bit unsigned Integer, uniquely identifying this reference set member.
Different versions of a reference set member share the same id but have different effectiveTime. This allows a reference set member to be modified or made inactive (i.e. removed from the active set) at a specified time.
NO
YES (Full /Snapshot)
effectiveTime
Time
The inclusive date or time at which this version of the identified reference set member became the current version.
Note: In distribution files the effectiveTime should follow the short ISO date format (YYYYMMDD) and should not include the hours, minutes, seconds or timezone indicator.
The current version of this reference set member at time T is the version with the most recent effectiveTime prior to or equal to time T.
YES
YES (Full)
Optional (Snapshot)
The following metadata supports the description format reference set:
Description Format Reference Set in the Metadata Hierarchy
9900000000000454005 |Foundation metadata concept| 900000000000455006 |Reference set| 900000000000538005 |Description format|
The table below shows the descriptor that defines the structure of the 900000000000538005 |Description format reference set| .
Refset Descriptor rows for Description Format Reference Set
This example holds the all the members of the 900000000000538005 |Description format reference set| in the SNOMED CT International Release for July 2014. Other members may added to future versions of the International Release if new description types are introduced. Owners of Extensions that support additional description types must also add members to the 900000000000538005 |Description format reference set| .
Sample Content from the Description Format Reference Set
255
id
UUID
A 128 bit unsigned Integer, uniquely identifying this reference set member.
Different versions of a reference set member share the same id but have different effectiveTime. This allows a reference set member to be modified or made inactive (i.e. removed from the active set) at a specified time.
NO
YES (Full /Snapshot)
effectiveTime
Time
The inclusive date or time at which this version of the identified reference set member became the current version.
Note: In distribution files the effectiveTime should follow the short ISO date format (YYYYMMDD) and should not include the hours, minutes, seconds or timezone indicator.
The current version of this reference set member at time T is the version with the most recent effectiveTime prior to or equal to time T.
YES
YES (Full)
Optional (Snapshot)
active
Boolean
The state of the identified reference set member as at the specified effectiveTime .
If active = 1 (true) the reference set member is part of the current version of the set, if active = 0 (false) the reference set member is not part of the current version of the set.
YES
NO
moduleId
SCTID
Identifies the SNOMED CT module that contains this reference set member as at the specified effectiveTime .
The value must be a subtype of within the metadata hierarchy.
YES
NO
refsetId
SCTID
Identifies the reference set to which this reference set member belongs.
In this case, set to
NO
NO
referencedComponentId
SCTID
A reference to the SNOMED CT component to be included in the reference set.
Identifies the SNOMED CT module to which the given concept model refset is applied. The value must be a subtype of within the metadata hierarchy.
NO
NO
mrcmRuleRefsetId
SCTID
A subtype of that defines the concept model rules that are applied to content in the module identified by referencedComponentId.
NO
NO
The following metadata hierarchy supports this reference set:
The table below shows the reference set descriptor for the 723563008 |MRCM module scope reference set| pattern.
The table below shows some example rows from the 723563008 |MRCM module scope reference set|.
sourceId
destinationId
relationship Group
typeId
characteristicTypesId
53442002 |Excision of stomach structure|
116680003
|Is a|
0
71388002 |Procedure|
900000000000010007 |Stated relationship|
Section Necessary Conditions and Sufficient Definitions, illustrated the following three points, which are not supported by the current use of relationships to represent concept definitions:
A concept may have more than one sufficient definition.
Use of relationships only supports representation of a single sufficient definition for each concept. If a concept is marked as sufficiently defined, all it relationships are considered to be part of its sufficient definition.
A concept may have a sufficient definition that includes some assertions that are not necessary conditions
Relationships are all assumed to be necessarily true.
Some necessary conditions may not be part of a sufficient definition.
Including these additional necessary conditions may cause some valid subtypes concepts (or expressions) to be omitted from the results of classification.
Section Additional Logic Features, identifies other useful features that are supported by description logic tools but cannot be represented using only SNOMED CT.
Relationships can be distributed in an easy to understand relational file structure. The relationship file has been an established part of the standard set of SNOMED CT release files since the first release in 2002, with a revision in 2011-2012 to use RF2 to enhance versioning capabilities. Relationships can be retrieved, displayed and processed using widely understood techniques such as SQL making it easy to join the relationships to the concepts to which they relate.
The stated view of concept definitions needed to be enhanced to allow more flexible and expressive use of description logic. The structure of the relationship file was not suitable for this and a decision was made to adopt the OWL Functional Syntax so that new DL features could be added over time. As a result, the stated relationship file was deprecated.
Information about the new representation for the stated view is included in section Concept Definitions Represented in OWL.
The current relationship file continues to be released containing the inferred view. Due to limitations of the relationship file format, the inferred definitions do not contain the more sophisticated DL features. The relationship file:
only contains necessary conditions
does not distinguish between multiple sufficient definitions, regardless of whether each necessary condition is part of any of the sufficient definitions.
Nevertheless, the end result is still more complete and precise than the previous content of this file. The reason for this is that the inferred relationships in the file is generated by processing the enhanced stated view. Details of the way the inferred relationships are generated from the stated view are documented in Generating Necessary Normal Form Relationships from the OWL Refsets.

An 723589008 |MRCM domain reference set| enumerates the concept domains to which SNOMED CT attributes may be applied, and provides additional information to support these concept domains.
Each concept domain is uniquely identified by a SNOMED CT concept. When the scope of a domain covers the concepts in a particular hierarchy (or subhierarchy), the supertype concept of this hierarchy (or subhierarchy) is used to identify the domain. When a domain is defined based on membership in a reference set, the associated reference set concept is used to identify the domain. In some situations, a query may be required to define a complex domain. In these cases, the query's expansion reference set (referred to by the 'referencedComponent' of the relevant Query reference set) is used to identify the domain.
For each domain in the SNOMED CT concept model, the 723589008 |MRCM domain reference set| will contain exactly one member. This reference set member will include an Expression Constraint that defines the concepts in the domain, the identifier of the immediate parent domain (or domains), the domain constraint defined in terms of its proximal primitive concepts and associated mandatory refinements, a generic Domain Expression Template for both precoordinated and postcoordinated content, and a reference to the associated guidance that provides additional human-readable text describing this domain. Please note that it is anticipated that the generic Domain Expression Templates will be specialized further for authoring of specific subdomains using specializations stored in a Template Library.
An 723589008 |MRCM domain reference set| is structured as shown in the following table.
The following metadata hierarchy supports this reference set:
The table below shows the reference set descriptor for a reference set that follows the pattern.
The table below shows some example rows from a reference set that uses the format of the .
Please note that the generic domain templates defined for the SNOMED CT International Edition are designed to support a proximal primitive parent authoring approach. However, domain templates included in an extension's may be designed to support a proximal parent authoring approach if required.
The Concrete Value file holds one relationship per row. Each relationship is of a particular type, and has a source concept and a value. An example of a relationship taking a concrete value is given below:
322236009 |Product containing precisely paracetamol 500 milligram/1 each conventional release oral tablet (clinical drug)| 1142135004 |Has presentation strength numerator value (attribute)| #500 where:
1142135004 |Has presentation strength numerator value (attribute)| is the relationship type concept and;
#500 is the value
Concrete Value file - Detailed specification
In general, the rules and behaviour of the Concrete Value file is identical to that of the Relationship file, with the destinationId column replaced with a value column.
Only one relationship record with the same id field will be current at any point in time. The current record will be the one with the most recent effectiveTime before or equal to the point in time under consideration.
If the active field of this record is false ('0'), then the relationship is inactive at that point in time. If the active field is true ('1'), then there is a relationship between the SNOMED CT concepts identified by sourceId and value.
The sourceId, typeId, value, relationshipGroup, characteristicTypeId and modifierId will not change between two rows with the same id. In other words, they are immutable. Where a change is required to one of these fields, then the current row will be de-activated (by appending a row with the same id and the active field set to false) and a new row with a new id will be appended. The relationshipGroup field is used to group relationships with the same sourceId field into one or more logical sets. A relationship with a relationshipGroup field value of '0' is considered not to be grouped. All relationships with the same sourceId and non-zero relationshipGroup are considered to be logically grouped.
The relationshipGroup field will be an unsigned Integer, and will not be limited to a single digit value. There is no guarantee that they will be assigned sequentially, and the values will not be unique across concepts.
The value field is restricted to 4096 (4K) characters in length.
S.
A allows a set of components to be specified for inclusion or exclusion for a specified purpose. This type of reference set represents an extensional definition of a subset of SNOMED CT components. Thus it can be used to fully enumerate a subset of concepts, descriptions or relationships.
See also , which can be used to represent an intensional definition of a subset of SNOMED CT components. In an intensional definition, the members of the subset are specified by rules rather than by enumerations (e.g. all subtypes of a specified concepts).
A Simple Reference Set does not have any additional fields.
Simple Reference Set - Data Structure
active
Boolean
The state of the identified reference set member as at the specified effectiveTime .
If active = 1 (true) the reference set member is part of the current version of the set, if active = 0 (false) the reference set member is not part of the current version of the set.
YES
NO
moduleId
SCTID
Identifies the SNOMED CT module that contains this reference set member as at the specified effectiveTime .
The value must be a subtype of 900000000000443000 |Module (core metadata concept)| within the metadata hierarchy.
YES
NO
refsetId
SCTID
Identifies the reference set to which this reference set member belongs.
In this case, a subtype descendant of: 900000000000538005 |Description format reference set (foundation metadata concept)|
NO
NO
referencedComponentId
SCTID
A reference to the SNOMED CT component to be included in the reference set.
Refers to the concept that represents the description type for which this row defines the format.
NO
NO
descriptionFormat
SCTID
A reference to a subtype of 900000000000539002 |Description format (foundation metadata concept)| attribute which specifies the format of terms in descriptions of this description type.
NO
NO
descriptionLength
Integer
The maximum length in bytes of the terms in descriptions of this description type.
NO
NO
0
1
2
255
4096
0
1
53442002 |Excision of stomach structure|
260686004 |Method|
1
129304002 |Excision - action|
900000000000010007 |Stated relationship|
53442002 |Excision of stomach structure|
405813007 |Procedure site - Direct|
1
69695003 |Stomach structure|
900000000000010007 |Stated relationship|
effectiveTime
Time
The inclusive date or time at which this version of the identified reference set member became the current version.
Note: In distribution files the effectiveTime should follow the short ISO date format (YYYYMMDD) and should not include the hours, minutes, seconds or timezone indicator.
The current version of this reference set member at time T is the version with the most recent effectiveTime prior to or equal to time T.
YES
YES (Full)
Optional (Snapshot)
active
Boolean
The state of the identified reference set member as at the specified effectiveTime .
If active = 1 (true) the reference set member is part of the current version of the set, if active = 0 (false) the reference set member is not part of the current version of the set.
YES
NO
moduleId
SCTID
Identifies the SNOMED CT module that contains this reference set member as at the specified effectiveTime .
The value must be a subtype of within the metadata hierarchy.
YES
NO
refsetId
SCTID
Identifies the reference set to which this reference set member belongs.
In this case, a subtype descendant of:
NO
NO
referencedComponentId
SCTID
A reference to the SNOMED CT component to be included in the reference set. A reference to the SNOMED CT concept that identifies the relevant concept domain.
NO
NO
domainConstraint
String
An expression constraint, which defines the set of concepts included in the given concept domain.
This string can be parsed using the ABNF syntax defined for the .
YES
NO
parentDomain
String
An expression constraint, which represents the set of immediate parent domains.
An immediate parent domain is a domain that is a proper superset of the given domain, and which is not a proper superset of any other parent domain.
YES
NO
proximalPrimitiveConstraint
String
The domain constraint, as it would be represented for proximal primitive modelling. If the domain concept is sufficiently defined, then its proximal primitive parent will be used instead, while if the domain concept is primitive, then the concept itself is used. Additional constraints on the proximal primitive parent are also included.
The expansion of the given constraint must be further filtered to find those concepts with a definitionStatusId = .
This string can be parsed using the ABNF syntax defined for the .
YES
NO
proximalPrimitiveRefinement
String
The template representation of any additional refinements that are required to model in the given domain using proximal primitive modelling. These mandatory refinements reflect the defining relationships of the domain concept, when it is sufficiently defined.
This string can be parsed using the 'refinement' rule in the ABNF syntax defined for the .
YES
NO
domainTemplateForPrecoordination
String
A general template that may be used to author precoordinated content. This template incorporates all of the mandatory attribute domain and range rules rules for precoordinated SNOMED CT content.
This string can be parsed using the Expression Template Language (currently under development).
YES
NO
domainTemplateForPostcoordination
String
A general template that may be used to author postcoordinated content. This template incorporates all of the mandatory attribute domain and range rules rules for postcoordinated SNOMED CT content.
This string can be parsed using the Expression Template Language (currently under development).
YES
NO
guideURL
URL
A Uniform Resource Locator (URL) that references a web resource in which the given domain is described in further detail.
This URL uses the following pattern: "http://snomed.org/dom<conceptId>"
YES
NO
0
1
2
3
4
5
6
7
<<
<<
[[+id(<< )]]: [[0..*]] { [[0..*]] = [[+id(<< )]], [[0..*]] = [[+id(<< )]], [[0..*]] = [[+id(<< )]], [[0..*]] = [[+id(<< OR << )]], [[0..*]] = [[+id(<< OR << )]], [[0..*]] = [[+id(<< )]], [[0..*]] = [[+id(<< )]], [[0..*]] = [[+id(<< )]], [[0..*]] = [[+id(<< )]], [[0..*]] = [[+id(<< )]], [[0..*]] = [[+id(<< )]], [[0..*]] = [[+id(<< )]], [[0..*]] = [[+id(<< )]], [[0..*]] = [[+id(<< )]], [[0..*]] = [[+id(<< )]], [[0..*]] = [[+id(<< OR << OR << OR << OR << )]], [[0..*]] = [[+id(<< OR << OR << )]], [[0..*]] = [[+id(<< )]], [[0..*]] = [[+id(<< )]], [[0..*]] = [[+id(<< )]], [[0..*]] = [[+id(<< )]] }
[[+scg(<< )]]: [[0..*]] { [[0..*]] = [[+scg(<< )]], [[0..*]] = [[+scg(<< )]], [[0..*]] = [[+scg(<< )]], [[0..*]] = [[+scg(<< OR << )]], [[0..*]] = [[+scg(<< OR << )]], [[0..*]] = [[+scg(<< )]], [[0..*]] = [[+scg(<< )]], [[0..*]] = [[+scg(<< )]], [[0..*]] = [[+scg(<< )]], [[0..*]] = [[+scg(<< )]], [[0..*]] = [[+scg(<< )]], [[0..*]] = [[+scg(<< )]], [[0..*]] = [[+scg(<< )]], [[0..*]] = [[+scg(<< )]], [[0..*]] = [[+scg(<< )]], [[0..*]] = [[+scg(<< OR << OR << OR << OR << )]], [[0..*]] = [[+scg(<< OR << OR << )]], [[0..*]] = [[+scg(<< )]], [[0..*]] = [[+scg(<< )]], [[0..*]] = [[+scg(<< )]], [[0..*]] = [[+scg(<< )]] }
<<
<<
[[1..*]] = [[+(<< )]]
[[+id(<< )]]: [[0..*]] { [[1..*]] = [[+id(<< )]], [[0..*]] = [[+id(<< OR << OR << OR << OR << OR << OR << OR << )]], [[0..*]] = [[+id(<< )]], [[0..*]] = [[+id(<< )]], [[0..*]] = [[+id(<< )]], [[0..*]] = [[+id(<< OR << OR << OR << OR << OR << OR << )]], [[0..*]] = [[+id(<< )]], [[0..*]] = [[+id(<< )]], [[0..*]] = [[+id(<< )]], [[0..*]] = [[+id(<< )]], [[0..*]] = [[+id(<< OR << )]], [[0..*]] = [[+id(<< OR << )]], [[0..*]] = [[+id(<< )]], [[0..*]] = [[+id(<< )]], [[0..*]] = [[+id(<< )]], [[0..*]] = [[+id(<< )]], [[0..*]] = [[+id(<< )]], [[0..*]] = [[+id(<< )]], [[0..*]] = [[+id(<<
[[+scg(<< )]]: [[0..*]] { [[1..*]] = [+scg(<< )]], [[0..*]] = [[+scg(<< OR << OR << OR << OR << OR << OR << OR << )]], [[0..*]] = [[+scg(<< )]], [[0..*]] = [[+scg(<< )]], [[0..*]] = [[+scg(<< )]], [[0..*]] = [[+scg(<< OR << OR << OR << OR << OR << OR << )]], [[0..*]] = [[+scg(<< )]], [[0..*]] = [[+scg(<< )]], [[0..*]] = [[+scg(<< )]], [[0..*]] = [[+scg(<< )]], [[0..*]] = [[+scg(<< OR << )]], [[0..*]] = [[+scg(<< OR << )]], [[0..*]] = [[+scg(<< )]], [[0..*]] = [[+scg(<< )]], [[0..*]] = [[+scg(<< )]], [[0..*]] = [[+scg(<< )]], [[0..*]] = [[+scg(<< )]], [[0..*]] = [[+scg(<< )]], [[0..*]] = [[+scg(<<
id
UUID
A 128 bit unsigned Integer, uniquely identifying this reference set member.
Different versions of a reference set member share the same id but have different effectiveTime. This allows a reference set member to be modified or made inactive (i.e. removed from the active set) at a specified time.
NO
YES (Full /Snapshot)
effectiveTime
Time
Specifies the inclusive date at which the component version's state became the then current valid state of the component.
Note : In distribution files the effectiveTime should follow the short ISO date format (YYYYMM DD) and should not include the hours, minutes, seconds or timezone indicator.
YES
YES
(Full) Optional (Snapshot)
active
Boolean
Specifies whether the state of the relationship was active or inactive from the nominal release date specified by the effectiveTime field.
YES
NO
moduleId
SCTID
Identifies the relationship version's module. Set to a child of within the metadata hierarchy.
YES
NO
sourceId
SCTID
Identifies the source concept of the relationship version. That is the concept defined by this relationship. Set to the identifier of a concept.
NO
NO
value
String
Identifies the concrete value that is related to the relationship version.
This could be an Integer, Decimal or String. Numbers are prefixed with a # (hash) symbol. Strings are surrounded with " (double quote) with double quotes inside the string escaped using \ (backslash).
Note that the values that can be applied to particular attributes are formally defined by the.
NO
NO
relationshipGroup
Integer
Groups together relationship versions that are part of a logically associated relationshipGroup. All active Relationship records with the same relationshipGroup number and sourceId are grouped in this way.
YES
NO
typeId
SCTID
Identifies the concept that represent the defining attribute (or relationship type) represented by this relationship version.
That is the concept representing the value of the attribute represented by the typeId column.
Set to the identifier of a concept. The concept identified must be a subtype of . The concepts that can be used as in the typeId column of the Concrete Value file are formally defined as follows: < .
Note that the attributes that can be applied to particular concepts are formally defined by the .
NO
NO
characteristicTypeId
SCTID
A concept enumeration value that identifies the characteristic type of the relationship version (i.e. whether the relationship version is defining, qualifying, etc.) This field is set to a descendant of in the metadata hierarchy.
YES
NO
modifierId
SCTID
A concept enumeration value that identifies the type of Description Logic (DL) restriction (some, all, etc.). Set to a child of in the metadata hierarchy.
Currently the only value used in this column is and thus in practical terms this column can be ignored. For further clarification please see .
YES
NO
id
SCTID
Uniquely identifies the relationship.
NO
YES
(Full/ Snapshot)
active
Boolean
The state of the identified reference set member as at the specified effectiveTime .
If active = 1 (true) the reference set member is part of the current version of the set, if active = 0 (false) the reference set member is not part of the current version of the set.
YES
NO
moduleId
SCTID
Identifies the SNOMED CT module that contains this reference set member as at the specified effectiveTime.
The value must be a subtype of 900000000000443000 |Module (core metadata concept)| within the metadata hierarchy.
YES
NO
refsetId
SCTID
Identifies the reference set to which this reference set member belongs.
In this case, a subtype descendant of: |Simple map with correlation from SNOMED CT type reference set (foundation metadata concept)|
NO
NO
referencedComponentId
SCTID
A reference to the SNOMED CT component to be included in the reference set.
The SNOMED CT concept that is mapped to the code in the other terminology or code system.
NO
NO
mapTarget
String
The other-code to which the SNOMED CT concept is mapped.
NO
NO
correlationId
SCTID
The correlation between the SNOMED CT concept and the other-code. Possible values are the following subtypes of 1193546000 |Map source to map target correlation (foundation metadata concept)| :
<
YES
NO
0
1
2
10226000
11205000
id
UUID
A 128 bit unsigned Integer, uniquely identifying this reference set member.Different versions of a reference set member share the same id but have different effectiveTime. This allows a reference set member to be modified or made inactive (i.e. removed from the active set) at a specified time.
NO
YES (Full/Snapshot)
effectiveTime
Time
The inclusive date or time at which this version of the identified reference set member became the current version.
Note : In distribution files the effectiveTime should follow the short ISO date format (YYYYMM DD) and should not include the hours, minutes, seconds or timezone indicator.The current version of this reference set member at time T is the version with the most recent effectiveTime prior to or equal to time T.
YES
YES (Full) Optional (Snapshot)
Simple References Sets are subtypes of 446609009 | Simple type reference set| in the metadata hierarchy.
Simple Reference Sets in the Metadata Hierarchy
900000000000441003 |SNOMED CT Model Component| 900000000000454005 |Foundation metadata concept| 900000000000455006 |Reference set| 446609009 |Simple type reference set|
The table below shows the descriptor for a specific reference set that follows the |Simple type reference set| pattern.
Refset Descriptor rows for the Simple Reference Set Type
Example Data for a Simple Reference Set
A Member Annotation Refset will be created to support annotations on members of any reference set(s).
The SNOMED CT International Release contains Annotations content in two reference sets:
The Member Annotation String Value reference set, in which annotations are held on members of any reference set(s).
The Component Annotation String Value reference set, in which annotations are assigned to any SNOMED CT component.
A Member Annotation String Value reference set is structured as shown in the following table:
A Component Annotation String Value reference set should be named along the lines of the following convention:
der2_sscsRefset_MemberAnnotationStringValueSnapshot__[Product]_ __[date]_.txt
For example, for an International Release on 1st December 2023:
der2_sscsRefset_MemberAnnotationStringValueSnapshot_INT_20231201.txt
The reference set example tables on this page have been revised as follows to aid clarity and understanding:
The first four columns which are present in all release files are not shown. The omitted columns ( id, effectiveTime, active) are used in the same way in all referenced sets to support identification, versioning and packaging. They do not directly affect the specific features of a particular reference set or reference set type.
Reference set columns that contain SNOMED CT identifiers are expanded to show details of the concept or description referenced by that identifier. In some cases, the term is shown in the same column using the expression syntax, in other cases an additional column with a name suffix '_term' has been added. In the standard reference set files only the identifier is present in the column and there is no added column for the term. When using reference sets, the term and other details of the component are looked up from the relevant component release files.
The table below shows the descriptors that define the structure of the 1292995002 |Member annotation with string value reference set (foundation metadata concept) | pattern and examples of the descriptors for specific reference sets that follow this pattern.
Descriptor templates for Member Annotation String Value reference sets
The same value of the referencedComponentId from an annotated refset is assigned in the annotation refset. For example, this OWL axiom has a referencedComponentId 91302008 |Sepsis (disorder)| in the OWL expression refset. The annotated text could indicate the intended annotation target is the OWL axiom though it is not referenced in referencedComponentId. This simplifies the query of annotations by referencedComponent.
A supports the representation of simple maps from SNOMED CT concepts to SNOMED CT concepts. No constraints are put on the number of SNOMED CT concepts to which each SNOMED CT concept is mapped.
A is a Component - Component reference set used to represent maps from SNOMED CT concepts to SNOMED CT concepts. Its structure is shown in the following table.
Simple map with correlation from SNOMED CT to SNOMED CT type reference set - Data structure
A supports the representation of simple maps from SNOMED CT concepts to values in other code systems. No constraints are put on the number of coding schemes supported, the number of codes within a particular scheme mapped to by a single SNOMED CT concept or the number of SNOMED CT concepts mapping to a particular code. However, this type of reference set is usually only appropriate where there is a close "one-to-one" mapping between SNOMED CT concepts and coded values in another code system.
A is a String Reference Set used to represent maps from SNOMED CT concepts to codes in another terminology, classification or code system. Its structure is shown in the following table.
Table: Simple map from SNOMED CT reference set - Data structure
active
Boolean
The state of the identified reference set member as at the specified effectiveTime. If active = 1 (true) the reference set member is part of the current version of the set, if active = 0 (false) the reference set member is not part of the current version of the set.
YES
NO
moduleId
SCTID
Identifies the SNOMED CT module that contains this reference set member as at the specified effectiveTime .
The value must be a subtype of 900000000000443000 |Module (core metadata concept)| within the metadata hierarchy.
YES
NO
refsetId
SCTID
Identifies the reference set to which this reference set member belongs.
A subtype descendant of:
NO
NO
referencedComponentId
SCTID
A reference to the SNOMED CT component to be included in the reference set.
NO
NO
0

effectiveTime
Time
The inclusive date or time at which this version of the identified reference set member became the current version.
Note: In distribution files the effectiveTime should follow the short ISO date format (YYYYMMDD) and should not include the hours, minutes, seconds or timezone indicator.
The current version of this reference set member at time T is the version with the most recent effectiveTime prior to or equal to time T.
YES
YES (Full)
Optional (Snapshot)
active
Boolean
The state of the identified reference set member as at the specified effectiveTime .
If active = 1 (true) the reference set member is part of the current version of the set, if active = 0 (false) the reference set member is not part of the current version of the set.
YES
NO
moduleId
SCTID
Identifies the SNOMED CT module that contains this reference set member as at the specified effectiveTime .
The value must be a subtype of within the metadata hierarchy.
YES
NO
refsetId
SCTID
Identifies the reference set to which this reference set member belongs.
In this case, a subtype descendant of: 1292995002 |Member annotation with string value reference set (foundation metadata concept)|.
NO
NO
referencedComponentId
SCTID
A reference to the SNOMED CT component to be included in the reference set.
The SNOMED CT component to which the Annotation applies.
NO
NO
referencedMemberId
UUID
The UUID of the relevant member of the reference set in SNOMED CT.
NO
NO
languageDialectCode
String
Specifies the language of the Annotation text using the two character ISO-639-1 code. Note that this specifies a language level only, not a country code. However, a dialect can also be included by following the standard , although this is an optional inclusion. The new concept 1304275002 |Language or dialect code (foundation metadata concept)| has been added for the metadata for this refset.
NOTE: This field should be blank wherever a language code is not applicable, but never NULL.
YES
NO
typeId
SCTID
Any descendant of 1295447006 |Annotation attribute (attribute)| minus 1295449009 |Additional relationship attribute (attribute)| and its descendant in the attribute hierarchy.
NO
NO
value
String
The Annotation text itself, with a maximum size of 32Kb, represented in encoding.
YES
NO
1292995002 |Member annotation with string value reference set (foundation metadata concept) |
1296891007 |Annotated member (foundation metadata concept)|
900000000000464001 |Reference set member type component|
1
1292995002 |Member annotation with string value reference set (foundation metadata concept) |
1304275002 |Language or dialect code (foundation metadata concept)|
900000000000465000 |String (foundation metadata concept)|
2
1292995002 |Member annotation with string value reference set (foundation metadata concept) |
1296892000 |Annotation type (foundation metadata concept)|
900000000000461009 |Concept type component|
3
1292995002 |Member annotation with string value reference set (foundation metadata concept) |
900000000000519001 |Annotation value|
900000000000465000 |String (foundation metadata concept)|
4
20240131
1
1292995002 | Member annotation with string value reference set (foundation metadata concept) |
91302008 |Sepsis (disorder)|
3ddfb6d2-0874-4916-8767-8d48c781d435
en
|Change note (attribute)| (to be released)
In the third International Consensus Definitions for Sepsis and Septic Shock (Sepsis-3) published in 2016, the new definition eliminated the requirement for the presence of systemic inflammatory response syndrome (SIRS) to define sepsis. The sepsis is now logically defined as Organ dysfunction syndrome (disorder) with pathological process of disregulated host response due to infectious disease.
id
UUID
A 128 bit unsigned Integer, uniquely identifying this reference set member.
Different versions of a reference set member share the same id but have different effectiveTime. This allows a reference set member to be modified or made inactive (i.e. removed from the active set) at a specified time.
NO
YES (Full /Snapshot)
1292995002 |Member annotation with string value reference set (foundation metadata concept) |
900000000000460005 |Component type (foundation metadata concept)|
excluding the postcoordinated expression and rerfset member type components
0
00000000-1111-2222-3333-444444444444
id
UUID
A 128 bit unsigned Integer, uniquely identifying this reference set member.
Different versions of a reference set member share the same id but have different effectiveTime. This allows a reference set member to be modified or made inactive (i.e. removed from the active set) at a specified time.
NO
YES (Full /Snapshot)
effectiveTime
Time
The inclusive date or time at which this version of the identified reference set member became the current version.
Note: In distribution files the effectiveTime should follow the short ISO date format (YYYYMMDD) and should not include the hours, minutes, seconds or timezone indicator.
The current version of this reference set member at time T is the version with the most recent effectiveTime prior to or equal to time T.
YES
YES (Full)
Optional (Snapshot)
The following metadata hierarchy supports this reference set:
Simple map with correlation to |SNOMED CT type reference set (foundation metadata concept)| in the Metadata Hierarchy
900000000000454005 |Foundation metadata concept| 900000000000455006 |Reference set| 1193544002 |Simple map with correlation from SNOMED CT to SNOMED CT type reference set (foundation metadata concept)|
The tables below show the descriptors that define examples of reference sets that follow the 1187636009 |Simple map to SNOMED CT type reference set (foundation metadata concept)| pattern.
Refset Descriptor rows for Simple Map with correlation from SNOMED CT to SNOMED CT Reference Set
Sample Content from a Simple Map with correlation from SNOMED CT to SNOMED CT Reference Set
id
UUID
A 128 bit unsigned Integer, uniquely identifying this reference set member.
Different versions of a reference set member share the same id but have different effectiveTime. This allows a reference set member to be modified or made inactive (i.e. removed from the active set) at a specified time.
NO
YES (Full /Snapshot)
effectiveTime
Time
The inclusive date or time at which this version of the identified reference set member became the current version.
Note: In distribution files the effectiveTime should follow the short ISO date format (YYYYMMDD) and should not include the hours, minutes, seconds or timezone indicator.
The current version of this reference set member at time T is the version with the most recent effectiveTime prior to or equal to time T.
YES
YES (Full)
Optional (Snapshot)
The following metadata hierarchy supports this reference set:
Simple Map from SNOMED CT Reference Sets in the Metadata Hierarchy
900000000000454005900000000000454005 |Foundation metadata concept| 900000000000455006 |Reference set| 900000000000496009 |Simple map from SNOMED CT|
The tables below show the descriptors that define examples of reference sets that follow the 900000000000496009 |Simple map from SNOMED CT reference set| pattern.
Refset Descriptor rows
Sample Content from a Simple Map From SNOMED CT Reference Set
G-3000
A 1193543008 |Simple map with correlation to SNOMED CT type reference set (foundation metadata concept)| supports the representation of simple maps from values in other code systems to SNOMED CT concepts. No constraints are put on the number of SNOMED CT concepts to which a particular code is mapped.
A 1193543008 |Simple map with correlation to SNOMED CT type reference set (foundation metadata concept)| is a String - Component reference set used to represent maps from codes in another terminology, classification or code system to SNOMED CT concepts. Its structure is shown in the following table.
Simple map with correlation to SNOMED CT type reference set - Data structure
The following metadata hierarchy supports this reference set:
Simple map with correlation to SNOMED CT type reference set (foundation metadata concept)| in the Metadata Hierarchy
The tables below show the descriptors that define examples of reference sets that follow the pattern.
Refset Descriptor rows for Simple map with correlation to SNOMED CT type reference set
Sample Content from a Simple Map to SNOMED CT Reference Set
active
Boolean
The state of the identified reference set member as at the specified effectiveTime .
If active = 1 (true) the reference set member is part of the current version of the set, if active = 0 (false) the reference set member is not part of the current version of the set.
YES
NO
moduleId
SCTID
Identifies the SNOMED CT module that contains this reference set member as at the specified effectiveTime.
The value must be a subtype of 900000000000443000 |Module (core metadata concept)| within the metadata hierarchy.
YES
NO
refsetId
SCTID
Identifies the reference set to which this reference set member belongs.
In this case, a subtype descendant of: 900000000000496009 |Simple map from SNOMED CT type reference set|
NO
NO
referencedComponentId
SCTID
A reference to the SNOMED CT component to be included in the reference set.
Refers to the SNOMED CT concept from which the mapTarget is mapped (i.e. the map source).
NO
NO
mapTarget
String
The equivalent code in the other terminology, classification or code system, to which the referencedComponentId is mapped.
YES
NO
0
1
L-55535
F-D5972
L-37904
P1-18376
DD-82950
T-D8602
T-F1102
T-49723
D9-12000
Boolean
The state of the identified reference set member as at the specified effectiveTime .
If active = 1 (true) the reference set member is part of the current version of the set, if active = 0 (false) the reference set member is not part of the current version of the set.
YES
NO
moduleId
SCTID
Identifies the SNOMED CT module that contains this reference set member as at the specified effectiveTime.
The value must be a subtype of within the metadata hierarchy.
YES
NO
refsetId
SCTID
Identifies the reference set to which this reference set meIdentifies the reference set to which this reference set member belongs.
In this case, a subtype descendant of:
NO
NO
referencedComponentId
SCTID
A reference to the SNOMED CT component to be included in the reference set.
The SNOMED CT concept to which the code in the other terminology or code system is mapped.
NO
NO
mapSource
String
The other-code which maps to the SNOMED CT concept.
NO
NO
correlationId
SCTID
The correlation from the other-code to the SNOMED CT concept. Possible values are the following subtypes of :
YES
NO
0
1
2
11205000
id
UUID
A 128 bit unsigned Integer, uniquely identifying this reference set member.
Different versions of a reference set member share the same id but have different effectiveTime. This allows a reference set member to be modified or made inactive (i.e. removed from the active set) at a specified time.
NO
YES (Full /Snapshot)
effectiveTime
Time
The inclusive date or time at which this version of the identified reference set member became the current version.
Note: In distribution files the effectiveTime should follow the short ISO date format (YYYYMMDD) and should not include the hours, minutes, seconds or timezone indicator.
The current version of this reference set member at time T is the version with the most recent effectiveTime prior to or equal to time T.
YES
YES (Full)
Optional (Snapshot)
10228000
active
10226000
active
Boolean
The state of the identified reference set member as at the specified effectiveTime .
If active = 1 (true) the reference set member is part of the current version of the set, if active = 0 (false) the reference set member is not part of the current version of the set.
YES
NO
moduleId
SCTID
Identifies the SNOMED CT module that contains this reference set member as at the specified effectiveTime.
The value must be a subtype of 900000000000443000 |Module (core metadata concept)| within the metadata hierarchy.
YES
NO
refsetId
SCTID
Identifies the reference set to which this reference set member belongs.
In this case, a subtype descendant of: 1193544002 |Simple map with correlation from SNOMED CT to SNOMED CT type reference set (foundation metadata concept)|
NO
NO
referencedComponentId
SCTID
A reference to the SNOMED CT component to be included in the reference set.
The SNOMED CT concept (mapSource) that is mapped to another SNOMED CT concept.
NO
NO
mapTarget
String
The SNOMED CT concept to which the referencedComponentId is mapped.
NO
NO
correlationId
SCTID
The correlation between the referencedComponentId (mapSource) and the mapTarget. Possible values are the following subtypes of 1193546000 |Map source to map target correlation (foundation metadata concept)| :
YES
NO
0
1
2
Historical Association Reference Sets are used to link concepts that have been inactivated to active concepts that represent an identical, similar or possible meaning of the inactivated concept.
Historical Association Reference Sets follow the release file specification documented in with the inactive concept represented by the referencedComponentId, the type of association represented by the refsetId and the related active concept represented by the targetComponentId.
The following subsections identify the metadata used to represent different types of historical associations.
The following metadata supports this reference set:
Historical Association Reference Set names in the metadata hierarchy
Each member of a |Historical association Reference Set| represents a reference from an inactive component to other equivalent or related components that were current in the Release Version in which that component was inactivated.
Each |Historical association Reference Set| represents a different type of association between the components referred to by the referencedComponentId and the targetComponentId as shown in the Table below.
Association reference set types in the International Release of SNOMED CT
Applies to a concept that is ambiguous. The targetComponent is an active concept that represents one of the possible meanings of the inactive concept . Multiple rows are used to refer to each of the possible meanings of the ambiguous concept.
Applies to a component that has been moved to (or are pending a move to) another namespace. The targetComponent identifies the target namespace (not the new component).
The component identified by the targetComponentId must be an instance of the same class of component as the component identified by the referencedComponentId for all Historical association reference sets apart from the |REFERS TO concept association reference set|.
The tables below show examples of the descriptors for specific reference sets that follow the |Association type reference set| pattern.
Refset Descriptor rows for the SAME AS association reference set
The following table holds example entries for the |REPLACED BY association reference set|.
Sample content from
Practical Guide to Reference Sets Representing Historical Associations
An 447258008 |Ordered type reference set| allows a collection of components to be defined with a specified given a priority ordering. This type of reference ret can also be used to specify ordered associations between different components. These can be used to specify several interrelated subsets of components and to define alternative hierarchies for navigation and selection of concepts or descriptions.
An Ordered Reference Set is an Integer Component Reference Set used to represent ordered lists and alternative hierarchies. Its structure is shown in the following table.
Ordered reference set - Data structure
The following metadata in the "Foundation metadata concept" hierarchy supports this reference set.
Ordered References Sets in the Metadata Hierarchy
The tables below show the descriptor that defines the structure of the pattern and an example of descriptor for a reference set that follows this pattern.
Refset Descriptor rows for Ordered Reference Set
Sample Content for an Ordered Reference Set
The basic pattern for SNOMED CT release file names consists of five elements, each separated by an underscore (" _ ") and followed by a full stop (" . ") and a file extension:
Each element in the above structure is described in more detail by table in the following section.
The FileType element of the filename designates the type and intended use of the release file. It consists of a 3 to 5 alphanumeric code with letters in lowercase.
The code comprises the following three sub-elements. The Type sub-element is required in all cases, other elements are required where relevant and otherwise omitted.
FileType Element - Sub-elements and Permitted Values
The ContentType element is mandatory for all FileTypes. It describes the content and purpose of the file. It consists of 2-48 alphanumeric characters in camel case.
The content of this element depends on the first element (FileType) of the filename, as described below:
ContentType Element - Permitted Values for FileType "sct"
ContentType Element - Permitted Values for FileType "der"
ContentType Element - Permitted Values for FileTypes "doc","res" and "tls"
The ContentSubType element is mandatory for all FileTypes. It provides additional information to describe the content and purpose of the file, including the language/ dialect, where appropriate. Its format is 2-48 alphanumeric characters in camel case (except for the capitalization rules specified below for languagecode). Hyphen (" - ") is a permitted character in conjunction with a language code, as described below.
ContentSubType Element - Sub-elements and Permitted Values for FileTypes "sct" and "der"
ContentSubType Element - Sub-elements and Permitted Values for FileType "doc"
ContentSubType Element - Sub-elements and Permitted Values for FileTypes "res" and "tls"
Examples of ContentSubType
der2_cRefset_AttributeValueSnapshot _INT_20180131.txt
Summary=AttributeValue (type of refset),
Release type=Snapshot,
Language not stated
The CountryNamespace element is mandatory for all FileTypes. It identifies the organization responsible for developing and maintaining the file. It is a string of 2 to 10 alphanumeric characters consisting of the two sub-elements described below. At least one of these two sub-elements must be present. SNOMED International or a National Release Center (NRC) may optionally include both sub-elements where they consider this to be appropriate.
CountryNamespace Element - Sub-elements and Permitted Values
The VersionDate element is mandatory for all FileTypes. It identifies the SNOMED CT version with which the file is intended to be used. Its format is an 8-digit number in the pattern "YYYYMMDD", in compliance with the standard.
For Data Files(sct ,der or res), and for Documentation (doc) with a status tag value of "Current ", the value of this element should always be the same as the SNOMED CT version date with which the file is associated.
For other file types, the VersionDate element will identify the (past) date of the SNOMED CT release for which the file was intended. A file distributed with a past version date has not been updated to reflect changes to SNOMED CT since that date, nor has it been validated as correct or appropriate for current use.
The extension element of the filename identifies the file format (encoding convention) of the file, such as " txt ", " pdf " or " zip ". It has a format of 1-4 alphanumeric characters.
File Extensions Applicable to Different FileTypes
The 705109006 |Code to expression type reference set| is designed to enable associations between codes in another code system (other-codes) and SNOMED CT concepts, where the following constraints apply:
Some of the other-codes cannot be mapped to an individual SNOMED CT concept.
Licensing conditions (or other considerations) prevent addition of new SNOMED CT concepts to represent the same meaning as the other-codes.
The other-codes can be logically defined using the SNOMED concept model to represent the same meaning (sufficiently defined) or a similar though less specific meaning (primitive).
Other requirements similar for those applicable to mapping may also apply including:
An indication of the degree of correlation between the other-code and the SNOMED CT expression.
An indication of whether the other-code was created before any single concept representation of that meaning in SNOMED CT or whether the single concept representation in SNOMED CT predated the creation of the association.
The general approach to the above requirements is to associate each of the other-codes with a representation of the same logic based definition as would have been applied to a SNOMED CT concept with that meaning. However, since the other-code are not identified by an SCTID, the logical definition cannot be represented using defining relationships. There are two potential approaches to this, one would be to use a general purpose description logic language (e.g. OWL) and the other is to use a SNOMED CT expression to represent each definition. The is designed to support the expression-based approach.
Code to Expression Reference Set - Data structure
The following metadata hierarchy supports this reference set:
Code to Expression Reference Set in the Metadata Hierarchy
The tables below show the descriptors that define examples of reference sets that follow the pattern.
Refset Descriptor rows for a Code to Expression Reference Set
Sample Content from a Code to Expression Type Reference Set
Applies to a component that has been moved to this namespace from another namespace. The targetComponent identifies the original componentIdentifier in its previous namespace.
Applies to an erroneous, obsolete and other inactive component for which there is a single active replacement. The targetComponent identifies the active component that replaces this component.
Applies to a component that is a duplicate. The targetComponent identifies the active component that this component duplicates.
Links an inactive classification concept such as "not otherwise specified" or "otherwise specified" with the active concept that was formerly its most proximal supertype.
(not used currently)
Links an inactive classification concept derived from ICD-9 Chapter XVI "Symptoms signs and ill-defined conditions" with the most similar active concept.
Applies to an inactive description which is inappropriate to the concept it is directly linked to but instead should refer to the concept referenced by the targetComponent.
Applies to a component that is inactivated with reason outdated. The assigned targetComponent identifies two or more potential replacements that are active and represent the possible meanings of the inactive outdated component.
Applies to a component that is inactivated with reason classification derived. The assigned targetComponent identifies two or more replacements that are active and represent the possible meaning of the inactive component. This association signifies that all applied potential replacements must be implemented within the clinical record to ensure the original clinical idea is represented.
0
1
Boolean
The state of the identified reference set member as at the specified effectiveTime. If active = 1 (true) the reference set member is part of the current version of the set, if active = 0 (false) the reference set member is not part of the current version of the set.
YES
NO
moduleId
SCTID
Identifies the SNOMED CT module that contains this reference set member as at the specified effectiveTime .
The value must be a subtype of within the metadata hierarchy.
YES
NO
refsetId
SCTID
Identifies the reference set to which this reference set member belongs.
A subtype descendant of:
NO
NO
referencedComponentId
SCTID
A reference to the SNOMED CT component to be included in the reference set.
NO
NO
order
Integer
Specifies the sort order of the list. The list is ordered by applying an ascending sort of the order value.
The value of order =1 represents the highest priority. A value of '0' is not allowed. Duplicate values are permitted and the sort order between two members with the same order value is not defined.
If the linkedToId value is not 0, sorting occurs within subgroups that share the same linkedToId.
Note: The name "order" is a reserved word in some database environments. Please consider this when using this column.
YES
NO
linkedToId
SCTID
The identifier of a SNOMED CT component that acts as a grouper or hierarchy node, collecting together a subgroup from within the list.
This field either enables reference set member linked into a number of subgroups. These subgroups can be nested allowing representation of alternative hierarchies.
To link members into a subgroup, all components in the same subgroup should reference the same component. This can either be a component that represents the name of that subgroup or the first member of the subgroup. In the latter case, the first row of each subgroup will contain the same identifier in referencedComponentId and linkedToId and with order =1.
To link a number of children concepts to a single parent concept, one member record should exist per child, with the referencedComponentId field referencing the parent and this field referencing the child concept. The order field is then used to order the children concepts under the parent concept.
For ordered lists that do not require grouping or hierarchical arrangement the value of linkedToId should be the digit zero (0).
YES
NO
1
2
2
3
4
5
6
7
8
9
10
Ordered Component Reference Set
This allows an ordered or prioritized list of components to be represented.
It omits the linkedToId field in the pattern shown below as this is not required to address this use case.
Ordered Association Reference Set
This enables representation of alternative navigation hierarchies (in which child concepts are ordered) and also also supports representation of groups of ordered components.
The linkedToId field in the pattern shown below is replaced by the targetComponentId (this name is used to align with the Association Reference Set (used from unordered associations).
id
UUID
A 128 bit unsigned Integer, uniquely identifying this reference set member.Different versions of a reference set member share the same id but have different effectiveTime. This allows a reference set member to be modified or made inactive (i.e. removed from the active set) at a specified time.
NO
YES (Full/Snapshot)
effectiveTime
Time
The inclusive date or time at which this version of the identified reference set member became the current version.
Note : In distribution files the effectiveTime should follow the short ISO date format (YYYYMM DD) and should not include the hours, minutes, seconds or timezone indicator.The current version of this reference set member at time T is the version with the most recent effectiveTime prior to or equal to time T.
YES
YES (Full) Optional (Snapshot)
1
active
0
Description
The file conforms to the and contains at set of descriptions with description types |Synonym| and |Fully specified name|.
Note that both these description types have a maximum term length of 255 characters.
TextDefinition
The file conforms to the and contains at set of descriptions with description type .
Note: This description type has a maximum term length of 4096 characters.
StatedRelationship
The file conforms to the and contains relationships that represent the stated view of a set of concept definitions.
Note: It is likely this file will be phased out and replaced with a reference set containing a richer OWL representation of stated concept definition.
Identifier
The file conforms to the .
Note: This file does not contain any data rows in the International Edition.
Pattern letter i
A signed integer.
Pattern letter s
A UTF-8 text string.
Examples
cRefset : A refset with one additional column containing a component identifier. This pattern supports refset types including: , and).
ciRefset : A refset with two additional columns, one containing a component identifier and one containing an integer. This pattern supports refset types including:
sRefset : A refset with one additional column containing a string. This pattern supports refset types including:
The file contains the Full view of the components or refset members within its scope (i.e. every version ever released).
"
Snapshot
The file contains the Snapshot view of the components or refset members within its scope (i.e. only the most recent version released).
"
Delta
The file contains the Delta view of the components or refset members within its scope (i.e. only additions/changes since previous release).
LanguageCode
Where it is necessary to specify the language or dialect used in a file, the appropriate language code must be included as the final sub-element of the ContentSubType. If a Summary or DocStatus sub-element is also included, the LanguageCode must be added after the last of those sub-elements and must be separated from it by a hyphen.
Representation of the LanguageCode
The language is specified with a 2 character (e.g. es = Spanish, fr = French, da = Danish). If necessary, a dialect code is added after the language code and separated from it by a hyphen.
Depending on the specificity required the dialect code comes from one of two sources:
If the dialect is general to an entire country, the two-letter is used to specify the dialect (e.g. en-US = US English, en-GB British English)
The document is up-to-date and complete for the current release of SNOMED CT, as indicated by the VersionDate element.
"
Draft
The document is a draft version; it may be incomplete and has not been approved in a final version.
"
Review
The document has been released for review and comments from SNOMED International Members, Affiliates and other stakeholders.
LanguageCode
Where it is necessary to specify the language or dialect used in a file, the appropriate language code must be included as the final sub-element of the ContentSubType. If a Summary or DocStatus sub-element is also included, the LanguageCode must be added after the last of those sub-elements and must be separated from it by a hyphen.
sct2_Description_Snapshot-en _INT_20180131.txt
Release type=Snapshot,
Language=English
der2_cRefset_LanguageSnapshot-en _INT_20180131.txt
Summary=Language (type of refset),
Release type=Snapshot,
Language=English
doc_IhtsdoGlossary_Current-en-US _INT_20170817.pdf
DocStatus=Current,
Language=en-US.
The file is maintained and distributed by the NRC for the country represented by this . The code consists of exactly two uppercase characters from the latin alphabet.
"
<blank>
The file is maintained and released by an SNOMED CT extension provider that is not an NRC.
NamespaceId
0000000 to 9999999
The file is maintained and released by an SNOMED CT extension provider that is not an NRC. In which case, this value is a 7 digit namespace identifier allocated to that organization by SNOMED International.
The file is maintained and distributed by either SNOMED International or an NRC and the distributing organization has chosen to include the namespace identifier to indicate that this is part of a release restricted to content in a single namespace.
"
<blank>
The file is maintained and distributed by either SNOMED International or an NRC and the distributing organization has not chosen to include the namespace identifier to indicate that this is part of a release restricted to content in a single namespace.
is the default format for documents distributed and made available for download in a format suitable for local viewing or printing.
"
<other>
Other document formats including plain text (.txt) and HTML (.html) may be used where deemed appropriate. In all cases the file extension (suffix) used should be one of the widely recognized format. Unless there are exceptional requirements, the format should be accessible using freely available software.
res
txt
Most resources should be provided as plain text UTF-8 files with the .txt suffix.
"
zip
Where appropriate a resource file, or a collection of such files, may be distributed as zip archive.
"
<other>
Other data formats may be used where appropriate.
tls
<any>
No specific statements are made about the file extsions to be used for tooling files. However, in general such tools should be provided in a format that does not compromise system security. In most cases, tools should be provided through an interface such as GitHub and should not be included as part of general releases of the terminology.
Sub-element
Values
Description
Status
<blank>
General release file
"
x
Provisional release file (e.g. part of an alpha or beta release package ).
"
z
Archival or unsupported file
Type
sct
Terminology Data File
"
der
Derivative Work Data File (e.g. Reference set release file)
"
doc
Documentation
"
res
Implementation Resource Data File (e.g. a data file not following a SNOMED CT standard release file format)
"
tls
Implementation Resource Tool (e.g. scripts or other software made available to process a release file)
Format
1
Release Format 1
"
2
Release Format 2
"
<blank>
Not specific to a release version
Value
Usage
Concept
The file conforms to the Concept File Specification and contains data related to a set of concepts.
Relationship
The file conforms to the Relationship File Specification and contains relationships that represent the distribution normal form inferred view of a set of concept definitions.
sRefset
Value
Description
Refset
The file conforms to the Simple Reference Set specification and contains the members of one or more simple reference sets.
<pattern>Refset
The file conforms to the Basic Reference Set Member File Format and include one or more additional columns, The number and order of the columns and their basic data types are specified by the <pattern> which precedes Refset.
The <pattern> consists of a sequence of lowercase letters each of which represent an additional column with a datatype specified by the letter as listed below
Pattern letter c
FileType
Value and Description
doc
The title of the document in CamelCase, abbridges if necessary to fit within the length constraint.
Note: Abbreviations should not be used unless they are essential to fit the title within the available length.
Examples of ContentType for Documents
doc_SnomedDecisionSupport_Current-en-US_INT_20170331.pdf (Title: Decision Support with SNOMED CT)
doc_SearchDataEntryGuide_Current-en-US_INT_20171122 (Title: SNOMED CT Search and Data Entry Guide)
res
tls
The value of the ContentType element may be determined on a case-by-case basis but, in conjunction with the ContentSubType element, should be adequate to identify the content and purpose of the file.
Sub-elements
Values
Description
Summary
An optional short camel case summary of the usage of the file. The value of this sub-element may be determined on a case-by-case basis but, in conjunction with the ContentType element, should be adequate to identify the content and purpose of the file.
Examples:
For references sets a brief indication about the type or purpose the reference set(s) in the file.
Note: If there is a summary the ReleaseType or DocStatus follows this Summary sub-element immediately without a space or other separator.
ReleaseType
Sub-elements
Values
Description
Summary
An optional short camel case addition to the ContentType title.
If there is a Summary the DocStatus follows this Summary sub-element immediately without a space or other separator.
DocStatus
Sub-elements
Values and Description
Summary
The value of this sub-element may be determined on a case-by-case basis but, in conjunction with the ContentType element, should be adequate to identify the content and purpose of the file.
LanguageCode
If it is necessary to specify the language or dialect used in a resource data file or tool, the appropriate language code must be included as the final sub-element of the ContentSubType. If a Summary sub-element is also included, the LanguageCode must be added after the Summary sub-element and must be separated from it by a hyphen.
Sub-element
Values
Description
CountryCode
INT
The file is maintained and distributed by SNOMED International.
"
FileType
Values
Description
sct or der
txt
All RF2 formatted release files are distributed as plain text UTF-8 files with the .txt suffix.
doc
The file conform to the single string reference set format. This only applies to the and followed by the content sub-element _OWLExpression which contains stated concept definitions represented as OWL axioms and additional OWL ontology information.
A SNOMED CT component identifier (SCTID) referring to a concept, description or relationship.
Full
Current
AA to ZZ
effectiveTime
Time
The inclusive date or time at which this version of the identified reference set member became the current version.
Note: In distribution files the effectiveTime should follow the short ISO date format (YYYYMMDD) and should not include the hours, minutes, seconds or timezone indicator.
The current version of this reference set member at time T is the version with the most recent effectiveTime prior to or equal to time T.
YES
YES (Full)
Optional (Snapshot)
active
Boolean
The state of the identified reference set member as at the specified effectiveTime .
If active = 1 (true) the reference set member is part of the current version of the set, if active = 0 (false) the reference set member is not part of the current version of the set.
YES
NO
moduleId
SCTID
Identifies the SNOMED CT module that contains this reference set member as at the specified effectiveTime.
The value must be a subtype of within the metadata hierarchy.
YES
NO
refsetId
SCTID
Identifies the reference set to Identifies the reference set to which this reference set member belongs.
In this case, a subtype descendant of:
NO
NO
referencedComponentId
SCTID
A reference to the SNOMED CT component to be included in the reference set.
A subtype of identifying the code system from which the code in the field is derived.
For example: .
NO
NO
mapSource
String
The other-code which is mapped to the SNOMED CT expression.
NO
NO
expression
String
A SNOMED CT expression that represents the meaning of the other-code. This expression may be a stated or inferred view of the definition provided that documentation of each identified reference set specifies the view provided.
The expression must conform to the syntax defined in the .
YES
NO
definitionStatusId
SCTID
Indicates whether or not the expression contains a sufficient definition of the other-code in the mapSource field. Possible values are the following subtypes of :
YES
NO
correlationId
SCTID
The correlation between the other-code and the SNOMED CT expression. Possible values are the following subtypes of :
YES
NO
contentOriginId
SCTID
Indication of whether the concept was initially in one of the terminologies (SNOMED CT or other-codes) and added to the other as part of mapping or was in both terminologies at the outset. Values are subtypes of .
YES
NO
0
1
2
3
4
5
363787002:246093002=720113009,370134009=123029007,246501002=702675006,704327008=122592007,370132008=117363000,704319004=50863008,704318007=705057003
51406-7
363787002:704323007=123027009,704321009=718500008,704327008=122575003,704322002=64033007,704318007=118544000,370132008=30766002,704324001=706939009
51406-7
363787002:370134009=123029007,704327008=122592007,704318007=118556004,370132008=30766002,704319004=50863008,246093002=4546008
59878-9
363787002:370134009=123029007,704327008=258459007,704318007=118556004,246093002=273948005,370132008=30766002,704319004=31773000
51921-5
363787002:704318007=118539007,370134009=123029007,704326004=703765007,704327008=122592007,370132008=30766002,704319004=50863008,246093002=387067003
id
UUID
A 128 bit unsigned Integer, uniquely identifying this reference set member.
Different versions of a reference set member share the same id but have different effectiveTime. This allows a reference set member to be modified or made inactive (i.e. removed from the active set) at a specified time.
NO
YES (Full /Snapshot)
48023-6
This approach follows Internet conventions.
When these values are applied to this reference set type, the phrase "map source" refers to the other-code. and the "map target" refers to the SNOMED CT expression.
The basic reference set file structure enables representation of subsets fo SNOMED CT components. However, the reference set format is extensible, allowing it to be used for a wide range of other purposes. For more details about the requirements that reference sets can address please see the Practical Guide to Reference Sets.
The basic reference set structure can be extended by adding one or more fields. Each of these fields will hold additional specific values related to each member. Three general data types are supported in the additional columns. These are
Integer
String and
Component (a reference to a SNOMED CT component)
Finer grained interpretation of these data types can also be specified using a special metadata reference set known as the .
The Reference Set patterns that are supported as part of the International Edition are documented in . Additional reference set patterns can also be created as part of an extension to support additional use case.
The penultimate two-digits of the SCTID (second and third from the right), are the partition identifier.
The partition identifier indicates the nature of the component identified. This allows the identifier of a description to be distinguished from the identifier of a concept.
The partition identifier also indicates whether the SCTID contains a namespace identifier (long format) or follows the short format applicable to identifiers of components that originated in the International Release. Identifiers of components that originated in the International Release of SNOMED CT have one of the following partition identifier values:
Partition identifier Values for Short Format SCTIDs
Identifiers of components that originated in an extension have one of the following partition identifier values:
Partition identifier Values for Long Format SCTIDs
All other partition identifier values are reserved for future use.
00
Concept
01
Description
02
Relationship
10
Concept
11
Description
12
Relationship
16
Postcoordinated Expression