Performance models offer a way to see scaling behavior before it bites. A model is a formula expressing a critical metric such as runtime as a function of execution parameters like the degree of parallelism or input size. The function t = c1 + c2·log(p), for example, characterizes an application whose execution time grows logarithmically on top of a constant base as processors are added—a benign weak-scaling scenario. Deviations of actual performance from what the model predicts can point to unforeseen hardware limitations or errors in the model itself. Crucially, the main goal of such a model is not to predict exact runtime at a different scale, although that is often used as a test; the goal is to identify performance bottlenecks, both relative to other parts of the code and compared to developer expectations.

Models can be created analytically or empirically. Analytical modeling means reasoning about the properties of the underlying algorithms, which is challenging for complex applications with thousands of source lines. Analysts usually restrict themselves to a few selected kernels they believe will dominate performance at scale, a practice that risks overlooking bottlenecks because recognizing dominance at scale is non-trivial—strictly speaking, identifying the right kernels requires the very model one is trying to build. Even modeling a selected kernel is error-prone and sometimes impossible, since the performance behavior of library calls often remains opaque, and reasoning alone can hardly determine constants and coefficients. Empirical performance modeling, the process of learning models from performance data, offers a convenient alternative because it can be largely automated and does not require intimate knowledge of the source code.

This is the premise of Extra-P, a project launched around 2012 to democratize performance modeling via automation. When the effort began, tools for measuring and analyzing performance were widely available, but modeling was confined to a community of experts. Extra-P, built entirely in Python for Linux, Windows, and macOS, generates models from a small number of carefully selected experiments—as few as five. The tool consists of six core components organized around a central experiment object holding parameters, call tree, measurements, and models. File readers load data from formats including the CUBE profiles produced by Score-P and JSON lines; modelers translate measurements into models; experiments can be saved as .extra-p files for reuse; and users interact through a command-line interface for scripting on clusters or a Qt-based graphical user interface for interactive exploration of models across the call tree, complete with severity indicators, line and contour plots, surface plots, and heatmaps.

The mathematical core is the Performance Model Normal Form, or PMNF. It rests on two insights: the function classes commonly found to represent communication and computation times as functions of execution parameters are limited to polynomial and logarithmic terms or combinations thereof, and analyzing the application at a fine-grained level such as individual function calls allows the performance contributions of each input parameter to be measured even with only a few measurements. The default search space spans exponents n = 5 and J = {0, 1, 2}, meaning scalability worse than p³·log²(p) is not distinguished—a choice reflecting common behavior in parallel programs that can be tailored when expectations are known. The workflow gathers at least five data points by varying a parameter of interest while keeping everything else constant, repeats measurements depending on system noise until confidence intervals are acceptable, then generates an individual model for each kernel in the call tree by fitting coefficients for all complexity expressions spanned by the PMNF using linear regression, selecting the best model via cross-validation and ranking kernels by asymptotic complexity. Model generation costs at most seconds; the experiments dominate.

The precision of this approach has been demonstrated on real codes. Reproducing analytical models of the Sweep3D neutron transport problem, Extra-P confirmed the previously computed analytical ones, with prediction errors remaining small even at a scale of more than 100 times the training data. Comparing models trained on runs up to 2,048 processes with models trained up to 8,192 processes showed that only the coefficients of the terms, not the terms themselves, slightly change—meaning Extra-P correctly captures asymptotic behavior. In the HOMME dynamical core of the Community Atmospheric Model, developed at NCAR and confirmed to work well up to 100,000 processes, a surprising discovery emerged: the MPI_Reduce call scales significantly worse than linearly with process count. The routine sits in HOMME’s initialization, outside the code developers considered performance critical, underscoring the need to examine entire applications. Subsequent analysis revealed the bug was caused by not adapting the number of MPI processes assigned to initial I/O to the total process count.

Multi-parameter modeling posed a harder problem. With a shared search space for all parameters, the combinatorial explosion would lead to over four billion model hypotheses for the default exponents and three parameters, meaning hours per function and metric on commodity hardware. A modified golden section search—ordering hypotheses by the magnitude of their first derivative at the observation with the largest input value and traversing the space to minimize error—reduces the search from billions to less than a hundred hypotheses for a three-parameter model. Evaluation on 100,000 synthetic samples showed the heuristic differs from the exhaustive approach in less than 0.6% of cases, and even then both identify the correct lead-order term, while modeling time drops from 107 hours to 1.5 hours. An iterative refinement variant replaces fixed search spaces by starting with integer exponents and refining them through fractions with growing denominators, using the mediant of two fractions and terminating when the rate of improvement in the scale-independent SMAPE error metric sufficiently decreases.

Reducing experiment cost became a central theme. Taint analysis through the Perf-Taint tool, built on LLVM, identifies which functions and loops are affected by performance-critical parameters, allowing Extra-P to prune false dependencies and skip modeling of constant functions—in LULESH and MILC, hundreds of functions were pruned statically or dynamically. Sparse modeling exploits the assumption that each parameter exhibits a single consistent behavior across the measured space, requiring only five measurement points per parameter plus one additional point to determine whether parameter effects are independent or compounded, instead of the 5^m points of a dense matrix. A reinforcement learning agent trained on hundreds of thousands of synthetic functions yielded a cheapest-points-first strategy; on average, sparse modeling combined with this strategy reduces modeling cost by 85% while retaining 92% of model accuracy. Gaussian process regression then refined point selection further, accounting for noise levels, repetitions, and parameter ranges, improving average accuracy by up to 64.29% within the same budget by selecting fewer but more informative measurement points.

Noise, the constant of all empirical measurements, demanded its own countermeasures. Deep neural networks trained on noisy data can learn to adapt to perturbations, so an adaptive modeler estimates the noise level using a range-of-relative-deviation heuristic and selects between regression and DNN modeling accordingly. The DNN predicts PMNF exponents as a classification task over 43 classes of common performance behaviors, with coefficients determined via regression afterward, and transfer learning specializes a pretrained network to each modeling problem. Software counters offer a complementary route: counting executed LLVM basic blocks and transferred message sizes yields measurements inherently resilient to noise, which are combined with noise-sensitive wall-clock measurements through prior models of MPI operations to fit coefficients with a single noise-sensitive measurement set instead of multiple repetitions. Segmented modeling detects piecewise behaviors—such as MPI implementations switching algorithms with process count—by sliding a window across data points and comparing subset models, while an expectation-validation framework lets users specify asymptotic growth rates in big O notation and automatically generates divergence models explaining discrepancies between expected and actual performance, successfully applied to MPI libraries and parallel sorting benchmarks.

The tool’s reach now extends beyond finding scalability bugs. Hardware-independent requirement models for memory footprint, computation, communication, and memory access support co-design: modeling five scientific applications including Kripke, LULESH, MILC, Relearn, and icoFoam showed how per-process requirements change when a system is upgraded—for LULESH, doubling the racks would grow computation and communication requirements by roughly a factor of 1.2 while memory footprint stays constant, augmenting traditional back-of-the-envelope calculations for system purchasing decisions. Task-graph modeling captures isoefficiency in task-based programs like Cilk and OpenMP by comparing actual, contention-free, and upper-bound efficiency functions through a task replay engine that simulates tasks by busy-waiting for measured durations. Compositional performance modeling splits programs along natural boundaries into modules with composition operators for sequential and parallel concatenation, tracking latency and throughput—revealing, for instance, that bubblesort delivers its first sorted elements earlier than mergesort even though mergesort wins on total time. The authors’ outlook emphasizes integration with AI-driven methods and adaptation to increasingly heterogeneous hardware, where understanding how code behaves differently on CPUs versus GPUs is crucial for accurate predictions in mixed-device systems.

Subject of Research: Computer Science

Article Title: Extra-P—Empirical performance modeling made easy

Article References: Calotoiu, A., Copik, M., Czappa, F., Geiss, A., de Morais, G., Ritter, M., Shudler, S., Hoefler, T., & Wolf, F. (2026). Extra-P—Empirical performance modeling made easy. Frontiers in High Performance Computing, 3, Article 1714042. https://doi.org/10.3389/fhpcp.2025.1714042

Image Credits: AI Generated

DOI: 10.3389/fhpcp.2025.1714042

Keywords: performance modeling, high-performance computing, scalability, machine learning, software engineering, Extra-P, Empirical, performance, modeling, made, easy, scientific research

The concept of semantic communication underlies much of this efficiency gain. Rather than transmitting every sample of raw sensor data, an event-driven system transmits only the information that carries meaning for the task at hand—in this case, updates to a patient’s health state when a clinically significant change is detected. A fall, a sudden instability episode, or a sustained deviation from an established mobility baseline triggers a semantic update that is forwarded to the digital twin, while long stretches of unremarkable activity generate only periodic summaries. This decoupling of sensing rate from communication rate is what allows the system’s costs to scale with event frequency rather than with sensor sampling rate, a property the population-scale analysis in the paper confirms. For a monitoring deployment covering hundreds or thousands of patients, the difference between paying a communication and energy cost proportional to how often meaningful events occur versus how often sensors sample can determine whether long-term operation is economically and logistically feasible.

Privacy considerations add further weight to the argument for edge intelligence. When raw physiological and movement data leave a patient’s home environment and travel to a centralized cloud, the data become exposed to interception, aggregation risks, and third-party access, and they fall under regulatory frameworks such as HIPAA in the United States and the GDPR in Europe, which impose strict requirements on the handling of personal health information. By performing inference locally and transmitting only abstracted health state updates, the proposed architecture substantially reduces the volume and sensitivity of data that ever leaves the device. This does not eliminate privacy obligations entirely—semantic updates can still reveal information about a patient’s condition, and the digital twin itself must be stored and protected securely—but it shifts the privacy posture from one of continuous raw data exposure to one of minimal, purpose-limited disclosure. The authors position this privacy-aware operation as a natural consequence of the architectural design rather than an add-on, which is a notable departure from systems where privacy controls are bolted onto a cloud pipeline after the fact.

The digital twin component of the architecture deserves particular attention because it changes what the transmitted updates are used for. In traditional remote monitoring, incoming data are analyzed for immediate alerts and then often archived with limited ongoing utility. A digital twin, by contrast, is a dynamic virtual counterpart of the patient that integrates multimodal data over time to track health states and trajectories. The semantic updates generated at the edge serve to keep this virtual counterpart synchronized with the patient’s actual condition. When a fall or instability event is detected, the twin’s state is updated to reflect the new reality; between events, periodic summaries allow the twin to track gradual trends such as declining gait stability or changing activity patterns. This continuous yet lightweight synchronization is what enables the twin to support downstream uses such as rehabilitation planning, risk stratification, and longitudinal analysis of disease progression, all without requiring the constant firehose of raw data that conventional implementations demand.

The literature review in the paper situates this contribution against a series of prior digital twin healthcare systems that illuminate why the integration gap has persisted. Karakra and colleagues introduced a digital twin framework for hospital services built on discrete event simulation, integrated with hospital information systems and IoT devices, allowing administrators to model resource utilization and patient flow without disrupting operations. Liu and colleagues proposed CloudDTH, a cloud-based framework combining big data, cloud computing, and IoT technologies for personalized health monitoring and lifecycle-oriented care, particularly aimed at elderly populations. Elayan and colleagues developed a context-aware digital twin system for continuous patient monitoring in which machine-learning-based ECG classification supports cardiac diagnosis, and Sharma and colleagues extended this line with a neural-network-based ECG analysis system for early abnormality detection. Each of these systems demonstrated valuable capabilities, but all inherited a cloud-centric communication pattern in which physiological data stream continuously to centralized infrastructure. The new work argues that this inheritance is not incidental but structural: as long as the intelligence resides in the cloud, the twin must be fed by raw data, and the energy, bandwidth, privacy, and scalability problems follow from that architectural choice.

Edge computing research in healthcare has partially addressed these concerns, but the paper identifies a persistent fragmentation. Studies of edge-based inference for physiological signals—including work on brain activity monitoring using deep and spiking neural networks applied to intracranial EEG, and on fall detection using deep neural networks—have shown that meaningful inference can indeed be performed on resource-constrained devices. Yet these efforts have generally treated the edge device as a classification endpoint rather than as a data source for a persistent, evolving model of the patient. Conversely, digital twin research has focused on the modeling and simulation layer without engaging deeply with the communication and energy constraints of the sensing layer. The proposed architecture is presented as an explicit bridge between these two research communities, with the event-driven update mechanism serving as the connective tissue: the edge performs the intelligence, and the twin receives only what it needs to remain current.

The evaluation methodology, while computational rather than based on a physical deployment, incorporates realistic elements that strengthen its relevance. The simulations model power consumption and communication behavior using realistic sensor traces, and the sensitivity analysis examines robustness across variations in event frequency, window sizes, and the computational cost of feature extraction. This last variable is particularly important because the energy budget of on-device inference depends heavily on how expensive the feature extraction pipeline is; a system that only wins if feature extraction is nearly free would be fragile in practice. The finding that the architecture’s advantages hold across a range of feature extraction costs suggests that the event-driven design is robust to reasonable variation in the underlying algorithms. Similarly, testing across different event frequencies addresses the concern that the approach might only work well for patients with rare events; the population-scale analysis extends this to show that aggregate system costs track event frequency across the monitored cohort rather than the aggregate sampling rate of all deployed sensors.

The clinical scenarios motivating this work—remote elderly care, assisted living facilities, and post-discharge rehabilitation—share a common structure that favors event-driven monitoring. In each case, the majority of a patient’s day involves unremarkable activity that does not require clinical attention, punctuated by relatively rare events such as falls, near-falls, or periods of instability that do. Continuous streaming spends most of its energy and bandwidth communicating about the unremarkable majority, while event-driven designs concentrate resources on the informative minority. For fall-risk detection specifically, the latency implications of local inference are also favorable: because the detection happens on the device itself, an alert can be generated without waiting for a round trip to a remote server, which matters in scenarios where seconds can affect outcomes.

The authors are careful to frame the work as an architectural modeling and analytical evaluation rather than a deployed clinical system, and this framing has implications for how the results should be interpreted. Computational simulations can capture energy and communication behavior with reasonable fidelity, but they cannot fully account for the messiness of real deployments: hardware variability across device generations, wireless conditions that fluctuate with building layout and interference, sensor artifacts from patient movement, and the clinical validation needed to confirm that locally detected events match clinically meaningful definitions. The path from this architectural demonstration to clinical deployment would involve implementing the inference pipeline on specific hardware platforms, validating event detection performance against clinical ground truth, and integrating the digital twin layer with electronic health record systems and clinical workflows. None of these steps are trivial, but the paper’s contribution is to establish that the architectural foundation—event-driven edge intelligence feeding semantic updates to digital twins—supports the scalability, energy efficiency, and privacy properties that long-term, population-level deployment requires.

Looking forward, the architectural principle identified here extends beyond fall and instability monitoring. Chronic disease management, medication reaction monitoring, and post-surgical recovery tracking all involve the same structure of continuous low-information background activity punctuated by clinically significant events. If the event-driven edge paradigm proves generalizable, the implications reach toward the design of future healthcare IoT infrastructure more broadly, suggesting that the field’s trajectory should favor systems in which intelligence is distributed to the point of data capture and communication is reserved for meaning rather than measurement. The convergence of digital twin modeling with edge-intelligent AIoT, demonstrated here in a monitoring context, offers a template for how that distribution might be achieved without sacrificing the continuity and personalization that make digital twins valuable in the first place.

Subject of Research: Edge-intelligent AIoT digital twins for scalable and privacy-aware healthcare monitoring

Article Title: Edge-intelligent AIoT digital twins for scalable and privacy-aware healthcare monitoring

Article References: Jun, M., & Ko, H. (2026). Edge-intelligent AIoT digital twins for scalable and privacy-aware healthcare monitoring. Frontiers in The Internet of Things, 5, Article 1779129. https://doi.org/10.3389/friot.2026.1779129

Image Credits: AI Generated

DOI: 10.3389/friot.2026.1779129

Keywords: digital twins, AIoT, edge intelligence, healthcare monitoring, fall detection, privacy, event-driven systems, energy efficiency, wearable sensors, scalability, cloud computing, semantic updates

Software-defined networking, or SDN, has reshaped how modern networks are run. In a traditional network, every switch and router makes its own forwarding decisions using embedded control logic. SDN breaks that model apart by decoupling the control plane, where decisions are made, from the data plane, where packets are physically forwarded. The result is a centralized controller, or a set of coordinated controllers, that can see the state of the whole network and steer traffic dynamically. This architecture enables flexible resource allocation, rapid reconfiguration, and policy enforcement at a scale that conventional networking struggles to match.

But centralization creates its own problem: scale. As networks grow to encompass thousands of switches spread across wide geographic areas, a single controller can become a bottleneck and a single point of failure. The standard remedy is clustering, grouping network nodes so that each cluster is managed by its own controller. Good clustering keeps controllers close to the switches they govern, which reduces the delay of control messages, distributes processing load evenly, and improves the scalability of the whole system. Poor clustering, by contrast, leaves some controllers overwhelmed while others sit idle, and forces control traffic to traverse long, slow paths.

The research team, led by Pradeesshma T with co-authors R. Raju and P Victer Paul, argues that the classical tools used for this task fall short in dynamic environments. Widely used clustering algorithms each carry well-known weaknesses. K-Means is sensitive to the initial placement of its cluster centers and requires the number of clusters to be specified in advance, a choice often made with heuristics such as the elbow method. DBSCAN, a density-based method, can struggle with varying node densities and adds computational overhead as datasets grow. Spectral clustering, while powerful for complex shapes, involves costly eigendecompositions that become burdensome at scale. Hierarchical and agglomerative approaches, meanwhile, are difficult to apply once a network has already been partitioned and must adapt to change.

Optimization algorithms have been brought in to fill the gap. Greedy algorithms make locally optimal choices at each step and run quickly, but they can become trapped at local optima, never discovering globally better arrangements. Genetic algorithms evolve populations of candidate solutions through selection, crossover, and mutation, yet they face high-dimensional complexity and can converge slowly. Particle Swarm Optimization, modeled on flocking birds, balances exploration and exploitation but is constrained by scalability issues in very large search spaces. Each technique, the authors note, addresses some challenges while introducing others, leaving room for a method that handles the particular demands of SDN clustering more gracefully.

That is where the krill come in. The Krill Herd Optimization Algorithm was introduced by Amir Gandomi in 2012 as a bio-inspired optimizer that mimics the behavior of krill swarms in the ocean. Krill aggregate in enormous herds, and their individual movements are governed by three processes: movement induced by the presence of other krill, foraging activity driven by food sources, and random diffusion that scatters individuals unpredictably. Each krill’s position in the search space encodes a candidate solution, and its fitness determines how strongly it influences and is influenced by its neighbors. Over successive iterations, the herd gradually converges toward regions of high fitness while the diffusion term keeps a degree of randomness alive, preventing premature collapse into a local optimum.

The elegance of the method lies in how it balances exploration and exploitation. The motion induced by neighboring krill pulls individuals toward dense, high-performing regions of the solution space, which is exploitation of what the swarm has already learned. The foraging component directs movement toward the best food source found so far, sharpening the search around promising areas. Random diffusion supplies the exploration that keeps the algorithm from stagnating, allowing it to escape local optima that would trap a greedy method. The relative influence of these three components adapts over the course of the run, so the algorithm explores broadly early on and exploits aggressively as it converges. For a problem like SDN clustering, where the search space of possible node-to-cluster assignments grows combinatorially with network size, that adaptive balance is exactly what is needed.

Applied to software-defined networks, the algorithm treats each potential clustering of SDN nodes as a candidate solution, and evaluates it using objectives that capture what network operators actually care about: the latency between switches and their controllers, the separation quality of the resulting clusters, and the evenness of the load across controllers. The researchers report that experimental results demonstrated significant improvements in all three measures compared with existing approaches, along with superior scalability, adaptability, and computational efficiency. In practical terms, that means control messages travel shorter distances, no single controller becomes a choke point, and the clustering can be recomputed quickly enough to keep pace with networks whose traffic patterns and topologies shift continuously.

The significance of the work extends beyond one algorithmic benchmark. Network operators are under mounting pressure to support 5G and beyond, dense Internet of Things deployments, and data-intensive cloud services, all of which strain the controller placement and clustering decisions at the heart of SDN management. Earlier research has explored related territory, including whale optimization for IoT-focused SDN clustering, density-peaks clustering for multi-controller placement, social-aware K-Means variants for device-to-device multicast, and hierarchical agglomerative clustering for interference mitigation in ultra-dense small cell networks. The krill herd approach adds a further option that is specifically tuned to dynamic environments, where the ability to reorganize clusters on the fly matters as much as the quality of the initial arrangement.

The study, published as article number 836 in volume 29 of Cluster Computing, was received in July 2025, revised in March 2026, and published in October 2026. The authors state that the research received no external grants or financial support, and the underlying data are available upon request. As networks continue their evolution toward fully programmable, centrally orchestrated infrastructures, the idea that a shrimp-sized plankton feeder could teach routers how to organize themselves is a reminder that some of the best engineering blueprints were written by nature long before the first packet was sent. If the reported gains in latency, cluster separation, and load balancing hold up in production deployments, krill herds may soon be quietly herding the traffic of the internet itself.

Subject of Research: Bio-inspired krill herd optimization for clustering nodes in software-defined networks

Article Title: A bio-inspired model for cluster optimization in software-defined networks

Article References: T, P., Raju, R., & Paul, P. V. (2026). A bio-inspired model for cluster optimization in software-defined networks. Cluster Computing, 29(15), Article 836. https://doi.org/10.1007/s10586-026-06554-3

Image Credits: AI Generated

DOI: 10.1007/s10586-026-06554-3

Keywords: software-defined networking, krill herd algorithm, clustering optimization, bio-inspired computing, controller placement, load balancing, network latency, swarm intelligence, K-Means, particle swarm optimization, scalability, dynamic networks

The team conducted a comparative analysis of four graph partitioning strategies: Random Vertex, Random Edge, a Metis-based approach, and HDRF, the hybrid dynamic replication factor algorithm popularized in the PowerGraph lineage of distributed graph systems. Two of these methods operate in the edge-cut paradigm, which keeps each vertex whole and distributes edges among machines, while the others embrace the vertex-cut paradigm, which keeps each edge whole and replicates vertices across partitions. The distinction is more than academic. In an edge-cut scheme, a celebrity vertex with millions of connections can drag its entire neighborhood onto a single overloaded server; in a vertex-cut scheme, that hub is mirrored across machines, trading extra memory for better balance.

To measure how these choices play out in practice, the researchers built a benchmarking environment that simulates distributed online transaction processing and online analytical processing workloads on a prototype graph database cluster. Each partitioning strategy was evaluated on both synthetic datasets and real-world graphs, using metrics that capture the twin demons of distributed graph computing: the amount of cross-machine communication a partition induces, quantified as the edge cut, and the replication factor, which records how many extra copies of vertices the scheme must maintain. The team also measured load balance across servers, query latency, and system throughput, giving a rounded picture of what users actually experience rather than a single narrow score.

The headline finding is a tale of two graph worlds. For static, relatively balanced graphs, the Metis-based partitioner achieved the highest partition quality, producing clean cuts that minimize communication between machines. Metis, a multilevel k-way partitioning algorithm, works by repeatedly coarsening the graph into a smaller skeleton, partitioning that miniature version, and then refining the solution as the graph is uncoarsened back to full size. That computationally intensive process pays off when the graph is known in advance and changes rarely, because the upfront investment in partition quality is amortized over a long lifetime of efficient queries.

For dynamic, power-law networks, the story flips dramatically. Real-world graphs, from social networks to the web itself, follow power-law degree distributions in which a tiny fraction of vertices hold the vast majority of connections. On such skewed, evolving structures, HDRF delivered superior performance and scalability compared with its rivals. HDRF makes a streaming, greedy decision for each edge as it arrives, assigning that edge to the machine that already holds the most relevant vertex state while penalizing overloaded servers. Because it never needs to see the whole graph, it adapts naturally to graphs that grow and shift over time, which is precisely the regime where offline methods like Metis stumble. The trade-off is a higher replication factor: more vertex copies consume memory, but the payoff in balance and reduced coordination often outweighs that cost in streaming settings.

Beneath these results lies a fundamental trade-off between partitioning complexity and runtime performance. Random Vertex and Random Edge partitioning cost essentially nothing to compute, which makes them tempting defaults, yet the study’s measurements show the price paid later in communication overhead and latency as queries hop between machines to traverse edges severed by careless cuts. In distributed systems, a network round trip is orders of magnitude more expensive than a local memory access, so every avoided hop compounds into tangible gains in query throughput. Conversely, the highest-quality offline partitioners impose a serious computational bill up front, and that bill grows with graph size, which is exactly when good partitions matter most.

The practical implications reach well beyond database internals. Enterprises running knowledge graphs for data interconnection, platforms powering fraud detection over transaction networks, and services driving personalized recommendations all face the same architectural fork: choose a partitioning strategy matched to their workload’s characteristics. The study’s statistically grounded insights offer a decision framework of sorts. If the graph is comparatively static and its structure is manageable, invest in a high-quality offline partition and reap the latency rewards. If the graph is enormous, skewed, and constantly changing, streaming vertex-cut approaches like HDRF are the more resilient bet, absorbing churn without expensive global recomputation.

The benchmarking framework itself is a meaningful contribution, as reproducible evaluation environments for distributed graph systems remain scarce. The researchers have released the scripts and configuration files supporting their findings in a public GitHub repository, inviting other teams to extend the comparison to new algorithms, larger clusters, and additional graph topologies. Open benchmarking matters here because partitioning claims have historically been made on heterogeneous hardware, datasets, and workload generators, making results difficult to compare across papers. A common harness that reports edge cut, replication factor, balance, latency and throughput side by side gives algorithm designers a consistent target and gives database engineers honest expectations.

The work also connects to a broader research lineage that has shaped how the industry thinks about large-scale graph computation. Google’s Pregel established the vertex-centric programming model that made distributed graph algorithms tractable, PowerGraph demonstrated the power of vertex-cut partitioning on natural graphs with skewed degree distributions, and systems such as GraphX, X-Stream and GraphGrind each staked out positions in the streaming-versus-offline, edge-cut-versus-vertex-cut design space. The Cluster Computing study synthesizes these threads in the specific context of graph databases serving interactive and analytical queries, a setting distinct from batch graph analytics because query latency dominates the user experience and partition choices directly determine how many machines must coordinate to answer a single traversal.

As graphs continue to metastasize through modern computing, from biomedical knowledge networks to supply chain digital twins to the operational graphs behind large language model retrieval systems, the unglamorous question of where to cut the graph is quietly becoming one of the most consequential engineering decisions of the decade. This study’s message is refreshingly pragmatic: there is no universal winner, only strategies matched to structure. Static and balanced favors Metis-grade precision; dynamic and power-law favors the streaming adaptability of HDRF; and blind randomness costs more than it saves. For the engineers building the next generation of distributed graph databases, the study offers both a map and the tools to redraw it as the landscape changes, and it is available, code and all, for anyone wrestling with graphs too big for any single machine to hold.

Subject of Research: Graph partitioning strategies for scalability and query performance in distributed graph databases

Article Title: Scalability and performance in distributed graph databases

Article References: Oloruntoba, O., Omolayo, O., Adepoju, S., Audu, K., Taiwo, S. O., Oyeyemi, D. O., Bamidele, A. A., Fakunle, S. O., & Henry-Machame, O. G. (2026). Scalability and performance in distributed graph databases. Cluster Computing, 29(12), Article 728. https://doi.org/10.1007/s10586-026-06406-0

Image Credits: AI Generated

DOI: 10.1007/s10586-026-06406-0

Keywords: graph partitioning, distributed graph databases, HDRF, Metis, edge-cut, vertex-cut, replication factor, load balancing, query latency, throughput, power-law networks, scalability

The problem HAMRL tackles is deceptively simple to state but brutally hard in practice. An IoT environment is a shifting landscape of heterogeneous devices: sensors, actuators, gateways, and cloud services, each with different capabilities, response times, and reliability levels. A user request rarely maps onto a single service. Instead, it demands a composition, a carefully ordered chain of services that together fulfill the request while respecting Quality of Service constraints such as latency, availability, and cost. In a static network, engineers could hand-craft these chains. But IoT networks are anything but static. Devices join and leave, wireless links degrade, workloads spike unpredictably, and the composition that worked perfectly yesterday may collapse today. Scalability compounds the difficulty: as the number of devices grows into the hundreds or thousands, the space of possible service combinations explodes combinatorially, overwhelming classical optimization techniques.

Reinforcement learning has emerged as a natural candidate for this challenge. In reinforcement learning, an agent learns by trial and error, taking actions in an environment and receiving rewards or penalties that gradually shape its behavior toward better outcomes. The approach has produced landmark results, from game-playing systems that reached human-level control to adaptive traffic signal networks. Applied to service composition, a learning agent can, in principle, discover which service chains deliver the best quality without needing an explicit model of every device. But single-agent learning hits a wall in large IoT systems, because no single agent can observe or manage the entire network. The field therefore turned to multi-agent reinforcement learning, where each IoT node hosts its own agent and the agents must coordinate. Coordination, however, introduces its own pathology: when every agent is learning simultaneously, each one perceives the others as part of a constantly changing environment, and the learning process can become unstable, a phenomenon researchers describe as the moving target problem.

The Kashan team, Sara Rezaei, Salman Goli-Bidgoli, and Fereshte Dehghani, designed HAMRL around a well-known architectural compromise called centralized training with decentralized execution. The framework combines three ingredients: decentralized actors, a centralized critic, and a hierarchical attention mechanism. Each actor is a small neural network that lives with an individual IoT agent and decides which service to select based on what that agent can locally observe. During training, however, a centralized critic, a second neural network with access to global information, evaluates how good the joint decisions of all agents actually were, providing each actor with a far more stable learning signal than any agent could compute alone. This division of labor, rooted in the actor-critic family of algorithms first formalized in 2000, means the system can learn with global oversight but operate without it, which is essential for real deployments where a global view may not exist at runtime.

The genuinely novel component is the hierarchical attention mechanism. Attention, the computational idea that now underpins modern language models, allows a neural network to weigh the relevance of different pieces of information rather than treating them all equally. HAMRL applies this idea at two levels. At the lower level, each agent fuses its local context, the state of its own device and immediate neighborhood, with global contextual information about the wider network, learning which of the many available signals actually matter for the decision at hand. At the higher level, the framework organizes these attention weights hierarchically, so that agents can reason about relationships across different scales of the network, from a single sensor cluster up to the system as a whole. The practical effect is that an agent choosing a service does not drown in irrelevant data from thousands of distant devices; it learns to focus on the handful of peers and conditions that genuinely influence quality of service.

This fusion of local and global context is what the authors identify as the key to HAMRL’s improved scalability and adaptability. Because each agent’s decision module only attends to the most relevant information, the computational burden does not grow uncontrollably as the network expands. And because the attention weights are learned rather than fixed, the system can re-prioritize its focus when conditions change, for example when a popular service becomes overloaded or a new device with better latency joins the network. Adaptability of this kind is precisely what static composition methods and even earlier learning-based approaches have struggled to deliver under the dynamic conditions that define real IoT deployments.

To find out whether these design choices actually pay off, the researchers ran extensive experiments comparing HAMRL against four state-of-the-art multi-agent reinforcement learning baselines: MAAC, an actor-attention-critic method; COMA, a counterfactual multi-agent policy gradient algorithm; MAA2C, a multi-agent extension of the widely used advantage actor-critic method; and MAPPO, a multi-agent version of proximal policy optimization that has surprised researchers with its effectiveness in cooperative settings. The evaluation focused on three criteria: the quality of service achieved by the composed solutions, the stability of the learning process, and adaptability when environmental conditions shifted. Across all three, HAMRL significantly outperformed the competition, according to the study. The hierarchical attention mechanism appears to give the agents a clearer, less noisy picture of their environment, which translates into steadier learning curves and better final compositions.

The implications reach well beyond benchmark experiments. Service composition sits at the heart of smart infrastructure: intelligent buildings, industrial automation, healthcare monitoring, smart cities, and logistics networks all depend on chaining device-level services into coherent applications. A composition framework that adapts in real time, maintains quality of service under load, and scales to large device populations could make these systems more resilient and less dependent on human reconfiguration. The study also contributes to a broader conversation in machine learning about the role of attention in multi-agent systems, a topic that has attracted growing interest as researchers seek principled ways to tame the complexity of many-agent coordination. By structuring attention hierarchically rather than flatly, HAMRL offers a template that other domains, from drone flocking to traffic control, might borrow.

None of this means the problem is solved. The authors frame HAMRL as a promising solution for next-generation scalable and resilient IoT applications, a carefully chosen phrase that acknowledges the gap between controlled experiments and messy production networks. Real deployments raise questions the paper’s benchmarks cannot fully answer: how the framework behaves under adversarial conditions, how it handles security and privacy constraints in service selection, and how it integrates with existing IoT protocols and standards. The researchers also note that the data supporting their findings are available from the corresponding author upon request, inviting the community to scrutinize and extend the results. Still, the central lesson stands. In ecosystems where no single controller can exist, intelligence has to be distributed, and the hardest part is not making individual agents smart but making them coordinate. HAMRL’s answer, letting agents learn what to pay attention to, locally and globally, at multiple scales, is an elegant step toward IoT networks that quietly assemble themselves, service by service, while the rest of us just ask for coffee.

Subject of Research: Multi-agent reinforcement learning for quality-of-service-aware IoT service composition

Article Title: HAMRL: a hierarchical attention-based multi-agent reinforcement learning approach for IoT-based service composition

Article References: Rezaei, S., Goli-Bidgoli, S., & Dehghani, F. (2026). HAMRL: a hierarchical attention-based multi-agent reinforcement learning approach for IoT-based service composition. Cluster Computing, 29(15), Article 832. https://doi.org/10.1007/s10586-026-06596-7

Image Credits: AI Generated

DOI: 10.1007/s10586-026-06596-7

Keywords: Internet of Things, service composition, multi-agent reinforcement learning, hierarchical attention, quality of service, centralized critic, decentralized actors, actor-critic algorithms, scalability, adaptability, smart infrastructure, Cluster Computing

At the heart of the vision is a continuous operational cycle the authors describe as Perceive, Reason, Act, and Learn. In this model, a perception module continuously gathers data from the environment through sensors, data streams, or other digital inputs. A cognition layer then analyzes this information, drawing on reasoning mechanisms that may combine symbolic logic, probabilistic inference, and deep neural representations. A decision-making component selects actions aligned with the agent’s objectives, constraints, and context, and feedback loops allow the system to refine its strategies as tasks unfold. Unlike automated scripts that follow fixed instructions, agents in this framework are entities with planned behavior, prioritization, and adaptation, capable of pursuing goals that are either preprogrammed or self-generated without continued human supervision.

The architecture proposed by the team is deliberately layered. At its core sits a large language model serving as the reasoning engine, surrounded by four functional modules covering planning, memory, tools, and action. Around these sit multi-agent scaling patterns, ranging from single agents to distributed, hierarchical, and orchestrated deployments, and finally the external interfaces that connect agents to users, APIs, data sources, cloud platforms, knowledge bases, and the web. Planning infrastructure breaks high-level objectives into practical subtasks, often using reinforcement learning or model-based planning, while memory components store short-term context and retain long-term knowledge. Policy layers enforce operational rules and boundaries. The authors stress that this holistic design is intended to solve a critical problem in the field: the isolated development of components that were never designed to work together.

That isolation problem runs deep. Modern large language models are trained predominantly on publicly available internet content, which gives them broad but shallow competence. When applied to real-world domains such as healthcare, transport, or industrial automation, they often fail to identify domain knowledge, dynamically evolving contextual signals, and operational constraints. The authors call this the jack-of-all-trades but master-of-none effect: generalist models provide a wide base of knowledge but lack depth in any particular area unless they are adapted, fine-tuned, or integrated with external resources and structured databases. Retrieval-augmented generation can mitigate some of these weaknesses by grounding outputs in external information, but only if the retrieval itself is reliable, and it adds computational overhead that strains infrastructure.

Hallucination remains perhaps the most stubborn technical defect. The paper notes that state-of-the-art systems struggle with hallucinations in their core language models, a problem rooted in pre-training restrictions and post-training behavior in which models deliver confident outputs even under ambiguity. The issue is compounded by a training-deployment misalignment: models are typically trained on limited, task-focused datasets rather than actual operational conditions, so performance degrades when the practical environment differs from the training setup. In an autonomous agent, such errors do not merely produce a wrong answer; they can cascade into harmful actions with unclear accountability for who is responsible, raising difficult questions of safety, trust, and ethics.

Scaling introduces its own failure modes. When multiple agents operate within shared environments, their interactions can produce emergent system-level behaviors that are not explicitly programmed but arise from collective dynamics, a hallmark of complex systems. While emergence can be powerful, it also invites coordination failures across distributed systems, and the authors observe that learning methods such as reinforcement, meta-learning, and transfer learning have been developed separately from scaling approaches that move from single-agent to multi-agent configurations, with no common standard for deploying them across different fields. High-level reasoning, planning, and learning operations are also computationally and energy intensive, making them practically unsuitable for real-time, large-scale tasks such as smart city management, and performance decay is observed as the number of agents or tasks grows.

Despite these caveats, the survey of applications is striking in its breadth. In healthcare, agentic AI is being used for autonomous construction and execution of medical image segmentation pipelines, real-time detection of drug-induced liver injury risks from clinical records, AI-assisted interpretation of neuromuscular electrodiagnostic tests, and personalized adaptive fitness coaching built on multimodal multi-agent digital twin systems. Future clinical assistants could integrate records, imaging, wearable devices, and genomic profiles to support continuous monitoring and early disease prediction. In transportation, agents support multimodal model predictive control for autonomous navigation and multi-agent routing optimization in logistics networks, with future systems coordinating vehicles, infrastructure, and public transit to manage congestion proactively.

The industrial and commercial reach is equally broad. In software engineering, agents automate task decomposition, tool selection, and execution with real-time feedback, and generate behavior-driven development test cases from natural language, with the long-term prospect of autonomous assistants managing the entire software lifecycle. In finance and banking, agentic systems underpin risk profiling, LLM-based financial modeling, compliance workflows, fraud detection, and personalized customer service. Smart manufacturing deploys agents for robotic assembly, supply-chain management, human-robot collaboration, and self-managing quality systems, while smart cities apply them to energy optimization, fault detection, and urban service coordination. The authors also document applications in military and security contexts, including swarm decision-making and moving-target defense, alongside multidisciplinary uses in radiology, predictive crime analytics, tourism pricing, and autonomous coding agents.

The challenges catalogued in the paper read like a checklist of everything that could go wrong. Agents may harbor biases that conflict with human values, ethics, and cultural beliefs, particularly dangerous in sensitive domains like medicine and finance. Unpredictable behavior arises from information gaps and interactions among agent components, and it is difficult to authenticate, test, and regulate agent decisions, risking failure cascades in multi-agent systems. Privacy and security risks loom because these systems handle sensitive data and are vulnerable to manipulation by malicious actors. Reliability suffers under noisy or incomplete inputs, and the lack of standardized benchmarks and evaluation methods makes impartial comparison nearly impossible, inviting exaggerated performance claims. Biased, incomplete, or outdated training data can perpetuate social inequalities, and poor coordination among agents in decentralized systems undermines both scalability and dependability.

To chart a way forward, the authors propose a six-dimensional research roadmap. It calls for trustworthy autonomous systems aligned with human values, reasoning frameworks that embed ethical principles and legal regulations, and explainable agents whose planning and decision-making can be verified by users. It urges research into decentralized communication strategies, adaptive task allocation, hierarchical coordination, and efficient collaboration protocols for large-scale multi-agent environments. Continuous adaptation through lifelong learning, meta-learning, and memory-enhanced reasoning would let agents acquire new knowledge without forgetting old lessons, while privacy-preserving techniques such as federated learning, secure multi-party computation, homomorphic encryption, and differential privacy would enable collaborative learning without exposing sensitive information. Finally, the roadmap demands standardized benchmarking datasets, evaluation metrics, testing environments, and validation protocols. The message of the paper is ultimately one of guarded optimism: agentic AI could transform healthcare, industry, cities, and governance, but only if the field abandons isolated component development and builds integrated, accountable, and rigorously evaluated systems fit for the real world.

Subject of Research: Conceptual frameworks, applications, and open challenges of autonomous agentic AI systems built on large language models

Article Title: Agentic AI: Vision and challenges

Article References: Gill, S. S., Murugesan, S. S., Anurag, K. A., Verma, P., Kaur, H., Kumar, S., & Kumar, M. (2026). Agentic AI: Vision and challenges. PLOS Complex Systems, 3(8), e0000120. https://doi.org/10.1371/journal.pcsy.0000120

Image Credits: AI Generated

DOI: 10.1371/journal.pcsy.0000120

Keywords: agentic AI, large language models, autonomous agents, hallucination, multi-agent systems, healthcare AI, smart cities, machine learning, AI ethics, scalability, retrieval-augmented generation, PLOS Complex Systems

Federated learning, first popularized by researchers at Google in 2017, flips the conventional training pipeline on its head. Instead of moving data to the model, the model moves to the data. Each device—or client—trains a local copy of the algorithm on its own measurements and then transmits only the resulting parameter updates, typically small numerical gradients, to a coordinating server. The server averages these updates into a shared global model and sends it back down for another round of local training. Because raw sensor readings never leave the device, the approach reduces direct exposure of sensitive information while slashing the volume of traffic that must cross the network. For IoT deployments, where a single greenhouse or smart building may host dozens of constrained devices, that distinction is not a luxury but a prerequisite.

What makes the Moroccan team’s contribution distinctive is where the federation logic lives. The OneM2M standard is an internationally recognized service layer designed to sit between heterogeneous IoT devices and applications, providing common primitives for registration, data storage, subscription, and notification regardless of whether devices speak HTTP, MQTT, or CoAP. Rather than bolting federated learning onto an ad hoc middleware stack, FL-OneM2M embeds it into this operational backbone, turning OneM2M into an orchestration infrastructure for decentralized intelligence. The authors argue that this integration addresses a genuine gap: most federated learning research assumes idealized communication conditions, while most IoT standards work ignores machine learning entirely. By unifying the two, the framework promises both quality-of-service awareness and scalable learning in a single architecture.

The experimental setup drew on data generated from IoT agricultural deployments, collected through Azure IoT devices and processed via OneM2M-based data injectors. The raw sensor streams included humidity, temperature, environmental plant indicators, and a suite of agricultural growth metrics, partitioned across multiple simulated greenhouse clients. On top of this dataset, the researchers deployed logistic-regression clients and compared two canonical federated optimization algorithms. Federated Averaging, known as FedAvg, is the simplest and most widely used scheme: clients train locally and the server weights each update by client data volume. Federated Proximal, or FedProx, adds a proximal term to the local objective that penalizes clients whose local updates drift too far from the global model, a modification intended to stabilize learning when devices are heterogeneous or perform varying amounts of local work.

The results, reported for an independently and identically distributed—or IID—data setting, tell a nuanced story. FedAvg reached a final accuracy of 80 percent, a gain of 50 percentage points over its starting point, and achieved a higher peak accuracy than FedProx, which topped out at 75 percent. FedProx, however, exhibited smoother loss convergence, suggesting that its regularization term does damp oscillations even when it costs some final performance on this particular problem. The authors are careful to frame these numbers as trends observed under their specific conditions rather than universal verdicts. With a single model class, a single dataset, and at most ten clients, the study deliberately scopes its claims, and the paper discusses the resulting limitations—large-scale behavior, statistical heterogeneity across clients, and security—explicitly rather than glossing over them.

Perhaps the most striking findings concern communication efficiency, the resource that often determines whether federated learning is practical at the edge at all. Under the study’s test conditions, switching the transport protocol from HTTP to MQTT reduced the average round-trip time by 98.4 percent, and the system reached peak accuracy roughly 40 training rounds earlier. The explanation lies in protocol design. HTTP is a request-response protocol that carries substantial header overhead and requires a new exchange for every message, whereas MQTT is a lightweight publish-subscribe protocol built for constrained networks, using minimal headers and persistent connections. In a federated loop, where the server and clients exchange model updates hundreds of times, shaving milliseconds off every round compounds into a dramatic acceleration of the entire training process. For anyone deploying learning across battery-powered sensors, that difference can separate a viable system from an intractable one.

Scalability tests at small scale—three, five, and ten clients—added another practical insight: five clients produced the most stable convergence in the studied configuration. This counterintuitive result reflects a real tension in federated systems. With very few clients, each local update carries outsized weight, so a single noisy or poorly conditioned client can destabilize the global model. As the client count grows, averaging smooths out individual noise, but coordination overhead rises and, in real deployments, stragglers and dropouts multiply. The team also probed resilience by simulating clients dropping out mid-training and found that the system retained 80 percent accuracy under a 10 percent client-dropout rate, an encouraging signal that the OneM2M-based orchestration can absorb a degree of real-world unreliability without collapsing.

The choice of agriculture as the application domain is more than incidental. Smart farming is emerging as a natural proving ground for federated learning because farms are simultaneously data-rich and privacy-sensitive: yield forecasts, disease detections, and growth metrics carry commercial value, and farmers may be reluctant to surrender raw operational data to third parties. Recent work in the field has explored federated crop disease detection from images, model-pruned yield forecasting, and blockchain-assisted trust mechanisms, all pointing toward the same conclusion that collaborative intelligence is only acceptable to many stakeholders if the data stays local. FL-OneM2M fits squarely into this movement, demonstrating that a standardized service layer can serve as the connective tissue between field sensors and a learning pipeline without a central data lake.

The authors are refreshingly candid about what their study does not establish. Ten clients is a toy scale compared with the thousands or millions of devices a production IoT network might involve, and behavior at large scale—where communication bottlenecks, stragglers, and server load become dominant—remains untested. The IID assumption is similarly generous: real sensor networks are notoriously non-IID, with each greenhouse, factory floor, or city block exhibiting its own statistical fingerprint, a condition known to degrade federated averaging and motivate algorithms like FedProx, SCAFFOLD, and adaptive federated optimization in the broader literature. Security is another open front, since model updates themselves can leak information or be poisoned by malicious clients, and the paper positions these challenges as explicit future work rather than solved problems. The researchers also note that the underlying dataset was generated specifically for the study and contains sensitive operational information, so it is not publicly available, though processed or anonymized subsets can be requested from the corresponding author.

Even within those limits, the study offers a genuinely useful template. It shows that federated learning need not live in bespoke middleware but can ride on an open, interoperable standard that the IoT industry already deploys, and it quantifies how much protocol choice—MQTT over HTTP—matters to the speed of decentralized training. As edge hardware grows more capable and privacy regulation tightens worldwide, the pressure to move intelligence out of the cloud and into the network’s periphery will only intensify. Frameworks like FL-OneM2M suggest a path in which the same infrastructure that routes sensor data today becomes the stage on which devices learn together tomorrow, one carefully averaged model update at a time.

Subject of Research: Federated learning integrated with the OneM2M service layer for quality-of-service-aware, scalable machine learning in Internet of Things networks

Article Title: A novel federated learning approach for enhancing QoS and scalability in IoT networks

Article References: Et-Tousy, J., & Zyane, A. (2026). A novel federated learning approach for enhancing QoS and scalability in IoT networks. Cluster Computing, 29(14), Article 825. https://doi.org/10.1007/s10586-026-06633-5

Image Credits: AI Generated

DOI: 10.1007/s10586-026-06633-5

Keywords: federated learning, Internet of Things, OneM2M, edge intelligence, MQTT, quality of service, FedAvg, FedProx, smart agriculture, privacy-preserving machine learning, scalability, Cluster Computing

Palash Dutta of the Department of Mathematics at Dibrugarh University in Assam, India, conducted a systematic comparison between Diophantine fuzzy models and a far simpler framework known as hyperbolic fuzzy sets. The Diophantine family includes several prominent variants that have attracted considerable attention in multi-criteria decision-making literature: linear Diophantine fuzzy sets, q-rung linear Diophantine fuzzy sets, generalized Diophantine fuzzy sets, and their fractional extensions. These models share a common design philosophy, embedding multiple reference parameters that users can tune to shape how membership and non-membership information is combined. On paper, that flexibility sounds like a strength. In practice, according to the new findings, it may be the very thing that undermines them.

The core problem Dutta set out to test is a trade-off that has received surprisingly little rigorous scrutiny. Every additional reference parameter in a fuzzy model increases its representational flexibility, but it also opens the door to what the study calls parameter-induced distortion. When users must choose parameter values, the model’s decision boundaries shift depending on those choices, and different users, or the same user on different occasions, can arrive at different conclusions from identical data. In high-stakes applications such as medical diagnosis, renewable energy selection, or infrastructure contracting, where fuzzy methods are routinely deployed, that kind of instability is not a theoretical curiosity. It is a practical liability.

To quantify the problem, the study employed two complementary evaluation strategies. The first was a threshold-based binary classification experiment across an expanded dataset of sixty cases, a sample size determined in advance through a priori power analysis rather than chosen after the fact. Crucially, the experiment used dual cut-offs, deliberately exposing how sensitive each model’s classifications were to the parameters embedded in its formulation. The second strategy was a direct assessment of computational complexity, measuring how each framework’s mathematical machinery scales as problem size grows. Together, the two approaches were designed to answer a deceptively simple question: does the extra flexibility of Diophantine models buy anything that matters?

The answer, at least within this experimental design, was an emphatic no. Hyperbolic fuzzy sets, which contain no reference parameters at all, achieved one hundred percent classification accuracy and perfect self-consistency across the full range of threshold values tested in a continuous, full-spectrum sensitivity analysis. The Diophantine variants told a very different story. Plagued by parameter-induced over-prediction and under-prediction, their accuracies collapsed to a range of roughly 43 to 55 percent. The best performer among them, the generalized Diophantine fuzzy set framework, still managed only 68.33 percent. In classification terms, several of the parameterized models performed worse than a coin flip, a result that raises uncomfortable questions about published applications relying on them.

The magnitude of the gap was not merely statistically detectable but practically enormous. Effect size analysis using Cohen’s d yielded values exceeding 3.0 for every comparison between the hyperbolic framework and its Diophantine rivals, a threshold far beyond the conventional benchmarks for large effects in the behavioral and computational sciences. In plain terms, the difference between the two families of models is not a marginal improvement that might vanish under slightly different conditions. It is a chasm, and the study attributes it directly to a structural feature: the parameter-free multiplicative formulation of hyperbolic fuzzy sets, which captures interaction effects transparently without the parametric sensitivity that warps Diophantine decision boundaries.

Computational results reinforced the picture. The hyperbolic framework maintains a lean linear, or O(N), complexity, meaning its cost grows in direct proportion to the size of the problem. The parameter-heavy Diophantine alternatives, by contrast, carry substantial computational overhead stemming from the extra operations their reference parameters require. For small illustrative examples in academic papers, that overhead is easy to overlook. But fuzzy decision models are increasingly proposed for large-scale, real-world systems, from agriculture decision support platforms to construction contract evaluation and solar panel prioritization, and at scale, the difference between linear scaling and parameter-burdened computation becomes consequential.

The study is careful to define its terms, and those definitions sharpen the critique. Sensitivity, in this context, means responsiveness to parameter variations, and the hyperbolic framework exhibits zero sensitivity while Diophantine models are highly sensitive. Subjectivity means dependence on user-defined choices, which the parameter-free approach eliminates entirely. Stability refers to consistency across conditions, and here the contrast is between perfect stability for the hyperbolic model and narrow optimal windows for its rivals, meaning Diophantine models perform acceptably only within limited ranges of parameter settings. Even the celebrated unity constraint, the bounding condition on membership and non-membership grades that Diophantine models relax in the name of generality, turns out to impose only a trivial, non-restrictive burden on the hyperbolic formulation while its relaxation introduces distortion elsewhere.

None of this means the Diophantine research program is without value. These frameworks emerged from a genuine mathematical lineage stretching from Atanassov’s intuitionistic fuzzy sets through Yager’s orthopair generalizations, Pythagorean and Fermatean variants, and a flourishing ecosystem of rung-based extensions. Each generation promised a wider space of admissible membership grades, and each attracted a wave of applications. What the new study challenges is the assumption that wider admissible spaces and more tunable parameters translate into better decisions. Flexibility, the findings suggest, is only a virtue if the person wielding it knows precisely how to wield it, and even then, the model’s output may say more about the chosen parameters than about the underlying problem.

The implications reach well beyond one corner of fuzzy mathematics. Multi-criteria decision-making methods built on parameterized fuzzy sets are embedded in software used for site selection, supplier evaluation, disease diagnosis, and disaster response planning. If the classification reliability of the underlying model can swing by tens of percentage points depending on parameter choices, then the credibility of those applications deserves fresh scrutiny. The study’s message is a bracing one for a field that has rewarded novelty and generality: sometimes the mathematically robust, globally scalable, and highly reliable choice is the one with fewer knobs to turn, and the burden of proof now lies with the complex models to demonstrate that their flexibility earns its keep.

Subject of Research: Comparative reliability and computational complexity of Diophantine fuzzy models versus hyperbolic fuzzy sets in decision-making

Article Title: A critical survey on critical issues of diophantine fuzzy models in light of hyperbolic fuzzy sets

Article References: Dutta, P. (2026). A critical survey on critical issues of diophantine fuzzy models in light of hyperbolic fuzzy sets. International Journal of Data Science and Analytics, 22(1), Article 327. https://doi.org/10.1007/s41060-026-01311-6

Image Credits: AI Generated

DOI: 10.1007/s41060-026-01311-6

Keywords: fuzzy sets, Diophantine fuzzy sets, hyperbolic fuzzy sets, multi-criteria decision-making, classification accuracy, sensitivity analysis, computational complexity, scalability, parameter sensitivity, uncertainty modeling, decision stability, effect size

The work builds on Object-Centric Event Data, a modern way of recording process behavior that captures how a single event involves multiple objects at once. In a hospital, the event of registering a test may simultaneously concern a patient, a caregiver, and a specific diagnostic procedure such as a 12-lead ECG or a fasting blood glucose test. The widely adopted Object-Centric Event Log standard, now in its 2.0 specification, stores these many-to-many relationships between events and objects, along with object-to-object relations and attributes that can change over time. This richness is precisely what allows object-centric process mining to discover far more realistic models than the traditional single-case logs that dominated the field for two decades. But it also creates a new challenge: the algorithms that transform these logs into visual models, such as Object-Centric Directly-Follows Graphs, operate at a fixed level of abstraction, deriving process logic from the sequence of event types associated with each object type over time.

The consequence of that fixed abstraction is illustrated by the researchers’ hospital running example. When a caregiver orders an ECG test, registers the result, and then orders a blood test as a standard follow-up procedure, the log faithfully records each concrete action. Yet because all tests share the same generic event types and the same Test object type, the discovered model shows only a flat loop of ordering and registering tests. The clinically meaningful pattern, in which a concerning ECG result triggers a blood test, remains invisible. The authors’ solution borrows a page from the world of Online Analytical Processing, the multidimensional analysis paradigm behind business intelligence tools like Excel pivot tables and data cubes. Van der Aalst proposed the idea of process cubes with slice, dice, drill-down and roll-up operations as early as 2013, but those early implementations predated object-centric process mining and could not handle events tied to multiple objects. The new work brings the OLAP vision fully into the object-centric era.

Four operations form the core of the contribution. Drill-down refines object types by splitting a generic type into variants based on an attribute value, so a Test object type can be decomposed into 12-lead ECG, Monitoring ECG, Fasting Blood Glucose Test and Arterial Blood Gas Test. The operation can be applied recursively and, importantly, comes in a time-aware variant that uses the historical values of object attributes, meaning an object can belong to different drilled-down types at different points in its lifecycle. Roll-up is the inverse: it merges several fine-grained object types into a coarser category, such as grouping the two ECG variants into an ECG Test category that matches how clinicians actually reason. Unfold operates on event types rather than object types, making implicit event-object associations explicit by projecting each event type into a combination of the event type and the object type it concerns, so the generic order test becomes order ECG Test or order Blood Test. Fold collapses those unfolded variants back into their original generic labels.

Each operation is accompanied by a formal algorithm that manipulates the components of the OCEL 2.0 structure, extending sets of object or event types, reassigning the type functions, and updating attribute type mappings while preserving all existing event-to-object and object-to-object relations. The structural connectivity of the log is never broken, which means analysts can chain operations freely: drill down into tests, unfold the ordering and registration events, fold selected variants back together, and roll up categories, all without reloading or reconstructing the data. The authors have implemented everything in an open-source Python library called processmining, installable with a single pip command, and released the running example, case study data and evaluation code on GitHub to support reproducibility.

To demonstrate real-world value, the team applied the approach to four years of educational process data from a Business Process Management course at Stockholm University, extracted from the Moodle learning management system following their OCPM2 methodology. The dataset covered 401 students organized into 91 groups, with between roughly 38,000 and 61,000 events per year and tens of thousands of event-to-object relations. In its raw form, the discovered process model was nearly useless: students and teachers were conflated under a single user object type, all assignments were lumped into one assign type, and no individual task could be distinguished. After drilling down on the user role and assignment name attributes and unfolding the relevant events, the model blossomed into a detailed flow of five clear milestones, revealing exactly which student in each group submitted each lab, how teachers graded individually even for group work, and how many students needed grade updates after failing a first attempt.

The case study also surfaced findings with practical consequences for course design. The final, optional process mining assignment attracted only 13 submissions compared with 23 for an earlier lab, and grading touched just 28 students against 134 for the first milestone. Follow-up investigation showed the optional module was scheduled close to the final exam, leading most students to prioritize exam preparation. More strikingly, the detailed models revealed that resubmission attempts for failed labs were entirely absent from the digital record, indicating those submissions were handled offline, an actionable gap for anyone seeking to improve the educational process. Quantitatively, the team discovered object-centric Petri nets before and after transformation and computed fitness and precision for 71 of the 91 groups, finding significant improvements for most groups after drilling down and unfolding. For the handful of groups with poor fitness, converting the logs into temporal Event Knowledge Graphs exposed the culprit: heavy rolling group membership, with one group losing 11 of its students to other groups during the course, something current object-centric techniques cannot account for because they model object relations as static.

The error analysis added a further layer of insight. Twenty groups defeated the conformance checking library entirely, and ten of those came from 2023, the year the course introduced optional tracks that made the process less structured. Point-biserial correlations showed that model complexity metrics, including the number of places, transitions, arcs, silent transitions, AND-splits and AND-joins, all correlated moderately and significantly with conformance checking failures, with synchronization-heavy parallel constructs exerting the strongest influence while XOR-based choice structures played a secondary role. This points to a broader need for more scalable and robust conformance checking algorithms for object-centric Petri nets, a limitation the authors candidly acknowledge as a threat to validity since the operations themselves applied successfully to all 91 groups.

Scalability was tested on publicly available object-centric event logs derived from the Business Process Intelligence Challenge datasets of 2014, 2016, 2017 and 2019, ranging from about seven hundred thousand to more than seven million events. The researchers drilled down on the most frequent object type using synthetic attributes with between 2 and 10 categories and unfolded all strongly associated event types. The number of categories had little effect on performance; what mattered was log size and connectivity. For the three smaller logs, unfold calls took roughly 1.5 to 3.2 seconds each, while the massive BPIC 2016 log, with its enormous number of event-to-object relations, required around 29 seconds per unfold call and about 60 seconds for drill-down. Crucially, the dominant cost for that log was simply loading it into the PM4Py library, an order of magnitude slower than the operations themselves. This finding underscores why in-place abstraction matters: being able to roll up or fold without reloading makes interactive analysis feasible on industrial-scale data.

The operations have already proven their versatility beyond education, having been applied in the insurance domain, providing a form of methodological triangulation across settings. Because object-centric event data can be transformed bidirectionally between OCEL and temporal Event Knowledge Graphs, the same OLAP operations can be combined with graph queries, centrality measures and community detection, letting analysts exploit the strengths of both representations. The authors frame their contribution as a foundation for more dynamic and detailed process mining methodologies, and they chart clear future directions: scalable conformance checking for object-centric models, better handling of dynamic object-to-object relationships during discovery, and integration of the operations into mainstream process mining tools. For organizations drowning in multi-dimensional event data, the message is simple and compelling: the right insight may already be in your log, waiting at the right level of zoom.

Subject of Research: Granularity-adjusting OLAP operations for object-centric process mining on Object-Centric Event Logs

Article Title: Advancing object-centric process mining with multi-dimensional data operations

Article References: Khayatbashi, S., Miri, N., & Jalali, A. (2026). Advancing object-centric process mining with multi-dimensional data operations. Knowledge and Information Systems, 68(1), Article 275. https://doi.org/10.1007/s10115-026-02904-0

Image Credits: AI Generated

DOI: 10.1007/s10115-026-02904-0

Keywords: object-centric process mining, Object-Centric Event Log, OLAP operations, drill-down, roll-up, process discovery, event knowledge graphs, educational process mining, conformance checking, scalability, OCEL 2.0, business process management

The central obstacle the researchers set out to overcome is a computational one that has shaped the field for over a decade. Classical subspace clustering methods rely on a self-representation model, in which every data point is expressed as a linear combination of all the other points. The resulting coefficient matrix encodes the relationships that define cluster membership, and it is extraordinarily informative. The problem is its size. For n data points, the full sample-to-sample affinity matrix contains n squared entries, so a dataset of one million samples would demand a matrix with a trillion coefficients. Constructing, storing, and optimizing over such an object is prohibitive on any hardware, which is precisely why many theoretically elegant subspace clustering algorithms have remained confined to benchmark datasets of a few thousand points.

The LSSC framework breaks this bottleneck by replacing the full self-representation with a compact sample-to-anchor representation. Instead of allowing every point to be reconstructed from every other point, the method first selects a much smaller set of anchor points that serve as representative landmarks for the data. Each sample is then expressed as a nonnegative combination of these anchors alone. Because the number of anchors grows far more slowly than the number of samples, the coefficient matrix shrinks from n squared to a size proportional to n times the anchor count, turning an intractable optimization into a manageable one. Crucially, the nonnegativity constraint on the coefficients gives the representation a natural probabilistic flavor: each weight reflects how strongly a sample belongs to the neighborhood of a given anchor, which makes the downstream clustering step far more stable.

Compactness alone, however, is not enough. The authors identify a second, subtler failure mode in existing scalable methods: fast representations often fail to preserve the intrinsic structural relationships of the data when distributions become complex. Two points that sit close together on the same underlying manifold may end up with very different anchor coefficients simply because of how the anchors were sampled, and the resulting affinity graph can fragment genuine clusters. LSSC counters this with a locality-aware coefficient initialization, which seeds the optimization using neighborhood information so that the reconstruction process starts from a configuration already consistent with the local geometry of the data. This initialization acts like a well-chosen starting point in a rugged optimization landscape, steering the solution toward coefficients that respect the manifold rather than artifacts of sampling.

On top of that initialization, the framework applies distance-weighted structure regularization, a mechanism that explicitly encourages the learned representation to remain smooth with respect to the geometry of the data. Samples that are near each other in the original feature space are pushed toward similar anchor coefficients, weaving locality information directly into the optimization objective rather than bolting it on afterward. The framework also employs coefficient regularization to keep the representation compact and well-conditioned, suppressing degenerate solutions in which a sample spreads its weight indiscriminately across many anchors. Together, these four components—anchor-based reconstruction, locality-aware initialization, distance-weighted regularization, and coefficient regularization—form a single coherent objective that learns a structured, nonnegative representation without ever forming the full sample-to-sample affinity matrix.

The mathematical machinery behind the approach draws on a rich lineage of research. Low-rank representation, introduced by Liu and colleagues, and sparse subspace clustering, developed by Elhamifar and Vidal, established the foundational idea that imposing structure on self-representation coefficients reveals subspace membership. Nonnegative matrix factorization, famously connected by Lee and Seung to the way humans learn parts of objects, supplies the theoretical justification for the nonnegative coefficients at the heart of LSSC. More recent work on anchor graphs and landmark-based spectral clustering demonstrated that working with a reduced set of representative points can preserve much of the quality of full spectral methods at a fraction of the cost. LSSC synthesizes these threads, but its distinctive contribution is the integration of structure-preserving regularization into the anchor-based pipeline, addressing the structural fidelity problem that earlier fast methods left unresolved.

To test the framework, the team ran extensive experiments on nine benchmark datasets, comparing LSSC against a battery of established clustering algorithms using four standard evaluation metrics: clustering accuracy (ACC), normalized mutual information (NMI), Purity, and the adjusted rand index (ARI). The results were striking. Among the compared methods that completed all nine datasets, LSSC achieved the best overall average rank across all four metrics, indicating that its advantage is not confined to one type of data or one evaluation criterion but reflects a consistently strong performance profile. On the large-scale datasets, where many competitors either slowed to a crawl or failed outright, LSSC maintained competitive clustering quality while demonstrating the favorable scalability that the anchor-based design was built to deliver.

The authors are careful to characterize the limits of their method as well as its strengths, a candor that lends the study particular scientific value. Their experiments reveal that LSSC shows sensitivity to highly imbalanced data distributions, a scenario in which some clusters contain vastly more samples than others. This vulnerability is a known hazard of anchor-based approaches, since anchors tend to be drawn disproportionately from dense regions of the data, leaving sparse clusters underrepresented in the reconstruction basis. By documenting this weakness explicitly, the researchers provide a clear empirical map of where the framework should be deployed and where practitioners should exercise caution, an honest assessment that is all too rare in a field often driven by headline benchmark numbers.

The implications reach well beyond the machine learning community. Subspace clustering underpins applications from image segmentation and hyperspectral image analysis to single-cell RNA sequencing, where biologists attempt to sort thousands of individual cells into functional types based on high-dimensional gene expression. A method that scales gracefully while preserving structural fidelity could make such analyses feasible on datasets that are currently out of reach, and the same logic applies to speech processing, anomaly detection, and any domain where high-dimensional observations hide low-dimensional group structure. The work, supported by research grants from Zhejiang Province and Hangzhou Dianzi University, arrives at a moment when the volume of unlabeled data is exploding faster than the tools to organize it. By showing that structure and scale need not be enemies, LSSC offers a template for the next generation of clustering algorithms: representations that are compact by design, yet rich enough to remember the geometry that made the clusters real in the first place.

Subject of Research: Scalable anchor-based subspace clustering for large high-dimensional datasets

Article Title: Large-scale structured subspace clustering

Article References: Chen, M., Yin, X., Huang, Q., Ding, J., Zhang, G., & Miao, X. (2026). Large-scale structured subspace clustering. Data Mining and Knowledge Discovery, 40(6), Article 99. https://doi.org/10.1007/s10618-026-01268-x

Image Credits: AI Generated

DOI: 10.1007/s10618-026-01268-x

Keywords: subspace clustering, anchor-based modeling, representation learning, affinity graph, manifold regularization, nonnegative matrix factorization, data mining, unsupervised learning, scalability, high-dimensional data, clustering algorithms, machine learning