Optimized topology control for large-scale IoT networks using graph-based localization

Abstract

Internet of Things (IoT) is increasingly realized through large scale deployments of heterogeneous devices and gateways operating under strict energy budgets and interference limited links, which motivates reliability aware topology control and end to end communication performance objectives. As IoT deployments grow to massive scales and incorporate highly heterogeneous devices, designing and controlling network topology in a reliable and energy-efficient manner becomes a fundamental challenge. In particular, poor link quality, interference, and localization uncertainty severely limit the effectiveness of traditional topology-control approaches. In this paper, we address this challenge by introducing IoTNTop, a novel and unified graph-based framework for joint localization, graph embedding, and topology control in large-scale, resource-constrained IoT networks. Unlike conventional methods that decouple localization from topology design, IoTNTop embeds both end-nodes and gateways into a globally consistent spatial structure using partial and noisy distance measurements, and directly couples this geometry with communication-aware topology optimization. IoTNTop adopts an error-centric topology-control objective that explicitly minimizes end-to-end (E2E) error probability while enforcing practical code-rate and transmit-power constraints. The framework jointly optimizes link activation, transmit power, and data transmission code rate, and employs a scalable sub-graph stitching pipeline based on eigenvector synchronization (EVS), landmark alignment (LA), and semidefinite programming (SDP) refinement. A greedy signal-to-noise-ratio (SNR)–guided edge selection strategy with convergence checking further ensures computational efficiency. Comprehensive numerical analysis and network-level simulations show IoTNTop retains approximately 60–80% of the initial per-node energy budget while maintaining symbol error probability below 15% for the majority of nodes. At the same time, it converges in fewer iterations than Genetic Algorithm (GA) and brute-force baselines and sustains higher achievable code rates at lower transmit power levels. These performance gains remain consistent across the tested signal-to-noise ratio regimes and network sizes.

Introduction

The rapidly expanding Internet of Things (IoT), featuring billions of heterogeneous devices across smart cities industrial automation and remote healthcare, faces unprecedented challenges in managing vast dynamic and resource constrained networks. As deployments grow in size and diversity, IoT networks must operate under strict energy limits while meeting application requirements on reliability data fidelity and timeliness. These demands make topology formation and control a central design issue, since link activation transmit power and coding rate choices directly shape interference decoding feasibility and long term network operation^1,2.

Early research in wireless sensor networks (WSNs) established important foundations for distributed connectivity and energy aware operation. However the assumptions that often made WSN era solutions effective are increasingly misaligned with modern IoT deployments. Contemporary IoT systems are typically larger, more heterogeneous and more dynamic with a mix of constrained end nodes and more capable gateways operating in interference limited environments. In such settings, measurement noise link variability and incomplete observability are not secondary effects but primary constraints. As a result approaches that treat the network as homogeneous or that rely on stable well observed links can produce topologies that appear adequate under simplified models, yet fail to deliver reliable communication under practical conditions^3,4.

This shift also changes the relationship between localization and topology control. In large scale IoT many decisions depend on inferred geometry, because distance driven path loss affects signal to noise ratio and therefore achievable code rate and error probability. When position estimates are inaccurate the resulting propagation estimates become biased, which can lead to selecting links that are nominally feasible but unreliable in practice. At the same time topology and power control decisions influence which links remain observable and which measurements remain informative over time. This creates a tight coupling where localization uncertainty and topology decisions interact rather than forming a clean pipeline. Consequently decoupled designs that first localize and then optimize topology often fail to propagate uncertainty into link selection power assignment and code rate choice. The outcome can be networks that preserve connectivity but do not meet end to end reliability targets under energy and coding constraints^3,4.

A further limitation is that much prior work optimizes proxy objectives such as connectivity node degree or energy alone instead of directly targeting an error centric objective that matches communication performance. In modern IoT with low power wide area networks and mission critical workloads, the priority is often low error probability and reliable decoding under tight energy budgets and interference constraints^3,4. In addition existing embedding pipelines can struggle to jointly place gateways and end nodes with global consistency when distances are partial and noisy, leaving a gap between spatial inference and link level performance at deployment scale⁵.

These gaps motivate a unified framework that couples geometric inference with reliability aware topology control. In this paper we introduce IoTNTop, a graph based framework that jointly localizes nodes and configures network topology by determining active links transmit power and code rate, so as to minimize end to end error probability under practical power and coding constraints^1,2. Unlike conventional pipelines that separate localization from topology design IoTNTop embeds both end nodes and gateways into a globally consistent spatial structure, using partial and noisy distance measurements and directly incorporates this geometry into topology optimization (in this paper, “embed/embedding” refers to graph embedding for localization: constructing a globally consistent geometric realization (node positions for gateways and end-nodes) from partial and noisy pairwise distance information and overlaps between local sub-graphs. It does not refer to graph representation learning that compresses nodes or graphs into abstract feature vectors for downstream predictive tasks. Our use of embedding is strictly geometric and serves to recover the spatial layout that underpins path loss, SNR, and code-rate feasibility in the subsequent topology-control step). Specifically, IoTNTop (i) constructs a scalable geometric embedding from partial and noisy distance measurements using eigenvector synchronization (EVS), landmark alignment (LA), and semidefinite programming (SDP) refinement, and (ii) performs topology control by jointly selecting links, transmit power levels, and code rates to minimize end-to-end (E2E) error probability under realistic constraints. An SNR-guided greedy strategy with convergence checking is employed to align early iterations with decoding feasibility while maintaining computational efficiency. The main contribution of this work is a joint optimization framework that integrates localization, graph embedding, and topology control in a principled, error-centric manner. In particular, this paper makes the following contributions:

• Unified graph-based modeling for joint localization and topology control: we present a single framework that integrates geometric inference of heterogeneous IoT end-nodes and gateways with topology optimization under realistic communication constraints.

• Error-centric topology optimization: we formulate a topology-control objective that minimizes E2E error probability while enforcing code-rate feasibility and transmit-power limits, explicitly linking decoding reliability to link activation.

• Scalable multi-stage embedding under partial and noisy measurements: we develop a noise-resilient embedding pipeline that decomposes the network into sub-graphs, stitches them via EVS and LA, and refines the global geometry using SDP to ensure consistency.

• IoTNTop algorithm with convergence-aware optimization: we propose an iterative algorithm that employs SNR-guided link selection and convergence checks to efficiently steer the topology toward reliable configurations.

• Practical relevance for large-scale IoT deployments: the proposed framework is designed to accommodate device heterogeneity, limited energy budgets, and evolving network conditions without relying on exhaustive search or data-intensive learning.

Unlike our earlier work MaxNTop⁶, which focuses on maximizing node and link activation, IoTNTop is driven by an error-centric, code-rate-constrained objective coupled with power-aware link selection and globally consistent geometric embedding. The remainder of the paper is organized as follows. “System model” introduces the system model. “Related works and problem definition” reviews related work and formalizes the problem definition. “Network graph modelling” presents the proposed IoTNTop framework in detail. “Topology design and control” and “Numerical results and discussion” evaluate its performance through numerical analysis and simulation studies. “Simulation results and discussion” concludes the paper.

System model

We consider a large-scale IoT network deployed over a two-dimensional geographic region and composed of heterogeneous wireless devices. The network includes two types of entities: end-nodes and gateways—interconnected through wireless links subject to power, noise, and reliability constraints. This section defines the entities, measurements, and physical-layer assumptions that underpin the subsequent problem formulation and algorithm design.

Network entities and geometry—let denote the set of all nodes, where represents IoT end-nodes (e.g., sensors, meters, actuators) and represents gateways (anchors). Gateways are assumed to have higher energy and computational resources and may possess known or partially known locations, whereas end-nodes are resource-constrained and typically have unknown positions. Each node is associated with an unknown spatial coordinate (or where stated explicitly). The network geometry is inferred from partial and noisy measurements and serves as the basis for topology control and communication optimization.

Links and distance measurements—wireless connectivity is represented by an undirected graph , where denotes a candidate wireless link between nodes i and j. Due to range and energy limitations, only a subset of all node pairs is observable, resulting in partial connectivity. For each feasible link , a noisy distance measurement

1

is available, where captures measurement noise and environmental uncertainty arising from ranging, receiver signal strength (RSS)-based estimation, or other proximity-sensing mechanisms.

Channel, power, and reliability model—communication follows a distance-dependent path-loss model. Let denote the transmit power of node i, and let represent the channel gain between nodes i and j. The received signal-to-noise ratio (SNR) on link (i, j) is given by:

2

where denotes noise power and denotes aggregate interference. Each node is subject to a transmit-power constraint . Each active link supports an achievable code rate determined by its SNR. A link is considered feasible if both and satisfy predefined reliability thresholds. The link reliability is strictly quantified by the symbol error probability, denoted as . We define as the conditional probability that a transmitted symbol s is decoded incorrectly as at the receiver, given the instantaneous channel quality. Formally, this is expressed as a strictly decreasing function of the SNR: . Here, represents the generalized physical layer transfer function that maps the received to an error probability. This function captures the fundamental performance characteristic of the link such that increasing transmit power (and thus ) monotonically reduces , directly linking topology control decisions to decoding reliability.

Related works and problem definition

Background

Database-matching (DB-M) has become a viable localization method in IoT networks by comparing real-time signal measurements (e.g., Received Signal Strength Indicator (RSSI), Time-of-Arrival (ToA), or Angle-of-Arrival (AoA)) with a pre-established database of signal fingerprints from known locations⁷. Traditional DB-M techniques use probabilistic models or distance-based metrics to find the closest match^8,9. However, DB-M requires extensive fingerprint databases that must be frequently updated—rendering them unsuitable for mobile or evolving IoT deployments. To enhance accuracy, machine learning (ML) methods have been applied. Key ML techniques include Artificial Neural Networks (ANN), which capture complex non-linear relationships^10,11, Random Forests for robustness against noise and overfitting^12,13, and Deep Reinforcement Learning (DRL), particularly useful in dynamic environments that require database updates^14,15. However, ML approaches often demand high amounts of computational resources and large labeled datasets, which are typically unavailable or impractical for low-power, heterogeneous IoT nodes. These models also struggle to generalize to unseen environments or react to dynamic topology changes.

The authors in⁶ are the first to combine node localization with topology control for power optimization, using noisy distance measurements and eigenvector synchronization. The network topology is constructed via linear programming to maximize spatial usage and throughput, emphasizing accurate localization for power-efficient IoT design. Under matched conditions used in our experiments, nodes uniformly deployed over a field and an average transmit power of per node (Figs. 9, 10, 11, 12), our proposed IoTNTop attains higher achievable code rates, lower symbol-error probabilities, and better per-node energy retention than heuristic and exhaustive baselines. In particular, most nodes maintain symbol error probability (Fig. 15), and the network retains 60– of the initial per-node energy budget (Fig. 16) while sustaining higher code rates across iterations and network sizes (Fig. 12). These trends persist for (Figs. 12, 13, 14, 15, 16). By contrast, MaxNTop¹⁵ optimizes node/edge activation but does not incorporate an error-centric, code-rate-constrained objective; IoTNTop’s joint optimization of power, code rate, and error probability yields superior operating points under the same deployment assumptions.

Fig. 9.

Comparative variation in average energy supply remaining in each node within the network over different number of iterations at average transmit signal power of 5dB per node in an IoT network consisting of 100 nodes randomly distributed over a 5 5 km square area.

Fig. 10.

Comparative variation in average error probability in transmission per node within the network, over different values of average transmit signal power per node in an IoT network consisting of 100 nodes randomly distributed over a 5 5 km square area.

Fig. 11.

Comparative variation in achievable transmission code rate per node within the network over different values of average transmit signal power per node in an IoT network consisting of 100 nodes randomly distributed over a 5 5 km square area.

Fig. 12.

Comparative variation in achievable transmission code rate per node within the network as the number of nodes within the network increases; the nodes are considered to be randomly distributed over a 5 5 km square area.

Fig. 15.

Symbol error probability per node in a large-scale IoT network. The vertical axis shows the average probability of symbol decoding failure, while the horizontal axis enumerates individual nodes.

Fig. 16.

Comparison of per-node energy retention across multiple topology control algorithms in a 500-node network. The figure plots the final energy level of each node as a fraction of its initial capacity, showing the extent to which each algorithm distributes energy consumption.

Fig. 13.

Scatter plot of node locations after topology optimization using IoTNTop, used to validate uniform node deployment and correlate spatial positions with performance.

Fig. 14.

Distribution of residual energy per node after network operation in a 500-node IoT deployment over a 5 5 km area. Each bar represents the energy retained by an individual node, expressed as a percentage of its initial energy budget.

In¹⁶, localized algorithms allow nodes to make decisions based on neighborhood information, utilizing techniques like iterative power adjustment and node state switching for energy conservation. Decentralized solutions are highlighted for scalability in large networks. In¹⁷, Graph Signal Processing (GSP) is used to treat network measurements as graph signals, enabling spectral analysis and filtering to enhance localization and topology inference. However, GSP and other above-mentioned techniques, rely on assumptions of linearity and stationarity, which limits their applicability under high-noise or non-ideal conditions commonly observed in real-world wireless systems. On the topology control side, traditional strategies frequently emphasize energy savings or basic connectivity, while neglecting performance metrics like error probability, link reliability, or transmission rate–all of which are essential for modern IoT applications.

Hybrid approaches combine the strengths of different localization methods to overcome their individual limitations. Kalman Filtering and Bayesian techniques are often used to fuse data from various sources for probabilistic location estimates. Advanced approaches, such as game-theoretic¹⁸ and optimization-based models²³, attempt to jointly manage transmit power and connectivity. However, these typically optimize for a single objective—such as network lifetime or throughput—while ignoring trade-offs involving link quality, error resilience, and coding efficiency. Most importantly, few existing methods integrate localization uncertainty into the topology design process, leaving a critical disconnect between spatial inference and performance optimization.

In addition to localization methods, a wide range of studies has explored topology control for IoT networks, with a focus on improving energy efficiency, maintaining connectivity, and enhancing fault tolerance. Classical approaches based on Minimum Spanning Tree (MST)²⁴ and Local Minimum Spanning Tree (LMST)²⁵ offer low-complexity link pruning but fail to incorporate dynamic environmental factors or communication noise. Clustering protocols like Low Energy Adaptive Clustering Hierarchy (LEACH)²⁶ and Hybrid Energy-Efficient Distributed (HEED)²⁷ introduce hierarchical structures to reduce interference and manage scalability, yet often assume homogeneous node capabilities and rely on periodic re-clustering, which limits adaptability in diverse network settings.

Existing approaches typically decouple localization from topology control, leaving measurement uncertainty unpropagated into link selection and routing; optimize energy or throughput in isolation rather than minimizing error probability under code-rate constraints; and rely on embeddings that do not jointly place gateways and end-nodes with guarantees of global consistency under partial and noisy distances. Moreover, quantitative analyses of convergence and computational complexity under realistic power and SNR budgets are limited. These gaps motivate an integrated, error-centric formulation that jointly optimizes power, code rate, and error probability and employs a scalable EVS and LA with SDP embedding tailored to large, noisy IoT deployments.

Problem definitions and scope

Building upon the system model described in “System model”, we now formalize the joint optimization problem addressed by IoTNTop. The overarching objective is to design a reliable and energy-efficient IoT network by tightly coupling spatial inference with topology control. This problem is conceptually decomposed into four interacting layers: localization, graph embedding, topology control, and topology design, which function sequentially to bridge the gap between noisy physical measurements and reliable communication.

Localization: the process begins with the challenge of estimating node positions from partial and noisy pairwise distance measurements, , along with the coordinates of any available gateways. The primary goal at this stage is to derive local coordinate estimates, denoted as , for nodes within overlapping network neighborhoods. Because these estimates are derived from incomplete data, they are not initially guaranteed to be globally consistent; local sub-graphs may differ from the true global geometry by rigid transformations such as reflection, rotation, and translation. Correcting these local ambiguities is critical, as localization errors directly distort propagation loss estimates, thereby compromising the accuracy of link feasibility, SNR calculations, and achievable code rates in subsequent control stages.

Graph embedding: to resolve the inconsistencies inherent in local estimates, the graph embedding stage reconciles the localized sub-graphs into a single, globally consistent geometric realization for both end-nodes and gateways. IoTNTop achieves this through a scalable, multi-stage pipeline designed to progressively align the network geometry. First, the pipeline employs EVS to resolve global reflection and rotation ambiguities. Conceptually, EVS is a spectral method that constructs a matrix representing the relative transformations between sub-graphs and computes its leading eigenvector to recover the consistent global orientation of each patch. Following orientation, the pipeline performs LA to correct rigid translation and scaling discrepancies. This technique estimates the optimal rigid transformations by minimizing the sum of squared Euclidean differences between shared nodes (landmarks) across overlapping sub-graphs. Finally, an SDP refinement step is applied to enforce global distance consistency across the stitched network. The result is a unified coordinate embedding that serves as the precise geometric substrate required for effective topology control.

Topology control: once the network geometry is embedded, the topology control layer determines the optimal configuration for network operation. Using the inferred global coordinates , channel parameters, and device power limits, this stage jointly selects the active link set , assigns transmit powers , and determines link code rates . IoTNTop distinguishes itself by adopting an error-centric objective, which explicitly minimizes the network-level end-to-end (E2E) error probability subject to strict decoding feasibility and power constraints. Central to this objective is the link-level symbol error probability, , which quantifies the reliability of a connection. We define as the probability that a transmitted symbol is decoded incorrectly at the receiver, a value computed analytically from the instantaneous link SNR according to the modulation-dependent error model. By aggregating these link-level probabilities, the control algorithm steers the network toward configurations that maximize global reliability.

Topology design: while topology control optimizes parameters for the current epoch, topology design enforces longer-term structural preferences that must persist over time. This layer specifies the admissible solution classes through constraints such as minimum coverage requirements, bounded node degrees, gateway attachment rules, or sparsity targets. These regularization terms guide the optimizer toward feasible configurations that satisfy high-level architectural goals beyond immediate error minimization.

Interfaces and information flow: the four components interact sequentially and iteratively. Partial and noisy distance measurements first drive the localization and graph embedding layers to recover the global geometry. This reconstructed geometry dictates the physical channel properties, specifically pathloss and SNR, which define the decoding feasibility of potential links. These constraints then feed into the topology control layer, which optimizes power and code rates to minimize error. The resulting topology decisions update the link feasibility and measurement availability for the subsequent epoch. Figure 1 provides a system-level illustration of this information flow, highlighting the interdependence of spatial inference and reliability-aware control within the framework.

Fig. 1.

A conceptual overview of proposed optimized topology control. Different colors represent different types of IoT nodes.

Coverage definition: to ensure network service quality, we define coverage based on signal quality rather than simple connectivity. A node i is considered covered if it possesses at least one neighbor j in the feasible link set such that the signal quality meets a minimum standard, . The network-wide coverage ratio is formulated as

A minimum threshold is enforced as a hard constraint during optimization to guarantee sufficient network availability. The primary decision variables governing this process are the node coordinates , transmit powers , active link set , and code rates . Collectively, these formulations define the joint optimization landscape where spatial inference and topology control converge, providing the necessary theoretical basis for the algorithmic solution presented in the following section.

Network graph modelling

Under the system and problem definitions above, IoTNTop operates on a known set of nodes with fixed roles (end-nodes and gateways). What is unknown are the node coordinates and the active communication topology. At each epoch, the algorithm is provided with partial, noisy distance measurements rather than a full distance matrix. The candidate link set is defined as

encoding links that are feasible under the power budget. The goal of IoTNTop is twofold: (i) to estimate a globally consistent geometric embedding from , and (ii) to design and control the active topology jointly with transmit powers and code rates to minimize end-to-end error probability. To achieve scalability, the network graph is decomposed into overlapping sub-graphs. Sub-graphs sharing sufficient common nodes are aligned through reflection, rotation, and translation to remove geometric ambiguities before being stitched into a global embedding. This process enables reliable topology inference and control in large, noisy IoT deployments. Figure 1 illustrates the resulting workflow, in which heterogeneous clusters are progressively aligned and integrated into a unified global graph that reflects both spatial structure and communication feasibility.

Graph-embedding for end-nodes

Let us first decompose the graph G into smaller, overlapping sub-graphs. Let these initial sub-graphs be denoted by , where N is the total number of sub-graphs created from the decomposition, and each represents a local patch or sub-network formed by a subset of nodes and their immediate edges. Let denote the spatial coordinate vector of node i; in particular, is the position of node n, and is the position of node 1. Let denote the set of node position vectors belonging to subgraph k. Uppercase symbols () refer to subgraph-level embeddings (collections of node locations), whereas lowercase symbols () refer to individual node locations. Each is obtained by locally realizing the nodes of subgraph k from the available partial/noisy pairwise distances; the resulting local embeddings are then aligned and stitched into a single global coordinate frame via the embedding pipeline (e.g., synchronization, alignment, and refinement), after which the global node vectors are read off. After the sub-graphs are independently embedded (localized) and subsequently aligned through reflection, rotation, and translation, they are stitched together to form a consistent global embedding. Let the resulting aligned and stitched sub-graphs be denoted by , where n is the number of nodes across the entire network after alignment (note: ). Each is the estimated coordinate vector (typically in or ) of node a in the global coordinate frame.

The observed or reconstructed distance between any two nodes a and j, denoted , is then expressed as where is the Euclidean distance between the estimated positions of nodes a and j, and represents the additive noise or distortion introduced during the sub-graph embedding and stitching process, due to misalignment, measurement error, or numerical approximation. The observed or reconstructed distance between any two nodes a and j, denoted , is either (i) an observed measurement obtained from ranging or RSSI under measurement noise , or (ii) a reconstructed distance computed from the current embedding when a direct observation is unavailable or unreliable. Unless stated otherwise, references to “distance” use , and the distance dataset is .. It is worth-mentioning here that consists of all the nodes within 1-hop neighborhood of the ath IoT end-node. To analyze interactions between two nodes, we can find the intersection of their 1-hop neighborhoods. This intersection forms the vertex set of the subgraph G(a, j), where is an edge in the original graph. So considering the nodes a and j, let us assume that we want to align the sub-graphs and . In order to achieve that, the first step is to formulate the relative reflection, .

Sub-graph reflection

In large-scale IoT deployments, sub-graphs reconstructed from partial and noisy distance measurements may appear mirrored, rotated, or shifted with respect to one another due to measurement errors and independent initialization of local coordinate frames. Without proper alignment, identical spatial relationships across sub-graphs may map to inconsistent global positions, leading to unrealistic network geometries and distorted connectivity. To address this issue, IoTNTop performs a three-stage geometric synchronization procedure—reflection, rotation, and translation—to register all sub-graphs within a common coordinate system. This process ensures that the recovered spatial topology faithfully represents the underlying communication structure, thereby enabling reliable subsequent topology control and power–rate optimization.

We first construct an sparse, symmetric reflection-consistency matrix , defined as

3

Each entry encodes whether sub-graphs and require a reflection to be aligned based on their shared distance information.

Let denote the diagonal degree matrix associated with , where each diagonal entry is defined as with representing the number of sub-graphs that share sufficient landmarks with sub-graph to permit alignment (i.e., non-zero entries in row of ). Using this degree matrix, we form the random-walk normalized reflection matrix

The matrix is used exclusively for eigenvector synchronization over the reflection group and is conceptually unrelated to coverage metrics or optimization variables introduced elsewhere in the paper.

We compute the dominant eigenvector of , and estimate the global reflection state of each sub-graph as

4

If , the corresponding sub-graph is reflected to its mirrored configuration prior to subsequent rotation and translation alignment steps.

Construction of

The reflection-consistency matrix is constructed as follows. We initialize an matrix with zero entries. For each pair of sub-graphs and , we compute the Pearson correlation coefficient between their distance measurements over the set of shared nodes:

5

where quantifies the linear correlation between the distance profiles of the two sub-graphs; and denote the Euclidean distance measurements from nodes a and j to the ith shared node; and are the corresponding sample means; and are the standard deviations of the distance measurements within sub-graphs and , respectively; and n is the number of shared nodes.

If , with threshold , we set , indicating that a reflection is required. Otherwise, we set . When insufficient overlap or unreliable measurements prevent meaningful correlation estimation, the entry is left as , indicating that alignment between the sub-graphs is not feasible and that the pair is excluded from synchronization. The threshold was selected empirically through a sensitivity analysis on simulated IoT networks with nodes and noise levels ranging from to . The threshold was varied between and in increments of 0.1, and alignment accuracy was evaluated over 50 Monte-Carlo runs. The chosen value provided the best balance between false reflection detection and missed alignments, yielding consistent alignment accuracy within across all tested noise regimes.

Sub-graph rotation

We construct the Hermitian matrix such that,

6

where , , , for any complex number and its complex conjugate. We compute the top eigenvector of with and estimate,

7

to rotate the patch . The next step is to compute the translation of the sub-graph into aligned sub-graph . Here is the bth patch or subgraph.

Construction of R

We start with an matrix where initially all elements are 0. For each pair of subgraphs and , where alignment is possible, we calculate following the Landmark Matching procedure²⁶. Let with as the mean points in , represent the coordinates of m shared landmarks in , , represent the corresponding coordinates in with as the mean points in , is the zero-centered coordinate for landmark in , is the zero-centered coordinate for landmark in , and is the covariance matrix between and .

Now let us define,

8

9

10

where is the translation vector and is the scaling factor. The goal is to find the parameter values that minimize the discrepancy between the transformed landmarks from and their corresponding points in . We formulate this as a least-squares problem;

11

In order to remove the effect of global translation, we substitute and for the centered coordinates in (11) to obtain the optimization problem as,

12

We solve the optimization problem using singular value decomposition (SVD) for the covariance matrix , to extract the value of using trigonometric functions and identities and then solve for as a function of eigenvectors and eigenvalues of . Optimality of (12) is detailed in Appendix A.

Sub-graph translation

For , we compute,

13

where is the associated translation. Using the over-determined system of (13), we can estimate the global coordinates, using least square solution to (13). The set of translations is disregarded. So for each edge , . The term refers to the set of edges within the -th sub-graph, i.e., , where is the overall edge set of the original IoT network graph. Each sub-graph contains a subset of nodes and the corresponding intra-subgraph links, and captures these localized connectivity relationships. When solving the over-determined system of equations to compute global node coordinates, we aggregate constraints from all edges across sub-graphs, ensuring consistency and continuity in the global graph embedding. If we replace the patches with the coordinates, , which can be solved separately.

Now we can write, , where is the least square translation matrix. It is constructed based on the relationships between the local coordinates of nodes in different subgraphs and their corresponding global coordinates. is the vector of -coordinates of all IoT end-nodes localized in a sub-graph. The vector represents the -coordinates of all the IoT end-nodes that have been localized within a particular subgraph. The goal is to estimate these global -coordinates. is the vector with entries from the right-hand side of (13). The vector containing the right-hand side values of the linear equations is derived from the subgraph translation process. These values are based on the local coordinates and the estimated translations between subgraphs. Similarly, we can write . The accuracy of these estimated coordinates is then evaluated by comparing them to the true coordinates using an error metric. Now by adding all the equations corresponding to the same edge (a, j) from different patches,

14

and similarly for the -coordinates we can formulate the least-square translation matrix , i.e. over-determined system of linear equations. If the estimated transition matrix is denoted by , the least square solutions to and will be given by, . The error in any estimated sub-graph coordinates can be calculated as . Now that we have solved the localization problem for IoT end-nodes, we can find the union of set (end-nodes) and set (gateways) to determine the locations of all nodes within the network.

The proposed alignment framework assumes moderate overlap between adjacent sub-graphs; however, in practice, link sparsity, high noise, or missing landmarks can degrade synchronization quality. To address this, IoTNTop employs two adaptive mechanisms: (i) a connectivity-aware expansion that temporarily enlarges low-overlap sub-graphs using nearest-neighbor augmentation until a minimum landmark ratio is met; and (ii) a noise-weighted confidence score that down-weights distance pairs with high variance during EVS computation, reducing the impact of unreliable edges. When landmark information is insufficient for global stitching, the system reverts to localized EVS alignment within connected components until new measurements become available. These mechanisms improve stability and maintain feasible embeddings even under adverse sensing conditions.

Graph-embedding for central and end-nodes

Let us assume that we want to connect the ith gateway, with the jth end-node, . Therefore the Euclidean distance is between the ith gateway and the jth end-node, where and are the set of edges between end-node and gateway, and two end-nodes, respectively. We now form a new network graph, with of size and edge set where is the number of edges between the end-nodes and gateways of the network. Here, we introduce the augmented edge set , which extends the original candidate edge set by including both end-node–to–end-node links and end-node–to–gateway links after quality gating. Specifically, represents the initial set of feasible communication links inferred from the SNR and distance thresholds among end-nodes only, while augments this set by adding the cross-layer connections between end-nodes () and gateways () that satisfy the decoding and signal-quality criteria. In cases where link reliability falls below the SNR threshold or distance constraints are violated, the corresponding edges are pruned from . Thus, serves as the refined, quality-gated edge set used in the joint embedding and topology-control stages, ensuring that only valid, high-quality links contribute to the construction of the global graph .

The partial distance measurement matrix is given by, and the graph realization problem (in this work, “realization” refers to graph realization or localization from partial and noisy pairwise distance information, producing a globally consistent geometry (node positions for gateways and end-nodes) that respects local measurements. Our pipeline links topology control and realization as follows: topology control selects feasible links and power/rate settings under reliability and energy constraints; the resulting measurement set and link feasibility inform the realization step, which stitches local sub-graphs into a single geometry. This geometry, in turn, feeds back into the next topology-control epoch by updating path-loss, SNR, and code-rate feasibility, ensuring that connectivity decisions remain aligned with the recovered spatial structure) becomes,

15

The symbol denotes the subset of edges connecting end-nodes in the set to gateways in the set . Each edge represents a feasible end-node–to–gateway communication link that satisfies the SNR and distance constraints. Together with the end-node–to–end-node links , these form the composite edge set used to construct the augmented network graph , where . This distinction allows the model to treat intra-cluster (L–L) and cross-cluster (L–S) communications separately when embedding and optimizing the topology.

We start by randomizing the realization of the sub-graph embeddings . We initialize the unknown global coordinates by placing each locally embedded patch into the global frame with a random rigid motion, a uniformly sampled rotation , an optional reflection, and a small random translation. This produces a non-degenerate warm start that breaks symmetries and avoids coincident placements. The subsequent EVS and LA synchronization and SDP refinement remove the dependence on this random initialization and determine the final, globally consistent embedding. We also introduce a small positive constant of (for example, ), small enough to filter out noisy or unstable positions, but not so small that it excludes nearby correct embeddings due to floating-point precision issues. Once we have the end-node network mapping in place, we look at the network between the end-nodes and gateways by solving the SDP problem,

16

for and where is an all-zeros vector with ith entry of 1 and

17

where is the matrix representation of coordinates. If the vector represents the diagonal elements of the matrix , we compute the new subset of vertices such that and form the end-node -gateway sub-graph, . We formulate the solution to (16) as SDP matrices, as eigenvalues being non-negative means the resulting computed ‘distances’ will make physical sense and SDP matrices generally enforce the triangle inequality, which is essential for realistic distances. For each candidate link , link quality is quantified by the instantaneous SNR defined in the previous section. A link is retained in if and its achievable code rate is feasible under the chosen coding profile, otherwise it is pruned.

In (16), indicates that the optimization problem aims to maximize the objective function while ensuring that all constraints are satisfied. In (16), the optimizing variable is the matrix , which represents the embedding of both end-nodes and gateways in the combined coordinate space. Specifically, is structured as a block matrix containing the coordinate relationships between nodes, where the diagonal and off-diagonal entries encode squared distances and inner products derived from the estimated node positions. The optimization seeks a feasible that satisfies the set of distance constraints for all pairs , while also ensuring that remains positive semi-definite. Solving this problem yields a coordinate embedding consistent with available partial distance measurements and the underlying network connectivity. The ’0’ in this context is a placeholder or represent a null objective function, implying that the primary focus is on feasibility rather than optimizing a specific numerical value. The actual optimization occurs through the constraints, which enforce conditions on the variables involved. Optimality of (16) is detailed in Appendix B.

Insights into

is a block matrix representation of the coordinates of both end-nodes and gateways. It has dimensions . Here corresponds to fixed gateway node positions and is an identity matrix, is an matrix where each column will hold the coordinates of an end-node to be estimated, is the transpose of the end-node coordinate matrix, and is the matrix where the diagonal elements will hold the squared pairwise distances between the end-nodes while the off-diagonal elements will be filled during the solution process.

Let us consider a small network with 2 gateways and 3 end-nodes. Here will look like,

18

The SDP formulation, together with specific structure of , allows to optimize the coordinates of the end-nodes to best match with the available set of distance measurements. Crucially, our formulated method assumes that we don’t have direct pairwise distance measurements for all possible node pairs–a realistic and desirable design feature for large-scale IoT networks. In practical deployments, obtaining complete distance information is infeasible due to energy constraints, communication range limitations, and environmental noise. By explicitly working with partial and noisy measurements, our approach remains scalable, resilient to missing data, and well-suited for resource-constrained and dynamically evolving network topologies.

Additionally, we assume that the network is connected—or, at a minimum, consists of connected components that are sufficiently large to allow meaningful embedding. This assumption is important because graph embedding and localization techniques rely on relative distance information between nodes. If the network is fragmented into very small or isolated components, there won’t be enough pairwise measurements to accurately determine the spatial relationships among nodes. Ensuring basic connectivity allows our algorithm to propagate positional information across the network and produce coherent global topologies. Finally, the SDP formulation is more robust to noisy measurements by adding regularization terms or relaxing the equality constraints in (16).A conceptual overview of the relationship between central and end-nodes in provided in Fig. 2. Figure 2 connects geometric embedding (recovering the global layout from partial noisy distances) with reliability-driven topology control (activating only links that meet decoding feasibility), making explicit how the method reduces symbol-error probability while respecting per-node power budgets.

Fig. 2.

Representation of relationship between Central and End-Nodes under optimized topology control. This figure depicts how IoTNTop uses partial, noisy pairwise distances together with node roles (end-nodes and gateways ) to construct the augmented graph via EVS/LA stitching and SDP refinement, applies link-quality gating on the composite edge set using per-link SNR and code-rate feasibility, and outputs a reliability-aware topology that activates only high-quality and necessary links for robust coverage, low error probability, and energy-efficient operation.

Sub-graph embedding for the global graph

For sub-graph embedding in our globally non-rigid IoT network graph, we resort to the three-step method outlined in⁶ (it is worth-mentioning here, that the term ’rigid’ refers to the property of a graph or network where the relative distances between all nodes remain constant. In other words, a rigid graph maintains its shape and structure even when subjected to transformations like rotations or translations. In this work, we resort to a non-rigid approach for sub-graph embedding because we are looking at topology optimization of IoT networks in a dynamic scenario). The first step is to estimate the distance, with (we are considering an annular graph, with a network where the IoT devices are distributed randomly on an annulus surrounding the IoT gateway at the center). , for,

19

20

The second step is to compute local coordinates of all nodes in a sub-graph using multi-dimensional scaling¹⁷ on the complete set of pairwise distances. We can express, where , is a matrix of ones, is the identity matrix, is the matrix of squared pairwise distances, , t denotes the transpose, is an integer, and the matrix of the local coordinates of all nodes in a patch can be calculated as,

21

where are the eigen-pairs of the matrix.

The final step is to refine the embedding using iterative majorization technique. The coordinates of each IoT node are updated according to,

22

where denotes the degree of node i in patch and,

A conceptual overview of sub-graph embedding in provided in Fig. 3.

Fig. 3.

IoTNTop epoch: EVS and LA stitching SDP refinement SNR-guided edge selection convergence check on global error & code rate.

Aligning sub-graphs and sewing them together

Now after finding the embedding for the sub-graph , we need to combine under the same objective function, the contribution of the end-node-to-end-node communications and the end-node-to-gateway communications. For the above, we formulate a least-square-problem-based synchronization as,

23

where,

24

where is the pairwise distance matrix within the set , is the pairwise distance matrix within the set . The sets, , and denote the end-node-to-end-node, end-node-to-gateway and gateway-to-gateway measurements. We will use the Lagrangian multiplier concept to solve the minimization problem of (23) as,

25

where denotes the sign of the gateway vertices, +-ve sign represents similar or cooperative vertices (gateway vertices that have some degree of functional redundancy or complementary roles within the network), −-ve sign represents dissimilar or competitive vertices (gateway vertices that have conflicting roles or compete for resources within the network). In Algorithm 1, we summarize our proposed algorithm for graph embedding within a massive IoT network with multiple heterogeneous IoT nodes and more than one central node or gateway.

Let us consider the true distance measurement between the jth and ath subgraphs as with random noise of added to the distance measurement distributed uniformly over the range . Consequently, we can express the noisy distance measurements as . We consider networks of size 20, 50 and 100 nodes with average node degree of 14 - 20 and noise levels up to 70% ( corresponding to 70%). We consider a network with gateways within a range of of different subgraphs. Let the true coordinates of all the nodes within subgraphs be represented by a matrix, with estimated coordinates of . We can compute the error in global localization of the nodes and the gateway owing to noisy measurement as,

26

where denotes the Frobenius norm, t denotes transpose, denotes matrix containing all ‘1’ elements, and represents the center of mass of all the true coordinates of the subgraphs. The denominator in (26) is the scaling and normalization factor for the graph embedding from the network perspective, representing the ‘spread’ of the true node coordinates around their center of mass. This makes the error metric less sensitive to mere scaling differences. Both the numerator and denominator include a subtraction of the center of mass (). This makes the metric largely insensitive to uniform translations of the entire embedding. By factoring out scale and translation, (26) concentrates on measuring the error in the relative placement of nodes, which is often the key goal in graph embedding tasks.

The primary goal of graph embedding is to capture the relationships between nodes based on their relative distances and positions, with less emphasis on the absolute location of the entire graph. By subtracting the center of mass, the focus shifts to errors in relative node placement rather than overall graph positioning. Shifting the entire set of estimated coordinates () should not significantly affect the error metric (). Aligning both the true (P) and estimated () coordinates with their respective centers ensures that the metric emphasizes relative positioning over absolute location.

In summary, to form a globally consistent topology from locally embedded sub-graphs, our approach performs sub-graph stitching through a three-stage alignment process involving reflection, rotation, and translation. First, we detect whether sub-graphs require reflection by computing the Pearson correlation coefficient between shared node distances; this information is used to construct a reflection matrix , from which global reflection decisions are derived via eigenvector synchronization ((1)–(2)). Second, we compute the relative rotation angle between sub-graphs and by aligning their common landmarks using Procrustes analysis and SVD, resulting in a Hermitian matrix (4), from which global rotation estimates are extracted via eigenvector decomposition. Third, we estimate sub-graph translations using a set of linear equations formed from overlapping nodes, expressed as and solved using least squares minimization ((11)–(12)). After reflection and rotation have been applied to each sub-graph, these translations align their coordinates in a common global space. Finally, we perform a least-squares synchronization over the composite graph Laplacian to refine the global topology (21). This layered approach enables us to consistently and efficiently embed sub-graphs with noisy and incomplete distance information, producing a coherent global graph suitable for topology control. A conceptual overview of aligning and sewing in provided in Fig. 4. Figure 4 provides a visual walkthrough of the embedding and control pipeline used within each epoch.

Fig. 4.

Aligning and sewing local sub-graphs into a globally consistent network. Two locally embedded sub-graphs (Sub-Graph 1 and Sub-Graph 2), each obtained from partial and noisy distance measurements, are aligned and stitched together through geometric transformations to form a unified global graph. This process resolves local ambiguities and enables consistent topology control at the network level.

Topology design and control

Next we formulate the topology extraction for an IoT network as an optimization problem with the target of minimizing error probability and maximizing information transmission rate over the link between the IoT nodes and the network gateways (refer to Algorithm 1). In the proposed mathematical model, we also consider (i) the transmit power from the node’s side and received power at the gateway end, (ii) how much energy is consumed when an IoT node fires its signal with a certain set of symbol coding on the information (the symbol coding can be simple space-time coding or other more complicated coding techniques like turbo coding) and (iii) how much energy is consumed on the gateway side for absorbing the received signal. We also consider the link quality as a defining factor using the pathloss exponent, the transmission range of the node, and the far-field reception range for the gateway. However, we do not consider the energy consumption for accumulating and computing information at the IoT nodes in our problem formulation.

We formulate and analyze a joint optimization over code rate, transmit power, and edge activation that minimizes network-level E2E error probability under power and decoding-feasibility constraints. This error-centric formulation, coupled with EVS, LA and SDP embedding and an SNR-guided convergence-checked solver, constitutes the core theoretical advance of IoTNTop.

Information coding for transmission

Let us consider the -th IoT node communicating with the -th gateway separated by Euclidean distance . Let the -th node transmit with power and use an encoding function to generate a sequence of input symbols from random variables, is the input on the link between (j, i). For the ith gateway, let the th received symbol be , so we can write,

27

where represents the input alphabet and represents the output alphabet of the links between the IoT end-nodes and gateways, is used to represent the actual link as a transfer function between the input and the output, and is a set of random variables. This objective aligns topology selection with decoding reliability by minimizing the network-level E2E error probability while respecting code-rate and power budgets. It is the global quantity IoTNTop seeks to reduce.

Unless otherwise noted, we adopt an error-prioritizing constraint form. We minimize network-level E2E error while enforcing a code-rate floor consistent with the selected coding profile and per-device power limits. Concretely, the optimization is solved in error constraint mode (error as the primary objective; code rate as a hard constraint), which operationalizes our claim of prioritizing error. We encode prioritization via a single weighted objective that balances network-level E2E error against achievable code rate. Let denote the trade-off weight; larger places more emphasis on minimizing error, and smaller places more emphasis on maximizing rate. In all main simulations, we use (chosen to match the coding profile’s operating region and validated by sensitivity checks), and we keep all power and feasibility constraints unchanged.

Algorithm 1.

IoTNTop-graph alignment algorithm.

Let the decoding function of the ith gateway be given by and the recovered message be of the form denoted by, , where is also a random variable of length . Then the error probability performance of the link is given by,

28

where, is the maximum probability of error in recovering the original message , considering all possible original messages within the set and a coding rate is achievable if there exists a sequence of codes such that tends to 0 as becomes infinitely large. In turn, we can also calculate the capacity of the link which is the supremum of all the achievable rates. This constraint ties the achievable code rate to link SNR and pathloss, ensuring that selected links operate inside the feasible decoding region for the chosen coding profile.

The greedy SNR-based optimization occupies the final stage of each epoch after geometric realization/embedding and before metric logging. Concretely, the epoch proceeds as: (a) acquire partial/noisy pairwise measurements and link-quality summaries; (b) update the geometric embedding using sub-graph stitching and refinement; (c) greedy edge selection: sort candidate links by current signal quality and code-rate feasibility, iteratively activate links that reduce the global error objective while respecting per-device power and capacity limits, and skip links that violate feasibility or offer no objective improvement; (d) convergence check: stop when global error and code-rate indicators change less than a small tolerance or a maximum iteration count is reached; (e) apply decisions by updating active links, per-node transmit powers, and link code rates for the next epoch.

Transmit power allocation

Given the transmit power of node , the received power when node transmits can be expressed as,

29

where is the transmission range of the jth node, is the pathloss exponent, is the constant defining the IoT node type, like whether it is a bi-static or a multi-static sensor, and quantifies the link quality between the jth node and the ith gateway that accounts for non-distance-related factors affecting signal reliability, namely, fading, interference from neighboring devices, environmental noise, receiver sensitivity variations at the gateway and antenna alignment mismatch. This enforces per-node power limits (and, when aggregated, a network budget), preventing solutions that unrealistically increase transmit power to reduce error. Now on the gateway side, the received power can be calculated as,

30

where is the received power at the ith gateway from the jth node over the Euclidean distance and is the received power at the ith gateway over the far-field distance . This provides an information-theoretic bound and approximation that maps SNR and code rate to symbol or packet error probability; it is how physical-layer reliability enters the optimization. Using the above formulations in (29) and (30), we can design the error probability minimization problem, with constraint on code rate maximization as,

31

where is the remaining energy at the jth node after transmission, is the virtual flow rate of symbols on the link (j, i), is maximum achievable code rate over the link between the jth and ath nodes, is the average maximum transmission range of any node within the network, and is the link transfer function between the jth node and the ith gateway. The variable denotes the net flow balance (symbol rate) at node , defined as the difference between the total outgoing and incoming coded symbol flows, Each represents the virtual flow rate of coded symbols transmitted along link , measured in symbols per second. These variables collectively describe the conservation of information flow across the network graph, where gateways (sink nodes) have and source nodes have . Binary (or relaxed) edge-activation variables couple geometry to connectivity: only activated links contribute to routes and error aggregation. Details on the optimality of (31) are provided in Appendix C. We, however, exclude local data-accumulation and MCU computation energy for two reasons. First, in our platform profile these costs are stationary and workload-light relative to RF TX and RX, contributing a small, nearly constant fraction of total per-epoch energy; including them would shift all methods by a similar offset without affecting relative rankings. Second, the proposed control acts primarily by adapting links and power (RF-dominant), so improvements we report (error, rate, energy) are driven by communication changes. We acknowledge that in compute-heavy sensing (like on-node inference) these costs may be non-negligible; such settings are out of scope here and are noted as future work.

Topology extraction

Next we will be using the solution to the code design problem formulated in (31), and improve information or code rate. First we compute the transmit power assignment to minimize error probability and then extract the corresponding network topology. The topology extraction algorithm continues iteratively until it converges to a point where error probability is minimum and code rate is maximum. The extraction algorithm is presented in Algorithm 1 (the terms “sew” and “stitch” are used interchangeably to describe the process of combining or joining smaller sub-graphs to form a larger, unified graph representation of the IoT network). Algorithm 1 summarizes one IoTNTop epoch. Each iteration (i) acquires partial and noisy distances and per-link SNR, (ii) performs sub-graph stitching and SDP refinement to obtain a globally consistent embedding, (iii) selects edges greedily by SNR under code-rate feasibility, and (iv) checks convergence on global error probability and code rate before updating device powers and links. The conceptual framework and the logical flow between graph-based localization and topology extraction through IoTNTop is presented in Fig. 4 and the awareness of IoTNTop in minimizing error probability is captured in Fig. 10.

Algorithm 2.

  Topology extraction for minimizing error probability (IoTNTop).

Convergence analysis

The overall optimization problem of minimizing error probability and maximizing code-rate within the network topology is non-convex. This makes it very challenging to perform direct convergence analysis by using techniques like contraction mappings and fixed-point theorems. Therefore, we resort to applying a Lyapunov Function approach. We invoke standard Lyapunov stability results ¹⁹ to establish boundedness and monotonic decrease under the proposed update rule. Since the objective function mixes error probability, energy and geometric quantities like distances and ranges, the formulated Lyapunov function will capture the combined behavior of these intertwined variables. We consider the global error probability metric () directly as the potential Lyapunov function; where is the state of the network including power allocations. To include topological measure, we modify to, where is the topology metric and is the weighting factor to adjust the influence of the topology. We define as,

32

where is the total number of active links in the network and is the quality of the link between jth node and ith gateway. The convergence test halts iterations when global error probability and code rate stabilize, avoiding unnecessary computation once improvements become marginal. can be defined as the received signal-to-noise ratio (SNR) of a reliably detectable signal formulated as,

33

where is the link gain between jth node and ith gateway, is the Euclidean distance between them, is the pathloss exponent, is the noise power and is the lower SNR threshold or the minimum detectable SNR on the receive side. In order to check the convergence of the algorithm, we need to continue as long as decreases along the trajectory of the system. Therefore, IoTNTop continues to iterate as long as where k represents the number of iterations. This stopping criterion (like, maximum iterations or tolerance) guarantees termination even in worst-case noise and geometry, ensuring predictable runtime.

Initial power assignment

We also need to think about the initial power assignment to the IoT nodes at the beginning of IoTNTop. Here we explore distance-based power assignment, where the initial transmit power is tailored to the distance between a node and its nearest gateway. Let us denote the distance between all IoT nodes and their nearest gateways by using a distance matrix of size , where l and s are the number of nodes and gateways, and is an element of . We incorporate a pathloss model to account for signal attenuation with distance.

A common model is the Friis transmission equation, , where is a constant depending on environment and node properties, like antenna gain, antenna height and orientation, antenna type, transmit power amplifier efficiency, receiver sensitivity, operating frequency and hardware losses. We want to find the minimum initial transmit power to ensure the signal reaches the receiver with sufficient strength for successful reception, while considering the path loss. Each receiver has a sensitivity threshold, which is the minimum power level it needs to correctly decode the signal. We assume we know this value. We solve the Friis formula for received power given a transmit power, set the received power to the minimum required level and solve this equation for the initial transmit power, . If is the minimum transmit power required for a successful transmission under ideal conditions, we can calculate the initial power, as, , where is a function that returns the index of the gateway closest to the jth node and the propagation pathloss is calculated using the pathloss exponent between the jth node and its nearest gateway.

Complexity and scalability: the joint problem is non-convex due to binary edge activation and the nonlinear error-rate-SNR coupling. Our solver proceeds by (i) EVS and LA stitching (linear in total edges for sparse graphs), (ii) an SDP refinement on block-diagonal subproblems (worst-case for block size m, mitigated by sub-graphing), and (iii) greedy SNR-based edge selection with per-iteration cost for sorting/pruning. Let k be the number of sub-graphs, N nodes, and E edges; then one epoch costs approximately

34

with by construction. Empirically (“Topology design and control”), earlier convergence (fewer iterations) offsets the per-epoch cost, yielding lower total runtime than exhaustive baselines at large N while maintaining comparable memory footprints (Table 1).

Table 1.

Scalability, runtime, and memory profile of IoTNTop. Although the joint objective is non-convex, the sub-graph EVS, LA and SDP pipeline and greedy SNR-guided update yield near-linear scaling in N with modest memory growth.

Network size N (nodes)	Sub-graph size k	Avg. iterations	Runtime (s)	Memory (MB)	Dominant complexity	Notes
50	8–10		1.8	72	(EVS/LA) +	Fast convergence
100	10–12		3.4	96	+	Efficient stitching
200	12–15		6.7	158	+	Near-linear scaling
300	15–20		9.2	204	+	Stable memory growth
500	20–25		15.6	281	+	Sub-linear runtime trend

Setup: averages over 20 runs; Python 3.10, Intel i9 CPU, 32 GB RAM. EVS and LA eigen-decompositions act on sub-graphs of size k (cubic in k); SDP refinement is applied only to stitched patches and pruned by SNR gating; greedy edge selection and rate/power updates are dominated by sorted link passes per epoch.

Note on network dynamics: the IoTNTop framework is designed to accommodate time-varying network conditions without requiring a complete re-optimization at every instant. When nodes move, links fail, or channel conditions change, the algorithm updates the affected sub-graphs locally using incremental synchronization and quality-gating. Specifically, only the sub-graphs whose edge weights or SNR values change beyond the pre-set tolerance are re-aligned using EVS module, while the remaining sub-graphs retain their previous embeddings. This incremental update ensures computational scalability and responsiveness to dynamic conditions. Traffic-pattern variations are handled by re-evaluating the flow variables and node balances in the rate-allocation layer, which adapts symbol flow and power allocation while preserving connectivity. If large-scale topology changes occur (like, massive node mobility or gateway re-deployment), the framework triggers a re-initialization of the global synchronization phase but reuses prior embeddings as warm starts, significantly reducing resolving time. Towards this end, IoTNTop employs a two-level adaptation mechanism: (i) flocal updates to sub-graphs and flow rates when minor link or channel variations occur, and (ii) global re-optimization only when major topology reconfiguration is detected. This hierarchical adaptation allows the method to efficiently track dynamic IoT environments without full re-computation at every change.

Numerical results and discussion

We compare the results of our proposed IoTNTop algorithm with those of Brute-force search, by choosing the minimum transmit power allocation to any IoT node for firing its signal to its farthest neighboring node in the graph. The Brute-force algorithm will systematically enumerate all the possible solutions to the transmit power allocation problem in (31), until all optimal solutions have been exhausted. Our proposed algorithm is also compared against standard baselines: the local minimal spanning tree (LMST) spanning topology ²⁰, a genetic-algorithm (GA) optimizer for topology and power settings, the clustering protocol Hybrid Energy-Efficient Distributed (HEED) ²¹, and Low-Energy Adaptive Clustering Hierarchy (LEACH) ²². We focus on a non-link-sharing scenario, where each link is used only between a pair of nodes in a particular iteration. We consider 100 IoT nodes and 6 gateways distributed randomly within a km square area without any central gateway. We considered average pathloss exponent of , dBm, dBm, and a typical value of dBm is considered for all simulation results. dBm represents the minimum received power level required at the gateway for successful decoding of the signal²⁸. Any signal received with power below this threshold is considered too weak to be reliably interpreted. dBm represents the maximum transmit power level that an IoT node is allowed to use. This constraint is chosen due to hardware capabilities of the nodes with a desire to limit interference in the network.

The chosen baselines span a representative range of commonly used topology-control approaches, including heuristic methods, metaheuristic optimization techniques, and exhaustive or near-exhaustive search strategies, like: (i) spanning-tree (LMST) capturing connectivity and coverage heuristics; (ii) clustering (HEED and LEACH) capturing energy-aware aggregation; and (iii) metaheuristic search (GA) capturing global combinatorial exploration. These represent widely adopted, reproducible methods with mature implementations compatible with our ns-3 pipeline. Recent reinforcement learning (RL) and other learning-based schemes are promising but typically require large training traces, specialized reward shaping, and nontrivial generalization across network sizes; they are also difficult to compare fairly without retraining per scenario and are outside the scope of this evaluation. Our formulation, code-rate and error-centric objective, and ns-3 integration are orthogonal and could serve as a substrate for future RL-based controllers; we list such integration as future work.

Figure 5 represents the convergence behavior of different algorithms compared to IoTNTop against the number of IoT nodes within the network. IoTNTop’s efficiency in terms of network resource utilization helps it converge with fewer number of nodes as compared to other algorithms. The Brute-Force curve starts at a higher number of nodes and slowly decreases. This is because a brute-force search exhaustively evaluates all possible configurations, initially considering a large number of nodes before converging to a minimum. A Genetic Algorithm (GA)-based approach also explores many possibilities before converging. The fact that IoTNTop optimizes network topology by using fewer nodes, implies a more streamlined network structure that reduces redundancy or unnecessary connections. Furthermore, as IoTNTop is optimizing power control, it uses fewer active nodes, effectively putting some nodes into sleep mode to conserve energy.

Fig. 5.

Variation in the number of iterations needed by different topology control algorithms as the number of nodes within the network increases; the nodes are considered to be randomly distributed over a 5 5 km square area.

Figure 6 presents a comparative analysis of the number of iterations required by different topology control algorithms for positioning 20 nodes distributed randomly over a 5 5 km square area. The efficiency of IoTNTop is attributed to its greedy SNR-based edge selection and convergence criterion that prioritizes high-quality links and halts iterations once global error probability and code rate stabilize. This allows the algorithm to reach near-optimal configurations early, even in large networks. In contrast, Brute-Force explores the entire configuration space exhaustively, resulting in exponential growth in iteration count. GA, while adaptive, still incurs high computational overhead due to its stochastic search nature. LMST is less sensitive to network size but lacks the error- and code-aware optimization layers present in IoTNTop.

Fig. 6.

Variation in the number of iterations needed by different topology control algorithms for 20 nodes within the network; the nodes are considered to be randomly distributed over a 5 5 km square area.

Figure 7 shows the average transmission range (in meters) achieved by different algorithms over different values of average received signal energy per node. IoTNTop demonstrates superior efficiency in achieving a stable average transmission range, suggesting a selective approach to finding suitable network configurations. While the Brute-Force method eventually reaches a similar range, its slower convergence highlights its exhaustive exploration of all possibilities. GA displays a more explorative nature, with fluctuations before settling on a lower average transmission range, indicating it considers a wider variety of solutions. In contrast, LMST prioritizes rapid convergence, but its lower average transmission range suggests it might not always find the absolute optimal solution. It is possible that the LMST got stuck in a local optimum, or it might be prioritizing other factors besides maximizing transmission range.

Fig. 7.

Comparative variation in average transmission range per node within the network, over different values of average received signal energy per node in an IoT network consisting of 100 nodes randomly distributed over a 5 5 km square area.

In Fig. 8, the average transmission range per node is reported in absolute units (meters), not normalized. The values are computed based on the transmit power allocated to each node during topology control, using the Friis pathloss model with the parameters described earlier. This provides a direct view of how efficiently different algorithms utilize the available transmit power to achieve link connectivity across the 5 5 km area, without applying any normalization relative to maximum possible range or network diameter. Figure 8 shows the effect of the variation in average error probability as a function of average received signal energy per node across different topology control algorithms. Brute-Force and GA may include longer or less reliable links in the topology due to their more general-purpose search strategies, while LMST lacks explicit error-awareness and tends to settle for minimal connectivity. The ability of IoTNTop to reduce error probability even at lower energy levels highlights its suitability for energy-constrained IoT environments where communication reliability is critical.

Fig. 8.

Comparative variation in average transmission range per node within the network, over average received signal energy of 10dB per node in an IoT network consisting of 100 nodes randomly distributed over a 5 5 km square area.

Compared to the other algorithms, IoTNTop consistently achieves a lower average transmit power throughout the iterations, as shown in Fig. 9. This reduction in transmit power translates to several benefits for the network. First, nodes will consume less energy to transmit data, which can significantly extend battery life in resource-constrained IoT devices. Battery life is a critical factor for the successful deployment of large-scale IoT networks, especially in applications where frequent battery replacements are impractical or infeasible. Second, lower power transmissions can help mitigate interference between nodes. This is because the strength of a signal attenuates with distance, and weaker signals are more susceptible to interference from overlapping transmissions. By reducing the transmit power, IoTNTop helps ensure that signals from different nodes are less likely to interfere with each other, improving overall network reliability and throughput. This can be especially important in dense IoT deployments where many devices are competing for limited channel bandwidth. Residual energy distribution shows IoTNTop retains of the per-node budget versus GA and LMST (gains and ).

The performance awareness of IoTNTop, in terms of its ability to minimize E2E error probability while sustaining feasible code rates, is quantified in Fig. 10. The figure presents convergence trends of the global error probability versus iteration index and network size, highlighting the algorithm’s early stopping behaviour and rapid stabilization across large-scale IoT deployments. IoTNTop’s error rate curve in Fig. 10 shows steady improvement, likely due to its ability to optimize configurations that reduce transmit power and improve transmission quality. While Brute-Force achieves a similar low error rate, it requires significantly more computational effort. The GA and LMST algorithms also reduce error rates, but their broader exploration of configurations slows convergence, with GA showing a gradual decrease and LMST exhibiting fluctuations. Although exploring a wider solution space can yield diverse results, it delays reaching optimal configurations compared to IoTNTop’s more efficient approach. In all performance plots, the comparative deviation shown for each data point represents the standard deviation across multiple independent simulation runs (typically 10 runs per configuration) with randomized node placements in a km area. This “comparative deviation” reflects the variability in algorithm performance under different network realizations. It is measured relative to the mean value of the corresponding metric (e.g., average error probability, transmission range, or number of iterations) for each algorithm at a fixed average received signal energy level or node density. These deviations provide insight into each algorithm’s consistency and robustness under spatial randomness. At , median E2E symbol error is versus GA 0.21, LMST 0.26, and HEED 0.24], corresponding to improvements of , , and respectively.

IoTNTop’s relatively fast convergence to a stable average transmit power suggests it adopts an efficient strategy for searching the solution space. In contrast, Brute-Force, while achieving a similar power level eventually, requires a significantly higher number of iterations due to its exhaustive exploration of all possible configurations. This brute-force approach guarantees finding the optimal solution but comes at the cost of high computational complexity. The GA and LMST curves, on the other hand, exhibit more fluctuations during their convergence process. This indicates that these algorithms are employing more explorative search strategies, evaluating a wider range of candidate solutions before settling on a final configuration. This exploration comes with the benefit of potentially uncovering alternative solutions that are not identified by a more directed search, but it will also lead to a slower convergence rate compared to IoTNTop.

Figure 11 illustrates the relationship between the achievable transmission code rate per node and the average transmit signal power per node for various optimization and clustering algorithms, including IoTNTop, Brute-Force, GA, LMST, HEED, and LEACH. The proposed IoTNTop algorithm consistently outperforms all other approaches across the full SNR range, particularly excelling at lower transmit power levels. This early advantage demonstrates IoTNTop’s ability to efficiently exploit channel conditions and optimize data throughput in power-constrained environments—an essential trait for practical IoT deployments where energy efficiency is critical. While the Brute-Force method yields high code rates, its computational inefficiency renders it impractical for real-time or large-scale deployments, positioning GA as a more feasible yet suboptimal alternative. Topology-aware protocols like LMST show moderate performance, limited by their lack of explicit link-quality or SNR optimization. Meanwhile, classical clustering algorithms such as HEED and LEACH exhibit the lowest code rate across the entire power range. These methods do not incorporate SNR-based metrics or link adaptation strategies, and their cluster formation processes are not tuned for rate maximization. Consequently, while simple and scalable, their performance is inadequate for high-throughput applications. At , median code rate is versus GA 0.62, LMST 0.55, HEED 0.58; improvements are , , and .

Compared to the other algorithms, IoTNTop achieves a significantly higher transmission code rate throughout the iterations (refer to Fig. 12). A higher code rate implies that more of the transmitted bits carry useful data rather than redundancy, which is beneficial for bandwidth efficiency and reducing transmission overhead. However, this is typically viable only when the link quality is sufficiently good, i.e., when SNR is high and error rates are inherently low. The fact that IoTNTop can sustain higher code rates while maintaining low error probabilities indicates that it is not just selecting efficient codes, but also constructing robust topologies with high-quality links. While Brute-Force also achieves high code rates, it requires significantly more iterations to do so. In contrast, GA and LMST converge more slowly and tend to select more conservative (lower) code rates early on, reflecting broader or less targeted exploration. Overall, IoTNTop’s ability to quickly reach high code rates without sacrificing reliability demonstrates its effectiveness in balancing efficiency and robustness in noisy, resource-constrained IoT environments.

Scalability metrics: to quantify computational overhead, we report wall-clock runtime and peak resident memory as functions of N for IoTNTop and baselines, measured on a standardized workstation. We summarize median runtime per iteration and total runtime to convergence, together with the interquartile range across 50 seeds. Peak memory usage is recorded via the process resident set size (RSS). The results in Table 1 show monotonic growth with N and earlier convergence for IoTNTop, resulting in lower total runtime than exhaustive baselines at and comparable memory footprints to graph-heuristic baselines.

IoTNTop’s advantage stems from (i) an error-centric objective that directly minimizes end-to-end (E2E) error probability while respecting code-rate and power constraints, aligning topology selection with decoding reliability; (ii) joint optimization of transmit power, code rate, and link set, which eliminates the mismatch between connectivity-centric objectives and communication performance; (iii) a scalable graph embedding that jointly places gateways and end-nodes with global consistency under partial/noisy distances, reducing geometric distortions that inflate path loss and error; and (iv) an SNR-guided greedy selector with a convergence check on global error probability and code rate, which steers the search toward high-quality configurations early and avoids unnecessary iterations. In contrast, degree and coverage-oriented heuristics (like LMST, HEED, LEACH) and metaheuristics (like GA) optimize proxies such as connectivity, cluster balance, or aggregate fitness without explicitly coupling error probability and code-rate feasibility, leading to topologies that may be energy-efficient yet suboptimal for reliable decoding.

Simulation results and discussion

To validate and evaluate the performance and scalability of our proposed IoTNTop algorithm, we implement a simulation environment using ns3 (Network Simulator Version 3). We leverage LPWAN capabilities of the simulation environment through a LoRAWAN module. This framework is particularly chosen to emulate real-world deployment conditions in large-scale IoT networks, incorporating spatial randomness, transmission noise, energy constraints, and protocol-level packet exchanges. The goal of the simulation is to assess how well IoTNTop performs under practical constraints, in terms of topology formation, error resilience and energy efficiency. All experiments use a region with nodes unless stated. We adopt , , and . IoTNTop is integrated into ns-3 with power and links updated each epoch after EVS, LA and SDP embedding and SNR-guided edge selection. We report symbol-error probability, achievable code rate, energy, and scalability metrics (runtime and memory) over 50 seeds.

We implemented IoTNTop as an ns-3 application that interfaces with the PHY/MAC stack and the mobility and energy modules. Each simulation epoch proceeds as: (a) measurement acquisition from partial and noisy distances (via the channel model) and collection of per-link SNR and energy states; (b) sub-graph realization and stitching using EVS and LA, followed by SDP refinement to obtain a globally consistent embedding; (c) greedy SNR-based edge selection with a convergence check on global error probability and code rate; and (d) parameter update of the ns-3 devices (transmit power, active links) and packet exchanges to evaluate symbol error, throughput, and energy consumption. Metrics are logged per iteration and aggregated over 50 independent seeds.

While the earlier “Network graph modelling” focused primarily on evaluating under varied network conditions the performance of the proposed IoTNTop algorithm - in terms of e.g., error probability, code rate, and transmission range—this section serves a different purpose. Here, we present extended results that validate key theoretical assumptions, examine scalability and robustness under deployment constraints, and benchmark IoTNTop against baseline algorithms across edge-case scenarios. The goal is to complement the primary numerical evaluation with a deeper, application-oriented analysis that emphasizes practical feasibility and performance boundaries. These additional results are included to highlight specific system-level insights that would be diluted if merged with the general algorithmic evaluation done earlier in this paper.

Between 2 to 6 gateway nodes are randomly positioned to function as access points and data collectors. Node placements are based on a uniform random distribution using the ns3:RandomRectanglePositionAllocator class. All nodes are stationary throughout the simulation, governed by the ns3:ConstantPositionMobilityModel class to isolate performance for mobility effects. Communication between nodes and gateways is governed by LoRAWAN PHY and MAC layers, configured through ns3’s LoraChannel model. To model signal attenuation over distance, we use the Log-distance pathloss model, where received signal power is related to the transmit power by, , where d is the distance between nodes and gateways, is the reference distance and is the pathloss exponent. To account for environmental uncertainty, we introduce measurement noise into all pairwise distance estimations used during graph realization. Specifically, observed distances, between node i and node j are given by,

35

where is the true Euclidean distance, is a random variable sampled from a uniform distribution and is the noise ratio representing up to 70% variation.

Each node within the network periodically transmits data packets to its nearest gateway using User Datagram Protocol (UDP), configured via ns3:UdpClientServerHelper. A payload size of 64 bytes and a transmission interval of 2 s are used, reflecting typical low data rate sensor behavior. The transmission activity enables the evaluation of end-to-end communication performance and energy usage under different topologies. Node energy consumption is simulated using ns3:BasicenergySource and ns3:LoraRadioEnergyModel. Each node starts with an initial energy budget of 1 Joule, and power levels are assigned based on the output of the IoTNTop optimization. Transmission and reception costs are dynamically tracked, and residual energy per node is recorded at the end of each run to evaluate energy balance. We start with 27dBm as the maximum allowable transmit power, and -63dBm is the minimum acceptable receive signal power at the gateway. A noise floor of -50Bm is used to model background environmental interference.

To ensure statistical reliability, each simulation configuration is repeated 50 times using randomized seeds controlled by ns3’s RngSeedManager. Each run is executed for 300 seconds of simulation time, allowing sufficient opportunity for data collection and topology convergence. A SNR level of 6dB is required at minimum for reliable communication over any link. The proportional error in distance measurement is considered to be 0.7 where this refers to the ratio of noise level to distance. The payload per transmission is limited to 64 bytes and the transmission interval is considered to 2 seconds. The SNR threshold of 6 dB ensures basic communication reliability, while a proportional distance error of 0.7 models the uncertainty inherent in Received Signal Strength Indicator (RSSI)-based localization. The payload size (64 bytes) and transmission interval (2 seconds) reflect common protocol and application-layer settings in low-power, delay-tolerant IoT deployments (IEEE 802.15.4, LoRa, Zigbee).

Parameter rationale—we adopt a maximum transmit power of to reflect gateway-class IoT links and to ensure non-saturation in the selected path-loss/channel model. The receiver sensitivity threshold is set to , matching the decoder operating point used in our coding profile for reliable demodulation. The SNR threshold of is chosen to align the link-admission rule with the same decoding profile, ensuring consistency between topology control and packet-level success probability. These choices provide a conservative operating point for the evaluated baselines and for IoTNTop; sensitivity sweeps around these values do not alter the qualitative ranking of methods.

We start by plotting the scatter plot (Fig. 13) of the node locations after topology optimization using IoTNTop. The plot validates the assumption of uniform node deployment and help visually correlate the spatial position with performance. For example, nodes farther from the gateway naturally exhibits slightly lower packet delivery rate (PDR) or higher power consumption. The plot further enables spatial debugging of outlier performance and supports decisions on gateway placements or network densification providing a geographical context on topology formation and link reliability. Fig. 14 provides a detailed breakdown of how energy is consumed across the network under IoTNTop. As shown in Fig. 9, IoTNTop achieves significantly higher average energy retention compared to other algorithms. The per-node bar chart further reinforces this by showing that most nodes retain between 60% and 80% of their initial energy budget, even in dense and noisy configurations. The plot also confirms that IoTNTop avoids energy imbalance - where certain nodes might exhaust energy prematurely due to repeated relaying or long-distance transmission. This balance is crucial for maintaining network connectivity and prolonging sensor lifetime, especially in unattended or infrastructure-limited deployments.

The plot in Fig. 15 offers the complementary view to the average code rate analysis in Fig. 14, directly quantifying the per-node symbol error probability. Most nodes exhibit error rates below 15% indicating stable communication links and effective power/code rate assignment. The worst case error values are rare and typically localized, supporting the claim that IoTNTop optimizes performance network-wide rather than at isolated nodes. The plot further highlights whether the system meets the uniform reliability requirements essential for industrial and mission-critical IoT applications. The results in Fig. 16 comparing energy retention across algorithms makes it evident that IoTNTop consistently conserves more energy per node than both Brute-force and GA regardless of node index. This demonstrates that IoTNTop’s energy savings are not just average-based, but systematically realized across the entire network. This plot exposes the equity in energy consumption, revealing whether certain strategies offload excessive transmission burden to specific nodes (as GA and Brute-force often do). IoTNTop avoids such bottlenecks, enhancing long-term sustainability and balancing load.

The Node Performance Heatmap in Fig. 17 integrates three metrics–remaining energy, PDR, and error probability–providing a holistic visual of each node’s performance. Nodes that perform well across all dimensions appear in cool blue-green hues, while under-performing nodes (e.g., with high error or low energy) are flagged in warmer colors. The heatmap further enables rapid visual identification of bottlenecks, vulnerable nodes, or regions needing intervention (e.g., adding a gateway or increasing transmit power). The plot in Fig. 18 demonstrates that IoTNTop achieves higher average SNR more rapidly and consistently across iterations. This validates the numerical results in the paper (see Figs. 5 and 6), which show that IoTNTop converges in fewer iterations than competing methods. While LEACH and HEED were designed for simplicity and energy efficiency, they do not scale well in terms of error resilience or range optimization. These limitations become starkly visible when compared against IoTNTop’s multi-layered optimization approach.

Fig. 17.

Heatmap showing node-wise performance in terms of three key metrics: residual energy, packet delivery rate (PDR), and symbol error probability. Each cell corresponds to a node, with intensities indicating performance levels. High residual energy and PDR, coupled with low error rates, denote well-performing nodes.

Fig. 18.

Average signal-to-noise ratio (SNR) evolution over optimization iterations for different topology control strategies. The vertical axis reports the mean SNR across all active links, while the horizontal axis denotes iteration count.

In Fig. 19, IoTNTop consistently outperforms all other methods in maintaining low localization error across nodes. This supports the paper’s results showing improved accuracy in graph embedding and sub-graph stitching (as discussed in Sections II-B and II-C). LEACH and HEED, which use simpler heuristics for cluster formation, demonstrate higher errors due to their lack of spatial awareness, namely, they do not account for physical node positions, inter-node distances, or geometric consistency when forming clusters or assigning communication paths. Furthermore, they lack measurement refinement steps, such as eigenvector synchronization, reflection correction, or code-aware distance alignment, which are central to IoTNTop’s accurate graph realization. The relatively good performance of GA suggests its capability to adapt, but it still lacks the structural rigor, namely, explicit enforcement of geometric constraints, global consistency in sub-graph alignment, and direct incorporation of communication-centric metrics such as SNR, code rate, or error probability into its optimization objective. Unlike IoTNTop, which leverages graph realization principles and synchronized sub-graph stitching, GA operates as a general-purpose optimizer and may converge to topologies that are locally good but globally inconsistent or suboptimal in terms of error robustness and communication quality. The results in Fig. 20 show a significant drop in error probability as transmit power increases for all protocols, but IoTNTop consistently maintains the lowest error rates across all power levels. This aligns directly with the analytical results in the paper (Figs. 8, 9, 10), which illustrate IoTNTop’s ability to minimize transmission errors by jointly optimizing transmit power and code rate. The logarithmic scale highlights how IoTNTop achieves exponential improvements, reinforcing the effectiveness of its error-centric design.

Fig. 19.

Localization error distribution across all nodes in the network after graph embedding and sub-graph alignment. Localization error is computed as the Euclidean distance between estimated and ground truth node positions.

Fig. 20.

Variation in symbol error probability as a function of transmit power. The horizontal axis represents transmission power levels in dBm, and the vertical axis shows the corresponding symbol error probability.

Finally, Fig. 21 confirms that IoTNTop can achieve a longer communication range for a given transmit power compared to the other protocols. This supports the claims in the paper (Figs. 7, 8) that IoTNTop balances energy efficiency with network coverage. LEACH and HEED achieve shorter ranges, indicating suboptimal power utilization, while GA performs moderately but lacks the adaptive precision that IoTNTop achieves via its greedy edge selection and convergence-checking strategy. One key insight is that optimizing error probability and code rate jointly, as IoTNTop does, leads to superior results in all other areas (SNR, power efficiency, and range). Most legacy protocols treat these metrics independently, which appears suboptimal for different IoT application scenarios.

Fig. 21.

Achievable average transmission range per unit of transmit power across different topology strategies. The vertical axis represents range achievable in meters and the horizontal axis lists the algorithms evaluated.

It is worth noting the “zigzag” behavior seen in Figs. 16,  18, and  19 and to a lesser degree in Figs. 20 and 21. These fluctuations are a direct result of the discrete nature of topology formation in the presence of dynamic network parameters. Small changes in input conditions can lead to abrupt shifts in the selected topology–such as inclusion/exclusion of certain links or nodes–thereby causing non-monotonic variations in metrics like code rate and error probability. This is further amplified by randomized node deployments, which may produce topology-sensitive outliers despite averaging across multiple simulation runs. Such behavior is expected in combinatorial optimization settings and reflects the sensitivity of real-world IoT deployments to small changes in physical or network-layer conditions.

Conclusions

This paper tackles the challenge of designing IoT network topologies to maximize coverage and throughput with minimal number of devices while addressing issues like poor link quality and interference. By introducing a novel graph-realization approach that incorporates local distance information into the global network structure, we optimize the placement of end-nodes and gateways, improving information rates, and reducing transmit power and error probability. The methodology divides the network into sub-graphs, aligning them to form an efficient global structure. Through advanced mathematical modeling and algorithms, this scalable, noise-resilient solution outperforms traditional methods in minimizing errors and maximizing code rates, making it ideal for large, heterogeneous IoT networks. Across matched conditions used in our simulations, nodes over a field with average transmit power of per node, IoTNTop achieves consistently better communication, localization tradeoffs than heuristic and exhaustive baselines. Most nodes maintain symbol error probability (Fig. 15), and the network retains 60– of the initial per-node energy budget (Fig. 16) while sustaining higher achievable code rates across iterations and network sizes (Fig. 12). These trends persist for (Figs. 12, 13, 14, 15, 16), and the algorithm typically converges in fewer iterations than baselines, reducing overall computational effort. Our present formulation assumes quasi-static deployments with partial but stationary distance/noise statistics; accuracy degrades when distance measurements are severely biased (like, persistent NLOS) or SNR estimates drift over time. We do not model mobility, clock drift, or rapid channel fading explicitly in this version; incorporating temporal dynamics, robust bias mitigation, and online recalibration are important directions. In future, we will explore : (i) adaptive re-embedding under time-varying channels and mobility, (ii) field trials with heterogeneous hardware to assess measurement bias and synchronization effects, and (iii) hybrid learning-based predictors that warm-start edge selection while preserving the error-centric guarantees.

Author contributions

Both authors have equally contributed to the main manuscript. I. Dey prepared the figures and both authors have reviewed the manuscript.

Funding

The contribution from I. Dey and N. Marchetti is supported by HORIZON-MSCA-2022-SE-01-01 project COALESCE under Grant Number 101130739 and HORIZON-HLTH-2024-ENVHLTH-02-06 project ENACT under Grant Number 101157151.

Data availability

All data generated in this paper are simulation-based. The datasets generated and/or analyzed during the current study will be available from the corresponding author on reasonable request.

Declarations

Competing interests

The authors declare no competing interests.

Supplementary Information

The online version contains supplementary material available at 10.1038/s41598-026-43621-6.