Elastic IoT Ontologies for Industry 4.0: Methodological Approach and Hybrid Architecture

Abstract

Industry 4.0 requires IoT ontologies that are interoperable, scalable, and adaptive in non-stationary industrial environments. This study combines methodological ontology optimization with a hybrid elastic framework for dynamic semantic updates and feedback-driven refinement. The methodological component systematizes literature and industrial practices to identify structural gaps and derive practical requirements. The engineering component integrates truth-table-based data structuring, vector–matrix automata for real-time classification and clustering, and in-memory event processing for low-latency operation. Experimental evaluation across no-drift, abrupt-drift, gradual-drift, and cyclic-drift scenarios shows a trade-off between semantic proximity and operational robustness: the rule-based approach reaches lower semantic distance in drift regimes, while the hybrid approach delivers higher stability and fewer false alarms in cyclic dynamics. All tested configurations preserve sub-millisecond processing latency, supporting edge/fog deployment. The results indicate that combining methodological analysis with elastic architecture is a practical pathway from static to adaptive IoT ontologies and a relevant step toward human-centric Industry 5.0 systems.

1. Introduction

Industry 4.0 denotes the transition to high-level cyber–physical systems, where data from IoT devices, analytics, and automated decisions interact in real time [1]. This implies a combination of approaches from computer science (data processing methods, semantic models, and algorithms) and computer engineering (architectures of embedded and network systems and computing platforms). A central element of this interaction is ontologies, which define shared concepts, relationships, and rules for data exchange between heterogeneous platforms [2]. They ensure the semantic compatibility necessary for scalable integration of sensors, actuators, digital twins, and analytics services [3].

However, in practical deployments, IoT ontologies are often static, fragmented, or domain-closed. This complicates the integration of new device classes, leads to increased maintenance costs, and limits the ability of systems to adapt to changes in technological processes. Issues of interoperability, scalability, and adaptability become key barriers to continuous automation and the transition to human-centric Industry 5.0 scenarios.

In this work, we combine two complementary research directions. The first focuses on the methodological optimization of ontologies: systematization of literature, identification of gaps, and formulation of requirements for model improvement. The second proposes an engineering solution in the form of a hybrid elastic framework that implements modularity, dynamic updates, and energy-efficient data processing. The interconnection of these approaches enables the transition from problem diagnosis to practical implementation.

The objective of the paper is to form a holistic trajectory for the development of IoT ontologies: from methodological analysis to architectural implementation of elastic models. To achieve this, the following sections consistently examine the evolution of Industry 4.0, key gaps in current ontologies, the architecture of the hybrid framework, and the results of its experimental validation.

Related Work and Research Gap

Existing research on IoT ontologies for Industry 4.0 has established a strong foundation for semantic interoperability, but most approaches remain focused on static modeling, domain-specific vocabularies, or architecture-level standardization rather than runtime adaptability. Foundational semantic standards such as SSN/SOSA, IoT-Lite, SAREF, WoT, oneM2M, RAMI 4.0, and OPC UA provide essential mechanisms for representing sensors, services, assets, and communication interfaces. However, these frameworks primarily support interoperability at the descriptive and integration levels and do not by themselves resolve the problem of continuous ontology adaptation under changing industrial conditions.

Recent studies indicate a growing shift toward adaptive and data-driven techniques in industrial IoT. Concept-drift-aware methods have been proposed for anomaly detection and stream learning in non-stationary environments, while ontology alignment and NLP-based semantic translation have improved machine-to-machine interoperability across heterogeneous systems. Other recent works explore graph learning, predictive maintenance, secure federated analytics, and broader IoT ontology surveys in application domains such as health and well-being. These studies confirm the importance of semantic flexibility, intelligent adaptation, and real-time processing in modern IoT ecosystems.

Nevertheless, the current literature still tends to address ontology engineering, semantic interoperability, drift detection, and online adaptation as largely separate research directions. Some works emphasize ontology design without runtime update mechanisms; others focus on stream adaptation without a structured semantic layer; still others propose AI-enhanced industrial analytics without explicitly integrating ontology evolution into the operational loop. As a result, there remains a methodological and architectural gap between semantic modeling and adaptive execution in dynamic Industry 4.0 environments.

The present study addresses this gap by combining a methodological analysis of ontology limitations with a hybrid elastic framework for runtime semantic refinement [4]. In contrast to prior approaches that typically optimize only one aspect of the problem, the proposed approach integrates four dimensions simultaneously: interoperability, scalability, adaptability to drift, and feasibility of controlled ontology updates during operation. This enables a direct transition from literature-derived requirements to an implementable architecture in which semantic state monitoring, drift-aware switching, and ontology updates are coordinated within a unified processing loop.

The proposed methodology is based on the assumption that ontology quality depends on four concrete factors: (i) the rate of change in device classes and operating regimes, (ii) the degree of semantic heterogeneity between subsystems and domains, (iii) the frequency of drift in streaming data, and (iv) the cost of updating ontology modules during operation. Accordingly, the methodological layer does not merely provide a general analysis but evaluates existing ontologies in terms of interoperability, scalability, adaptability, and update feasibility under streaming conditions. Based on these factors, it derives explicit requirements for modular decomposition, semantic alignment of shared entities, drift-aware update rules, and validation procedures. The hybrid architecture then implements these requirements in practice through real-time classification, controlled ontology updates, and feedback-guided refinement. Unlike many existing approaches reported in the literature, which typically address ontology modeling, semantic interoperability, drift detection, and runtime adaptation as separate problems, the proposed approach considers them simultaneously within a single unified framework.

2. Evolution of Industry 4.0 and the Role of IoT Ontologies

The Fourth Industrial Revolution is the result of evolutionary changes that began with mechanization, progressed to mass production, then to digitalization, and now to intelligent interacting systems [5]. The key distinction of Industry 4.0 is the integration of IoT, big data, cloud platforms, and cyber–physical components into unified production loops [6,7], where decisions are made based on streaming data rather than only static regulations. This changes the very logic of control: from sequential scenarios to adaptive, context-oriented processes.

In this historical context, Industry 4.0 continues previous stages of industrial development: mechanization (I), electrification and mass production (II), and digitalization and automation (III). The current stage differs in that cyber–physical systems and IoT form “digital twins” of processes, enabling monitoring, analysis, and optimization in real time [8]. This creates conditions for increasing productivity, flexibility, and resilience of production systems [9].

Within such loops, IoT ontologies serve as a semantic layer that aligns data between physical devices, analytics services, and the control level. They define a shared vocabulary for describing sensors, objects, events, and interactions and provide typing and context for data interpretation. This enables heterogeneous platforms to collaborate without rigid binding to a specific vendor or protocol.

In global practice, foundational ontologies have emerged that define the basic principles for describing IoT entities. For example, W3C Semantic Sensor Network/Sensor, Observation, Sample, and Actuator (SSN/SOSA) standardizes the representation of sensors, observations, and metadata, while IoT-Lite simplifies semantic models for resource-constrained devices. Such solutions create a basis for compatibility but at the same time often remain static and domain-oriented, which complicates their application in dynamic industrial environments. An important source for engineering architecture is the evolution of standards and reference models. SSN/SOSA defines a modular structure for describing sensors, observations, and actuators, enabling separation of the “core” and domain-specific extensions while maintaining compatibility at the level of fundamental concepts [10]. IoT-Lite, as a lightweight instance of SSN, is focused on minimizing query complexity and is suitable for resource-constrained nodes while preserving the possibility of extension for domain-specific needs [11].

For cross-domain alignment in industrial environments, extensible application-level ontologies are essential. European Telecommunications Standards Institute (ETSI) Smart Applications Reference (SAREF) and its domain extensions form a unified vocabulary for sectors such as industry, energy, buildings, and urban environments, simplifying data integration between vendors [12]. In parallel, W3C Web of Things (WoT) introduces standard descriptions of “things” (Thing Description) and an interface model to reduce IoT fragmentation and ensure consistent metadata and interfaces across different platforms [13].

At the service architecture level, oneM2M is significant, as it formalizes the functional distribution between the Application Entity (AE), Common Services Entity (CSE), and network services (NSE) and also describes mechanisms for inter-system interoperability through proxy interfaces [14]. Taken together, these sources define practical guidelines for hybrid architecture: modular semantics, lightweight design for the edge layer, a service layer for unified functions, and interoperability through standardized descriptions and gateways.

To link the ontological layer to industrial architecture, it is useful to consider the Reference Architectural Model for Industrie 4.0 (RAMI 4.0) as a reference three-dimensional model of Industrie 4.0. RAMI 4.0 structures the system along three axes: hierarchy levels (from field devices to the “Connected World”), lifecycle and value stream (type/instance), and the layered model (asset–business), ensuring alignment between operational technology/information technology (OT/IT) components [15]. Within the hybrid framework, this provides a way to “anchor” ontology modules to specific levels and to separate stable “types” from dynamic “instances” during updates. In particular, the input vector $x_t$ is formed from signals arriving from the RAMI 4.0 Field Device layer, whereas the switching function $\varphi$ is interpreted at the Control layer as mode management logic.

The second key engineering block is Open Platform Communications Unified Architecture (OPC UA), which provides a service-oriented architecture, a unified information model, and mechanisms for secure data access. OPC UA supports platform independence, advanced information modeling (Address Space), a set of read/write/event services, and flexible subscription mechanisms, making it suitable for semantic alignment across edge–cloud levels [16]. The combination of OPC UA with ontological modules enables minimizing “semantic gaps” between telemetry and domain knowledge, as well as standardizing access to digital twins through shared information models.

Recent literature (2022–2024) indicates a clear shift from static semantic stacks toward adaptive and data-driven approaches for non-stationary IoT ecosystems. In particular, concept-drift-aware online learning has been actively studied for IoT security and telemetry streams [17,18], while dynamic semantic interoperability is increasingly supported by NLP-driven ontology alignment for machine-to-machine translation in IIoT environments [19]. In parallel, graph-based learning, including GNN-oriented methods for IoT network semantics, is used to improve the robustness of classification and contextual representation in evolving infrastructures [20]. Drift-adaptive detectors have also been validated in real sensor streams, confirming the practical need for update policies that jointly optimize sensitivity and stability under changing regimes [21].

In the context of Industry 4.0, IoT ontologies also support the concept of the “digital twin,” where physical processes are represented in digital form with a complete semantic description. This makes it possible not only to observe but also to predict and optimize processes using consistent data from multiple sources. It is precisely the semantic layer that determines whether this digital twin is suitable for decision-making.

Within the proposed framework, a digital twin is modeled not merely as a virtual replica of a physical asset but as an ontologically structured representation that integrates entities, states, events, attributes, and service relations. In this view, the ontology defines the classes required to describe the physical object, its sensors, operational states, maintenance-related events, and associated decision-support services, while semantic relations connect the physical and digital layers into a consistent representation. Such a model enables the twin to capture not only measurement values but also their context, interpretation rules, and links to operational processes. As a result, the digital twin becomes a semantically grounded object that can support monitoring, diagnostics, and predictive maintenance in Industry 4.0 environments, which is consistent with recent studies on semantic interoperability and ontology evolution in IoT systems [22].

Semantic integration between digital twins and the proposed IoT system is provided by the elastic ontology, which serves as a shared semantic layer for devices, events, services, and virtual asset representations. Through this layer, heterogeneous IoT streams are aligned with common ontology concepts, allowing physical observations and operational events to be consistently interpreted within the state of the digital twin. In this way, the digital twin is not treated as an isolated model but as a semantically synchronized component of the overall IoT ecosystem. The role of the elastic ontology is therefore twofold: it ensures interoperability across domains and maintains semantic consistency between physical processes and their digital counterparts under changing operating conditions, in line with recent practical studies on AI-IoT integration for predictive maintenance in Industry 4.0 environments [23].

Maintaining the consistency of digital twins in dynamic environments is challenging because changes in operating regimes, equipment degradation, sensor behavior, and event patterns may gradually invalidate the semantic correspondence between the physical asset and its digital representation. In predictive maintenance scenarios, this problem is particularly critical, since outdated semantic states may lead to incorrect interpretation of anomalies, degradation indicators, or maintenance priorities. Within the proposed framework, this challenge is addressed through elastic ontology updates driven by drift-aware monitoring of streaming data. When semantic mismatch increases, the system triggers controlled refinement of ontology modules, re-alignment of relevant concepts and relations, and synchronization of the digital twin with the updated operational context. In this way, the framework preserves semantic consistency while allowing the digital twin to evolve together with the monitored industrial process, which also agrees with recent results on drift-aware anomaly detection in adaptive industrial analytics [24].

From this follows a strategic effect: ontology optimization directly affects the quality of intelligent production systems. Improving semantic interoperability and scalability enhances the ability of systems to integrate new subsystems, while increased adaptability ensures resilience to technological changes. Thus, the development of IoT ontologies is not an auxiliary but a system-forming element of the evolution of Industry 4.0. The generalized structure of interaction between entities, services, and resources is shown in Figure 1, which illustrates interaction between the fundamental ontological sets: E (entities/devices), S (services), and R (resources). Their relationships and typical data exchange flows justify the need for a unified semantic layer. In formal terms, ontology links are represented as $\mathcal{L}\subseteq (E\times S)\cup (S\times R)\cup (E\times R)$; in the base model, $E,S,R$ are treated as disjoint role-oriented sets.

Figure 1. Fragment of a conceptual IoT ontology: entities, services, and resources in relation to devices.

The growth of the IoT ecosystem scale increases the requirements for ontologies. New classes of devices and domains emerge, the need for real-time stream processing increases, and requirements for energy efficiency and reliability rise. Static ontologies cannot keep up with these changes, which creates “gaps” between description and reality: new types of sensors or algorithms cannot be integrated without significant manual effort, and the model quickly becomes outdated.

Another problem is related to semantic interoperability: even with the presence of foundational ontologies, different vendors or domains interpret the same concepts differently. This leads to ambiguities in data, complex transformation rules, and increased maintenance costs. In industrial systems, this directly affects the reliability of automated decisions and the ability to rapidly introduce new services.

In addition to technical aspects, Industry 4.0 has socio-economic and regulatory dimensions: standardization, data security, and compliance with privacy and reliability requirements. These factors reinforce the need for clear semantic models, since ontologies ensure transparency and formalization of process descriptions underlying industrial solutions.

Therefore, the evolution of Industry 4.0 naturally leads to the need for elastic ontologies that are capable of scaling, adapting, and updating in real time. Such ontologies must support modularity, mechanisms for semantic alignment, and automated knowledge updates. This transition is also a prerequisite for Industry 5.0, where the human factor is added, and the need arises to promptly consider context, intentions, and human feedback in intelligent production systems.

3. Methodological Approach to Optimizing IoT Ontologies

3.1. Method Logic

The methodological approach consists of three sequential steps: (1) systematized analysis of literature and cases, (2) identification of gaps in current ontological models, and (3) development of targeted optimization strategies. This logic ensures not only the description of problems but also the formulation of requirements for future architecture. We use a unified set-theoretic notation throughout this section: E is the set of entities/devices, S is the set of services, R is the set of resources, and the global ontology universe is $O=E\cup S\cup R$. For semantic concepts used in classification/clustering, we denote the concept set by $\mathcal{K}=\{{\mu }_1,\dots ,{\mu }_K\}$.

In the first step, a holistic picture of the state of IoT ontologies is formed: from foundational standards and reference models to applied domain implementations in industrial scenarios. The analysis covers the structure of ontologies, their application boundaries, mechanisms of term alignment, and existing approaches to maintaining compatibility. This makes it possible to distinguish fundamental solutions from local ones, as well as to capture typical modeling practices.

The second step is aimed at identifying gaps between Industry 4.0 requirements and the actual properties of existing ontologies. The criteria include interoperability, scalability, adaptability, support for streaming data, the possibility of modular updates, and maintenance cost. At this stage, “bottlenecks” are identified: vocabulary incompatibility, lack of model evolution mechanisms, and weak support for multi-domain integration.

The third step transforms diagnosis into a set of optimization requirements and strategies. Principles of modularity, scenarios of dynamic updates, rules of semantic alignment, and validation criteria are formulated. It is important that these requirements are described in a way that allows their engineering implementation (for example, through formal update schemes, automata for classification, and mechanisms for fast knowledge indexing).

Thus, the methodological approach acts as a bridge between theoretical analysis and practical architecture: it defines the structure of the problem, determines the target characteristics of elastic ontologies, and creates a foundation for subsequent engineering implementation.

A separate emphasis is placed on integrating intelligent computational approaches into the methodology of optimization itself. Without such integration, semantic models remain “passive” descriptions, whereas intelligent computing provides them with the ability to operate in real time. This highlights the necessity of a methodology that, from the outset, considers the relationship between semantics and computational infrastructure.

3.2. Theoretical Requirements for Optimization

Based on the literature review and practical cases, a set of theoretical requirements can be formulated that define the quality of IoT ontologies in Industry 4.0 systems [25]. First, semantic interoperability is required, i.e., the ability of different components to correctly interpret data regardless of its source. Second, scalability is critical, ensuring system expansion without degradation of performance and maintainability. Third, adaptability is required for new classes of devices, protocols, and regulations, including support for streaming data.

Additionally, in industrial environments, it is important to consider reliability and security: ontologies must contain formal mechanisms for access control, descriptions of data processing policies, and validation rules. These requirements form the foundation for creating elastic ontologies that can evolve together with production systems. In formal terms, access control can be represented as mappings between the set of actors U and the set of protected resources R, governed by a policy/rule set P; equivalently, admissible operations are encoded by a relation $\Pi \subseteq U\times P\times R$.

The consistency of these requirements ensures a balance between formal rigor and practical flexibility. On the one hand, the ontology must be sufficiently formal to enable consistency verification [26], and on the other hand, sufficiently simple to allow rapid updates without a significant increase in computational complexity.

3.3. Key Gaps

The analysis shows that the main barriers are related to:

• Interoperability—different ontologies use incompatible vocabularies and structures;
• Scalability—the growth in the number of devices and domains leads to exponential complexity in maintenance;
• Adaptability—static models respond slowly to changes in environment, production, or objectives.

Interoperability in practice suffers from different levels of abstraction and proprietary approaches: sensor data, technological objects, and business processes are described using different terms, which complicates semantic alignment. As a result, integration even of adjacent domains requires manual coordination of terms and data transformations, which reduces reliability and reproducibility. In Article [27], this problem is described as a consequence of the lack of a universal communication scheme between platforms, which hinders data exchange in Industry 4.0.

The scalability problem manifests itself when the system expands: the number of entities, relationships, and rules that must be maintained increases. Without modularity and clear boundary interfaces, ontologies become overly coupled, difficult to maintain, and slow during validation or updates. Classical models are not designed for the dynamic growth of IoT ecosystems, leading to bottlenecks in data processing.

Adaptability is limited by the absence of mechanisms for real-time model evolution. Most ontologies are designed as “static” artifacts, whereas industrial environments change: new devices, operating modes, safety parameters, and operational constraints emerge. Without dynamic updates, the semantic model quickly becomes outdated, and its use in automated loops becomes risky. The first material explicitly points to the need for flexible ontologies capable of integrating new technologies without a complete restart of models.

In summary, the key gaps share a common cause: the mismatch between the speed of evolution of real IoT systems and the pace of updates of their ontological models. Overcoming this gap requires a combination of methodological principles and technical mechanisms, which motivates the transition to elastic ontologies.

An additional group of gaps concerns security and access control. In industrial IoT environments, ontologies must reflect not only technical characteristics of devices but also access policies, security requirements, and permissible data exchange scenarios. The absence of such semantic descriptions complicates integrity control and compliance with regulatory requirements.

A separate issue is the gap in experimental validation. Many proposed ontologies are demonstrated on limited examples that do not reflect the real complexity of industrial environments. This creates the risk of overestimated expectations regarding the performance and adaptability of models in large-scale deployments.

3.4. Strategic Directions for Optimization

The methodological approach proposes the following directions: ontology modularity, dynamic updates, standardization of boundary entities, support for multi-domain integration, and tools for automated validation and term alignment.

First, modularity implies dividing the ontology into relatively independent subsets (for example, the sensor set $S_{\mathrm{ens}}\subset E$, the event set W, the process set $P_{\mathrm{proc}}$, and the service subset $S_{\mathrm{srv}}\subset S$). This reduces coupling, simplifies local changes, and allows scaling the system without complete restructuring of knowledge. It is modularity that enables updating parts of the ontology without stopping the system. Formally, this is the partitioning of the global ontology set O into functional subsets $O_i\subset O$ such that $O=E\cup S\cup R$ and $O={\bigcup }_i{O}_i$, with explicitly controlled cross-subset constraints.

Second, dynamic updating should rely on formalized rules for structural changes: adding new classes, refining properties, and revising relationships. Such rules must be compatible with the streaming nature of data so that the ontology can adapt during system operation, not only at the design stage. The practical logic of updating should be based on a combination of modular ontology organization, real-time stream processing, support for human feedback loops, and intelligent classification/clustering (in particular through vector–matrix automata and in-memory computing), which ensures prompt knowledge updates without stopping the system.

Third, standardization of boundary entities is required to align data at the intersection of domains. This means defining “shared” entities and attributes (for example, units of measurement, timestamps, and spatial coordinates) that allow consistent interpretation of data across different subsystems. In the methodological article, this direction is directly linked to the requirement for universal protocols and communication schemes.

Fourth, multi-domain integration should be achieved through common linking schemes, term mapping, and mechanisms for semantic alignment. This reduces losses when combining data from different domains and makes analytics more robust to domain shifts.

Finally, automated validation and term alignment ensure ontology quality control. It is advisable to apply consistency checking rules, duplication detection, and procedures for regular vocabulary updates to maintain the model in an up-to-date state and reduce the risk of semantic errors. In the hybrid approach, these procedures are combined with automated classification of data streams, reducing system response time.

Together, these directions form a methodological foundation that can be implemented in an engineering architecture focused on elasticity, rapid updates, and real-time operation.

The practical result of these strategies is the creation of ontologies that can support both long-term stability (through standardization) and rapid local changes (through modularity and dynamic updates). This combination corresponds to the dynamics of Industry 4.0 and forms the basis for the transition to Industry 5.0.

4. Hybrid Elastic Framework of IoT Ontologies

4.1. Connection with the Methodological Approach

The elastic framework is a practical continuation of methodological recommendations: it implements modularity, supports dynamic updates, and improves semantic compatibility. Thus, the hybrid architecture transforms strategic requirements into engineering mechanisms. The conceptual scheme of data flows, the semantic layer, and intelligent processing is shown in Figure 2; it illustrates how raw events from devices are normalized, semantically interpreted, and passed into classification/decision-making blocks without interrupting the flow.

Figure 2. Conceptual scheme of the hybrid framework: data flows, semantic layer, and centralized data processing and analysis.

In operational terms, Figure 2 connects the theoretical model to the actual system flow. Raw telemetry and service requests enter the platform through the ingestion/API layer, where heterogeneous device messages are normalized into the input vector $x_t$. These inputs are then transformed into semantic state representations $z_t$ and compared with the current ontology-based clusters or concept centroids. The semantic discrepancy is quantified through the distance measure $D_{sem}$, while the switching function $\varphi$ determines whether the stream remains in the regular Observe/Classify path or activates Drift/Adapt procedures. In this way, the framework explicitly links the mathematical definitions to the real processing chain: API/stream input $\to x_t\to z_t\to D_{sem}\to \varphi \to$ ontology update and service-level output.

Modularity in the methodological approach corresponds to the component-based organization of the framework: each domain or subsystem has its own ontological module with clearly defined exchange interfaces. Dynamic updating is implemented through mechanisms for restructuring knowledge during system operation without stopping the data flow. The requirement for interoperability is reflected in the layer of term alignment and transformation rules between modules.

The hybrid nature of the framework lies in combining semantic structures (ontologies) with intelligent computational mechanisms. This connection is formalized through three core technologies: truth tables for event unification, vector–matrix automata for classification/clustering, and in-memory computing for low-latency processing. This ensures the transformation of streaming data into knowledge suitable for automated actions while maintaining ontology relevance in real time.

4.2. Problem Statement and Designed System

The scientific problem of this section is to construct a formal and computationally feasible model of an elastic IoT ontology that simultaneously satisfies three requirements: (1) maintains semantic consistency between heterogeneous data sources, (2) adapts to event drift and the emergence of new patterns without stopping the production loop, and (3) ensures low-latency processing at edge/fog levels.

In design terms, a cyber–physical, semantically driven decision support system for industrial IoT is developed. Its structural scheme includes a module for event collection and normalization, a semantic module with domain knowledge, a module for vector–matrix stream analysis, an ontology validation/update loop, and an operator interface for human-centric control of critical changes.

Functionally, the system operates as a closed loop: event → feature normalization → semantic interpretation → classification/clustering → drift or anomaly detection → controlled updating of ontological modules → returning updated knowledge into the operational loop. Thus, the algorithm within the hybrid framework solves not an isolated classification task, but the problem of continuous co-evolution of data, models, and semantics in real time.

4.3. Architecture and Components

The proposed framework combines three key technical components:

• Truth tables for data structuring and semantic normalization at the event level.
• Vector–matrix automata for real-time classification and clustering of data.
• In-memory computing for energy-efficient processing and rapid ontology updates.

The architecture of the framework has three levels: (1) the level of data collection and primary event normalization, (2) the level of semantic interpretation and term alignment, and (3) the level of intelligent processing and decision-making. Such a multi-level organization allows separating fast operations on streams from deeper semantic transformations and reduces latency in production loops.

Truth tables are used to transform heterogeneous events into formalized sets of features. In the implemented pipeline, continuous IoT channels (e.g., vibration, temperature, pressure) are first scaled to a fixed range and then complemented with Boolean threshold bits, i.e., rule-based binarization, before Boolean composition. This simplifies further processing, reduces noise, and improves data consistency between modules. Vector–matrix automata are responsible for real-time classification and clustering of streams, as well as for detecting anomalies or new patterns that must be reflected in the ontology. In-memory computing ensures low latency and energy efficiency, which is critical for industrial IoT platforms.

Modular ontologies can be updated independently, and feedback loops (including human participation) allow adjusting the model without interrupting production processes. This is key for Industry 5.0 scenarios, where a combination of automated decisions and contextual operator expertise is required.

A key feature is modularity: the ontology is divided into independent blocks that can be updated without stopping the system. This ensures elasticity and resilience in dynamic environments and also allows integrating new domains by connecting additional modules without completely restructuring the entire model.

The hybrid architecture also supports feedback loops that allow for the involvement of an expert in adjusting the semantic model. This is particularly important in cases where automatic learning or classification requires refinement of domain rules or when changes in technological processes must be reflected quickly and without loss of consistency.

Thus, the framework combines formal semantic models with intelligent data processing methods. This allows maintaining knowledge integrity under high dynamics of data streams while simultaneously performing low-latency computations, meeting the requirements of industrial cyber–physical systems.

In applied terms, such an architecture supports scenarios of predictive maintenance, dynamic planning, and management of distributed resources. vector–matrix automata provide fast event classification, while in-memory computing reduces latency critical for production cycles. This directly correlates with the results of the experimental section.

4.4. Theoretical Model of the Vector–Matrix Automaton

For the tasks outlined in this section, it is appropriate to use a switching bilinear vector–matrix automaton (VMA), which combines (i) fast matrix computations for data streams, (ii) discrete operating modes of the production system, and (iii) online parameter adaptation during data drift. In the context of the hybrid framework, this makes it possible to formally link the level of event normalization, the semantic layer, and the decision-making loop.

The parameters of matrices $A,B,G$ are determined at the stage of offline training of the system on historical data of the technological process (telemetry, event logs, operating modes), after which they are refined in the online adaptation loop. The parameters $C,D$ are identified based on labeled outputs (event classes, risk indicators, production KPIs). Accordingly, in the experimental prototype, the matrices are initialized with numerically stable scaled parameters (demo configuration) and then refined online through regime-aware adaptation and centroid updates; this preserves bounded dynamics while enabling reproducible drift experiments under controlled settings.

Let $x_t\in {\mathbb{R}}^m$ be the event feature vector after truth tables and primary normalization, $z_t\in {\mathbb{R}}^n$ be the hidden state vector of the automaton, $y_t\in {\mathbb{R}}^p$ be the output vector of estimates (classes, risks, or clusters), and $q_t\in \mathcal{Q}$ be the active discrete mode. For the classification branch, we set $p=K$, i.e., the output dimension equals the number of classes. The set of modes is defined as

$$\mathcal{Q}=\{\mathrm{Observe},\mathrm{Classify},\mathrm{Drift},\mathrm{Adapt},\mathrm{Alert}\}.$$

The VMA dynamics in discrete time are described by the system

$$z_{t+1}=A^{\left(q_t\right)}{z}_t+{\displaystyle \sum _{k=1}^m}{x}_t^{\left(k\right)}{B}_k^{\left(q_t\right)}{z}_t+G^{\left(q_t\right)}{x}_t+r^{\left(q_t\right)},$$

(1)

$$y_t=C^{\left(q_t\right)}{z}_t+D^{\left(q_t\right)}{x}_t,$$

(2)

$$q_{t+1}=\varphi \left(q_t,x_t,z_t,y_t,{\theta }_t\right),$$

(3)

where $x_t^{\left(k\right)}$ is the k-th scalar component of the feature vector $x_t$, $A^{\left(q_t\right)}$ defines the base linear dynamics, the term $\sum x_t^{\left(k\right)}{B}_k^{\left(q_t\right)}{z}_t$ captures nonlinear interactions between features and the internal state, $G^{\left(q_t\right)}{x}_t$ is the direct input channel of the event, and $r^{\left(q_t\right)}\in {\mathbb{R}}^n$ is a mode-dependent bias vector. Here, ${\theta }_t$ denotes the vector of adaptive thresholds and control parameters used by the switching logic. This structure represents a compromise between the expressiveness of nonlinear models and computational efficiency for low-latency processing.

The switching function $\varphi (·)$ implements the state transition graph. In practice, it is defined by a set of threshold rules and scoring functions:

$$s_j\left(t\right)=w_j^{\top }{z}_t+u_j^{\top }{x}_t+b_j,q_{t+1}=arg\underset{j}{max}{s}_j\left(t\right),$$

(4)

or in event-based form (for critical transitions):

$${\varrho }_t=tanh(\parallel y_t{\parallel }_2),{\overline{d}}_t=(1-\alpha ){\overline{d}}_{t-1}+\alpha D_t,d_t=(1-\beta )d_{t-1}+\beta |D_t-{\overline{d}}_t|,$$

$$\mathrm{if}{\varrho }_t>\rho \Rightarrow q_{t+1}=\mathrm{Alert},\mathrm{if}{d}_t>\delta \Rightarrow q_{t+1}=\mathrm{Drift},$$

where ${\varrho }_t$ is the scalar risk index (to avoid notation conflict with the bias vector $r^{\left(q_t\right)}$), $D_t={min}_k{\parallel z_t-{\mu }_k\parallel }_{M_k}$ is the current semantic-distance proxy, and $d_t$ is the smoothed drift indicator used for switching. Here $\alpha ,\beta \in (0,1)$ are smoothing coefficients. $\rho$ is the alert threshold, while drift control uses a hysteresis pair $({\delta }_{hi},{\delta }_{lo})$ in implementation. For compact notation, we keep ${\theta }_t$ as the vector of switching thresholds. In (4), j indexes candidate modes, $w_j\in {\mathbb{R}}^n$ and $u_j\in {\mathbb{R}}^m$ are score weights, and $b_j$ is a bias term.

Within the proposed framework, the transitions have the following meaning: Observe → Classify (a sufficient data window has been accumulated), Classify → Drift (distribution instability detected), Classify → Alert (risk threshold exceeded), Drift → Adapt (parameter update initiated), Adapt → Classify (after validation of new parameters), Alert → Adapt or Observe (after operator confirmation).

4.5. Classification, Clustering, and Ontological Feedback

The output (2) is treated as a logit vector (raw class scores), which is mapped to the probability simplex via the softmax activation function:

$${\pi }_c\left(t\right)={\displaystyle \frac{exp\left(y_t^{\left(c\right)}\right)}{{\sum }_{\ell =1}^{K}exp\left(y_t^{(\ell )}\right)}},{\widehat{c}}_t=arg\underset{c}{max}{\pi }_c\left(t\right),$$

(5)

The vector $y_t$ serves as a logit representation, which is mapped to the probability simplex via the softmax activation function defined in (5). In this form, $y_t=C^{\left(q_t\right)}{z}_t+D^{\left(q_t\right)}{x}_t$ from (2); equivalently, in the purely state-based classification case, the class vectors $v_c$ can be interpreted as rows of $C^{\left(q_t\right)}$, or interpreted as a cluster membership criterion:

$${\widehat{k}}_t=arg\underset{k}{min}{\parallel z_t-{\mu }_k\parallel }_{M_k}^2,{\mu }_k\leftarrow {\mu }_k+{\eta }_t(z_t-{\mu }_k).$$

(6)

Here, the distance in the z space is interpreted as an approximate semantic distance: the ontological graph (classes, relations, attributes) is preliminarily mapped into vector representations aligned with the feature space of events. Therefore, the metric $\parallel z_t-{\mu }_k{\parallel }_{M_k}$ is not only geometric but also semantically weighted; the matrix $M_k$ defines feature weights according to the importance of ontological relations in a specific domain. In the implemented prototype, $M_k$ is diagonal with fixed domain priors: higher weights for primary sensor-driven dimensions and lower weights for auxiliary latent dimensions (e.g., $M_k=\mathrm{diag}(1.5,1.5,1.5,0.5,\dots )$). This explicitly encodes the stronger contribution of core physical channels when computing ontology-aligned distances. In (5), K is the number of classes/concepts, $y_t^{\left(c\right)}$ is the c-th logit component, and ${\pi }_c\left(t\right)$ is the posterior probability of class c. In (6), ${\mu }_k$ is the centroid of cluster k, ${\eta }_t\in (0,1]$ is the adaptation step (implemented as a decreasing schedule, e.g., ${\eta }_t={\eta }_0/\sqrt{t+1}$), and ${\parallel a\parallel }_{M_k}^2=a^{\top }{M}_{k}a$ is the weighted (Mahalanobis-type) norm. From the ontology perspective, the set of known semantic units is $\mathcal{K}=\{{\mu }_1,{\mu }_2,\dots ,{\mu }_K\}$; the criterion in (6) determines membership of state $z_t$ in the nearest concept ${\mu }_{{\widehat{k}}_t}\in \mathcal{K}$.

From the perspective of in-memory implementation at the edge level, only active automaton parameters ($A^{\left(q\right)},B_k^{\left(q\right)},G^{\left(q\right)},C^{\left(q\right)},D^{\left(q\right)}$), current state vectors, cluster centroids, and switching thresholds are primarily stored. Here, $A^{\left(q\right)}\in {\mathbb{R}}^{n\times n}$ is the state-transition matrix in mode q, $B_k^{\left(q\right)}\in {\mathbb{R}}^{n\times n}$ are bilinear interaction matrices for feature k, $G^{\left(q\right)}\in {\mathbb{R}}^{n\times m}$ is the input matrix, $C^{\left(q\right)}\in {\mathbb{R}}^{p\times n}$ maps state to output, and $D^{\left(q\right)}\in {\mathbb{R}}^{p\times m}$ is the direct input-output mapping. The full ontology graph is not fully replicated in node memory: only relevant modules/caches are maintained locally, while the full ontological base resides in the fog/cloud layer. This ensures resource feasibility for IoT nodes with limited memory.

The key advantage of elastic IoT ontologies is that new patterns (${\widehat{c}}_t$ or ${\widehat{k}}_t$), which frequently fall into Drift/Alert modes, are interpreted as candidates for updating semantic modules. In terminological terms, a cluster in (6) is considered a candidate for an ontological concept: after validation, it is either mapped to an existing class/instance or initiates the creation of a new subclass/concept. In set form, elasticity is implemented as expansion of the concept set, $\mathcal{K}\leftarrow \mathcal{K}\cup \left\{{\mu }_{\mathrm{new}}\right\}$, after expert validation of a new cluster. Thus, the VMA serves not only as a stream classifier but also as a trigger for ontology evolution: detection of a new event type → expert validation → addition/refinement of concepts and relations → return to the operational loop without stopping the system. The human expert performs asynchronous validation of new concept candidates; in S2 simulation, the 82% acceptance rate models a realistic scenario with occasional expert rejections.

Thus, the selected switching bilinear VMA directly aligns with the requirements of this section: it supports real-time processing, multi-mode operation, anomaly and drift detection, as well as controlled knowledge updates within a human-centric Industry 5.0 loop.

Separately, we emphasize the role of the bilinear term ${\sum }_{k=1}^m{x}_t^{\left(k\right)}{B}_k^{\left(q_t\right)}{z}_t$ in (1). Unlike purely linear mapping, this term allows modeling interdependence between the current system state and event features. In practical scenarios with changing regimes (especially S4), this interaction proved important for reducing the semantic gap and stabilizing the cluster structure without complete ontology restructuring at each step.

5. Evaluation of the Approach and Discussion

The quantitative evaluation was performed in four controlled scenarios: S1 (no drift), S2 (abrupt drift), S3 (gradual drift), and S4 (recurrent regimes). Three approaches were compared: static, rule-based, and hybrid. The metrics used were $T_{adapt}$, $D_{sem}$, $SpikeRate$, false alarm rate ($FAR$), missed drift rate ($MDR$), $R_{update}$, and $Latenc{y}_{p95}$. Here, $T_{adapt}$ is adaptation time to a new regime, $D_{sem}$ is semantic distance to the target ontology state, $SpikeRate$ is the fraction of abrupt instability spikes in trajectories, $R_{update}$ is the update activation ratio, and $Latenc{y}_{p95}$ is the 95th-percentile processing latency.

In addition to the controlled synthetic scenarios, we evaluated the framework in a fifth scenario, S5, using realistic smart-home IoT data from the IoTSyn dataset [28] with natural cyclic behavior. This experiment was introduced as a practical validation step intended to test whether the semantic adaptation logic remains operational when the stream contains diurnal temperature and CO₂ fluctuations, occupancy-related oscillations, and other recurrent variations that are typical for cyber–physical environments but are not present in idealized step-based simulations. In contrast to S1–S4, where drift patterns are cleanly specified by construction, S5 represents a more demanding setting in which ordinary periodicity may resemble semantic drift at the raw signal level.

When the raw real-data stream was fed directly into the vector–matrix automaton, the semantic distance repeatedly crossed the anomaly threshold because routine environmental oscillations were interpreted as persistent deviation. As a consequence, the automaton tended to enter the Adapt regime too early and remain there too long, which in practice means that the uncalibrated system reacted not to genuine semantic change but to normal cyclicity of the monitored environment. This observation is important for the interpretation of the whole study: raw VMA sensitivity is sufficient for controlled drift scenarios, but realistic IoT streams require an additional calibration layer that separates structural change from naturally recurring temporal variation.

To address this limitation in a transparent way, two explicit adjustments were introduced before reporting S5. First, an exponential moving average pre-filter with $\alpha =0.01$ was applied before semantic distance evaluation in order to suppress short-term periodic fluctuations while preserving slower structural variation. Second, the switching configuration was relaxed by increasing the drift-entry threshold to $0.20$, lowering the exit threshold to $0.05$, and reducing the minimum retention time in the Adapt regime to 50 steps. These modifications were not intended to artificially improve results, but to prevent mode saturation and unnecessary ontology expansion under realistic cyclic conditions where unfiltered oscillations would otherwise dominate the automaton logic.

After this calibration stage, a synthetic failure event was injected at the midpoint of the real-data timeline as a 50% upward parameter shift, simulating an HVAC-like malfunction superimposed on the natural background dynamics. This design allows S5 to serve two purposes simultaneously: it validates the framework under realistic periodic behavior and tests whether a critical anomaly remains detectable after the model has been made more conservative toward ordinary cyclicity. The resulting comparison should therefore be interpreted as a real-world validation scenario rather than as a direct replacement for the controlled S1–S4 experiments.

Semantic distance in the proposed framework is interpreted as an indicator of ontology adequacy under changing operating conditions. When semantic distance increases, it signals that the current ontology structure no longer fully captures the semantics of the observed industrial process, thereby motivating ontology evolution through concept refinement, extension, or re-alignment. Conversely, a decrease in semantic distance after the update indicates that the ontology evolution step has improved semantic consistency between the physical system and its digital representation.

To position the proposed framework with respect to established streaming drift detectors, Table 1 compares it with representative approaches that are widely used for online change detection. The comparison is intentionally methodological rather than purely numerical: unlike ADWIN, CUSUM, Page–Hinkley, or DDM, the proposed framework does not treat drift only as a statistical deviation in a signal or error stream but interprets it as a semantic inconsistency between incoming observations and the active ontology state. This distinction is important in Industry 4.0 environments, where the practical objective is not merely to detect change but to relate it to ontology evolution, service adaptation, and digital-twin consistency.

Table 1. Conceptual comparison of the proposed framework with representative drift-detection methods.

Method	Detection Basis	Main Drift Sensitivity	Semantic Adaptation	Strengths	Limitations
CUSUM	Cumulative deviation from a reference mean or baseline statistic	Abrupt numeric shifts	No	Low computational cost; effective for sharp change points; simple online implementation	Assumes a relatively stable reference process; weak for semantic mismatch and ontology-level updates
ADWIN	Adaptive sliding- window test for distribution change	Statistical changes in evolving streams	No	Strong streaming support; automatic window resizing; robust generic baseline for non-stationary data	Detects distribution shift rather than semantic inconsistency; no built-in mechanism for ontology refinement or concept insertion
Page–Hinkley	Accumulated deviation from the running mean	Gradual or persistent mean shift	No	Lightweight; suitable for online monitoring; effective for persistent deviations	Primarily signal-oriented; limited explainability at the semantic level; no direct support for knowledge- base restructuring
DDM	Monitoring of predictive error rate and variance	Classifier-performance degradation	Indirect only	Simple and interpretable for supervised pipelines; useful when labeled performance is available	Depends on classification error rather than ontology state; not designed for unsupervised semantic drift or concept evolution
Proposed hybrid elastic framework	Semantic distance, automaton switching, and ontology-aware update logic	Statistical drift interpreted as semantic mismatch across evolving regimes	Yes	Couples detection with controlled ontology update; supports explainable drift handling, digital-twin synchronization, and service-level adaptation; preserves low-latency streaming operation	Higher architectural complexity than pure detectors; requires semantic representation and ontology-maintenance pipeline

The comparison in Table 1 clarifies that the proposed method should be understood as a drift-management framework rather than as a standalone detector. Classical methods such as CUSUM, ADWIN, Page–Hinkley, and DDM are effective for identifying statistical or performance-related changes, but they typically stop at signaling the shift. In contrast, the proposed framework extends detection into an operational semantic loop: deviation is quantified, interpreted relative to ontology concepts, passed through switching logic, and then translated into controlled update actions affecting the ontology, classification state, and digital-twin representation.

The aggregated experimental results are presented in Table 2. In experiments, we report $D_{sem}$ as the post-drift average of the nearest-centroid distance proxy, i.e., over the evaluation segment after the drift onset: $D_{sem}={\displaystyle \frac{1}{|{\mathcal{T}}_{post}|}}{\sum }_{t\in {\mathcal{T}}_{post}}{min}_k{\parallel z_t-{\mu }_k\parallel }_{M_k}$. The visual dynamics of this proxy and mode switching are shown in Figure 3 and Figure 4.

Table 2. Comparison of approaches in scenarios S1–S4 and S5.

Metric	Static	Rule-Based	Hybrid	Scenario
$D_{sem}$	1.137	0.112	0.047	S1
$SpikeRate$	1.0000	0.0010	0.0004	S1
$FAR$	0	10	12	S1
$MDR$	1	1	0	S1
$R_{update}$	0.00	1.00	1.00	S1
$Latenc{y}_{p95}$, ms	0.022	0.028	0.090	S1
$D_{sem}$	1.753	0.130	0.381	S2
$SpikeRate$	1.0000	0.0020	0.0006	S2
$FAR$	0	10	12	S2
$T_{adapt}$	0	9	18	S2
$MDR$	1	0	0	S2
$R_{update}$	0.00	1.00	1.00	S2
$Latenc{y}_{p95}$, ms	0.022	0.032	0.106	S2
$D_{sem}$	1.698	0.166	0.288	S3
$SpikeRate$	1.0000	0.0085	0.0007	S3
$FAR$	0	10	12	S3
$T_{adapt}$	656	3	6	S3
$MDR$	1	0	0	S3
$R_{update}$	0.00	1.00	0.80	S3
$Latenc{y}_{p95}$, ms	0.022	0.032	0.133	S3
$D_{sem}$	1.443	0.116	0.252	S4
$SpikeRate$	0.9997	0.0212	0.0006	S4
$FAR$	0	80	7	S4
$T_{adapt}$	499	5	12	S4
$MDR$	1	0	0	S4
$R_{update}$	0.00	1.00	0.82	S4
$Latenc{y}_{p95}$, ms	0.022	0.032	0.127	S4
$T_{adapt}$	Failed	0	0	S5
$D_{sem}$	1.396	0.220	0.567	S5
$SpikeRate$	1.000	0.016	0.066	S5
$FAR$	1250	20	14	S5
$MDR$	0	0	0	S5
$R_{update}$	0.0000	0.0500	0.0468	S5
$Concepts$	1	3	9	S5
$Latenc{y}_{p95}$, ms	0.028	0.035	0.124	S5

Note: In S1 (nominal flow), MDR is a formal indicator of zero drift-events detection in a drift-free stream. Scenario S5 uses real cyclic IoT data with EMA smoothing ($\alpha =0.01$), recalibrated thresholds ($0.20/0.05$), and midpoint fault injection; only the metrics explicitly evaluated for this realistic setting are reported.

Figure 3. Dynamics of the nearest semantic distance $neares{t}_{d}ist$ over time.

Figure 4. Switching of automaton modes (Observe, Classify, Drift, Adapt, Alert).

For reproducibility, drift and alert states are governed by explicit decision criteria. Let $d_t={min}_k{\parallel z_t-{\mu }_k\parallel }_{M_k}$ denote the current nearest semantic distance. A drift condition is declared when $d_t$ exceeds the drift threshold ${\theta }_{\mathrm{drift}}$ for a predefined number of consecutive observations, indicating that the incoming stream no longer matches the active ontology state within the admissible semantic range. An alert condition is triggered when $d_t$ exceeds a higher threshold ${\theta }_{\mathrm{alert}}$, or when the distance remains above ${\theta }_{\mathrm{drift}}$ even after adaptation, indicating persistent semantic inconsistency. Thus, drift detection captures semantic deviation, whereas alerting marks escalation.

Figure 3 should be interpreted as a temporal indicator of semantic consistency between incoming streams and the current ontology state: lower values of $neares{t}_{d}ist$ correspond to better semantic alignment, whereas sharp peaks indicate regime changes, drift episodes, or transient mismatches. In turn, Figure 4 explains the control logic behind these deviations by showing mode transitions of the automaton (Observe, Classify, Drift, Adapt, Alert). Their joint interpretation is causal: growth of semantic distance in Figure 3 is followed by transitions to Drift/Adapt in Figure 4, after which a decrease of distance confirms successful adaptation. Thus, the pair of figures simultaneously characterizes both the quality of semantic tracking and the internal mechanism of dynamic stabilization.

From the implementation perspective, the behavior shown in Figure 3 and Figure 4 corresponds to the runtime reaction of the same pipeline illustrated in Figure 2. Incoming API-driven telemetry is continuously mapped to $x_t$ and then to the semantic representation used for distance evaluation. When the measured $neares{t}_{d}ist$ exceeds the expected semantic proximity range, the function $\varphi$ triggers a transition from routine processing to Drift or Adapt modes. After adaptation, the updated ontology modules and classification state are propagated back to the semantic service layer, which restores consistency between the incoming stream and the active knowledge model. Thus, Figure 4 is not only a control diagram but also an operational manifestation of the theoretical update rule under real data flow conditions. The corresponding real-data S5 semantic-distance dynamics and automaton mode switching are shown in Figure 5 and Figure 6.

Figure 5. Semantic-distance dynamics on real IoT data in scenario S5 after EMA smoothing and threshold recalibration, with the injected fault placed at the midpoint of the observation window.

Figure 6. Mode switching of the automaton on real IoT data in scenario S5 after EMA smoothing and threshold recalibration.

To improve interpretability, the reported results should be read as a joint description of semantic quality and operational robustness rather than as isolated metric values. In this setting, $D_{sem}$ is the primary indicator of semantic adequacy: it quantifies how closely the active ontology matches the evolving process state after drift, so lower values mean better semantic alignment between the current stream and the target ontology representation. However, $D_{sem}$ alone is not sufficient for evaluating performance in non-stationary industrial environments, because a method may achieve very low semantic distance at the cost of excessive sensitivity, unstable update behavior, or repeated reactions to transient fluctuations.

For this reason, the remaining metrics describe complementary operational properties. $SpikeRate$ reflects the instability of the adaptation trajectory and therefore shows whether the response to drift is smooth or oscillatory. $FAR$ measures the number of false alarms and is particularly important in recurrent regimes, where unnecessary reactions may degrade trust in the monitoring system and trigger redundant interventions. $MDR$ captures the opposite risk, namely failure to detect actual drift events. $T_{adapt}$ indicates how quickly the framework converges after a regime shift, $R_{update}$ characterizes how aggressively ontology updates are activated, and $Latenc{y}_{p95}$ confirms whether semantic adaptation remains feasible under real-time streaming constraints. Taken together, these indicators distinguish between a method that is merely sensitive to change and one that is both accurate and operationally reliable.

From this perspective, the experimental results reveal a clear trade-off between semantic proximity and runtime stability. The rule-based approach consistently produces the lowest $D_{sem}$ in drift scenarios, which means that it follows the target semantic state more closely after change. At the same time, this advantage is accompanied by a more aggressive update profile and, in the cyclic regime S4, by substantially more false alarms. In contrast, the hybrid approach does not always minimize $D_{sem}$, but it yields the lowest $SpikeRate$ in all scenarios and markedly lower $FAR$ under recurrent changes. This means that the hybrid framework intentionally sacrifices part of semantic proximity in exchange for smoother adaptation, stronger resistance to oscillatory behavior, and more stable long-term operation.

Scenario S4 is especially informative in this regard. Although the hybrid method has a higher semantic distance than the rule-based one in this scenario, it reduces false alarms by an order of magnitude and maintains very low instability. This indicates that, under repeated or cyclic drift, the practically preferable method is not necessarily the one with the smallest semantic distance value but the one that balances semantic alignment with controlled reaction. Hence, the results do not identify a single universally best strategy; rather, they show two optimization profiles: the rule-based method prioritizes minimum semantic mismatch, whereas the hybrid method prioritizes robust and trustworthy operation in realistic non-stationary industrial conditions.

Scenario S5 extends this conclusion from controlled cyclic drift to realistic cyclic IoT behavior. In the uncalibrated setting, the real smart-home stream produced repeated threshold crossings, so the automaton overreacted to normal periodicity and generated excessive false adaptation pressure. After EMA smoothing and threshold recalibration, the comparison became much more informative. The threshold of the static baseline was calibrated to suppress false alarms during nominal operation ($FAR=0$). However, precisely because the ontology remained fixed, once real drift occurred, the static model failed completely ($T_{adapt}=\mathrm{Failed}$), while the semantic distance remained persistently high ($D_{sem}=1.396$). In the resulting real-data scenario, this led to a very large number of false alarms ($FAR=1250$), confirming that a non-adaptive ontology may appear stable under normal conditions yet break down as soon as the stream departs from the original semantic regime. The rule-based baseline yields the lowest final semantic distance ($D_{sem}=0.220$), the lowest spike rate ($SpikeRate=0.016$), and a compact updated structure with 3 concepts, at the cost of $FAR=20$ and $R_{update}=0.0500$. The proposed hybrid framework, in turn, reduces false alarms further ($FAR=14$), preserves zero missed drifts, and supports richer ontology adaptation (9 concepts in the final state), although at the price of a higher semantic distance ($D_{sem}=0.567$), a higher spike rate ($SpikeRate=0.066$), and latency that remains sub-millisecond ($Latenc{y}_{p95}=0.124$ ms).

This result is fully consistent with the interpretation developed for S2–S4 but now under a more realistic background. The rule-based configuration remains preferable when the primary objective is to minimize semantic mismatch as measured by $D_{sem}$ and to keep the adaptation trajectory smoother. The hybrid configuration becomes preferable when lower false-alarm pressure and structurally richer ontology growth are more important than achieving the smallest final distance alone. Therefore, S5 strengthens rather than changes the main claim of the paper: the hybrid architecture should be understood not as a universal minimizer of semantic distance, but as a controlled elastic framework that preserves ontology adaptation capability under realistic non-stationary IoT conditions.

The results show that in drift scenarios S2–S4, the minimum semantic distance is achieved by the rule-based approach ($D_{sem}=0.130$, $0.166$, $0.116$), while in S1, the lowest value is obtained by hybrid ($D_{sem}=0.047$). At the same time, hybrid ensures the lowest spike rate across all scenarios ($SpikeRate=0.0004$ in S1, $0.0006$ in S2, $0.0007$ in S3, $0.0006$ in S4), indicating higher dynamic stability compared to rule-based and especially static.

For cyclic regimes S4, this is particularly evident: despite a higher $D_{sem}$ compared to rule-based ($0.252$ vs. $0.116$), the hybrid scheme significantly reduces false alarms ($FAR=7$ vs. 80). The extended $T_{adapt}$ in S4 reflects a conservative learning strategy required to stabilize the ontology structure against cyclic noise and prevent redundant class generation. In terms of temporal characteristics, all approaches remain within the sub-millisecond range ($Latenc{y}_{p95}<0.14$ ms), although hybrid has higher latency ($0.090$–$0.133$ ms), which is still suitable for edge/fog processing. Testing was conducted on an Intel Core i7-12700 (2.1 GHz) with 16 GB RAM, Python 3.10, and NumPy 1.23.

6. Discussion: Alignment of Two Approaches

The methodological approach provides a theoretical map of problems, while the hybrid framework implements a practical mechanism for overcoming them. The relationship between the two approaches can be described as follows:

• The methodological analysis defines “what needs to be changed” in ontologies;
• The hybrid framework shows “how to change it” with minimal cost and high flexibility;
• Both approaches together prepare IoT ontologies for the requirements of Industry 5.0, where support for human-centric feedback loops is required.

The obtained results confirm that ontology elasticity is realized as a controlled trade-off between semantic proximity and operational stability. Unlike ADWIN or CUSUM drift detectors that only flag statistical shifts, the proposed approach maps these shifts into a semantic domain and provides explainable insights for the operator. The rule-based approach minimizes $D_{sem}$ in drift scenarios but is accompanied by an aggressive update policy ($R_{update}=1.00$) and increased $FAR$ in S4. In contrast, the hybrid approach maintains the lowest $SpikeRate$ in all scenarios and significantly better $FAR$ in the cyclic regime, which is important for stable operation.

Although a full ablation study was not performed in the present version, the contribution of the main components can be explained through a component-wise functional analysis. The truth-table layer provides deterministic normalization of heterogeneous device events, the VMA layer enables multi-mode online tracking and drift-aware switching, and the semantic update layer converts detected mismatches into ontology adaptation. Without the truth-table stage, the input representation becomes less consistent; without the VMA, the framework loses dynamic regime-aware adaptation; without semantic update logic, drift may be detected but not resolved at the ontology level. Thus, the reported performance should be understood as the combined effect of structured normalization, dynamic tracking, and controlled semantic adaptation.

For the correct interpretation of indicators in S1 (without actual drift), the value of $MDR$ should be treated conditionally, since the event-based detection logic is oriented toward the presence of a drift event. Therefore, in further comparisons, it is advisable to use a separate evaluation protocol for “no-drift” and “drift” scenarios.

Thus, static ontologies evolve into elastic ones, and methodological analysis provides a stable foundation for their lifecycle.

7. Conclusions

The paper combines two complementary approaches to the development of IoT ontologies for Industry 4.0: a methodological optimization approach and a hybrid elastic architecture. In this work, the methodological part identified the key practical requirements for modern IoT ontologies—interoperability, scalability, adaptability, and controlled update feasibility under streaming conditions—whereas the engineering part translated these requirements into an operational framework based on truth-table normalization, vector–matrix automata, and feedback-guided semantic updates. As a result, the study moved from a conceptual diagnosis of limitations in static ontologies to a concrete adaptive architecture capable of online semantic tracking, drift-aware switching, and ontology evolution without interrupting system operation. Experimental results show that in the updated formulation, the rule-based approach achieves minimal $D_{sem}$ in drift scenarios (S2–S4), while the hybrid approach demonstrates the highest dynamic stability (minimum $SpikeRate$ across all scenarios) and significantly fewer false alarms in the cyclic regime S4. In the additional real-data scenario S5, the rule-based configuration again achieved the lowest semantic distance, whereas the hybrid configuration provided lower false-alarm pressure and richer ontology growth under realistic cyclic IoT conditions.

A practically important result is the preservation of sub-millisecond event processing latency for all approaches ($Latenc{y}_{p95}<0.14$ ms), which confirms the suitability of the framework for edge/fog infrastructure. The hybrid framework also demonstrated structural elasticity, autonomously expanding the knowledge base from 2 to 11 concepts in complex scenarios. Taken together, these results show that the proposed approach does not merely detect changes in streaming IoT environments but supports their semantic interpretation and controlled incorporation into the ontology lifecycle. Therefore, the main achievement of the study is the demonstration that IoT ontologies can be made both methodologically grounded and operationally elastic, which is essential for robust Industry 4.0 deployment and for the transition toward human-centric Industry 5.0 systems.

Future work should include a dedicated ablation study to quantify the individual contribution of the normalization, VMA, and semantic-update components, as well as broader validation on additional real-world datasets, more diverse industrial drift regimes, and human-in-the-loop update policies.