"Shallow" vs. "Deep" LIMs (Templates)

Background

In discussion at the out-of-cycle constraints meeting in Washington on 10/29/2005, M&M discussed the issue of defining and supporting both "shallow" and "deep" LIMs. (This occurred after a discussion that templates are represented as a "Local Information Model" - LIM.)

The discussion arose in the context of determining how to assert the binding to a LIM in a message instance. The issue arises because

• The element names in a LIM do not need to be the same as the name in the CIM (Message Type) that the LIM element constrains.
  • This is asserted in the M&M Template Iplementation Specification.
  • This rule allows a single template (LIM) to be asserted as a constraint against multiple, independently defined message types (CIMs)

• If a receiving system seeks to validate a received instance against the templates, the receiving system must perform a coordinated "tree walk" on both the message and the LIM simultaneously in order to determine which LIM element should be governing each node.

• If the sending system can (and does) include in the nodes of the instance message an identification of the LIM element used to constrain the instance node, the coordinated tree walk is straightforward.

• Absent such identification in the instance, there are numerous example cases in which the coordinated tree walk becomes computationally burdensome and some in which it is virtually impossible.

As a consequence, discussion arose on the mechanisms by which such references can be made. It included concerns that the current method of inclusion of CMETs in a design may obscure the identification of where a CMET begins owing to the fact that, in the XML ITS, the element naming is the same whether a CMET is used or the same content is fully expressed in the parent design, and that this obscures the way in which a LIM may refer to other LIM's to allow users to build LIMs that reuse the concepts defined in other LIM's in a greater pattern.

This led to the consideration of "shallow" versus "deep" LIMs (templates).

Processing Requirements

We discussed the processing requirements for LIM's in instances.

• LIM's are useful because they can allow the instance reader to associate knowledge of the instance over and above the inherit semantics of the information in the instance
• The instance must be able to identify the LIM(s) that have been applied to the instance.
• Senders may choose not to identify the LIM in the instance, but in this case the receiver may not know to invoke special LIM dependent processing.
• LIM's may further unroll the relationships in the CIM that is being used
• Readers wishing to use the information associated with the further unrolling must be able to associate the parts of the instance with the parts of the LIM

This leads to the more technical requirement stated above:

• If a receiving system seeks to validate or fully understand a received instance against the templates, the receiving system must perform a coordinated "tree walk" on both the message and the LIM simultaneously in order to determine which LIM element should be governing each node.
• If the sending system can (and does) include in the nodes of the instance message an identification of the LIM element used to constrain the instance node, the coordinated tree walk is straightforward.
• Absent such identification in the instance, there are numerous example cases in which the coordinated tree walk becomes computationally burdensome and some in which it is virtually impossible.

"Deep" LIMs (templates)

A "deep" lim:

1. is simply any valid static model, with the full richness and complexity allowed in any HL7 message type design.
2. establishes constraints for all the elements that it contains.

Although another LIM (LIM-b) might also be asserted against elements that are "internal" to the LIM in question (LIM-a), this assertion is in addition to the assertion of LIM-a, not a part thereof.

All LIM's are bound to the instance at a single point, which must link that node of the instance to the root node of the LIM. There is 3 different approaches to binding parts of the instance to the parts of the LIM within the context of the root nodes.

• Readers are expected to figure out the linking themselves
• Writers are expected to link every node in the instance to the associated name in the LIM (by using the templateId property of InfrastructureRoot)
• Writers are expected to link the important nodes to the LIM, and need not link the others to the LIM

The first solution is known to be computationally incomplete, so cannot be adopted. The problem with the third option is that it is not possible for HL7 to define which nodes are "important", and even if it was, it would still introduce unnecessary optionality.

So this leads to a rule:

• If a LIM is associated with the instance, then all sub-parts of the instance which conform to the LIM must identify the name of the LIM element in their templateId property*

This rule is required to enable deep LIM's to be appropriately processed by readers.

"Shallow LIMs (templates)

Purpose A "shallow" LIM is a construct designed to support bottom-up composition of templates. It creates sub-templates that can be included in larger LIMs to build a larger concept. Thus a LIM to represent hemoglobin, and one to represent hematocrit can be defined and then used in the definition of a blood test. This pattern has been used successfully in several health record implmentations.

Requirements In order to fullfill this purpose, a "shallow" LIM should:

• present no ambiguities when doing a coordinated tree walk of an instance and the LIM;
• have the ability to declare, in a message instance being constrained by a LIM (LIM-a, above) that a portion of the message is constrined by another, subsidiary LIM that is a component(??) (LIM-b, above) of the original LIM.

Rules for a proper "shallow" LIM The rules that determine whether a LIM is a valid "shallow" LIM are those rules which assure that the node tree of an instance can be unambiguously walked in coordination with that LIM. Specifically:

1. A "shallow" LIM may 'include" a subsidiary LIM at any node (class clone).
2. The "shallow" LIM must 'include' a subsidiary LIM at any point where: the maximum carindality of an association is greater than one.