Social network influence maximization privacy protection method based on zero-knowledge proof

Abstract

The application discloses a social network influence maximization privacy protection method based on zero-knowledge proof and belongs to the technical field of cryptography and social network analysis, and comprises the following steps: constructing a network topology structure of a social network; generating a network commitment based on a Commitment circuit according to the network topology structure; after topological sorting according to the network topology structure, obtaining a final seed node set and a final proof set by using a greedy algorithm; compressing the final proof set by using a tree-shaped proof recursive method to form a final proof; and taking a tuple formed by the final proof, the network commitment, the final seed node set and a final influence diffusion value as a social network influence maximization privacy protection result. The method can provide a verifiable influence maximization calculation result to a third party on the premise that the network structure of the social network is completely private, and ensures efficient operation on an actual social network.

Description

Technical Field

[0001] This invention belongs to the field of cryptography and social network analysis technology, specifically relating to a privacy protection method for maximizing social network influence based on zero-knowledge proofs. Background Technology

[0002] Influence Maximization (IM) is a fundamental problem in social network analysis, aiming to identify a set of seed nodes to maximize the spread of influence. This problem has significant applications in fields such as information dissemination.

[0003] Influence maximization currently faces fundamental challenges in practical deployments: those seeking to maximize influence (such as advertisers, influencers, or third-party analysts) often lack direct access to the underlying social networks. Without sufficient network data, influence maximization becomes a black-box optimization problem, relying on noisy feedback and limited observations. This typically requires expensive online experiments and complex learning methods (such as reinforcement learning-based exploration), leading to significant financial and time costs and suboptimal accuracy due to limited observability and exploration constraints. In contrast, when the underlying network (including its parameters) is available, users can avoid black-box learning and obtain more accurate seed sets at a significantly lower cost if the platform owner, who controls and observes the proprietary network, can run influence maximization on the real graph. However, entrusting influence maximization to the platform owner introduces trust issues. The platform may have an incentive to manipulate results (e.g., favoring certain users or concealing the true influence of others). Furthermore, the network structure itself is private and proprietary, making its disclosure for auditing purposes generally unacceptable. Therefore, real-world influence maximization needs to simultaneously satisfy privacy (the graph must remain hidden) and verifiability (the returned influence maximization results must be correct on the real graph).

[0004] In existing technologies, one type of solution employs differential privacy to protect the underlying social network. Differential privacy methods protect individual privacy by injecting noise, achieving significant success in maximizing the impact of privacy protection. However, their protection mechanism has fundamental limitations: noise injection can lead to biased impact estimation, resulting in a decline in the quality of seed node selection; the allocation of privacy budgets requires fine-tuning, and improper settings can lead to privacy leaks or utility losses; furthermore, the node-level protection granularity of differential privacy cannot meet the requirements of overall graph confidentiality. However, they protect privacy at the cost of decreased accuracy, as the added noise significantly affects the quality of the results. Furthermore, the protection guarantees of differential privacy are often context-dependent, typically operating on a per-node (individual) basis, which is inconsistent with the privacy requirement of keeping the entire network confidential. Another type of solution uses secure multi-party computation (MPC) to provide an alternative, enabling joint computation without revealing private inputs. However, it is designed for different deployment scenarios where both the platform and users hold portions of the data. The classic design of MPC was to solve the data silo problem, where multiple distrustful participants each possess a portion of the data and jointly complete the computation. However, in real-world scenarios where influence is maximized, data is highly centralized. Platforms (such as social media companies) possess complete, proprietary underlying graph structure data, while users (such as advertisers) typically only have query needs (e.g., limitations on the number of seed nodes) and lack actual graph data. Forcing MPC into this scenario leads to redundancy in role allocation and protocol design. Furthermore, both schemes assume platform trustworthiness, even if the underlying social network might be maliciously modified to bias the outcome. MPC's cryptographic guarantees are limited to ensuring privacy during computation and strict adherence to agreed-upon logic, but it completely fails to guarantee the authenticity of the input data. If the platform has commercial motives (e.g., falsifying connectivity of well-known accounts to charge higher advertising fees), it can maliciously tamper with the underlying social network (e.g., adding fake edges or deleting genuine edges) before the data even enters the MPC protocol. MPC schemes are powerless against such malicious input-level manipulation.

[0005] Zero-Knowledge Proofs (ZKPs) are a class of cryptographic protocols that enable a prover to convince a verifier that a proposition is true without revealing any information other than the proposition's validity. Due to their non-disclosure of additional information, this method provides a trustless guarantee. In this setup, the platform (acting as the prover) computes the influence maximization result on an immutable and network-committed social network, then distributes zero-knowledge proofs to demonstrate the result's correctness. Users can then verify the correctness of the result without needing to know any additional information about the network itself. Due to the lack of dedicated zero-knowledge proof support for influence maximization, existing techniques use general-purpose zero-knowledge proof systems (also known as zero-knowledge virtual machines, zkVMs, a virtual machine architecture that transforms general-purpose program execution into provable computation) to prove the correctness of influence maximization. In this approach, the platform implements the influence maximization algorithm in a high-level programming language (such as Rust), compiles it into low-level CPU instructions, and finally simulates these instructions in the zero-knowledge proof circuitry. However, this transformation incurs significant overhead, typically resulting in long proof generation times and large storage requirements.

[0006] Furthermore, existing technologies generally lack a technical solution capable of performing efficient zero-knowledge proofs on large-scale social networks (thousands of nodes) while maintaining strong privacy guarantees and computational feasibility. Therefore, there is an urgent need for an influence maximization technique that can maintain complete privacy of the network structure and provide verifiable computational results, while also operating efficiently on real-scale networks. Summary of the Invention

[0007] The purpose of this invention is to address the above-mentioned problems by proposing a privacy-preserving method for maximizing influence in social networks based on zero-knowledge proofs. This method can provide verifiable influence maximization calculation results to third parties while maintaining the complete privacy of the social network structure, thus ensuring efficient operation in real-world social networks.

[0008] To achieve the above objectives, the technical solution adopted by the present invention is as follows:

[0009] The proposed method for maximizing social network influence and protecting privacy based on zero-knowledge proof includes the following steps:

[0010] S1. Construct the network topology of the social network;

[0011] S2. Based on the commitment circuit, network commitments are generated according to the network topology.

[0012] S3. After sorting the network topology, a greedy algorithm is used to obtain the final set of seed nodes and the final set of proofs, as follows:

[0013] S31. Obtain the topological sort of all nodes in the network topology, traverse all nodes according to the topological sort, and obtain the influence value of the corresponding node based on the FullEval circuit to determine the activation state of each node.

[0014] S32. Initialize both the seed node set and the final proof set to be empty sets. Use a greedy algorithm to obtain the final seed node set and the final proof set. The final proof set includes all the sub-proofs generated by the circuits in each iteration of the greedy algorithm.

[0015] S4. Use a tree-based recursive proof method to compress the final proof set to form the final proof;

[0016] S5, Get Tuples As a result of maximizing social network influence while protecting privacy, among other things... To prove in the end, For network commitment, For the final set of seed nodes, This is the final influence diffusion value, which is the total number of active nodes corresponding to the final seed node set.

[0017] Preferably, the network topology is constructed as follows:

[0018] S11. Representing social networks as directed graphs ,in, For a set of nodes, The set of edges is a node set, each node in the node set has a corresponding threshold, and each edge in the edge set has a corresponding influence weight.

[0019] S12. Obtain the list of incoming edges for each node using the edge-center encoding method. Inbound edge list ,in, Represents a node The set of parent nodes, , For the edge Influence weight;

[0020] S13. Fill the incoming edge list of each node with zeros to form an array of a preset size. The array of incoming edge lists of all nodes forms the network topology.

[0021] Preferably, network commitment , Indicates splicing, Represents a cryptographic hash function. This represents the threshold value for all nodes in the network topology. This is a list of incoming edges for all nodes.

[0022] Preferably, the influence value of a node is calculated as follows:

[0023] Determine the activation status of each parent node in the current node's inbound edge list. Accumulate the influence weights of all active parent nodes on the current node to obtain the current node's influence value. When the influence value is greater than or equal to the corresponding node's threshold, the corresponding node is active. When the influence value is less than the corresponding node's threshold, the corresponding node is inactive. For all nodes with an in-degree of 0, their influence value is 0 by default.

[0024] Preferably, a greedy algorithm is used to obtain the final set of seed nodes and the final set of proofs, as follows:

[0025] S321, Execute the... The corresponding seed node set is obtained through rounds of iteration, k=1~ , To maximize the number of iterations, a random permutation table is generated for all nodes using the PermGen circuit, and a privacy-preserving pruning algorithm is executed on each candidate node in the random permutation table.

[0026] S322. After selecting the candidate node with the largest influence diffusion value using the Select circuit, the RP circuit restores the actual node according to the random permutation table and adds it to the current seed node set. The sub-proofs generated by each circuit corresponding to the current seed node set are then included in the proof set. Return to step S321 and continue until the maximum number of iterations is reached. The final set of seed nodes and the final set of proofs are obtained. The influence diffusion value is the total number of nodes that are active for a given node.

[0027] Preferably, the privacy-preserving pruning algorithm is as follows:

[0028] A Merkle tree is constructed based on the MT circuit for the set of active nodes, and the root hash ρ is calculated. All nodes in the active state constitute the set of active nodes.

[0029] Each candidate node is reconstructed into an actual node using a random permutation table, and a Merkle authentication path for the actual node is generated and verified in the PruneEval circuit. , Represents the actual node leaf index, actual nodes Merkle authentication path, This represents the Merkle tree verification function;

[0030] Determine whether the verification is successful. If it is, it indicates that the candidate node is in an active state, and proceed to step S322. Otherwise, it indicates that the candidate node is in an inactive state. After restoring the candidate node to the actual node using the RP circuit according to the random permutation table, execute the FullEval circuit to obtain the corresponding influence diffusion value.

[0031] Preferably, the PermGen circuit is used to execute the Fisher-Yates shuffle algorithm and the Fiat-Shamir heuristic algorithm sequentially.

[0032] Preferably, the final proof set , , To determine the total number of sub-proofs in the final proof set, To finally prove the first in the set Individual proof.

[0033] Preferably, the tree-based recursive proof method is as follows:

[0034] Each aggregation Each individual proves and verifies: ,in, To verify the function, For recursion width, For the corresponding aggregation of the first Individual proof, , For logical conjunction;

[0035] The process involves aggregating from the bottom up, layer by layer, until a single root proof is generated, which is the final proof.

[0036] Preferably, the topological sorting of all nodes in the network topology is obtained using the Kahn algorithm or the depth-first search algorithm.

[0037] Compared with the prior art, the beneficial effects of the present invention are as follows:

[0038] This invention generates network commitments by acquiring the network topology and threshold parameters of a social network; it then performs a greedy iteration, evaluating the influence diffusion of all candidate nodes in each round and selecting the node with the largest marginal gain to generate several sub-proofs; it compresses all sub-proofs into a single final proof using a tree-based recursive proof method; and outputs the seed node set, influence diffusion value, network commitment, and final proof, verifying the correctness of the result through a single validation. It has the following advantages:

[0039] 1) Global network privacy protection: This invention uses zero-knowledge proof technology, which allows the platform to provide services with maximum influence without disclosing any network structure information, thus achieving global network-level privacy protection, rather than just protecting the privacy of individual nodes. Compared with differential privacy methods that protect individual node information, this invention protects the entire social network structure, and the two have different protection granularities.

[0040] 2) Strong verifiability: Users can verify the correctness of the calculation results through cryptographic methods based on zero-knowledge proofs without trusting the platform, preventing the platform from maliciously manipulating the results or using the wrong network, and providing a trustless guarantee.

[0041] 3) High computational efficiency: This invention decomposes the zero-knowledge proof problem of maximizing influence into multiple parallelizable sub-circuits through compact network representation, topology optimization, privacy-preserving pruning, and tree-structured proof recursion, thereby reducing the originally infeasible fourth-power exponential computational load to a much lower level. The complexity is reduced to a practically manageable scale, enabling social networks with thousands of nodes to generate zero-knowledge proofs within a reasonable time. The proof generation speed is increased by up to 12.19 times, supporting social networks with approximately 2,000 nodes, far exceeding existing MPC schemes (approximately 100 nodes) and general zkVM schemes (approximately 500 nodes).

[0042] 4) High accuracy of results: Based on real social networks, accurate calculations are performed to avoid noise interference introduced by existing differential privacy methods, ensuring the accuracy of results that maximize influence and enabling users to obtain a better set of seed nodes;

[0043] 5) Constant proof size: The tree-based recursive proof method compresses the proof size, which remains constant regardless of the number of sub-proofs. The verification cost is constant, meaning that the verification cost is independent of the input size. The verification time remains constant regardless of the network size, making it suitable for verifiers with limited resources (such as smart contracts).

[0044] 6) High degree of parallelizability: Sub-proofs are generated independently, which can make full use of multi-core processors for parallel computing. The tree-structured recursive proof method allows aggregated nodes at the same level to be processed in parallel, significantly shortening the overall proof generation time. Attached Figure Description

[0045] Figure 1 This is a flowchart of the privacy protection method for maximizing social network influence based on zero-knowledge proof according to the present invention.

[0046] Figure 2 This is a schematic diagram illustrating the peak memory usage of the central processing unit at different scales according to the present invention;

[0047] Figure 3 This is a schematic diagram illustrating the scalability of the present invention in terms of social network size and number of seed nodes;

[0048] Figure 4 This is a schematic diagram illustrating the effect of the privacy-preserving pruning algorithm of the present invention. Detailed Implementation

[0049] The technical solutions of the embodiments of this application will be clearly and completely described below with reference to the accompanying drawings. Obviously, the described embodiments are only some embodiments of this application, and not all embodiments. Based on the embodiments of this application, all other embodiments obtained by those skilled in the art without creative effort are within the scope of protection of this application.

[0050] It should be noted that, unless otherwise defined, all technical and scientific terms used herein have the same meaning as commonly understood by one of ordinary skill in the art. The terminology used herein is for the purpose of describing particular embodiments only and is not intended to limit the scope of the application.

[0051] The method of this invention enables platforms to provide users with verifiable, privacy-preserving computational results that maximize influence without revealing the social network structure, through a mechanism of sequential network commitment, greedy iterative optimization, proof recursion, and final verification.

[0052] Proofreader: A party that possesses private data and needs to prove to the other party that a certain proposition, calculation result, or business logic is true and valid, without disclosing any private data.

[0053] Verifier: A participant who receives the proof generated by the prover and verifies the validity of the proposition, calculation result, or business logic solely through publicly available information and the proof itself, without needing to obtain any of the prover's private data.

[0054] Example 1:

[0055] like Figures 1-4 As shown, the privacy-preserving method for maximizing social network influence based on zero-knowledge proof includes the following steps:

[0056] S1. Construct the network topology of the social network.

[0057] In one embodiment, the network topology is constructed as follows:

[0058] S11. Representing social networks as directed graphs ,in, For a set of nodes, The set of edges is a node set, each node in the node set has a corresponding threshold, and each edge in the edge set has a corresponding influence weight.

[0059] S12. Obtain the list of incoming edges for each node using the edge-center encoding method. Inbound edge list ,in, Represents a node The set of parent nodes, , For the edge Influence weight;

[0060] S13. Fill the incoming edge list of each node with zeros to form an array of a preset size. The array of incoming edge lists of all nodes forms the network topology.

[0061] Specifically, the network topology construction process is as follows:

[0062] 1) Represent social networks as directed graphs ,in, A set of nodes, which includes 1 node Let the set of edges be the nodes in the directed graph. It has corresponding thresholds and edges Associations have corresponding influence weights, and nodes are recorded. threshold ,side Influence weight , ;side Influence weight Represents a node For nodes The degree of influence, the side Represents a node Pointing to node Directed edges, nodes threshold Represents a node The minimum cumulative impact required for activation, the threshold, and the impact weight can be preset by human experience;

[0063] 2) Obtain the list of incoming edges for each node using edge-center encoding. Inbound edge list ,in, Represents a node The set of parent nodes in a directed graph. All pointers to nodes The set of starting nodes of directed edges. , Represents a node Belongs to node The set of parent nodes, For the edge Influence weight;

[0064] 3) Fill the incoming edge list of each node with zeros to form an array of a preset size. The array of incoming edge lists of all nodes forms the network topology.

[0065] Among them, the edge density (the ratio of the actual number of edges to the theoretical maximum number of edges) is... arrive For sparse social networks, an edge-centered encoding method is used to represent the network topology as a list of incoming edges of all nodes. , among which, nodes Inbound edge list Each element in the incoming edge list of a node contains the parent node of the corresponding incoming edge and its influence weight. By using an array of preset size to store the incoming edge list of each node, and using zero padding to maintain structural consistency, the space complexity is reduced from... Reduce to ,in, This represents the maximum in-degree. The list of in-edges is private data owned by the social network platform.

[0066] In this embodiment, for those having =1000 nodes, maximum in-degree In traditional social networks, the network topology requires storing 1000 × 1000 = 1,000,000 elements, while the compact representation (network topology) of this invention only requires 1000 × 50 = 50,000 elements, achieving a compression ratio of 20 times. The incoming edge list of each node is stored as a fixed-length array of 50 elements; if the actual number (length) of incoming edges in a node's incoming edge list is less than 50, it is padded with zeros. This invention employs an edge-centered encoding method, where each node maintains an incoming edge list containing all corresponding parent nodes and their influence weights, stored in an array of a preset size, with zeros used to padded any insufficient edges. The influence weights and thresholds possessed by the social network platform can be represented as a finite field in zero-knowledge proofs. The native elements are directly added and compared without fixed-point number conversion. This utilizes native field arithmetic from zero-knowledge proofs to represent the influence weights and thresholds in the traditional Linear Threshold Model (LT model) as finite fields. It utilizes native elements to avoid the complex fixed-point quantization schemes found in zero-knowledge proofs, eliminates complex fixed-point arithmetic circuits, and maintains a sufficient numerical range to accommodate weight accumulation without overflow. It is suitable for applications such as information dissemination and social networks.

[0067] S2. Based on the commitment circuit, network commitments are generated according to the network topology.

[0068] In one embodiment, the network commits , Indicates splicing, Represents a cryptographic hash function. This represents the threshold value for all nodes in the network topology. This is a list of incoming edges for all nodes.

[0069] Among them, the prover generates network commitments based on the network topology of the social network. The network commitment is generated before all subsequent computations begin (the network commitment is obtained by performing a one-way computation on the network topology and its threshold parameters using a cryptographic hash function), ensuring that all subsequent proofs reference an immutable network snapshot (i.e., the network commitment), preventing retroactive manipulation, and thus protecting network privacy. In other words, the network commitment is bound to the network topology and threshold parameters of the social network, ensuring immutability, satisfying computational concealment and computational binding, protecting the privacy of social network details, and preventing commitment ambiguity.

[0070] S3. After sorting the network topology, a greedy algorithm is used to obtain the final set of seed nodes and the final set of proofs, as follows:

[0071] S31. Obtain the topological sort of all nodes in the network topology, traverse all nodes according to the topological sort, and obtain the influence value of the corresponding node based on the FullEval circuit to determine the activation state of each node.

[0072] In one embodiment, the topological sorting of all nodes in the network topology is obtained using the Kahn algorithm or a depth-first search algorithm.

[0073] In one embodiment, the influence value of a node is calculated as follows:

[0074] Determine the activation status of each parent node in the current node's inbound edge list. Accumulate the influence weights of all active parent nodes on the current node to obtain the current node's influence value. When the influence value is greater than or equal to the corresponding node's threshold, the corresponding node is active. When the influence value is less than the corresponding node's threshold, the corresponding node is inactive. For all nodes with an in-degree of 0, their influence value is 0 by default.

[0075] The algorithm uses the Kahn algorithm or depth-first search algorithm to obtain the topological sort of all nodes in the directed graph, and traverses the nodes according to the topological sort. Based on the FullEval circuit, it determines the activation state of each parent node in the inbound edge list of each node and accumulates the influence weights of all active parent nodes on the current node to obtain the influence value of the current node. When the influence value is greater than or equal to the threshold of the corresponding node, the corresponding node is determined to be in an active state. When the influence value is less than the threshold of the corresponding node, the corresponding node is determined to be in an inactive state. For all nodes with an in-degree of 0, their influence value is 0 by default.

[0076] In this embodiment, leveraging the acyclic structure of social networks (i.e., social networks can be modeled as directed graphs, specifically directed acyclic graphs (DAGs), the Kahn algorithm (a topological sorting algorithm based on in-degree, which sorts nodes by repeatedly removing nodes with an in-degree of 0) or the depth-first search (DFS) algorithm is used for topological sorting. Topological sorting refers to linearly arranging the nodes in a directed acyclic graph (DAG) such that for any edge... ,node The node appears in the sorting. Previously, the influence value of each node was calculated in a single traversal according to the topological sorting order, reducing the computational complexity from... Reduce to Therefore, topological sorting can be calculated directly without affecting the zero-knowledge property.

[0077] Topological sorting ensures that parent nodes are always processed before child nodes in the sorted node list. During subsequent influence value calculation, nodes are traversed in topological sort order. Each node only needs to check the activation status of its parent nodes in its incoming edge list and accumulate their influence weights (i.e., accumulate the influence weights of all activated parent nodes on that node). This can be completed in a single traversal, without multiple iterations. For 1000 nodes (… For a social network with a count of 1000, the computational complexity ranges from... Down to It is reduced by 1000 times.

[0078] S32. Initialize both the seed node set and the final proof set to be empty sets. Use a greedy algorithm to obtain the final seed node set and the final proof set. The final proof set includes all the sub-proofs generated by the circuits in each iteration of the greedy algorithm.

[0079] In one embodiment, a greedy algorithm is used to obtain the final seed node set and the final proof set, as follows:

[0080] S321, Execute the... The corresponding seed node set is obtained through rounds of iteration, k=1~ , To maximize the number of iterations, a random permutation table is generated for all nodes using the PermGen circuit, and a privacy-preserving pruning algorithm is executed on each candidate node in the random permutation table.

[0081] S322. After selecting the candidate node with the largest influence diffusion value using the Select circuit, the RP circuit restores the actual node according to the random permutation table and adds it to the current seed node set. The sub-proofs generated by each circuit corresponding to the current seed node set are then included in the proof set. Return to step S321 and continue until the maximum number of iterations is reached. The final set of seed nodes and the final set of proofs are obtained. The influence diffusion value is the total number of nodes that are active for a given node.

[0082] In one embodiment, the privacy-preserving pruning algorithm is as follows:

[0083] A Merkle tree is constructed based on the MT circuit for the set of active nodes, and the root hash ρ is calculated. All nodes in the active state constitute the set of active nodes.

[0084] Each candidate node is reconstructed into an actual node using a random permutation table, and a Merkle authentication path for the actual node is generated and verified in the PruneEval circuit. , Represents the actual node leaf index, actual nodes Merkle authentication path, This represents the Merkle tree verification function;

[0085] Determine whether the verification is successful. If it is, it indicates that the candidate node is in an active state, and proceed to step S322. Otherwise, it indicates that the candidate node is in an inactive state. After restoring the candidate node to the actual node using the RP circuit according to the random permutation table, execute the FullEval circuit to obtain the corresponding influence diffusion value.

[0086] In one embodiment, the PermGen circuit is used to execute the Fisher-Yates shuffle algorithm and the Fiat-Shamir heuristic algorithm sequentially.

[0087] In one embodiment, the final proof set , , To determine the total number of sub-proofs in the final proof set, To finally prove the first in the set Individual proof.

[0088] Among them, the seed node set is initialized. and the final proof set Π The final set of seed nodes and the final set of proofs are obtained using a greedy algorithm, as follows:

[0089] 1) Execute the first The corresponding seed node set is obtained through rounds of iteration, k=1~ , To maximize the number of iterations, a random permutation table is generated for all nodes using the PermGen circuit. Based on this random permutation table, a privacy-preserving pruning algorithm is executed using the PruneEval circuit. The PermGen circuit is used to sequentially execute the Fisher-Yates shuffle algorithm and the Fiat-Shamir heuristic. The privacy-preserving pruning algorithm performs the following operations:

[0090] Construct a Merkle tree for the set of active nodes and compute the root hash ρ. When evaluating candidate nodes in the random permutation table, for each permutation node... Restore the actual node Generate nodes authentication path , , This represents a permutation mapping, verified in the PruneEval circuit. , Represents a node The leaf index. If the verification passes, it indicates that the node... If the state is active, the FullEval circuit calculation is skipped, consuming only about 36K constraints; if the verification fails, it indicates that the node... In the inactive state, the FullEval+RP circuit is executed (after restoring the candidate nodes to their actual state using the RP circuit based on the random permutation table, the FullEval circuit is executed) to calculate the influence diffusion value of the corresponding node. A Merkle tree is used to provide logarithmic complexity membership proofs, activating the set of nodes. The commitment is for a single public root (root hash) ), through a length of The authentication path proves membership. The Merkle tree implementation includes three core algorithms (MT.Commit function for constructing commitments, MT.Open function for generating membership proofs, and MT.Verify function for verifying membership), specifically: MT.Commit( This is used to construct Merkle trees (such as binary Merkle trees) and output the root hash. MT.Open( , ) used to extract elements and nodes authentication path MT.Verify Used to verify elements Membership.

[0091] Specifically, the relationship between nodes and their activation states (where activation state refers to whether a node has been activated by the influence propagation process, dynamically determined by the influence value) is blurred through a random permutation mechanism. This is achieved by constructing a random permutation table `perm` using a randomly generated one-to-one mapping. → The nodes in the random permutation table are mapped to the original actual nodes, and the nodes are verified using Merkle tree membership proofs. Whether a node belongs to the current set of active nodes; the Merkle tree promises that the root hash ρ encapsulates the set of active nodes from previous iterations, and membership proofs are used to verify without revealing the complete set of active nodes, with a verification complexity of O(n log n). Verify nodes using a Merkle tree. If a node is in the set of active nodes, the influence value calculation is skipped if the verification passes, thus improving efficiency while protecting privacy. When calculating the influence diffusion value, nodes are traversed in topological sorted order. As influence diffusion progresses, the number of active nodes increases, and the benefit of eliminating redundant influence diffusion calculations outweighs the logarithmic overhead. By utilizing a privacy-preserving pruning algorithm to avoid repeated calculations on already active nodes, the overall computational cost is significantly reduced. The final set of seed nodes is obtained through multiple iterations, which corresponds to the determination of the final influence diffusion value. Each iteration generates several sub-proofs, with each circuit corresponding to one sub-proof. Adding the same node repeatedly to the seed node set does not increase the influence diffusion value (i.e., propagation amount), therefore the impact evaluation of already selected nodes can be skipped.

[0092] 2) Using the Select circuit, select the actual node corresponding to the candidate node with the largest influence diffusion value and add it to the current seed node set. Then, include the sub-proofs generated by each circuit corresponding to the current seed node set into the proof set. Return to step S321 and continue until the maximum number of iterations is reached. The final set of seed nodes and the final set of proofs are obtained. The influence diffusion value is the total number of nodes that are active for a given node.

[0093] The circuit selection strategy can be dynamically adjusted according to the proportion of nodes in the active state: when more than 50% of the nodes are in the active state, the PruneEval circuit has a significant cost advantage; when less than 50% of the nodes are in the active state, the FullEval circuit is more efficient.

[0094] In this embodiment, a random permutation table is generated using the Fisher-Yates shuffle algorithm (which achieves uniform random permutation by traversing the array from back to front and swapping the element at the current position with an element at a random position) combined with the Fiat-Shamir heuristic (execution order: first, the Fisher-Yates algorithm is used to generate initial random permutations, then the Fiat-Shamir heuristic is used to convert public parameters into deterministic randomness, ensuring that the permutation result is verifiable and unpredictable). A Merkle tree is constructed for the set of active nodes, and the root hash is calculated. Verification is performed in the PruneEval circuit when evaluating candidate nodes. If the verification passes, it indicates that the node... It is in an active state, i.e., a replacement node. If the state is active, the FullEval circuit calculation is skipped, consuming only about 36K constraints; if the verification fails, it indicates that the node... It is in an inactive state, i.e., a replacement node. In the inactive state, FullEval+RP circuit computation is performed, consuming approximately 2546K constraints. When the proportion of active nodes exceeds 95%, the privacy-preserving pruning algorithm brings significant performance improvements, reducing execution time by 83%.

[0095] By designing modular zero-knowledge proof sub-circuits, such as constructing the following core sub-circuits: A Commitment circuit (commitment generation circuit) is used to generate network commitments based on the network topology of the social network (approximately 280K constraints, where constraints refer to the number of arithmetic constraints in the zero-knowledge proof circuit, determining the proof generation complexity, @1K nodes (corresponding to 1000 nodes)); a PermGen circuit (permutation generation circuit) is used to generate a random permutation table (approximately 1034K constraints); a FullEval circuit (full evaluation circuit) is used to calculate influence values ​​based on topology sorting (approximately 2516K constraints); and a FullEval+RP circuit (which sequentially executes the inverse permutation generation circuit and the full evaluation circuit) combines the random permutation table to calculate... The algorithm consists of several circuits: Influence Value (approximately 2546K constraints); FullEval+RP+MT circuit (which sequentially executes the inverse permutation generation circuit, full evaluation circuit, and Merkle tree circuit) expands the root hash ρ of the active nodes (approximately 11229K constraints); PruneEval circuit (pruning evaluation circuit) verifies whether a node is active using a privacy-preserving pruning algorithm (approximately 36K constraints); Select circuit (node ​​selection circuit) selects the node with the largest marginal gain (approximately 118K constraints); and Select+RP circuit (which sequentially executes the node selection circuit and the inverse permutation generation circuit) is used to select nodes using a random permutation table (approximately 297K constraints). The final proof set includes sub-proofs generated by each circuit in all iterations of the greedy algorithm. These circuits include the Commitment circuit, PermGen circuit, FullEval circuit, MT circuit, PruneEval circuit, Select circuit, and RP circuit. Sub-proofs are the proofs generated by each sub-circuit after each run, and they are generated using the UltraHonk zero-knowledge proof backend within the Noir zero-knowledge proof framework. Alternatively, for encapsulated circuits, such as FullEval+RP circuits, the UltraHonk zero-knowledge proof backend only generates one composite sub-proof, without the need for separate sub-proofs generated by the FullEval circuit and the RP circuit, and the same applies to others.

[0096] The algorithm iterates through several rounds until the maximum number of iterations is reached. Each round includes two steps: influence diffusion assessment and greedy selection. Based on cost analysis, either a FullEval circuit or a FullEval+RP circuit is selected. For nodes in an active state, the PruneEval circuit is used to skip computation. The Select+RP circuit is used to select the optimal node and update the seed node set. The greedy algorithm selects the node that maximizes the marginal gain at each step. By identifying the optimal seed node set, users can maximize influence propagation in a social network at a lower cost.

[0097] S4. Use a tree-based recursive proof method to compress the final proof set to form the final proof.

[0098] In one embodiment, the tree-based recursive proof method is as follows:

[0099] Each aggregation Each individual proves and verifies: ,in, To verify the function, For recursion width, For the corresponding aggregation of the first Individual proof, , For logical conjunction;

[0100] The process involves aggregating from the bottom up, layer by layer, until a single root proof is generated, which is the final proof.

[0101] Among them, a tree-based recursive proof method is used to compress the final proof set. To form the final proof , , To determine the total number of sub-proofs in the final proof set, To finally prove the first in the set Each sub-proof, each node aggregates Each individual proves and verifies: That is, for the current node to be aggregated Each sub-proof is verified by a validation function to prove that it is valid and correct. To verify the function, The first aggregation of the corresponding node Individual proof, , To achieve logical conjunction, the mathematical correctness and logical consistency of the sub-proofs are verified by a bottom-up, layer-by-layer aggregation until a single root proof (i.e., the final proof) is generated.

[0102] Among them, the tree-structured recursive method compresses all sub-proofs into a single final proof. Compared with the linear chain recursive method, it breaks the dependency relationship between adjacent nodes at the same level, making all aggregated nodes at the same level independent of each other and able to generate corresponding proofs in parallel, which significantly improves the proof generation efficiency.

[0103] In this embodiment, the recursion width is set in the tree-based proof recursive method. =2 (i.e., binary tree recursion). For the maximum number of iterations... Round iteration, k=1~ Each round generates =1000 FullEval sub-proofs (zero-knowledge proofs generated by the FullEval circuit) and 1 Select sub-proof (zero-knowledge proof generated by the Select circuit), totaling 10 × 1001 = 10,010 sub-proofs, without considering the random permutation table. All sub-proofs are treated as leaf nodes, and each node aggregates at most... Each sub-proof is verified for correctness, and a parent proof is generated (the parent proof is a single zero-knowledge proof that aggregates multiple sub-proofs, containing a commitment to the correctness of the sub-proofs). Specifically, the first level of aggregation: 10,010 sub-proofs are combined pairwise through a recursive circuit to generate 5,005 proofs; the second level of aggregation: the 5,005 proofs are paired to generate 2,503 proofs (when the number of proofs at the same level is odd, the last proof is directly paired with itself); and so on, generating a single root proof after approximately 13 levels of aggregation. This tree-structured recursive proof method allows nodes (sub-proofs) at the same level to be processed in parallel, aggregating layer by layer from bottom to top, ultimately generating a single root proof π. final On an 8-core processor, it can achieve a speedup of about 6x. The reason why the speedup is lower than the ideal value of 8 is that recursive aggregation has data dependencies, and it is parallel within the layer but serial between layers.

[0104] S5, Get Tuples As a result of maximizing social network influence while protecting privacy, among other things... To prove in the end, For network commitment, For the final set of seed nodes, This is the final influence diffusion value, which is the total number of active nodes corresponding to the final seed node set.

[0105] This invention, based on the network topology and number of seed nodes in a social network, forms a complete zero-knowledge proof process through four stages: network commitment, greedy iterative optimization, proof recursion, and final verification, ultimately outputting the first... Seed node set for round iteration Final influence diffusion value Network commitment and zero-knowledge proof The verifier can also perform a single verification of the privacy protection result for maximizing social network influence (the verifier can run the verification program based on the final seed node set, network commitment, and final proof, and complete the single verification) to confirm its correctness. If the single verification passes, it confirms that the privacy protection result for maximizing social network influence is correct and has not been tampered with, and the requester confirms that the privacy protection result for maximizing social network influence is trustworthy; otherwise, it confirms that the privacy protection result for maximizing social network influence is incorrect, and it is determined that there is tampering or calculation error, and the requester confirms that the privacy protection result for maximizing social network influence is untrustworthy.

[0106] The core of privacy protection for maximizing social network influence based on zero-knowledge proofs lies in ensuring data remains within its domain and that the algorithm is verifiable. The network owner (such as a bank or social platform) compresses their private social network into an irreversible digital fingerprint (final proof). This digital fingerprint (final proof) anchors the authenticity of the original data without revealing any specific social relationships. The network owner runs the method locally, and the circuit records the calculation steps in real time, proving that the prescribed influence calculation logic was strictly executed on the anchored social network. After the calculation is complete, the network owner provides the requesting party with the final seed node set and the final proof set. The requesting party only needs a single verification to be certain that the list is indeed based on evidence and not fabricated, and that no original social connections or the privacy of unlisted users were seen during the calculation process. Essentially, it allows the requesting party to trust the calculation results even without seeing the specific information of the social network.

[0107] Specifically, social networks can serve as networks for disseminating product information, such as the entire social media ecosystem, communication platforms, or student groups, defining a potential audience pool for purchasing activities. Nodes in a directed graph represent consumers (each potential buyer or account in reality). Node states are typically categorized into two types: inactive (haven't bought a product or seen an ad) and activated (have already purchased a product or forwarded an ad). Edges represent social relationships or communication channels (connections between people), such as friends on social media, followers on communication platforms, or colleagues in real life. In a directed graph, edges are usually directed; if user A follows user B, the information flow is from user B to user A. Therefore, there exists a directed edge in the graph pointing from user B to user A (user B can influence user A). Influence weight represents conversion rate, trust level, or influence strength, which is the most critical metric in purchasing activities. It represents the success rate of interactions between nodes. For example, an edge... The weight is 0.3, meaning that if the user Users who purchased and recommended the product There's a 30% chance they'll make a purchase. The seed node set is the initial target audience for the campaign; for example, the brand directly hires them, gives away samples, or reaches the core demographic initially. This is the source of the entire campaign (which could be a well-known account or an opinion leader in a class). Budget constraints (total budget) are considered when identifying the most influential individuals. Each node, such as This refers to the maximum number of spokespeople or KOLs (Key Opinion Leaders) that the brand can afford to hire. The objective function (total market conversions) is the total number of people who ultimately purchase the product or participate in the activity after multiple rounds of dissemination, starting from the seed node (i.e., the expected total number of nodes ultimately activated). ).

[0108] To facilitate understanding and verification of the technical solution of this invention, specific experiments are conducted below.

[0109] First, the network topology of the social network is represented as a compact edge-center encoding format. Then, network commitments are generated. A PermGen circuit is used to generate a random permutation table. Next, a greedy algorithm for iterative influence propagation is executed for several rounds. In each round, the influence diffusion value of all candidate nodes is calculated, and their influence gain is obtained. Based on cost analysis (which compares the number of constraints and computational costs of different circuits and selects the circuit with the lowest total cost), a suitable circuit is selected. The Select circuit is then used to select the node with the largest marginal gain of total influence, i.e., the node with the largest influence diffusion value. Finally, a tree-based recursive proof method is used to compress all sub-proofs into a single final proof π. final Finally, output. For verification purposes.

[0110] This embodiment uses the Noir zero-knowledge proof framework and the UltraHonk zero-knowledge proof backend, providing greater flexibility and better performance, optimized for lightweight proof verification. The cryptographic hash function used is the Poseidon2 hash function (Poseidon2 is a hash function optimized for zero-knowledge proofs, employing a sponge structure for high efficiency in zero-knowledge proof circuits), providing standard security guarantees comparable to the SHA-256 algorithm (including collision resistance, anti-preimage properties, and resistance to second preimages, ensuring the hash value is difficult to forge or tamper with). A finite field is selected. ,in, greater than Prime numbers. Recursion width. It can be configured to 2 to 4 (preferably 2, which can achieve a balance between proof size and parallelism).

[0111] In this embodiment, the method of this invention (the method itself) is tested using the synthetic dataset. On a social network with 1000 nodes, the proof generation time is improved by 12.19 times compared to general zkVM schemes, such as the Risc 0 scheme (baseline 1) and the SP1 scheme (baseline 2), and the verification time remains in the second range. The proof size is constant at approximately several hundred KB (independent of the size of the social network nodes and the number of seed nodes). The maximum supported social network size (number of social network nodes) is approximately 2000 nodes, far exceeding the MPC scheme (approximately 100 nodes) and the general zkVM scheme (approximately 500 nodes). These results demonstrate that the method of this invention is suitable for verifiable, privacy-preserving, influence-maximizing services on social networks. This invention has also been experimentally evaluated using real datasets, such as standard social network datasets (EmailEU dataset and Hamster dataset), achieving performance superior to the baselines (baseline 1 and baseline 2).

[0112] Figure 2 The peak memory usage of the central processing unit (CPU) is shown at different scales. The method of this invention remains below 40GB at 1000 nodes, while the SP1 scheme exceeds 40GB at 100 nodes. Due to the use of CPU instruction simulation, the SP1 and Risc0 schemes cannot complete the IM task (influence maximization task) at 1000 nodes. In contrast, the modular circuit design of the method of this invention can release the sub-proof computation process after the sub-proof is completed, resulting in more efficient memory utilization.

[0113] Figure 3 The scalability of the method of this invention is demonstrated from two dimensions: the number of social network nodes. With the number of seed nodes The left image is fixed. =10, demonstrating the increasing trend in generation time as the number of nodes increases from 100 to 1000. The empirical complexity of the method in this invention is... Superior to the theoretical upper limit Benefiting from the additional advantages of pruning strategies (privacy-preserving pruning algorithms) in practice. In the right-hand diagram, the social network has a fixed 1000 nodes, making... From 5 to 50. Prove that the generation time is approximately linear with respect to... Growth, i.e., complexity is This verifies the modular circuit design of the present invention: each round of greedy iteration has an approximately constant amortized cost under parallel sub-proof. Even in Even when seed nodes account for 5% of the social network, the method of this invention can still complete the proof within 3426 minutes, demonstrating its potential for application in large-scale practice.

[0114] Table 1

[0115]

[0116] Table 1 illustrates the contribution of each circuit module through ablation experiments, corresponding to 100 nodes. =10. The complete adjacency matrix of the social network encounters an OutOfMemory (OOM) error with only 500 nodes, indicating that compact representation (network topology) is a necessary condition. Without topology sorting, the IM task would need to... Repeated round-robin expansion also suffers from memory shortage errors at large scales. Therefore, ablation experiments were conducted on 100 nodes. When compact representation plus topological sorting was used for single-pass propagation, the proof generation time was improved by 413 times (413×). Furthermore, by introducing a random permutation pruning strategy (network topology, topological sorting, and privacy-preserving pruning algorithm, corresponding to the method of this invention) on the basis of compact representation plus topological sorting, the total speedup was improved to 515 times (515×) while maintaining zero knowledge.

[0117] Figure 4 The effect of the pruning strategy in the greedy iteration process was analyzed. The red dashed line represents no pruning evaluation (only the FullEval circuit), the blue solid line represents pruning evaluation (FullEval + RP + PruneEval circuit, i.e., executing the RP circuit, FullEval circuit, and PruneEval circuit sequentially), the gray dashed line corresponds to the method of this invention, and the cyan filled area corresponds to the time saved. In the early iterations (rounds 1-3), there are fewer active nodes, and the additional overhead of the pruning strategy outweighs the benefits. Therefore, the method of this invention uses the FullEval circuit. From round 4 onwards (approximately 3.1% of nodes are active), the PruneEval circuit becomes advantageous; by round 50 (approximately 34.2% of nodes are active), the benefit reaches 27.6%. The adaptive strategy of this invention can further reduce the total proof time by 14.1% compared to always using the standard evaluation (FullEval circuit only).

[0118] It should be understood that each step of the present invention is performed in accordance with Figure 1 The arrows indicate the order in which they are executed, but these steps are not necessarily executed in the order indicated by the arrows. Unless otherwise specified in this document, there is no strict order in which these steps are executed; they can be performed in other orders. Furthermore, Figure 1 At least some of the steps in the process may include multiple sub-steps or multiple stages. These sub-steps or stages are not necessarily completed at the same time, but may be executed at the same or different times. The execution order of these sub-steps or stages is not necessarily sequential, but may be executed in turn or alternately with other steps or at least some of the sub-steps or stages of other steps.

[0119] Furthermore, the privacy protection method for maximizing social network influence based on zero-knowledge proof can also be stored in a storage medium, namely a privacy protection storage medium for maximizing social network influence based on zero-knowledge proof, used to store a computer program. When the computer program is executed by a processor, it implements the privacy protection method for maximizing social network influence based on zero-knowledge proof as in Example 1.

[0120] The zero-knowledge proof-based social network influence maximization privacy protection storage medium (hereinafter referred to as the storage medium) and the processor are directly or indirectly electrically connected to enable data transmission or interaction. For example, these components can be electrically connected to each other through one or more communication buses or signal lines. The storage medium stores a computer program that can run on the processor. The processor implements the zero-knowledge proof-based social network influence maximization privacy protection method in Embodiment 1 of the present invention by running the stored computer program.

[0121] The storage medium includes, but is not limited to, semiconductor storage media, magnetic storage media, and optical storage media; the corresponding memory may include, but is not limited to, Random Access Memory (RAM), Read Only Memory (ROM), Programmable Read-Only Memory (PROM), Erasable Programmable Read-Only Memory (EPROM), and Electrically Erasable Programmable Read-Only Memory (EEPROM). The storage medium is used to store computer programs, and the processor executes the computer programs after receiving execution instructions.

[0122] The processor may be an integrated circuit chip with data processing capabilities. The aforementioned processor can be a general-purpose processor, including a Central Processing Unit (CPU), a Network Processor (NP), etc. It can implement or execute the methods, steps, and logic block diagrams disclosed in Embodiment 1 of this invention. The general-purpose processor can be a microprocessor or any conventional processor.

[0123] The technical features of the above embodiments can be combined in any way. For the sake of brevity, not all possible combinations of the technical features in the above embodiments are described. However, as long as there is no contradiction in the combination of these technical features, they should be considered to be within the scope of this specification.

[0124] The embodiments described above are merely specific and detailed examples of the embodiments described in this application, and should not be construed as limiting the scope of the application. It should be noted that those skilled in the art can make various modifications and improvements without departing from the concept of this application, and these modifications and improvements all fall within the scope of protection of this application. Therefore, the scope of protection of this application should be determined by the appended claims.

Claims

1. A privacy-preserving method for maximizing social network influence based on zero-knowledge proofs, characterized in that: Includes the following steps: S1. Construct the network topology of the social network; S2. Based on the commitment circuit, network commitments are generated according to the network topology. S3. After sorting the network topology, a greedy algorithm is used to obtain the final set of seed nodes and the final set of proofs, as follows: S31. Obtain the topological sort of all nodes in the network topology, traverse all nodes according to the topological sort, and obtain the influence value of the corresponding node based on the FullEval circuit to determine the activation state of each node. S32. Initialize both the seed node set and the final proof set to be empty sets. Use a greedy algorithm to obtain the final seed node set and the final proof set. The final proof set includes all sub-proofs generated by all circuits in each iteration of the greedy algorithm. The greedy algorithm is used to obtain the final set of seed nodes and the final set of proofs, as follows: S321, Execute the... The corresponding seed node set is obtained through rounds of iteration, k=1~ , To maximize the number of iterations, a random permutation table is generated for all nodes using the PermGen circuit, and a privacy-preserving pruning algorithm is executed on each candidate node in the random permutation table. S322. After selecting the candidate node with the largest influence diffusion value using the Select circuit, the RP circuit restores the actual node according to the random permutation table and adds it to the current seed node set. The sub-proofs generated by each circuit corresponding to the current seed node set are then included in the proof set. Return to step S321 and continue until the maximum number of iterations is reached. The final set of seed nodes and the final set of proofs are obtained. The influence diffusion value is the total number of nodes that are active. The privacy-preserving pruning algorithm is as follows: A Merkle tree is constructed based on the MT circuit for the set of active nodes, and the root hash ρ is calculated. All nodes in the active state constitute the set of active nodes. Each candidate node is reconstructed into an actual node using a random permutation table, and a Merkle authentication path for the actual node is generated and verified in the PruneEval circuit. , Represents the actual node leaf index, actual nodes Merkle authentication path, This represents the Merkle tree verification function; Determine whether the verification is successful. If it is, it indicates that the candidate node is in an active state and proceed to step S322. Otherwise, it indicates that the candidate node is in an inactive state. After restoring the candidate node to the actual node using the RP circuit according to the random permutation table, execute the FullEval circuit to obtain the corresponding influence diffusion value. S4. Use a tree-based recursive proof method to compress the final proof set to form the final proof; S5, Get Tuples As a result of maximizing social network influence while protecting privacy, among other things... To prove in the end, For network commitment, For the final set of seed nodes, This is the final influence diffusion value, which is the total number of nodes in the final seed node set that are in an active state.

2. The privacy protection method for maximizing social network influence based on zero-knowledge proof as described in claim 1, characterized in that: The network topology is constructed as follows: S11. Representing social networks as directed graphs ,in, For a set of nodes, The set of edges is a node set, each node in the node set has a corresponding threshold, and each edge in the edge set has a corresponding influence weight. S12. Obtain the list of incoming edges for each node using the edge-center encoding method. Inbound edge list ,in, Represents a node The set of parent nodes, , For the edge Influence weight; S13. Fill the incoming edge list of each node with zeros to form an array of a preset size. The array of incoming edge lists of all nodes forms the network topology.

3. The privacy protection method for maximizing social network influence based on zero-knowledge proof as described in claim 2, characterized in that: The network commitment , Indicates splicing, Represents a cryptographic hash function. This represents the threshold value for all nodes in the network topology. This is a list of incoming edges for all nodes.

4. The privacy protection method for maximizing social network influence based on zero-knowledge proof as described in claim 2, characterized in that: The influence value of the node is calculated as follows: Determine the activation status of each parent node in the current node's inbound edge list. Accumulate the influence weights of all active parent nodes on the current node to obtain the current node's influence value. When the influence value is greater than or equal to the corresponding node's threshold, the corresponding node is active. When the influence value is less than the corresponding node's threshold, the corresponding node is inactive. For all nodes with an in-degree of 0, their influence value is 0 by default.

5. The privacy protection method for maximizing social network influence based on zero-knowledge proof as described in claim 1, characterized in that: The PermGen circuit is used to execute the Fisher-Yates shuffle algorithm and the Fiat-Shamir heuristic algorithm sequentially.

6. The privacy protection method for maximizing social network influence based on zero-knowledge proof as described in claim 1, characterized in that: The final set of proofs , , To determine the total number of sub-proofs in the final proof set, To finally prove the first in the set Individual proof.

7. The privacy protection method for maximizing social network influence based on zero-knowledge proof as described in claim 6, characterized in that: The tree-based recursive proof method is as follows: Each aggregation Each individual proves and verifies: ,in, To verify the function, For recursion width, For the corresponding aggregation of the first Individual proof, , For logical conjunction; The process involves aggregating from the bottom up, layer by layer, until a single root proof is generated, which is the final proof.

8. The privacy protection method for maximizing social network influence based on zero-knowledge proof as described in claim 1, characterized in that: The topological order of all nodes in the network topology is obtained using the Kahn algorithm or the depth-first search algorithm.

Images