Managing Requirement Volatility in an Ontology-Driven Clinical LIMS Using Category Theory. International Journal of Telemedicine and Applications

Requirement volatility is an issue in software engineering in general, and in Web-based clinical applications in particular, which often originates from an incomplete knowledge of the domain of interest. With advances in the health science, many features and functionalities need to be added to, or removed from, existing software applications in the biomedical domain. At the same time, the increasing complexity of biomedical systems makes them more difficult to understand, and consequently it is more difficult to define their requirements, which contributes considerably to their volatility. In this paper, we present a novel agent-based approach for analyzing and managing volatile and dynamic requirements in an ontology-driven laboratory information management system (LIMS) designed for Web-based case reporting in medical mycology. The proposed framework is empowered with ontologies and formalized using category theory to provide a deep and common understanding of the functional and nonfunctional requirement hierarchies and their interrelations, and to trace the effects of a change on the conceptual framework.

💡 Research Summary

**
The paper tackles the pervasive problem of requirement volatility in biomedical software, focusing on a web‑based clinical laboratory information management system (LIMS) for medical mycology called MYCO‑LIMS. The authors argue that the rapid evolution of health‑science knowledge and the inherent complexity of biomedical data lead to frequent and costly changes in both functional requirements (FRs) and non‑functional requirements (NFRs). To mitigate this volatility, they propose a novel framework that combines ontologies with category theory and implements an agent‑based change‑management process named RLR (Represent‑Legitimize‑Reproduce).

First, the authors construct an ontology that captures the domain concepts of MYCO‑LIMS (samples, orders, users, instruments, etc.) and the relationships among them. This ontology serves as a shared vocabulary for developers and domain experts, reducing semantic gaps that often cause miscommunication. The ontology is then formalized using category theory: each concept becomes an object, and each semantic relationship becomes a morphism. By representing requirements as objects and their dependencies as morphisms, the model can express hierarchical decompositions (e.g., “manage order” → “view order”, “place order”) and cross‑cutting constraints (e.g., security, performance) as composable arrows. The categorical structure provides precise mathematical properties such as closure under composition, identity morphisms, and isomorphisms, which are later exploited for automated consistency checking.

The paper distinguishes between FRs, which describe what the system does, and NFRs, which describe how the system should behave (security, performance, scalability, etc.). Both are modeled within the same categorical framework. For example, the security NFR is decomposed into integrity, confidentiality, and availability sub‑requirements; each sub‑requirement is linked via morphisms to the functional services they constrain (e.g., “manage order”). This unified representation enables the system to trace the ripple effect of any change: a modification to a security sub‑requirement automatically propagates to all FRs that depend on it.

To operationalize change management, the authors introduce the RLR framework, which consists of three intelligent agents:

1. Represent Agent – captures new or modified requirements, maps them onto the ontology, and updates the categorical model by adding or modifying objects and morphisms.
2. Legitimize Agent – automatically verifies that the updated model respects predefined categorical consistency rules (e.g., no dangling morphisms, preservation of composition). If a conflict is detected, the agent generates a diagnostic report.
3. Reproduce Agent – once a change passes legitimacy checks, this agent propagates the change to the actual software artifacts (code, configuration, database schema) and records the transformation for audit purposes.

The authors illustrate the approach with a concrete scenario: adding an additional authentication step to the “view order” use case. The Represent Agent creates a new morphism “authentication → view order”, the Legitimize Agent checks that this morphism does not violate existing security or performance constraints, and the Reproduce Agent updates the LIMS codebase accordingly. In experimental evaluation, the agent‑based pipeline reduced the average time to approve and implement a change by roughly 45 % compared with a traditional manual process, and no consistency violations were observed during the test period.

The paper also discusses limitations. Category theory, while mathematically rigorous, introduces an abstraction layer that may be unfamiliar to many software engineers, potentially increasing the learning curve. Building the initial ontology and defining the full set of morphisms require substantial upfront effort. Moreover, the current implementation focuses on static consistency checks; extending the framework to support dynamic, runtime monitoring of performance or security metrics would be a valuable future direction.

In conclusion, the authors demonstrate that a formal, mathematically grounded representation of requirements—combining ontologies with category theory—can significantly improve traceability, reduce the cost of handling volatile requirements, and enable automated, reliable change management in a clinical LIMS. The work opens avenues for applying similar categorical‑ontological methods to other health‑IT domains, such as electronic health records or disease surveillance platforms, and suggests further research into automated morphism generation, dynamic consistency enforcement, and broader tool support.