3.1 Proposed Architecture

This article proposes an architecture for IoT devices, social networks, and service provision in the SIoT model. The proposed architecture consists of four layers; the bottom layer is the physical layer, followed by the relational communities, making the subcommunity layer, the service provision layer, how to find, select and combine services and applications layer, as shown in Figure 1. The relationships in IoT devices make their interactions easy. This article presents a hybrid optimization algorithm applied to the user needs of the search selection and composition services. The search functionality in the multirelationship model is that all of the search operations are set up in parallel, which makes it quick for searches over relationships and specific services. Service combines many services with the best parameters and attributes to fulfill users' needs.

3.2 Proposed Model

In the SIoT environment, we introduce the service provision based on the community detection method. The proposed method starts with detecting various relationships in the SIoT network, POR, OOR and SOR, as illustrated by Figure 2. The community detection algorithm partitions the IoT network into smaller communities. Through this first stage, social relations are examined among the IoT devices. Detecting a group of devices with common characteristics and attributes helps in service provision purposes. In the second stage, upon detecting some services a user requested in the standard services provision, the algorithm balances the requested service and the other users' demands. Then, service quality metrics are analyzed to select better services based on user requirements from the discovery stage. This composite service runs on the application created with just the best services expected to form a near-optimal composite service that finally meets all task needs. Once the user gets its executable composite service, the recommendation procedure stops. This way, our method for discovering, selecting, and composing services in an SIoT network is highly effective and efficient to ensure users receive high-quality services.

3.3 Hybrid Optimization Algorithm

A hybrid optimization algorithm is a composite method that integrates more than one individual optimization technique to successfully solve complex problems that are difficult to solve by traditional or single methods. This hybrid approach increases the GA strengths for exploration and BSA for exploitation to provide near-optimal solutions. This is done by utilizing the concept of natural selection in GA optimization. It solves high-dimensional search and optimization problems. The way biological evolution has mutation, crossover, and selection. It can handle many issues and multiobjective optimization problems, avoid poor solutions and fit the changes of requirements. It has a high computational, is highly dependent on the parameters, and does not assure getting into the best solution. The GA starts creating random solutions. This fitness function determines which solutions are most suitable for reproduction. This method also applied the crossover and mutation operation to generate new solutions in the next generation by involving a proposed algorithm. This goes on until the maximum iteration count or fitness levels GA can perform well in finding solutions for a vast number of applications [49].

BSA is an evolutionary optimization algorithm developed in 2013 by Civicioglu to detect the complexity of global optimums effectively. The optimization methods are search algorithms (e.g. PSO and GA). The BSA uses genetic crossover, mutation and selection using BSA grow candidate solutions. First, it randomly creates a candidate solution list. Hybrid and adapted solutions are generated according to an arbitrary value of control parameter and best historical solutions. Compute the fitness of each solution. The solutions have been short-listed, and fitness scores have been used to form the future generation. This loop keeps iterating until either the maximum iteration count or solution fitness is met [31]. Since BSA has fewer control parameters than other optimization algorithms, it can escape local optima by returning and revising solutions. Continuous, discrete and multiobjective optimization problems are readily solvable and modifiable [50-53].

To enhance service discovery, selection and composition in the SIoT environment, this research work proposes a hybrid optimization algorithm that integrates and utilizes the IGA and the BSA. It seamlessly combines exploration (searching widely for possible solutions) and exploitation (refining potentially good solutions). This integration allows effective management of high-dimensionality and multiobjective optimization problems. This hybrid algorithm introduces some key features. Dynamic discovery, selection and composition of services in the SIoT environment facilitate improvement in service provisioning. Unlike traditional approaches that rely on fixed rules or deterministic methods, this approach adjusts to changing network conditions and provides near-optimal solutions on time. A hybrid approach intertwines IGA and BSA, leveraging their respective strengths. Through the process of mutation, crossover, and selection, which are based on the principle of natural selection, the IGA shows excellent performance in large-scale search spaces. It maintains a diversity of solutions, avoids premature convergence, and is also an effective solution for multiobjective optimization problems. However, it can be very computationally expensive and depends on specific parameters. BSA finds efficient solutions to numerical problems by making use of past information, using fewer control parameters, and avoiding local optima by retraining solutions that consider previous generations. These approaches balance exploration and exploitation, which leads to strong performance by exploring different solutions while refining those that seem most promising. This mixed algorithm is in sharp contrast to existing service provision systems. Traditional systems often rely on well-defined rules and static optimization methods and tend to struggle in dynamic and complex environments like the SIoT. The hybrid algorithm operates in real-time adaption to a network environment or scenario that is evolving. Additionally, traditional optimization techniques have difficulty escaping local optima, particularly in high-dimensional search spaces. By incorporating BSA's backtrack capability and IGA's exploration ability, this hybrid algorithm can promptly locate near global optima. This technique enables a more practical method of handling multiobjective problems as opposed to traditional systems that require extensive computation or constraints to solve these problems.

Our approach differs from the state-of-the-art ones with its novel facets. This makes it well suited to solve SIoT issues, which involve complex interactions among devices and between devices and services. The BSA revisits potential solutions, which prevents the system from converging too early, resulting in better overall results. By requiring a smaller number of control parameters than standard methods such as particle swarm optimization (PSO) or independent GAs, BSA reduces the dependence on the parameters. The new hybrid algorithm is designed for upscale and modularity, addressing the challenges of large amounts of data and complex maps by parallelization. BSA benefits from the use of historical data, and GA preserves diversity, both of which lower computational redundancy, thus enabling a more rapid approach while achieving appropriate accuracy. The hybrid optimization algorithm proposed in this study represents a significant advancement over traditional service provision systems and optimization algorithms. IGA and BSA come together to present a solution that is powerful, nimble, and responsive to the wide range of problems posed by SIoT. Its ability to juggle exploration versus exploitation, adapt to high dimensional spaces, and respond on the fly to modifications to the network makes it a powerful and novel tool in current optimization and service provisioning problems. The main goals of this article are how to find services more efficiently through social relationships with IoT devices, and the selected services can be combined into task executions to meet users' demands. To obtain this, we apply the SIoT service provision with detected communities to design a customized intelligent device classification scheme using their corresponding service by minimum distance and delay to fast response speed for user demands. This article introduces a new community detection algorithm in SIoT. Then, it proposes a novel hybrid service provision based on a community detection algorithm that further enhances GA exploratory strength and BSA exploration capabilities in detected communities. This method is named IGBSA-CD. In each domain, it demonstrates the performance of these proposed algorithms on real-world datasets, showing improvement over existing methods. IGBSA-CD presents higher efficiency and adaptability concerning tasks and sample size.

Due to many limitations in the SIoT service provision research, this work introduces new hybrid optimization algorithms to discover, select and compose services provided by unified SIoT to provide service. An optimization strategy consists of finding the best possible solution from various options, considering the limitations and requirements. Classical approaches require assistance finding the global optimal solution as the number of dimensions in the search space increases with a greater dimension of optimization problem [19, 20]. These problems are cared for by the optimization algorithms to find fast global optimum solutions such as [21-23]. However, some algorithms might be better for complex problems and need to be improved. This hybrid algorithm can increase its efficiency. In this article, a new approach to a hybrid optimization algorithm is proposed to improve service provision in the SIoT environment. The nature of the problem is to find nearly optimal solutions quickly, and optimization algorithms are efficient in this regard [24-28]. The new aspect of the SIoT, the automatic exchanges between objects building a social paradigm, can bring benefits to the user-oriented approach of awareness about usage and smart administration to diminish the costs related to it like energy consumption inside the building. The system uses both user and location object profiles automatically. GA is used for the optimization algorithm [29]. This research is motivated by the need to address the many challenges faced within SIoT, such as service provisioning (discovery, selection, and composition). The motivation behind this work is to address the critical issue in the SIoT, which is to allow appropriate service provisioning, discovery, selection, and composition. GAs are a widely used optimization technique with some benefits. However, they are also plagued with severe limitations. BSA has a slow convergence, and GA has duplicability. To face these problems, this study proposes a hybrid approach known as IGBSA-CD. The integration of the two methods allowed us to benefit from the advantages both algorithms present to enhance the efficiency of computing, scalability and adaptability. The incentive is to further the community detection process and consequently prune the search field for service discovery by grouping SIoT devices based on social ties and features of services. By reducing delay and distance through intelligent device classifications, as well as optimizing reaction time, the proposed system aims to ensure fast and reliable service provisioning. This article offers several key benefits for improving and demonstrating enhanced efficacy and adaptability in the context of SIoT service provisioning.

This article uses the GA with BSA to develop and enhance the proposed method. We first improve GA (IGA) and then combine it with BSA as a hybrid algorithm. This article uses these optimization algorithms because of their simplicity and effectiveness in finding the optimal solution. Both the IGA and BSA are powerful computing algorithms with their respective advantages and disadvantages. GA solution can adapt to the changing environment of implementers, and it can withstand long-time iterations while searching through vast search spaces. The GA is computationally resource-demanding; global optimum help may also be necessary, and efficiency can benefit here, in particular with large datasets [30]. The BSA method can solve numerical optimization problems by using real-valued variables [31]. This calculates the search directions matrix from the past generation population. This means it can work data-wide across the globe or use local resources effectively. It might have to look at other populations with better properties for the multiple objectives of optimization. It showed a reduced rate of movement than previous optimization algorithms [32-34]. This article proposed a hybrid algorithm based on detected communities for service provision. It introduces a novel algorithm for community detection and proposes an efficient service compositing method. This algorithm can classify SIoT devices into communities and detect highly socially connected nodes to reduce the search space.

3.4 Formulation of Fitness Function

This article evaluates three metrics, distance, delay and speed, which can be characterized to examine the suggested method. A single multiobjective fitness function is used to discover, select and combine services in the best-suited task. It provides maximum speed by minimizing the distance and delay. The three metrics have definitions and formulas explained below.

Distance measures the spatial separation of two devices in a multidimensional space. The Euclidean distance is used to calculate distances by the square root of the quantity of their actual coordinate differences squared. The dataset in this article is based on devices that are placed in a two-dimensional; their position is defined as the coordinates ($$$ {x}_1,{y}_1 $$$) and ($$$ {x}_2,{y}_2 $$$). $$$ \mathit{\operatorname{Re}}{q}_{dev} $$$ is the requesting device and $$$ \mathit{\operatorname{Re}}{c}_{dev} $$$ is the receiving devices of requested services.

Where $$$ {\overline{M}}^{all}\left({t}_i\right) $$$ is the single multiobjective fitness function that metrics all participant services in each task, $$$ {\overline{M}}_{Distance}\left({t}_i\right) $$$, $$$ {\overline{M}}_{Delay}\left({t}_i\right) $$$, and $$$ {\overline{M}}_{Speed}\left({t}_i\right) $$$ are the single objective fitness functions for each task. The $$$ {w}_1 $$$, $$$ {w}_2 $$$, and $$$ {w}_3 $$$ are the weights assigned to each fitness function, the weight of the metrics defined by a user. This article gives equal weight to each measure such that $$$ \sum {w}_i=1\kern1em \mathrm{where}\kern1em i=1,\kern0.3em 2,\kern0.3em 3 $$$. The fitness function shown in Equation (9) aims to minimize the multiobjective function and get the best measure to fulfill user requirements.

4.1 Proposed Community Detection Algorithm

Community detection in the SIoT concerns the identified communities, which are a collective of IoT devices demonstrating similar characteristics or being involved in achieving shared objectives for optimizing network efficiency and scalability and improving service discovery. Identifying the network into distinct communities facilitates more efficient service discovery by searching the clusters of devices rather than separate entities. Nodes in this context refer to devices, whereas edges indicate the relationships or interactions between these devices [15].

ALGORITHM 1. Proposed Community Detection Algorithm (CD).

Algorithm 1 presents a systematic method for detecting communities in a network of devices. Each device has social relationships and services. The algorithm takes input from a set of ID devices ($$$ I{D}_{-} Devices $$$), ID services ($$$ I{D}_{-} Services $$$), and adjacency matrices ($$$ Adj $$$) of social relationships. First, the process initializes the Community List ($$$ {C}_i $$$) list to store the identified communities and $$$ ConnectedDevices $$$ list to track the devices based on social relations. The algorithm evaluates the social connections of each device within $$$ Adj $$$ that display the presence or absence of links between devices. The device is recognized as having a social connection and then added to the $$$ ConnectedDevices $$$ list. If a device lacks connections, it is excluded, and the next device is assessed.

Communities are detected by processing each device in the $$$ ConnectedDevices $$$ list and counting the related services after analyzing all devices for social connections. Each device provides one or multiple services in the dataset we used. The algorithm evaluates a community in $$$ {C}_i $$$ with devices providing an equal number of services. A device with a service count corresponding to an established community is introduced. If there is no existing community or the device does not provide services, it is not evaluated for inclusion in the community list. The community detection process is repeated until all devices are in $$$ ConnectedDevices $$$. The proposed method provides that each socially linked item is considered for possible inclusion in a community based on its services. The identified communities are the valuable outcome of the algorithm. They represent the community structures inside the network based on shared social and service counts. Figure 3 shows the proposed community detection algorithm in the SIoT environment. First, the proposed algorithm starts with the initialization of $$$ {C}_i $$$ list to handle the detected communities and the $$$ ConnectedDevices $$$ list to match socially interconnected devices.

The proposed algorithm uses adjacency-based social relationship matrices to detect and establish social links between devices. Every element of this matrix denotes the relation between two devices if one means it exists; otherwise, 0. Each analyzed device has at least one relationship identified in the social network analysis, such as at least one adjacency matrix this device participates in; if so, it is included in the $$$ ConnectedDevices $$$ list. Within an analysis of the $$$ ConnectedDevices $$$ list, communities are found for devices. Determine the service count for each device. It checks if devices have an equal number of services. Otherwise, the devices not in $$$ {C}_i $$$ are excluded. This is repeated for all devices in the list of $$$ ConnectedDevices $$$ through all devices. After this detailed analysis, the algorithm ends with $$$ {C}_i $$$, which is the final output of the algorithm.

The process of detecting communities between connected devices has multiple steps involved that contribute to its overall computational complexity in terms of time and space required. Iterating through all the available devices in the network is of $$$ O(n) $$$ time complexity, where n is the number of devices. Calculating the number of associated services $$$ k $$$ per device per algorithm, yielding $$$ O(k) $$$ per device. The total complexity for $$$ n\cdotp k $$$ for device-based services is $$$ O\left(n\cdotp k\right) $$$. Then, the algorithm checks for all the community that exists corresponding to the service count. We denote the number of communities with $$$ c $$$. Thus, this step has a complexity of $$$ c $$$ for each device and $$$ O\left(n\cdotp k\right) $$$ for all devices. The device is integrated into the existing community if it exists. Otherwise, a new community is created. The complexity of adding devices to communities or creating new entries is $$$ O\left(n(1)\right) $$$ per device, leading to the overall complexity of $$$ O(n) $$$. This operation is repeated until every device has been considered, and the overall computational complexity is mainly determined by counting services and evaluating communities. Overall, we have both time complexity represented as $$$ O\left(n\cdotp \left(k+c\right)\right) $$$, which is linearly dependent on the number of devices, services, and communities. Space complexity includes $$$ O(n) $$$ for devices, $$$ O\left(n\cdotp k\right) $$$ for device-based services (where $$$ k $$$ is the number of services), and $$$ O\left(c\cdotp k\right) $$$ for community data (where c is the number of communities). We get the total space complexity of $$$ O\left(n\cdotp \left(1+k+c\right)\right) $$$, dominated by device-service relationships and the data needed for storing communities. The algorithm has a time complexity of $$$ O\left(n\cdotp \left(k+c\right)\right) $$$ and a space complexity of $$$ O\left(n\cdotp \left(1+k+c\right)\right) $$$. The positive phenomenon seen in thin networks corresponds to linear increasing complexity in the number of services and communities.

ALGORITHM 2. IGBSA-CD.

4.2 Proposed Service Provision Based on Community Detection Algorithm

We introduce the IGBSA-CD algorithm into (Algorithm 2) as the proposed hybrid optimization algorithm for service provision (i.e., service discovery, selection and composition) in the SIoT environment, which combines BSA with IGA. This hybrid approach increases the GA strengths for exploration and BSA for exploitation to provide near-optimal solutions. This is done by utilizing the concept of natural selection in GA optimization. It solves high-dimensional search and optimization problems. The way biological evolution has mutation, crossover, and selection. It can handle many issues and multiobjective optimization problems, avoid poor solutions and fit the changes of requirements. It has a high computational cost, is highly dependent on the parameters, and does not assure getting into the best solution. The GA starts creating random solutions. This fitness function determines which solutions are most suitable for reproduction. This method also applied the crossover and mutation operation to generate new solutions in the next generation by involving a proposed algorithm. This goes on until the maximum iteration count or fitness levels GA can perform well in finding solutions for a vast number of applications [49].

BSA is an evolutionary optimization algorithm developed in 2013 by Civicioglu to detect the complexity of global optimums effectively. The optimization methods are search algorithms (e.g. PSO and GA). The BSA uses genetic crossover, mutation and selection using BSA grow candidate solutions. First, it randomly creates a candidate solution list. Hybrid and adapted solutions are generated according to an arbitrary value of control parameter and best historical solutions. Compute the fitness of each solution. The solutions have been short-listed, and fitness scores have been used to form the future generation. This loop keeps iterating until either the maximum iteration count or solution fitness is met [31]. Since BSA has fewer control parameters than other optimization algorithms, it can escape local optima by returning and revising solutions. Continuous, discrete and multiobjective optimization problems are readily solvable and modifiable [50-53].

The proposed algorithm initializes with the number of individuals and populations. Next, quality of care metrics for each group are considered; this is a critical process as these specific dimensions of the quality of service are experienced by each individual. This article regards the metrics Delay ($$$ {M}_{Delay}(s) $$$), Distance ($$$ {M}_{Distance}(s) $$$) and Speed ($$$ {M}_{Speed}(s) $$$). Arrays of these metrics are used to characterize the distance, delay, and speed of each service from the resulting composition. First, this article defines several identification devices and their attributes for evaluation. It then determines every service that is required by the task being requested. Various predefined aggregation functions are used to find the values of these metrics for every identified service. Equation (1) calculates the distance of the $$$ {i}^{th} $$$ instance of services $$$ {M}_{Distance}(s) $$$, Equation (2) calculates the delay of the $$$ {i}^{th} $$$ instance of services $$$ {M}_{Delay}(s) $$$ and Equation (3) computes the speed of the $$$ {i}^{th} $$$ instance of services ($$$ {M}_{Speed}(s) $$$. These Equations (4) and (5) derive the normalized metrics of a service. Fitness value aggregates the quality metrics between all inputs and their corresponding gene. The fitness of population composition is computed using Equation (9). A critical stage of this optimization strategy has been designed to find the best composite service for executing applications. This optimization algorithm is utilized to reduce this result to enhance selected service quality. Chromosomes use the ($$$ I{D}_{-} Devices $$$) to $$$ m $$$ tasks $$$ k $$$ services for creating. For example, each gene ($$$ IDDevice $$$) in a chromosome has three, four or five services. Algorithm 2 starts with initializing an initial population and service compositions individuals. To begin with, a task request is sent by a user. Each service saved in this repository stores the quality of device metrics. Multiple services are present for each gene chromosome using ($$$ I{D}_{-} Devices $$$), as shown in Figure 4. A chromosome is constructed using the($$$ I{D}_{-} Devices $$$) with $$$ m $$$ tasks, and there are $$$ k $$$ services.

The tournament compares services by pitting two contestants against one another as one device can be declared the winner over another. The first and second devices rank the same but next to the first. Many characters are controlled by two or more parents that act together to form new chromosomes. Figure 5 presents the case of evaluating a child's genes based on crossover type 1.

The local optimum is eliminated by using mutation. The mutation updates the genes on chromosomes by adding a random number of $$$ ID $$$ devices to a gene with an index one less than the last one (see Figure 6).

The appropriate services for the task are found and run in a suitable application. The collected metrics value is determined for each task containing services to obtain the total value for service composition in Equation (9). $$$ {\overline{M}}^{all}\left({t}_i\right) $$$ is the sum of the metric values for each service concerned in a task.

Figure 7 presents the hybrid optimization technique to enhance and optimize solutions iteratively. This process begins by populating an initial population and chromosomes, as shown in Figure 7a. A fitness function scores these effective chromosomes. It allows a flexible adjustment of IGA and BSA parameters after establishing the population. Mutation rates, crossover rates, and backtracking tactics can govern how the algorithms hunt throughout the solution space and exploit it. It ends when, in the loop, a generation number has been reached.

The first improved genetic algorithm (IGA) activities applied in this cycle, as shown in Figure 7b. The IGA begins with tournament selection to choose parent chromosomes based on their fitness by selecting the best individual from a random population subset. It enhances the quality of offspring by selecting only the fittest individuals to contribute to the next generation. Then, the algorithm generates children by grouping two offspring from two parents using single-point crossover methods. This crossover operation develops the children by taking genetic materials from both parents. IGA mutates the offspring by applying the mutation operations. These mutations allow the algorithm to explore new areas in the solution space and avoid getting local optima. The IGA evaluates the new population and all the individuals of this new population according to their performance and mixes them in with the former population by replacing less fit individuals. This evaluation step keeps getting better in subsequent generations. Also, this approach introduces elitism to the way that a fixed number or fraction of the best solutions from the current population survive into the next generation. Elitism guarantees that high-quality solutions are preserved during optimization, avoiding optimal or near-optimal individuals lost due to random genetic operations. These improvements upgrade the GA into a more stable, fast, and near-optimal solution procedure. Therefore, BSA is then easily linked to advanced search by uniting the explorative of IGA capacity with BSA exploitative methods.

Although BSA is a robust optimization, it uses incremental construction and systematic exploration. It starts with a halfway solution and iteratively increases elements to develop the final complete possible solution. At each step, BSA approves if the current partial solution is feasible. If, at any point, a constraint is violated, then the algorithm backtracks, which means the current path is discarded, and it returns to previous steps to explore other options instead. This systematic approach ensures that all possible regression paths are explored so as not to buckle the algorithm in the wrong direction portion of the solution space. BSA systematically lays out the operational flow at different stages. The first step of the algorithm is to assign the variables that need filling to have the best solution. Next, it will recursively parse all its variables, one by one, instantiated, and check the satisfaction of constraints. If it gets a valid assignment, it moves to the next variable. Otherwise, it backtracks one step and tries again till the solution is found. It then repeats the process recursively until a correct solution is found or all possibilities are tried. BSA attempts to explore and refine solutions to minimize the difficulty of the problem.

By combining BSA with IGA, the limitations of each algorithm are overcome in this hybrid optimization method. IGA starts by making a population using genetic operators like selection, crossover, and mutation to generate new offspring. Afterwards, these offspring solutions are refined using BSA. Once the genetic operations generate the new candidates, BSA systematically searches and refines individual parts of these solutions by enhancing their fit to satisfy problem constraints. This allows the algorithm to diversify its exploration through genetic diversity and backtrack by exploiting and refining certain areas of the solution space.

The advantages of combining IGA and BSA are powerful because they promote both exploration and exploitation in the algorithm. However, where IGA is good for the exploration of a wide range of solutions, BSA exploits specific regions (local minima) and refines them by progressively optimizing. The moderate balance between structured sampling and heuristic search helps the learning process avoid falling into local optima during the early stage and keeps global optima discovery robust. In addition, systematic backtracking in BSA exhibits robustness for IGA as it can backtrack to improve insufficient decisions and thus increase quality. The combining approach ensures the population progresses toward better solutions, stabilizing individuals and promoting diversity when needed. The BSA promotes the IGA to couple systematic refinement of solutions with the satisfaction of any constraints that may have been invoked. BSA generates multiple high-quality and diversified solutions incrementally with backtracking. When combined with IGA with genetic operators, BSA can use the proposed solutions by optimizing exploration and exploitation. This optimization problem solver is more efficient and solid in solving complex problems. The proposed combined IGA and BSA algorithm keeps improving solutions by continuous refinement over multitudes of iterations and convergence towards near-optimal values.

This collaborative integration leads to better solutions and resolution. Next, the fitness of the new generation is evaluated, and previous explorations and exploitations retraced solutions are added to the population. The best solutions are saved for the last. The algorithm returns near-optimal fitness values, or near-optimal solutions, reached after the generation. The algorithm executes the solutions in its target application and returns the best results to the user, as shown in Figure 7c. Therefore, this article avoids the complexity of service composition in SIoT networks by leveraging the benefits of IGA and BSA based on detected communities with a new method.

IGBSA-CD is a powerful strength service composition algorithm. The aim is to successfully realize real-world data sets by selecting the best devices and services possible, responding in near real-time to rapidly changing conditions yet demanding user requirements. This method starts with $$$ {C}_i $$$ generated by the community detection algorithm suggested in this article. The network is divided into groups of devices that provide services and applications. Each device in such communities has a unique identifier ($$$ I{D}_{-} Device{s}_i $$$), and it can offer particular services and run various applications represented by the user. Coordinate location of receive and request device ($$$ \mathit{\operatorname{Re}}{c}_{dev}\left({x}_i\right) $$$, ($$$ \mathit{\operatorname{Re}}{c}_{dev}\left({y}_i\right) $$$), ($$$ \mathit{\operatorname{Re}}{q}_{dev}\left({x}_i\right) $$$, $$$ \mathit{\operatorname{Re}}{q}_{dev}\left({y}_i\right) $$$) respectively. We input the population size ($$$ p $$$) and the generation number ($$$ g $$$) to apply the optimization algorithm. In addition to device and community information, the algorithm takes into account many applications ($$$ Ap{p}_i $$$) installed and provided many services ($$$ I{D}_{-} Servic{e}_i $$$) by devices. It contains the conditions to run some specialized tasks in a specific application ($$$ Ap{p}^{required} $$$) required to run ($$$ Tas{k}^{required} $$$). This is also composed of the context and application conditions ($$$ Tas{k}^{found} $$$ representing found best tasks and run in a given application ($$$ Ap{p}^{found} $$$). Moreover, the availability of each device and their spatial coordinates, as well as the beginning and end timestamps ($$$ {T}^{req},{T}^{rec} $$$) of this period, are vital for scheduling and executing time-sensitive and location-based tasks. IGBSA-CD algorithm selects the best services and produces the best service composition from ($$$ bestSC $$$), which can perform available tasks wisely within communities through proper distribution of services among devices.

For matrices used to generate feedback for existing services and applications, we define $$$ S=\left[{S}_ij\right] $$$ for services, where elements are 0 or 1. Services exist if elements ($$$ {S}_{ij} $$$) are one and not are zero. We introduce another matrix of applications $$$ A=\left[{A}_ij\right] $$$ whose elements are 0 or 1; if elements $$$ A=\left[{A}_ij\right] $$$ is equal to 1, then the application exists; otherwise, 0, it does not exist.

The procedure is initiated by forming a random set of solutions during the IGBSA-CD process. It sets each solution and proposes a different allocation of services to tasks on devices in the form of chromosomes. The fitness value of each chromosome is according to height capacity for metrics such as distance and delay in service composition, maximizing speed, and minimizing best fitness solutions. Their method is organized in iterative cycles, with selection, crossover or mutation performed incrementally on the genetic elements at round. It enables the population to evolve towards better and better solutions. At the same time, the BSA component is the one way things progress because it thoroughly inspects all possibilities. Then, it repeats to apply genetic operations on the population, such as selection, crossover and mutation, to make the population move towards near-optimal solutions. The BSA looks at a search space part to support this optimization method. It also backtracks several distinctly near-optimal selection solutions.

This method replaces the highest fitness values with values improved by genetic and backtracking techniques. It saves the minimum fitness values from each run and stops when a fixed number of iterations is achieved or if no more improvement can be made. The IGBSA-CD algorithm's time complexity begins with the initialization phase, where random population solutions and chromosomes are generated for each individual in the population, taking $$$ O(p) $$$, where p is the population size. Evaluating the fitness function for all individuals in the population requires $$$ O\left(p\cdotp m\right) $$$, where m is the number of tasks or services. Setting the parameters for the IGA and BSA, such as mutation rate and crossover rate, is a constant-time operation, $$$ O(1) $$$. Within the while loop that runs over $$$ g $$$ generations, the time complexity depends on several factors. Updating the feedback matrix for services $$$ {S}_{ij} $$$ across communities and devices takes $$$ O\left(c\cdotp n\right) $$$, where c is the number of communities and n is the number of devices. The IGA operations, including selection, crossover, mutation, and offspring evaluation, have a complexity of $$$ O\left(p\cdotp m\right) $$$. Integrating BSA with IGA for backtracking and reintegration adds $$$ O(p) $$$ per iteration. Re-evaluating the fitness values for both the updated and backtracked solutions further contributes to $$$ O\left(p\cdotp m\right) $$$. Maintaining and updating the archive of best solutions during this process requires $$$ O(p) $$$. Finally, checking application compatibility for tasks and returning executable tasks takes $$$ O\left(c\cdotp n\right) $$$. The overall time complexity per generation is $$$ O\left(p\cdotp m+c\cdotp n\right) $$$, and for $$$ g $$$ generations, it becomes $$$ O\left(g\cdotp \left(p\cdotp m+c\cdotp n\right)\right) $$$. Computationally, the algorithm is dominated by the population size $$$ p $$$, the number of tasks or services $$$ m $$$, the number of communities $$$ c $$$, the number of devices $$$ n $$$, and the number of generations $$$ g $$$. The algorithm offers several advantages. It efficiently evaluates fitness by combining historical data through BSA with real-time evaluations from IGA, ensuring accurate and faster convergence. The backtracking mechanism in BSA prevents the loss of potentially good solutions, avoiding premature convergence to suboptimal results. The modular design makes the algorithm scalable and suitable for parallelization, particularly for fitness evaluations across the population. Moreover, the integration of application compatibility checks ensures task-specific solutions for practical implementation. The hybrid algorithm with $$$ O\left(g\cdotp \left(p\cdotp m+c\cdotp n\right)\right) $$$ is better suited for large-scale optimization problems due to its linear growth and scalability.

4.3 Relation Between Community Detection and Service Provisioning Process

This article presents a hybrid optimization algorithm applied to the user needs of the search selection and composition services. The search functionality in the multirelationship model is that all of the search operations are set up in parallel, which makes it quick for searches over relationships and specific services. Service combines many services with the best parameters and attributes to fulfill users' needs. As a user needs to get some services available, the services search and composition method to decide who the most appropriate devices are. To do this, services will have a device that meets the desired requirements and can complete the task at an acceptable quality of service when a device sends a service request, the system uses the user's requirements when a request comes to select the best device service based on the request. After that, combine services, execute them and provide them to the user. After finding, selecting and combining, the user sends services in computing devices or devices with applications tested to know if they have the essential quality of task execution and return to the user. The services, in turn, allow devices to communicate by finding the services through the services search mechanism. This meets the users' requests by choosing the appropriate services to provide. SIoT devices can be grouped into communities to a certain extent to build truthful and effective search methods for services. Instead of the whole network, reducing the search space by detecting communities among SIoT devices and searching for services in less restricted regions is a good idea. The results show that service providers can use their community detection to respond sooner and deliver better outcomes to certain users. A community detection algorithm can detect communities with highly interconnected nodes in a social network.

In this multilayered mode, the proposed architecture consists of four layers; the bottom layer is the physical layer, followed by the relational communities, making the subcommunity layer, the service provision layer, how to find, select and combine services and applications layer, as shown in Figure 1. The subcommunity layer includes community construction, service management, and service requests. First, community detection is layered based on the main factors discussed in Section 4.1, and then the communities are formed, and each community has its relative service. When a request comes to the service management layer, the service discovery starts, selecting and combining the service is done based on the candidate's services and the execution in specific applications, and the final answer is returned. Otherwise, if the services or applications do not exist, the final answer is this task cannot be executed. In the SIoT environment, we introduce the service provision based on the community detection method. The proposed method starts with detecting various relationships in the SIoT network, POR, OOR and SOR, as illustrated by Figure 2. The community detection algorithm partitions the IoT network into smaller communities. Through this first stage, social relations are examined among the IoT devices. Detecting a group of devices with common characteristics and attributes helps in service provision purposes. In the second stage, upon detecting some services a user requested in the standard services provision, the algorithm balances the requested service and the other users' demands. Then, service quality metrics are analyzed to select better services based on user requirements from the discovery stage. This composite service runs on the application created with just the best services expected to form a near-optimal composite service that finally meets all task needs. Once the user gets its executable composite service, the recommendation procedure stops. This way, our method for discovering, selecting, and composing services in an SIoT network is highly effective and efficient to ensure users receive high-quality services.

The relationship between service provisioning and socially detectable community processes is depicted in Figure 8. This comprises service discovery, selection, and composition, and then composed services are executed in the application within detected communities. First, communities are detected using some measures of devices. Every service is specific to the devices in a specific community. The service controller's function is to wait for service requests from users and respond to the request. It contains two Matchmaking Engines (ME). ME Request, as a service activations module for the services provision process; ME Response, an aggregation module in the controller that returns the final composite response to the application to execute on the community's service request and response controller.

In the first step, the Controller receives a request, assigns an ID to each request and keeps them to generate a list of service requests. Whenever a device receives this request, it looks for the list of services to exclude duplicate requests [54, 55]. Every device has ID, Services ID, Application ID, location, and time stamps. The ME Request is in the controller part, along with the requested service complaint from its community service information. Since the ME Request has stored services for it, it can directly move to the community in which the service is located. If the requested service conforms to the services of available communities, then forward the request to the ME in such a community. Otherwise, it states no such service and response to Request ME. Each community has its own ME. Each service contains data about device features (like ID, Services ID, Applications ID, location and time stamp). Since each community is designed to provide services and applications, MEs in communities store information on the communities and device characteristics supporting those services within a specific community. The Controller knows about each community and its corresponding ID; it can be an ID of the service a community provides or the application being presented.

The ME in each community starts by looking for the required attributes of the devices in the community. Among all composite services, IGBSA-CD is used to select the best one. Instead, it returns the best combination of services that can respond to the request. Every community has a service composition at the ME. The communities send the composite services' results to the Request ME. ME Request is responsible for sending the outputs of composition services or, if services do not exist, to ME Response. ME Response check if the ME Request outcomes composite services; it sends to communities and delivers from there into the application; otherwise, it replies to the requester user that the service does not exist. When the application performs the results, they return to ME Response, and then the final executable results are returned to the user's requester.

5.1 Dataset

This article evaluates the proposed algorithms using SIoT devices on real-world datasets in Santander, Spain. The network includes physical components, both private and public devices [8]. Each classification has an object profile, services, and applications in the dataset. Each device may offer one or more applications and services. This article uses three adjacency matrices with ID devices and their relationships. Then, it combined them with the ID service, ID application, position, and time stamp of the device. It randomly chooses three tasks within applications and services. A user asks for details on a particular task. The proper application is required to run the requested task to satisfy users' requirements. Table 3 shows examples of applications with tasks and services [8, 56] used in this article, and Table 4 displays the service ID and their descriptions. Figure 9 shows samples of each required service in tasks that appear in different applications with the ID based on the number of services. Figure 9 shows samples of all the services needed in tasks to execute them in required applications with their ID based on the number of services.

Figure 10 shows how socially connected IoT devices are integrated to offer services and applications to run tasks in the SIoT network. IoT devices rely on different social relationships, which leads to diverse services and applications. Each of these uses the application to run requested tasks from their devices.

This article selects examples from this dataset. Each is a different IoT device and its relations (OOR, POR, SOR) in the SIoT network. These devices provide services and applications that handle various functional aspects of the IoT environment. IoT Device 1 provides Location Service, Environment Service, and Movement Service. The Location Service can be used to track the location of devices. The Service tracks metrics such as air quality and temperature. The Movement Service manages the movement of nearby devices. The Weather Service and Traffic Status Service are offered from IoT Device 2. The Weather Service keeps updated traffic and congestion report service. The Energy Consumption Service and the Street Light Service are used by IoT Device 3. This device is used as an energy consumption service to track their energy usage. The Street Lighting Service executes street luminaires. These IoT devices have different services and applications. For example, Drive Monitoring in IoT Device 4 uses Location, Weather, Traffic Status, Street Light and Movement services to regulate the driving experience better. The Electric Car Charge in IoT Device 6 uses Location, Weather and Energy Consumption Services of IoT service to efficiently command electric car charging stations. IoT Device 7 has a Traffic application to control traffic based on Location, Environment, Traffic Status and Movement Services [8, 56]. Devices with applications that run requested tasks, as in Figure 11. Finally, the users get their results.

5.2 Proposed Community Detection Algorithm Results

In this study, a Community Detection algorithm (CD) has been proposed to reduce search space and the complexity of SIoT networks. The proposed CD is applied over SIoT networks within two random samples of 1000 and 2000 devices (Sample 1000 and Sample 2000) on three adjacency matrices for POR, OOR, and SOR; the elements in each matrix represent an edge. These relations are used to form communities of IoT devices that offer a similar number of services in devices and enable helped networks to discover the individual device quickly for performing the tasks. The CD effectively takes devices and sorts them in order into buckets of the communities that provide an equal number of services. It depends on the idea that servers with similar service counts are responsible for similar responsibilities in the network, making the algorithm work better. This article uses the service count method as a community detection mechanism to achieve network simplification, increase device density, and improve service management efficiency. This helps locate the services that can be used for different tasks.

Whether the results with 1000 and 2000 sample graphs were accurate, in this study, a random graph was constructed for ten devices as an example of clarifying how the algorithm detects the communities. It is the device level, where a device represents each node, and edges are social relationships between devices. Each device serves one or more services. They are grouped in the same community for devices presenting an even number of facilities. It can help service discovery to quickly find users as an example dataset consisting of ten $$$ I{D}_{-} Device\mathrm{s} $$$ and ten $$$ I{D}_{-} Service\mathrm{s} $$$. Figure 12 shows the employment of the proposed CD. Each device has one or more services, and the ID of services ranges from 1 to 10. The equal number of services each device provides belongs to the same community. For example, devices with the same number of services in the same community may offer different services. Communities that did not have devices without services were excluded. Only devices that serve are used in this method.

This analysis compared our algorithm with two traditional clustering methods, K-means, and agglomerative clustering (AC) algorithms. K mean is an implementation of a clustering algorithm in data analysis. The goal is to partition a set of points into k clusters so that the average value of each point is closer to its assigned cluster center. Therefore, K-means can be applied in all adaptive ways, and it is the best way to solve any problem. Due to its centroid-based nature, K-means clustering is scale-dependent and has certain limitations due to the initial selection of centroids leading to different clustering solutions [57]. The AC algorithm is a family of clustering algorithms that build nested clusters by merging and successively grouping the data points based on their similarity. It is a hierarchical Bottom-up approach, i.e., the data points themselves are treated as clusters and then merged by considering one point at a time against all the other points. It can be used with many different distance metrics. Unlike the K-means algorithm, this technique does not need the number of clusters to be predefined prior. It requires computational demand to calculate the distances between clusters for large datasets [58].

Differences in execution time between 1000 and 2000 samples for applying the (CD, AC, and K-means) algorithms are illustrated in Figure 13. For Sample 1000, the proposed CD takes much less time (2.59 s and around 5.99 s are needed for this execution in Sample 2000). It has the slowest runtime compared with other algorithms. For both samples, the execution time for K-means is increased substantially compared with the community detection. Sample 1000: execution time of 2.72 s; for Sample 2000, it grows to around 6.4 s. With the increasing number of samples, the K-means degrades and performs less efficiently. AC takes execution time for Sample 1000 (2.8 s), and for Sample 2000, it takes more than 6.56 s; in both cases, it takes the longest to perform. The proposed CD performs best in execution time for both small and large sample sizes. K-means takes more time to execute than the CD approach and has a lower execution time for small and large sample sizes than AC.

The proposed CD is also better than existing techniques in getting better silhouette scores for both sample sizes. This superiority would suggest that the CD can better separate more similar elements into the same cluster while maintaining a larger contrast between distinct clusters. The CD is strong clustering, resulting in high silhouette scores (above 0.85) for both samples. The silhouette cores were above 0.7 for K-means while above 0.69 for AC methods.

Figure 14 shows the silhouette scores between three clustering methods: CD, AC, and K-means algorithm. It is compared with two different sample sizes: 1000 and 2000. This CD contains the best silhouette scores for both samples. It provides better cluster quality performance and scalability. For both samples, the silhouette score is greater than that of K-means and AC.

Table 5 compares the proposed CD algorithm with K-means and AC algorithms across two different sample sizes (1000 and 2000) by using three measures (execution time, modularity, and silhouette score). The proposed CD algorithm shows a sample execution time of 2.592 for Sample 1000, which is indeed better than K-means (2.728) and AC (2.804) ($$$ -4.985 $$$%, and $$$ -7.56 $$$%) as shown in Table 5. The modularity of the proposed CD algorithm is better than K-means (0.65) and AC (0.675), with the scores for the top clustering being 0.8, equivalent to 23.076% improvement over K-means and 18.518% improvement over AC This suggests that community structure detection has improved ability. The proposed CD algorithm achieves a silhouette score of 0.851, indicating well-defined and distinct clusters, 20.197% improvement concerning K-means (0.708) and 22.799% improvement concerning AC (0.693). With Sample 2000, our proposed CD algorithm execution time is 5.991, which is better than K-means (6.509) and AC (6.563), with improvements of ($$$ -7.958 $$$% and $$$ -8.715 $$$%), respectively. With the proposed algorithm, the modularity score is improved to 0.82 (0.675), which is 21.481% higher than K-means and 17.142% higher than AC. These would indicate its capability to detect strong community structures within larger networks. The silhouette score of 0.871 shows a better clustering quality than K-means (0.726) and AC (0.697), which are (19.972% and 24.964%), respectively. The proposed CD algorithm is more efficient than K-means and AC under both the modularity, execution time, and silhouette score. As a consequence, results show how well both perform through the quality of the community structures found and their ability to scale to networks of various sizes.

5.3 Proposed Service Provision Based on Detected Communities Algorithm Results

This article introduces a new hybrid algorithm that combines the IGBSA-CD. Using a new community detection algorithm, the IGBSA-CD combines the IGA with the backtracking search algorithm (BSA). To measure the performance of IGBSA-CD, this article followed sample sizes from real-world data sets and community detection, randomly applying three specific tasks. The relationship between service provisioning and socially detectable community processes is depicted in Figure 8. The proposed search algorithm is compared with RDPM [60], movement pattern aware routing (MPAR) [61], and QoS Aware [35] algorithms. Resource discovery based on preference and movement similarity (RDPM) uses an object profile to get the object's preference vectors and uses a global positioning system to get movement trajectories. The tracking approaches in three-dimensional coordinates. Communities emerge by fleeing motion and influence neighbors of items exchanged for high forwarding delay [60]. The MPAR approach for social delay tolerant networks facilitates community service discovery. The authors used two types of search schemes, a local search and a Tabu search, and proved that the Tabu search scheme is faster in search efficiency and leads guide relay nodes in comparison with the local search scheme [61]. A quality of service (QoS) aware service discovery algorithm (QoS Aware) is a new method for finding and selecting services that uses GAs and Whale optimization to speed up the decision-making for IoT selection. Compared with the traditional algorithms, it makes it easier to discover services [35].

The average response times of three distributed service discovery algorithms (IGBSA-CD, QoS Aware, MPAR, and RDPM) in two sample sizes (1000 and 2000) are reported in Figure 16. The results show that IGBSA-CD always achieves the minimum response time in both sets of sample sizes, which indicates its high efficiency. RDPM performs response time is larger than that of IGBSA-CD and the QoS Aware service discovery algorithm, but smaller than that of MPAR. QoS Aware algorithm then MPAR shows the best response time throughout the experiment, making it the most inefficient algorithm. As IGBSA-CD is both efficient and scalable concerning the growing number of samples to be indicated as service providers, in such cases, IGBSA-CD is better suited for time-sensitive service discovery tasks.

Success rates of three service discovery algorithms (RDPM, MPAR, QoS Aware, and IGBSA-CD) are shown in Figures 17a, 17b, and 17c. for three tasks and two sample sizes (1000 and 2000). This analysis provides some perspective on the relative success rates of these algorithms. Figure 17a shows that for Sample 1000, the IGBSA-CD outperforms consistently across all three tasks. Specifically, the success rate of IGBSA-CD is more than 94%, and the success rate of MPAR and RDPM is far lower than IGBSA-CD, and RDPM has the lowest success rate in all. A similar pattern is shown in Figure 17b for Sample 2000. The IGBSA-CD performs remarkably well, with success rates of over 94%. MPAR and RDPM show only marginal differences for the larger sample, but their performance is still far behind IGBSA-CD. Success rates for both sample sizes are illustrated in Figure 17c, highlighting the performance differences across the tasks as well as the algorithms. Overall, IGBSA-CD reliably outperforms in every task size and sample size than QoS Aware, MPAR, and RDPM algorithms. The experimental results shows that the advantage of IGBSA-CD over other algorithms is relatively stable, which demonstrates that IGBSA-CD has good robustness and adaptability in different sample sizes.

Our IGBSA-CD is more effective than QoS Aware, MPAR, and RDPM algorithms in attaining high success rates across different sample sizes and tasks. This illustrates well why it is good for service discovery use cases in dynamic environments. In addition, we demonstrate that IGBSA-CD outperforms QoS Aware, MPAR, and RDPM algorithms in terms of multiple success rates and response times, indicating the efficiency of IGBSA-CD. It always reaches the best success rates and provides robust reliability by increasing either tasks or samples. Additionally, IGBSA-CD presents significantly lower response times, making IGBSA-CD capable of handling service discovery processes rapidly and correctly. These features focus, among others, on scalability, flexibility, and suitability for dynamic scenarios in which a high level of efficiency and reliability in service production is required. IGBSA-CD outperforms conventional algorithms, establishing it as a preferred choice for advanced service discovery applications. IGBSA-CD produces even more significantly better results in terms of success rates and response times than QoS Aware, MPAR, and RDPM algorithms. It maintains high success rates and highlights its reliability and robustness in service discovery tasks. The algorithm significantly reduces response times, making it especially well-suited for time-critical applications. These advancements showcase the ability to maximize resource allocation and improve performance, reflecting the effectiveness in addressing service discovery issues within dynamic and intricate settings. This improves IGBSA-CD to be both an effective and efficient algorithm, because the primary objective is always to improve these crucial measures.

According to the simulation results, in terms of search efficiency and average response time, our proposed method performs better than the existing state-of-the-art resource discovery schemes. The ratio of the number of successful services to the overall number of services calculates the success rate of resource discovery. Average response time: the mean time adopted for processes due to a successful service. The search efficiency of the three schemes within the detected communities and community search of samples 1000 and 2000 is evaluated. The MPAR scheme is outperformed by the IGBSA-CD, QoS Aware, and RDPM algorithms in terms of efficiency. Therefore, the success rate of resource discovery of the RDPM scheme is much lower than that of the IGBA-CD algorithm. The IGBSA-CD increases the effectiveness of resource discovery. As simulation results show, the average response time of the MPAR becomes the largest among them. The average time taken is the average time used in arranging alternate targets for different household tasks. Table 6 illustrates the comparison of the performance of the proposed and the existing schemes concerning the average response time of the proposed algorithm in contrast to state-of-the-art service discovery algorithms. Equation (13) is used to compute the improvement in performance of the methods.

In Table 6, we show the average response times (milliseconds) for service discovery algorithms (IIGBSA-CD, QoS Aware, MPAR, and RDPM) considering the different samples (1000 and 2000). The performance of IGBSA-CD concerning QoS Aware, MPAR, and RDPM is indicated by a percentage. For Sample 1000, the response time of IGBSA-CD has significantly improved, being (15 ms, 20.33 ms, 56 ms, and 24.333 ms) compared with QoS Aware service discovery algorithm, MPAR and RDPM, respectively, which enhances ($$$ -26.270 $$$%) for QoS Aware algorithm, ($$$ -73.582 $$$%) for MPAR, and ($$$ -38.895 $$$%) for RDPM. For Sample 2000, IGBSA-CD shows its response time as (33.333 ms), which is ($$$ -28.333 $$$%) better than QoS Aware (response time of 48 ms, $$$ -66.368 $$$%) better than MPAR (response time of 98.666 ms), and ($$$ -37.166 $$$%) better than RDPM (response time of 55 ms). The result shows the unmatched dynamic performance of the IGBSA-CD algorithm in reducing response time for service discovery tasks in comparison with QoS Aware, MPAR, and RDPM algorithms. With increasing sample sizes, the advantage becomes clearer, demonstrating the scalability and applicability of IGBSA-CD for large-scale datasets.

The results in Table 7 show the success rates of the three service discovery algorithms, IGBSA-CD, QoS Aware, MPAR, and RDPM, across three tasks and two sample sizes: 1000 and 2000. Based on a sample size of 1000, the IGBSA-CD successfully resolves tasks 1, 2, and 3 with success rates of 95.05%, 94.06%, and 98.02%), respectively (24.509%, 28.849%, and 24.866%), which are higher than MPAR. It also outperforms QoS Aware, respectively, by (14.518%, 15.694%, and 17.798%) in terms of success rate on the same tasks. It also outperforms RDPM, respectively, by (46.231%, 52.943%, and 48.967%) in terms of success rate on the same tasks. On Sample 2000, the IGBSA-CD outperforms participation in the three tasks, obtaining success rates of (99.01%, 94.06%), and 98.02%) for tasks 1, 2, and 3, correspondingly. It shows enhancement of (18.058%, 17.472%, and 18.238%) over QoS Aware service discovery algorithm. It shows improvements of (26.466%, 21.839%, and 23.607%) over MPAR and (46.899%, 49.302%, and 43.935%) over RDPM. IGBSA-CD consistently achieves the best success rate regardless of both task complexity and sample size, as demonstrated by the result. IGBSA-CD outperforms QoS Awrae, MPAR, and RDPM on all tasks and sample sizes, demonstrating its high efficiency and reliability for service discovery. The significant improvements in success rates highlighted the suitability of the algorithm for SIoT environments, which are also extremely challenging and have made it a top candidate in service discovery.

The effectiveness of IGBSA-CD is illustrated by the fact that it outperformed QoS Aware algorithms, MPAR, and RDPM on several metrics, including success rate and response time. These characteristics (scalability, adaptability) highlight the fact that stateless applications are suitable for dynamic settings, which require high efficiency and reliability while providing services. The attained accuracy of IGBSA-CD is better than the other traditional algorithms and, therefore, proved to be the preferred algorithm, especially in advanced service discovery models. The IGBSA-CD algorithm exhibits improved efficiency with significant improvements under both success rate and response time in comparison with QoS Aware, MPAR, and RDPM. The performance of the proposed algorithms shows that the service discovery task is robust and reliable.

IGBSA-CD fits the best performance scalability on various sample sizes of devices. The results comparison explains that the algorithm retains a high success rate and low response time means that the requests are also managed successfully despite the increase in the number of devices. The same consistency and reliability can be observed by increasing the sample size (1000 and 2000). The results demonstrate that IGBSA-CD is adaptable to different tasks with various types of service requests, has consistently high success rates and is robust in a diverse, dynamic environment. Scalability due to growing device numbers and adaptability over diverse tasks not only advocates for IGBSA-CD's usefulness but also reinforces the viable application of IGBSA-CD in solving the intricacies behind contemporary service discovery systems. Its capacity to exhibit stable behavior over a sequence of circumstances makes it relevant to many real-life environments. A high success rate on different tasks and scenarios indicates that the algorithm efficiently manages diverse services, device configurations and network changes. A significant measure is response time, and performance is optimal in heterogeneous tasks, suggesting the algorithm's capacity to adhere to real-time necessities on these issues despite the distinctive example sizes. The way the algorithm adapts to the specific parameters by tackling the intricacies involved in solving an array of tasks (many services of different types and quantities needed) is well reflected in this event.

This study also compares with four state-of-the-art optimization algorithms the performance of IGBSA-CD: multiobjective genetic algorithm (MOGA) [62], non-dominated sorting genetic algorithm II (NSGA-II) [63], GA [49], and BSA [31]. It has highlighted the improvements in efficacy and scalability of IGBSA-CD across the diverse communities that it captures. Figure 18a shows Task1 within detected communities for Sample 1000 by alignment of the rate of lowest best fitness value over algorithms. The advantage of the IGBSA-CD is it convergences fast and stable. Then, the fitness value of BSA that has low fitness and fast to optimal solutions in the number of generations. It is the second fastest in the stability category. The MOGA's fitness value is slower stabilized than that of BSA and IGBSA-CD. The fourth-ranked NSGA-II algorithm reduces the fitness value but, after some generation, stabilizes on a lower level. The fitness value of GA arrives at its highest last and slowly fluctuates. IGBSA-CD learns low fitness values faster than any algorithm when it stops at the same level, whereas BSA, MOGA, and NSGA-II follow it, followed by GA. Figure 18b ranks the low best fitness value maintenance rate of algorithms to analyze their performance in Task 2 among detected communities for Sample 1000. The IGBSA-CD is the most efficient, establishing its peak early in the generation to close to optimal fitness. Unlike BSA, fitness decreased; the second algorithm converges quickly. Then, MOGA had higher fitness values concerning both IGBSA-CD and BSA. After that, NSGA-II best fitness values. Finally, the major fitness values start getting from GA. Thus, IGBSA-CD is the most efficient regarding low fitness values, followed by BSA, MOGA, NSGA-II, and GA in decreasing order.

Figure 18c displays the speed and consistency algorithms of Task 3 to acquire optimal fitness values as low as possible inside detected communities within Sample 1000 among generations. During the early generations, IGBSA-CD rapidly converged to the minimum fitness values for Task 3 and maintained them. The BSA goes straight to low fitness and stabilizes before finishing. The MOGA is the third fastest in terms of convergence to solutions after BSA and IGBSA-CD. However, the NSGA-II suffers from a decrease in fitness value over time. The final method, GA, significantly lags all other algorithms. As it converges quickly and consistently, it is ranked last as the best fitness values fall slowest. For Sample 1000, in detected communities, for all three tasks, IGBSA-CD performs best with faster and always lower best fitness values than BSA, MOGA, NSGA-II, and GA as their decreasing efficiencies.

Figure 18d shows convergence curves of five algorithms for Task 1 on Sample 2000. The IGBSA-CD is highly efficient at finding near-optimal. Its convergence to a lower fitness value is faster, and once it reaches the lowest, it ends with superior maintenance. BSA is quicker to drop the best fitness values and is the second most efficient method. The fitness of the MOGA goes down slowly. The fourth-ranked NSGA-II has a lower fitness value, although it consumes more generations to stabilize concerning BSA and IGBSA-CD. The GA is also the slowest algorithm to reduce its best fitness values.

Figure 18e also shows the low best fitness values reached by the algorithms and maintained across generations in Task 2 on Sample 2000. IGBSA-CD is the most efficient method because it rapidly achieves near-optimal fitness and holds this down. In contrast, the best fitness value returned by BSA converges fast to a low best. The MOGA is retarded than IGBSA-CD and BSA, which is faster to drop but also remains to achieve a low fitness value. The NSGA-II has a slow decrease in low fitness value in earlier generations, which is more random and less stable than BSA and IGBSA-CD. The slowest fall of the best fitness value is GA. To eventually match those values later in the generations for Task 2 within Sample 2000, IGBSA-CD is the most efficient of all algorithms in terms of speed and ability to achieve/maintain low best fitness values, followed by BSA, MOGA, NSGA-II, and GA.

Figure 18f displays the results of five methods on three tasks in Sample 2000. Fitness values for the IGBSA-CD reduce rapidly to the lowest fitness values compared with other methods. The BSA drops quickly and is the second most effective method over generations. The MOGA demonstrates a similar slow fitness decay but also low values at the end. NSGA-II is ranked after MOGA according to delay convergence. In GA, optimal values of fitness slowly fall. For all three tasks in Sample 2000, IGBSA-CD has the lowest best fitness compared with BSA, MOGA, NSGA-II, and GA.

Figure 19a shows three tasks with low best fitness GBSA-CD for stabilization and optimization quickly. In Task 1, IGBSA-CD can quickly converge to low fitness. The quick descent of Task 2 to low fitness values implies that the algorithm can optimize multiple tasks. It stabilizes rapidly and efficiently. The IGBSA-CD is more efficient in Task 3. It quickly locates and remembers the lowest fitness values. In Sample 1000, IGBSA-CD had the best results in Task 3, Task 2, and Task 1. The IGBSA-CD converges fast on minimizing Task 3 although it has additional services (s5, s6, s8, s9, and s10), while Task 2 includes four services (s1, s5, s8, and s10), and Task 1 contains three services (s5, s6, and s7). The IGBSA-CD has fast convergence and stabilization, with minimum best fitness values for task difficulties. Its performance improvement is due to its scalability and suitability for more complicated optimization.

Figure 19b presents the convergence curves of the IGBSA-CD algorithm in Sample 2000 for three tasks. Task 3 has more services (s5, s6, s8, s9, and s10); it performs exceptionally with this, where the quick drop to minimum fitness values. Similarly, Task 2 takes relatively longer to converge, like in Task 3, due to its complex problem and various combinations of services (s1, s5, s8, and s10). For Sample 2000, IGBSA-CD finds near-optimal solutions and generalizes them across tasks.

The IGBSA-CD performs the same as shown with samples 1000 and 2000 for Task 1 in Figure 20a. It can change the data scale without any impact on stability or convergence. The GBSA-CD for Task 1 has strong stability and consistent fitness values throughout generations for both sample sizes. As illustrated in Figure 20b, the performance of the IGBSA-CD can be observed for both Sample 1000 and 2000 for Task 2, which means that the proposed algorithm can deal with varying sample sizes without affecting its convergence or stability. The IGBSA-CD for Task 2 showed remarkable stability and maintained fitness values across generations in both sample sizes. The IGBSA-CD demonstrated with samples 1000 and 2000 for Task 3, as shown in Figure 20c. It shows robustness even when tested on varying amounts of data at different times and if it shows variation in stability and convergence. The IGBSA-CD for Task 3 is stable, maintains, and has fixed the fitness values for each sample size across generations.

For Sample 1000, Figure 20d shows that the IGBSA-CD algorithm goes well in all three tasks by preserving stable fitness values throughout convergence. It is robustly stable within fitness values for all tasks at 0.2 to 0.3 over generations for Sample 1000. Figure 20e shows the IGBSA-CD for Sample 2000 consistently in all three tasks compared with stability and convergence of fitness values. The fitness values of all tasks have been stable between 0.2 and 0.3 over the generations for different tasks. The IGBSA-CD algorithm on all tasks had strong stability and good performance in stability and convergence in Sample 2000. Figure 20f illustrates the ability of the IGBSA-CD algorithm for all three tasks at both Sample 1000 and Sample 2000. The fitness values for each sample size and task also exhibit similar convergence, which stabilizes at 0.2–0.3 after multiple generations. The IGBSA-CD maintains strong stability and performance on different tasks for both sample sizes.

Figure 21 shows the fitness values where the horizontal axis represents the algorithm type and the vertical axis represents the fitness values. In the general Boxplot diagram, the box is defined from the first to third quartile, and the line dividing the box indicates the median. Fitness is lower; the closer to the higher edge of the box are the median lines, and higher as it is near the lower edge. Where the vertical scale goes down, low in the box is associated with a lower fitness value in the algorithm and high in the box is associated with a higher. The boxplots for Task 1, Task 2 and Task 3 for Sample1000 are presented in Figure 21a–21c, respectively. The boxplots of Task 1, Task 2, and Task 3 for Sample 2000 are shown in Figure 21d–21f, respectively.

Figure 21a shows IGBSA-CD for Task1 is the most successful for smaller fitness values. Figure 21b IGBSA-CD for Task 2 has lower fitness values compared with BSA, MOGA, NSGA-II and GA, same in Figure 21c for Task 3.

Figure 21d for Task1 illustrates the IGBSA-CD has performed better than other algorithms regarding lower fitness values produced by this algorithm. Figure 21e for Task 2 also shows the corresponding fitness values of several compared algorithms. The IGBSA-CD outperforms most of these (as there are notably the lowest fitness values in all cases). Figure 21f for Task 3 shows that IGBSA-CD has achieved the lowest fitness values than BSA, MOGA, NSGA-II, and GA, respectively. Performance by the proposed algorithm under identical operating conditions as all other algorithms and the comparison with BSA, MOGA, NSGA-II, and GA.

Figure 22a shows the IGBSA-CD algorithm in three tasks on Sample 1000. It demonstrates that Task 1 is better with slightly smaller ranges and median. Task 2 shows higher consistency by further narrowing the range of fitness loaded. Task 3 has the most steady and greatest fitness values in contrast to other tasks and a narrower range. The results in the same three tasks by applying IGBSA-CD to Sample 2000 are shown in Figure 22b. The lower impact and median of Task 1 indicate a better performance. Task 2 has a lower fitness value. Task 3 has the best fitness values and results.

Table 8 displays the IGBSA-CD means, standard deviations and variances of fitness values for samples 1000 and 2000 over three tasks. Sample 2000 has a higher mean fitness than sample 1000, which indicated better performance for the larger sample size. Lower standard deviation figures indicate more stable performance. Sample 2000 has standard deviations lower than the Sample 1000. The sample 2000's fitness values are more evenly distributed towards the mean. Lower variance shows consistency in finding the optimal fitness values. This discovery has narrowed the performance variance for most tasks related to Sample 1000 because it is less scattered over time for the larger sample size (Sample 2000).

This combines the mean and standard deviation to plot the number of fitness values around the mean for each task, as illustrated in Figure 23. This is due to lower error bars (less variance and more consistency) in Sample 2000 compared with Sample 1000. The IGBSA-CD algorithm achieves better mean fitness values and lower standard deviations for higher outcome consistency for both samples. The frequency of Sample 2000's reduced variance compared with Sample 1000 would suggest a more reliable achievement of the optimal fitness values.

The success rates of three tasks through five optimization algorithms (IGBSA-CD, BSA, MOGA, NSGA-II, and GA) for Sample 1000 are illustrated in Figure 24a. IGBSA-CD as an algorithm is more efficient, reliable and consistent than existing methods. The performance of BSA on 80% is decent, but by Task 3, it has slowly degraded to 55%. On all tasks, NSGA-II consistently outperforms at a higher than 10% success rate. MOGA for Task 3 has a small increasing success rate of 15%. GA success rates are less than 10%. The most successful algorithms are IGBSA-CD and BSA; NSGA-II, MOGA, and GA have far lower success rates. Figure 24b compares the success rates of three tasks for five optimization algorithms (IGBSA-CD, BSA, MOGA, NSGA-II, and GA) on Sample 2000. The IGBSA-CD algorithm can improve the performance of different tasks with high reliability and substantial success rates, indeed nearly reaching above 90% on all tasks. Furthermore, BSA performs exceptionally well with 65% for Task 1 and even still achieves around 60% for Task 3. MOGA, NSGA-II, and GA show noticeably reduced success rates. The NSGA-II for Task 3 is still lower than 10%. IGBSA-CD demonstrated better performance of all metrics and is more robust than BSA. MOGA, NSGA-II, and GA. Figure 24c shows the performance comparisons on Sample 1000 and Sample 2000 among three tasks using the IGBSA-CD algorithm.

Figure 24c shows the success rate for Task 1 within Sample 1000 lies at 95%, remains there for Task 2, and slightly increases to 96% for Task 3. The success rate for Sample 2000 is for Task 1 (98%), Task 2 (96%), and Task 3 (95%). An excellent success rate for Sample 2000 always is, and it works better when more samples are taken. IGBSA-CD demonstrates high performance under both sample sizes. Both samples maintain a success rate of over 90%, which shows the robustness of the proposed algorithm.

Figure 25a shows that the proposed algorithm is faster among the three services in Task1. With larger sample sizes, BSA indicates speedy response times. Performance at Task 2 includes four services, as shown in Figure 25b. In terms of efficiency, the IGBSA-CD is the fastest. The response times for BSA grow with increasing sample sizes. Figure 25c shows the IGBSA-CD for Task 3, which includes five services, high efficiency compared with the others for complex tasks. Figure 25d shows the response times of all tasks in Sample 1000. The IGBSA-CD performs adequately and preserves the least response time. In Figure 25e, the IGBSA-CD shows better efficiency with Sample 2000, and BSA has the response time growth. The average response time for each algorithm in samples 1000 and 2000 of all tasks is shown in Figure 25f. For Task 1 with three services, the IGBSA-CD demonstrates a significantly lower response time and better efficiency and scalability for both sample sizes (1000 and 2000). The response time of the GA after IGBSA-CD performs better than other methods. NSGA-II and MOGA have high response times as more samples are generated and task complexity increases. Maximum response times for more sample sizes as reported by BSA.

The average response time of IGBSA-CD shows that it is efficient in all three tasks. It also consistently has a lower response time, even when the task is complex. The IGBSA-CD performs the best and is most scalable for all tasks and sample sizes. It is competent to perform well with higher loads and will work on a larger set of samples, as it has complex tasks.

The overall performance analysis of the IGBSA-CD algorithm under different metrics such as (convergence, boxplot of mean and standard deviation, error plots between the standard deviation and mean, success rate, and response time) guarantees the effectiveness, reliability and scalability. Thus, from the analysis of the comparative algorithms algorithm with both sample sizes against multiple performance metrics (convergence, boxplot of mean and standard deviation, error plots between the standard deviation and mean, and success rate), the ranking of their performance from high to low is given by BSA, MOGA followed by NSG-II and then GA. Regarding response time results, the GA had the fastest performance, and the BSA came last, from high to low performance, as well as GA, NSG-II, MOGA, and BSA. The GA ranks second after IGBSA-CD in terms of less response time than other methods. NSGA-II and MOGA have a high response time when the tasks grow in complexity, or this shows a semantic size.

The IGBSA-CD algorithm located optimal or near-optimal solutions with a high success rate. Both sample sizes have quickly converged to their standard fitness values over many generations. The mean fitness of the sample sizes is high, which makes this proposed approach very effective. Both sample sizes result in low standard deviation values, which indicate the consistency of the results of the algorithm. The error plots indicate the algorithm is trustworthy because standard deviations are small for both samples compared with the means. The IGBSA-CD method achieved a success rate above 90% for both samples. At the scale of larger data sizes (Sample 2000), IGBSA-CD more rapidly produces solutions that are near-optimal with success rates over 92%.

The GA and the BSA are used within the proposed IGBSA-CD algorithm based on their performance. This hybrid approach not only achieves a better compromise between the solution quality and execution time but also, by applying the complementary strengths of GA and BSA, overcomes the limitations of alternative optimization methods like MOGA and NSGA-II or stand-alone BSA. The statistics show that IGBSA-CD achieves the highest success rates on multiple tasks with varying composite services and sample sizes, outperforming other algorithms considerably. This is due to the excellent explanatory ability of GAs based on mutation, crossover, and selection, making it possible to generate diverse solutions. The optimal performance of IGBSA-CD is a product of an acceptable combination of BSA's ability to mine and evade local optima adaptively. Also, just comparing response times shows how efficient IGBSA-CD is. BSA shows higher response times than sample sizes increase, but IGBSA-CD remains more efficient than BSA, which further confirms scalability. Other compared algorithms (such as NSGA-II and MOGA) have higher computational indication and slower convergence rates with values shown in factors compared with the fitness plot corresponding configuration.

Standalone GA can suffer from premature convergence, a phenomenon common to search heuristics, and despite having an efficient framework, lacks exploratory diversity, which is necessary for solving a complex problem. We select GA and BSA to constitute the design of IGBSA-CD, providing an efficient, scalable and robust service provisioning solution for the SIoT environment as demonstrated in the experiment. Hence, to adapt to ever-changing requirements, we propose a hybrid approach to combine the advantages of both algorithms, which shows better performance than the existing optimization algorithms.

Consequently, the IGBSA-CD algorithm works fine for both sample sizes. It achieves high task success rates, low response times, and high mean fitness values with low standard deviations, which leads to formally stable solutions. IGBSA-CD scales. IGBSA-CD achieves the best performance and scales well across all experiments, outperforming other methods with significant margins. It is the near-optimal method for larger task complexes as it scales very well with higher loads. IGBSA-CD converges to the lowest best fitness values significantly faster and more reliably across all tasks and smaller and larger sample sizes. The BSA came in the second. The MOGA fitness ratings have been consistently low across generations. However, despite their lower fitness, the NSGA-II stabilized more slowly than the IGBSA-CD and BSA methods. The convergence speed in 100 generations for the GA is the lowest. IGBSA-CD is still the best algorithm of all methods in terms of stability, and it performs slightly better than BSA, MOGA, NSGA-II, and GA. IGBSA-CD is the best algorithm for scalability, and then GA, NSGA-II, MOGA, and BSA follow it. The performance of the IGBSA-CD algorithm is almost scalable, consistent, and efficient in three tasks with two sample sizes. The proposed system is extensively tested and validated using various simulations based on real-world SIoT datasets. The datasets were designed to reflect real-world challenges and scenarios so that the evaluation is realistic and relevant. Sample data: a set holds two different sizes, Sample 1000 (1,000 devices) and Sample 2000 (2,000 devices), for scalability and efficiency evaluation. The samples allowed for an assessment of the system's performance with varying sizes of networks and provided insight into its adaptability and scalability. Simulations were conducted, ensuring computational efficiency and allowing assessment of the system's behavior for moderate hardware specifications. System performance is evaluated by several metrics: execution time, success rate, modularity, presence or absence of silhouette and response time. Execution time is used to evaluate computational efficiency, while the success rate indicates the system's efficacy in service provisioning and community detection. The quality of detected communities is evaluated through Modularity and silhouette score metrics, and response time highlights the system's ability to stably process service requests promptly.

This system's performance comparison is carried out against widely used optimization algorithms that include GA, MOGA, NSGA-II, and BSA. These were compared using metrics such as average response time, modularity and clustering quality. The results showed that the proposed system consistently outperformed current algorithms in scalability, efficiency, and in terms of quality of community detection. The validation process is extensive and considers numerous real-world scenarios. The performance and reliability of the proposed system using various realistic datasets, different sample sizes, and evaluation metrics proved the system to be appropriate for practical applications in real-world SIoT domains such as healthcare, smart cities, and industrial IoT.

For measuring the quality and structure of SIoT networks, a dedicated community detection algorithm that operates on the concept of modularity has been proposed. The results showed the scheme produced higher modularity values compared with existing approaches, thus indicating better community detection quality. The improved community structure enables the implementation of a more efficient and flexible service search paradigm inside the SIoT network. The IGBSA-CD algorithm, derived from this method of community detection, reduces the search space, increasing search efficiency and scalability. The proposed method outperforms the existing schemes in the aspect of average response time, which is much less than other schemes. The proposed CD algorithm as a component can be used in the standard IGBSA-CD algorithm to significantly improve the algorithm performance and effective service provisioning in complex and dynamic environments. Such high modularity values, complemented by shorter response time and smaller search space, make the proposed mechanism highly useful in real-world SIoT settings. The algorithm proposed has good scalability, flexibility, and efficiency, which make it a valid solution for the optimization of the service discovery process in SIoT Networks.

We show that the IGBSA-CD-based approach is efficient for service discovery, selection and composition, allowing us to optimally perform service invocation in large-size and complex SIoT networks. A key proposed aspect of this algorithm is that it allows for community-aware service searches where the system sorts devices in terms of the similarity counts of services to minimize the search space and thus improve overall efficiency. Designed scalable methodologies to handle high-scale networks. Capable of concurrent solution evaluation and fitness computation, which enhances scalability. Because, in most cases, a service implementation is bound to a community of devices instead of an entire network, the configuration system reduces the provisioning search space through time. It also utilizes historical data to speed up the search process, eliminate duplicated calculations and enhance computational efficiency. In allowing the real-time system to absorb devices as they come online within a network and to use connections between devices to update the structure of communities and service associations, the architecture is inherently adaptable and, as such, this represents a core feature of the system.

The key novel aspect of the proposal is integrated into the proposed system together with community-based provisioning and advanced hybrid optimization techniques with a focus on scalability and modularity characteristics. These functionalities and enhancements address some of the major limitations of existing solutions, making the system adaptable for several scenarios of SIoT. It is an excellent and effective base for present IoT ecosystems, which means better calculating effectiveness along with aiding in real-time adjustment. In this work, hybrid optimization combining the IGA with BSA is exploited to take advantage of the effectiveness of each approach. IGA shows effective exploration in terms of preserving the diversity of solutions, avoiding premature convergence, and adapting to changing environments. BSA improves on this further by focusing on exploitation, using historical data to bypass local optima, thus allowing for better solutions down the line. The system is claimed to be more efficient and accurate in dealing with high-dimensional problems and multiobjectives in comparison with classical methods, thanks to this hybrid mechanism for optimization.

This hybrid algorithm manages a crucial balance between the exploration of diverse solution space and the exploitation of the best ones. This balance strengthens the robustness of the algorithm, yielding better convergence and avoidance of local optima, which is significant in the domain of large-scale optimizations. It reduces dependence on control parameters for tuning of parameters, enhancing usability and lessening the computation burden of parameter optimization. Instead of passively updating the communities using a snapshot of information, the system continuously updates the set of communities and reallocates the devices accordingly for efficient real-time operation in rapidly changing environments. As the design of the system is modular and flexible, this increases its potential in different fields of SIoT such as smart cities, healthcare, and industry IoT. All its optimization capabilities for specific work allow it to address unique needs at multiple levels. By incorporating the exploration from IGA to the exploitation from BSA and leveraging historical data, this approach eliminates the need for redundancy in computations and enables faster convergence with adequate accuracy.

One limitation of the performance of this work is mobility and changes in device connections in the real-world scenario. Mobile environments, for example, smartphones and tablets, can break up previous communities by the movement of devices. If a device moves from one community to another due to geographic rearrangements or changes in network topology, it gets assigned to a new community or else becomes unassociated. This adds additional computational overhead for updating the community structure in real time and can lead to decreased efficiency in the algorithm. However, one major drawback is the challenge posed by the algorithm in real-time adaptability for dynamic networks exhibiting rapid fluctuations in device mobility and variations in connectivity. Under these conditions, changes in community structures and reoptimizing service delivery lead to higher latency and computational overhead. A key challenge for this system is communication overhead that occurs as the number of clients and groups grows, which could degrade performance for large-scale deployments. In highly connected networks made up of many connected devices, the computation of similarity elements and compatibility has a high computational cost, resulting in a performance penalty as the number of interactions and associations grows.