A cross-institution global community search method for graph federations

Abstract

The application discloses a cross-institutional global community search method for a graph federation, and aims at the problems of a local view in an existing graph federation, such as a damaged topology, a large high-frequency interaction overhead, and a high degree of statistical deviation caused by overlapping edges. The application generates a pseudo-random identifier through client privacy alignment and constructs a global mapping table. The client uses a pair of masks to add noise to an adjacent vector, and the server side aggregates and eliminates bias through logical binarization to generate a compressed adjacent bitmap. The server side uses degree bucketing to perform cascading stripping calculation of the core number in a compressed state, adopts reverse traversal to construct a global core tree and an inverted index. Finally, the server side matches the index based on a ciphertext request, and the client analyzes the desensitization result to obtain a target community. The application completely eliminates the statistical deviation of overlapping edges, avoids high-frequency ciphertext interaction, and realizes accurate, complete and efficient federated community search under the premise of strictly guaranteeing data privacy.

Description

Technical Field

[0001] This invention belongs to the interdisciplinary fields of federated computing, graph data mining and privacy protection, and specifically relates to a cross-institutional global community search method for graph federation. Background Technology

[0002] In modern data science, graphs, as a fundamental data structure for depicting complex dependencies between entities, are widely used in fields such as social network analysis, financial risk control, and bioinformatics mining. Community search, as one of the core tasks of graph mining, aims to identify subgraph structures from massive graph data that contain a specific set of query nodes and simultaneously satisfy connectivity and high cohesion. Among these, the k-core model has become the most classic technique in community search due to its good structural stability and theoretical interpretability.

[0003] For community search in distributed scenarios, many existing technologies have been explored. Among them, the vertex center iterative scheme proposed in the paper [Montresor A, De Pellegrini F, Miorandi D. Distributed k-core decomposition, IEEE Transactions on Parallel and Distributed Systems, 2012] is representative. It achieves iterative convergence of the global core number through multiple rounds of local state exchange between computing nodes. However, such schemes are naturally based on the premise that "the underlying nodes are absolutely trustworthy and the topology is visible".

[0004] In real-world cross-institutional collaboration scenarios, due to data privacy compliance requirements, graph data is physically isolated among mutually untrusted clients. To address this security risk, the literature [Araki T, Furukawa J. Three-party computation under high-throughput semi-honest secure honest majority, ACM, Conference on Computer and Communications Security, 2016] proposes introducing a secret sharing and obfuscated circuit mechanism to attempt to complete graph structure queries in the ciphertext domain; however, due to the dense network communication interactions and heavy protocol conversion overhead induced by its protocol design, its processing capability is limited to very small-scale graph data and cannot be extended to deep topology mining tasks.

[0005] In summary, achieving accurate and comprehensive community search in a federated graph environment that balances the privacy of multiple parties with high computational efficiency still faces severe technical constraints. Existing technologies have at least the following shortcomings: First, local perspectives disrupt the true graph structure. The local degree observed by a single client is significantly lower than the global true degree. If k-core pruning is performed based solely on local information, core nodes are easily deleted, resulting in the incomplete identification of true cross-domain communities.

[0006] Secondly, frequent interactions can lead to communication disasters. Classical k-core decomposition relies on cascading stripping from the outside in. In traditional distributed or secure multi-party computation (MPC) frameworks, such high-frequency ciphertext or state interactions can cause exponentially increasing communication latency. Furthermore, federated learning schemes tend to be probabilistic in their modeling and cannot meet precise topological constraints.

[0007] Finally, edge overlap leads to inflated statistics and loss of precision. Duplicate edge data often exists across institutions. Existing secure aggregation protocols mostly only support numerical summation, causing overlapping edges to be repeatedly accumulated and node degrees to be inflated. This completely breaks the underlying logic of degree-based stripping, resulting in invalid final query results. Summary of the Invention

[0008] In view of the above problems, in order to overcome the performance bottlenecks of privacy protection and multi-party collaborative computing in graph federation environments, this invention provides a cross-institutional global community search method for graph federations. It securely constructs a deduplicated global compressed graph view through pairwise masking and logical binarization techniques. In the compressed state, it completes the cascading stripping of core numbers and hierarchical index construction offline, and supports lightweight and fast retrieval based on pseudo-random identifiers online. Under the premise of strictly protecting the local topological privacy of each participating party and the original node identity, it achieves accurate, complete and highly scalable global federation community search.

[0009] A cross-institutional global community search method for graph federations includes the following steps: (1) The client performs privacy alignment by mapping the local original node identifier to a unified pseudo-random identifier. The server collects the pseudo-random identifiers of all clients, assigns consecutive integer indices, and builds a global mapping table. (2) The client adds noise to the local adjacency vector using pairwise masking technology. The server aggregates all the noise vectors, eliminates the statistical bias caused by overlapping edges through logical binarization, and then stores them to generate a global compressed adjacency bitmap of the nodes. (3) Based on the global compressed adjacency bitmap, the server uses the degree bucketing mechanism to perform bottom-up cascading stripping in the compressed state and calculate the global core number of all nodes; (4) Based on the global core tree, the server adopts a reverse traversal strategy to dynamically maintain node connectivity and construct a GCT (Global Core Tree) index and an inverted index with containment relationship; (5) The client sends an encrypted query request. The server returns the de-identified target community node set by traversing the GCT index and inverted index based on the global mapping table. The client decrypts the data to obtain the final community.

[0010] Furthermore, the specific implementation of step (1) is as follows: S11. Each client interacts in multiple rounds through the Diffie-Hellman group key exchange protocol to jointly derive a shared session key that is invisible to the server. S12. Each client uses a hash function and a shared session key to perform deterministic mapping on all original identifiers in the local node set, generate a masked set of de-identified identifiers, and upload it to the server. S13. The server performs a union operation on the set of de-identified identifiers submitted by all clients to eliminate duplicate nodes, assigns consecutive integer indices to each unique de-identified identifier in lexicographical order, constructs a global mapping table, and distributes it to all clients. S14. Each client converts the node identifiers in its local adjacency table into corresponding consecutive integer indices based on the global mapping table.

[0011] Furthermore, the specific implementation of step (2) is as follows: S21. For any node, the client constructs a local bit vector based on its local neighbor set, and negotiates with other clients through the Diffie-Hellman protocol to generate pairs of random seeds, and then uses a pseudo-random number generator to generate a consistent mask vector. S22. Before uploading data, the client uses the mask vector to perform noise masking on the local bit vector to generate a mask vector; S23. The server collects all masking vectors and performs modular aggregation. It uses the zero-sum property to cancel masking noise between different clients and restores the global statistical vector representing the number of times the edge appears. S24. The server performs logical binarization on the global statistical vector to generate a global adjacency bitmap, thereby eliminating statistical bias caused by different clients repeatedly storing the same edge. S25. The server divides the global adjacency bitmap into multiple logical data blocks, and adaptively selects an array container, bitmap container, or run-length container for compression encoding based on the sparse distribution of non-zero elements within the block, generating a global compressed adjacency bitmap of the nodes.

[0012] Furthermore, the specific implementation of step (3) is as follows: S31. For any node, the server obtains the initial precise global degree by counting the cardinality of the effective elements in the global compressed adjacency bitmap, puts all node indices into the corresponding degree bucket, and sets the current stripping threshold to the minimum degree of the entire graph. S32. The server checks all degree buckets whose degree is less than or equal to the current stripping threshold, extracts the set of nodes to be removed, assigns the global core count of the nodes in the set to the current stripping threshold, and marks them as removed. S33. For a removed node, the server uses an iterator in the global compressed adjacency bitmap to traverse the indices of all its non-removed neighbor nodes and decrements the degree of these neighbor nodes by 1. S34. If the degree of a neighboring node after the update drops to the current stripping threshold or lower, move it into the corresponding low-order degree bucket and add it to the set of nodes to be removed, and trigger a recursive cascading update and stripping operation. S35. If there are no removable nodes in the current level, increment the current stripping threshold and repeat steps S32~S34 until all nodes are assigned the global core count.

[0013] Furthermore, the specific implementation of step (4) is as follows: S41. The server defines the tree node of GCT as a triple containing a unique identifier, a core level, and a set of connected component nodes, and uses tree edges to depict the inclusion relationship of the contraction of lower-order connected components to higher-order connected components. S42. The server initializes a disjoint-set data structure for dynamically maintaining the connectivity between nodes, and forms each node into an independent set, and buckets all nodes in descending order according to the number of global cores; S43. Following the reverse traversal strategy of decreasing the core level from the largest core level to 0, for each newly activated node in the current level, enumerate its neighboring nodes using the global compressed adjacency bitmap. If the neighboring nodes are also active, perform a merge operation in the disjoint-setup. S44. After completing all merging operations at the current level, if the newly generated largest connected component is formed by merging one or more connected components from the previous level, then establish the corresponding parent-child relationship and generate a GCT. S45. The server attaches the node to the corresponding tree node based on the connected component to which the node ultimately belongs, and generates an inverted index to map the node index to the tree node position.

[0014] Furthermore, the specific implementation of step (5) is as follows: S51. The client receives a query request containing the original set of nodes of interest and the target threshold, performs a hash mapping on the original set of nodes using the shared session key, generates a de-identified query set, and sends it to the server. S52. After receiving the de-identified query set, the server uses a global mapping table to convert it into a set of consecutive integer indexes; S53. The server searches in the inverted index to quickly locate the GCT tree node on which the query node is attached, extracts all node indexes contained in the tree node and all its subtree nodes, forms an accurate query result set and returns it to the client. S54. The client uses the locally stored mapping table from the original identifier to the pseudo-random identifier to identify the real nodes in the query result set that belong to its own local view, thus completing the parsing of the target community results.

[0015] A computer device includes a memory and a processor, wherein the memory stores a computer program and the processor executes the computer program to implement the above-described cross-agency global community search method for graph federations.

[0016] A computer-readable storage medium storing a computer program that, when executed by a processor, implements the above-described cross-agency global community search method for graph federations.

[0017] Based on the above technical solution, the present invention has the following beneficial technical effects: 1. This invention introduces a noise addition and logical binarization mechanism based on pairwise masks. Without revealing the local topology of any participant, it perfectly eliminates the problem of edge duplication caused by cross-organization data overlap, ensuring the absolute accuracy of global degree calculation, thereby realizing accurate and complete global community search.

[0018] 2. This invention innovatively transforms the global graph into a compressed bitmap state and combines it with a degree bucketing mechanism to directly perform bottom-up cascading stripping operations on the server side. This mechanism completely decouples the complex k-core iterative stripping from multi-party interactions, eliminating the frequent ciphertext / state broadcasting in traditional distributed or secure multi-party computations, and significantly reducing the system's communication overhead and synchronization latency.

[0019] 3. This invention abandons the traditional forward real-time stripping approach and uses a reverse traversal strategy to build a global core tree and inverted index containing parent-child hierarchical relationships offline. This reduces the complexity of online community search to lightweight tree-like index matching, greatly improving online response speed while hiding the client's query intent.

[0020] 4. This invention utilizes the Group Diffie-Hellman group key exchange and hash mapping mechanism to negotiate a shared session key that is completely invisible to the server. While generating a unified pseudo-random identifier and achieving logical alignment of heterogeneous graphs, this mechanism fundamentally resists offline frequency inference attacks on the server side, ensuring the high confidentiality of the original entity's identity. Attached Figure Description

[0021] Figure 1 This is a schematic diagram of the cross-organizational global community search method for graph federations according to the present invention. Detailed Implementation

[0022] To describe the present invention in more detail, the technical solution of the present invention will be described in detail below with reference to the accompanying drawings and specific embodiments.

[0023] This embodiment provides a cross-institutional global community search method for graph federations, applied to cross-institutional biomedical knowledge graph and drug target discovery scenarios: assuming there exists Pharmaceutical R&D companies or top research institutions as client participants All parties share a potential global set of biological entity nodes. (such as proteins, genes, compounds, etc.), but only holds core intellectual property information such as experimental target relationships, clinical trial validation data, and metabolic pathway associations that are highly confidential within the institution (i.e., edge sets with blind spots and overlapping interaction records). To identify complex molecular mechanism networks with high biological stability and synergistic effects without disclosing unpublished research data from various institutions and strictly protecting core trade secrets, and to overcome the problems of "underestimation of associated pathway degrees" caused by the limited perspective of a single institution and "statistical overestimation caused by repeated experimental records" in multi-party joint calculations, this example sets up... ,in This refers to a set of seed targets for a complex disease (such as Alzheimer's disease) that have been preliminarily validated by a certain institution. As a global core number stripping threshold that measures the tightness of intermolecular interactions and functional stability, we seek highly condensed cross-mechanisms that satisfy global correlation constraints. -Core Target Function Community; ultimately, under the premise of strictly complying with intellectual property protection and data physical isolation constraints, it accurately locates the key drug synergistic target network hidden in the global underlying layer, providing reliable underlying network mining support for joint innovative drug development and precision medicine solution formulation. The specific implementation process is shown in Figure 1: (1) The client performs privacy alignment by mapping the local original node identifier to a unified pseudo-random identifier. The server collects the pseudo-random identifiers of all clients, assigns consecutive integer indices, and constructs a global mapping table. The specific implementation process includes the following steps: Step S11. Each client interacts multiple times through the Diffie-Hellman group key exchange protocol to jointly derive a shared session key that is invisible to the server. .

[0024] During the system initialization phase, a shared configuration is set. Each client, each client Generate a high-strength random private key locally. Each client Using public generators and large prime numbers Calculate its public key The public key is then broadcast to the network; all clients perform multiple rounds of Diffie-Hellman key exchange calculations based on the received public key; each client independently calculates the exact same shared session key. Due to the discrete logarithm problem, the server cannot derive the key from the public key information exchanged. .

[0025] Step S12. Each client uses the hash function and key. Deterministic mapping is performed on all original identifiers in the local node set to generate a masked set of de-identified identifiers and upload it to the server.

[0026] Client Traverse the set of nodes in its local original graph data For any node Call the keyed hash function (HMAC) and combine it with the key. Calculate its desensitization identifier After the client has mapped all local nodes, it packages and generates a set of de-identified identifiers. The final client Will Send to the server.

[0027] Step S13. The server performs a union operation on all client-submitted de-identification identifier sets to eliminate duplicate nodes, assigns consecutive integer indices to each unique de-identification identifier in lexicographical order, and constructs a global mapping table. And distribute it to all clients.

[0028] The server receives from The set of de-identification identifiers for each client, and the global set of de-identification identifiers. This operation directly eliminates duplicate nodes across organizations in encrypted state. Subsequently, the server-side... All elements are sorted in ascending order according to lexicographical order, and each unique identifier in the sorted list is assigned an auto-incrementing consecutive integer index, i.e. Based on this, a key-value pair mapping relationship is established, and a global mapping table is generated. Then, the mapping table is distributed to all clients.

[0029] Step S14. Each client uses the global mapping table. This converts the node identifiers in the local adjacency list into their corresponding consecutive integer indices.

[0030] The client receives the global mapping table. Then, traverse the local edge set. For any edge First use the key Calculate the de-identification identifier for the corresponding node. and Subsequently, according to the mapping table Query the corresponding integer index to retrieve the original edge. Replace with indexed edges This completes the logical reconstruction of the local graph structure.

[0031] (2) The client adds noise to the local adjacent vectors using pairwise masking technology. The server aggregates all the noise-added vectors, eliminates the statistical bias caused by overlapping edges through logical binarization, and then stores them. The specific implementation process includes the following steps: Step S21. For any node The client bases its local neighbor set. Constructing bit vectors It negotiates with other clients through the Diffie-Hellman protocol to generate paired random seeds, and then uses a pseudo-random number generator to generate a consistent mask vector.

[0032] Client Initialize a length of bit vector All bits are initially set to 0. Traverse the nodes. local neighbor set If there are neighbors Then set the corresponding index position in the bit vector to 1, that is... At the same time, for any two clients on the network... Both parties agree on an independent random seed. And use a pseudo-random number generator (PRG) to generate the corresponding mask vector. Therefore, the client By combining the pairwise masks from all other clients, a composite mask vector is calculated for itself: .

[0033] Step S22. Before uploading data, the client uses a mask vector to add noise to the local bit vector and generate a mask vector.

[0034] Step S23. The server collects all masking vectors and sums and aggregates them. It uses the zero-sum property to cancel masking noise between different clients and reconstructs a global statistical vector representing the number of times an edge appears. .

[0035] Server-side indexing by node Align the mask vectors from all sides and perform a modular aggregation operation: Because pairwise masks have the mathematical property of zero-sum, i.e., summing... At that time, the mask noise was perfectly canceled out, and the final result was obtained. Exactly equal to .

[0036] Step S24. Server-side... Perform logical binarization processing to generate a global adjacency bitmap. This is to eliminate statistical bias caused by different clients repeatedly storing the same edge.

[0037] The server iterates through the global statistical vector. Perform logical judgments on each dimension, if Then let ;like Then let The aforementioned nonlinear mapping effectively eliminates the artificially high degree caused by intersections in multi-party collaboration.

[0038] Step S25. The server will The data is divided into multiple logical blocks. Based on the sparse distribution of non-zero elements within each block, an array container, bitmap container, or run-length container is adaptively selected for compression encoding to generate a globally compressed adjacency bitmap. .

[0039] The server uses a fixed length (e.g.) (bit) will be a high-dimensional sparse bitmap The data is divided into multiple blocks, and the number of valid elements with a value of 1 is counted within each block. If the number of valid elements... The system automatically uses an array container to store only the offsets of non-zero positions; if the number of valid elements... Furthermore, since the data is discretely distributed, the system switches to a bitmap container to support fast bitwise operations; if consecutive 1s form a clear interval structure, the system uses a run-length container for compressed storage. The format ultimately outputs a unified globally compressed adjacency bitmap. .

[0040] (3) The server uses the degree bucketing mechanism to perform bottom-up cascading stripping in the compressed state to calculate the global core count of all nodes. .

[0041] Step S31. The server-side calculates the initial precise global degree. Index all nodes Put it into the corresponding diopter container In, and the current stripping threshold Set as the minimum degree of the entire graph .

[0042] The server uses statistical bitmaps. The cardinality of the valid elements within the node is used to obtain the unbiased, precise global degree of that node. Next, allocate several degree bucket lists in memory. , index each node Press it into the bucket corresponding to its degree. Then, scan all degree buckets, find the index of the smallest degree bucket containing the element, and initialize the current stripping threshold. .

[0043] Step S32. The server checks all degrees that are less than or equal to the current stripping threshold. Degree bucket, extract the set of nodes to be removed , and its global core count Assign the value to the current stripping threshold. It is then marked as removed.

[0044] The server will satisfy all diopter bucket Clear the list, pop all node indices and move them to the queue to be removed. In China. For Each node in Record the global core count calculation result as follows And add the node to the global node state table The status flag has been changed to .

[0045] Step S33. For each removed node The server uses a globally compressed adjacency bitmap. The iterator in the middle traverses the indices of all its neighboring nodes that have not been removed. and the corresponding neighbor nodes degree Subtract 1.

[0046] from Remove a node that has been removed from the queue. Directly compress the global adjacency bitmap of this node. Load a bitmap iterator that can output valid neighbor indices one by one without decompression. Check the neighbors. The state in the global node state table, if not equal to Then, its real-time degree will be decremented: .

[0047] Step S34. If neighboring nodes The updated degree is reduced to the current stripping threshold. If the degree is lower, it is moved to the corresponding lower-order degree bucket and added to the pending queue, triggering a recursive cascading update and stripping operation.

[0048] Determine the degree after the decrease Does it meet the requirements? If satisfied, then the node will be... Remove it from its current higher-order degree bucket and move it into the updated lower-order degree bucket. In the middle, and immediately the node Pressed into this round In the queue, step S33 is retried to achieve a localized, cascading removal of debris until it reaches the queue. It was completely wiped out.

[0049] S35. If there are no removable nodes in the current level, increment the current stripping threshold. Repeat steps S32 to S34 until all nodes are assigned the number of cores. .

[0050] Specifically, when When the queue is empty, it indicates that the threshold has been reached. All unstable nodes have been removed. Now, perform the increment operation. Then, it jumps back to step S32 to perform the next layer check, until the system records that a definite core number has been assigned to all nodes in the graph. Then, the algorithm terminates.

[0051] (4) The server adopts a reverse traversal strategy to dynamically maintain node connectivity and constructs a GCT index and an inverted index with containment relationship.

[0052] S41. Server-side definition of GCT tree nodes For including unique identifiers Core level and connected component node set triples Furthermore, the inclusion relationship of lower-order connected components shrinking towards higher-order connected components is depicted through tree edges.

[0053] Define the data structure of the tree node as N= These represent the unique ID of the tree node, its core level, and the index of all graph nodes contained in that component, respectively. The rule for determining connectivity components is set as follows: if two tree nodes exist... and Satisfying the node set And hierarchy Then the system establishes a path by point to The directional tree.

[0054] S42. The server initializes a disjoint-set data structure for dynamically maintaining connectivity between nodes, and groups all nodes into independent sets according to the number of cores. All nodes are bucketed in descending order.

[0055] Initialize the disjoint-set data structure so that each node in the initial state... Each parent node points to itself; a boolean array of activation states is also initialized. The initial value of all positions is set to Subsequently, based on the core number calculated from the stripping process... Group all nodes into different hierarchical sets: .

[0056] S43. According to the core hierarchy From the highest core level The strategy of traversing in reverse order, decreasing towards 0, for the current level Each newly activated node in Using a globally compressed adjacency bitmap Enumerate its neighbor nodes If neighboring nodes If it is also active, then the merge operation will be performed in the merge set.

[0057] Control core level variables From the system's global maximum number of cores Start by iterating through the layers in descending order until... For the current level set Each node in Update its state in the array to active: Then through bitmap Locate its neighbors If determined Then the merge function of the disjoint-set data structure is called. Logically merge these two nodes into the same connected component.

[0058] S44. After completing all merging operations at the current level, if the newly generated largest connected component is formed by merging one or more connected components from the previous level, then establish the corresponding parent-child relationship and generate the global core tree.

[0059] When the level After processing all nodes, all independent connected sets are extracted using a disjoint-set data structure (union-set data structure). For each connected set, a corresponding tree node is created. = Further testing is needed to determine whether the set contains... Old connected component tree nodes generated at higher levels and above If it is included, then in and Parent-child attachment edges are established between the trees to solidify the tree topology.

[0060] S45. The server attaches the node to the corresponding tree node based on the connected component to which the node ultimately belongs. This process generates an inverted index that maps node indices to tree node positions. .

[0061] Traverse all original node indices Backtrack through the global core tree to find the core level corresponding to the node. The lowest level of the mounting tree node Subsequently, a hash map table, i.e., an inverted index, is built in memory. To support Node location and addressing with time complexity.

[0062] (5) The client sends an encrypted query request. The server traverses the global core tree index and inverted index to return the de-identified target community node set, and the client decrypts it to obtain the final community.

[0063] S51. The client receives the set of original nodes of interest. and target threshold query request Utilizing the shared session key negotiated during the preprocessing phase For the original set of nodes Perform hash mapping to generate a de-identified query set. And send it to the server.

[0064] The client that initiates the query obtains the input query target. ,in For the set of plaintext nodes of interest, the client selects the set. Each node in Use session key Calculate mapping value The de-identified query set is obtained by summarizing. Ultimately, the client will construct the de-identified query object. Send it to the server for processing.

[0065] S52. The server receives the de-identified query set. Then, using the global mapping table Convert it to a set of consecutive integer indices .

[0066] S53. Server-side inverted index The system performs a retrieval process to quickly locate the tree node of the GCT attached to the query node, extracts all node indexes contained in that tree node and all its subtree nodes, and constructs an accurate query result set. And return it to the client.

[0067] Retrieved from the server any index in ,by Cost query inverted index Lock the tree node it is attached to. Next, it is verified whether the tree node meets the target threshold. and verify the collection Does all nodes within the tree belong to the same connected tree branch? If the query constraint is satisfied, the system will... A breadth-first traversal of the subtree is performed from the root downwards. The node indices of all child nodes along the traversal path are extracted and their union is calculated. Finally, the results are packaged into a precise ciphertext set. It is returned to the client that initiated the request via the same route.

[0068] S54. The client uses a locally stored mapping table from original identifiers to pseudo-random identifiers to identify the query result set. The actual nodes belonging to its own local view are used to complete the parsing of the target community results.

[0069] The client receives the de-identified result set sent by the server. Then, it iterates through its own local plaintext nodes and calculates their respective hash indices. The final visible community results are filtered and output using the set intersection operation: .for The remaining unmatched index sequences cannot be parsed for their physical meaning because the client lacks topological mapping data from other participants. This mechanism achieves on-demand availability and unseen visibility of cross-organizational data.

[0070] The above description of the embodiments is provided to enable those skilled in the art to understand and apply the present invention. Those skilled in the art can readily make various modifications to the above embodiments and apply the general principles described herein to other embodiments without creative effort. Therefore, the present invention is not limited to the above embodiments, and any improvements and modifications made to the present invention by those skilled in the art based on the disclosure thereof should be within the scope of protection of the present invention.

Claims

1. A cross-institutional global community search method for graph federations, characterized in that, Includes the following steps: (1) The client performs privacy alignment by mapping the local original node identifier to a unified pseudo-random identifier. The server collects the pseudo-random identifiers of all clients, assigns consecutive integer indices, and builds a global mapping table. (2) The client adds noise to the local adjacency vector using pairwise masking technology. The server aggregates all the noise vectors, eliminates the statistical bias caused by overlapping edges through logical binarization, and then stores them to generate a global compressed adjacency bitmap of the nodes. (3) Based on the global compressed adjacency bitmap, the server uses the degree bucketing mechanism to perform bottom-up cascading stripping in the compressed state and calculate the global core number of all nodes; (4) Based on the global core number, the server adopts a reverse traversal strategy to dynamically maintain node connectivity and construct a GCT index and an inverted index with containment relationship; (5) The client sends an encrypted query request. The server returns the de-identified target community node set by traversing the GCT index and inverted index based on the global mapping table. The client decrypts the data to obtain the final community.

2. The cross-institutional global community search method for graph federations according to claim 1, characterized in that, The specific implementation method of step (1) is as follows: S11. Each client interacts in multiple rounds through the Diffie-Hellman group key exchange protocol to jointly derive a shared session key that is invisible to the server. S12. Each client uses a hash function and a shared session key to perform deterministic mapping on all original identifiers in the local node set, generate a masked set of de-identified identifiers, and upload it to the server. S13. The server performs a union operation on the set of de-identified identifiers submitted by all clients to eliminate duplicate nodes, assigns consecutive integer indices to each unique de-identified identifier in lexicographical order, constructs a global mapping table, and distributes it to all clients. S14. Each client converts the node identifiers in its local adjacency table into corresponding consecutive integer indices based on the global mapping table.

3. The cross-institutional global community search method for graph federations according to claim 1, characterized in that, The specific implementation method of step (2) is as follows: S21. For any node, the client constructs a local bit vector based on its local neighbor set, and negotiates with other clients through the Diffie-Hellman protocol to generate pairs of random seeds, and then uses a pseudo-random number generator to generate a consistent mask vector. S22. Before uploading data, the client uses the mask vector to perform noise masking on the local bit vector to generate a mask vector; S23. The server collects all masking vectors and performs modular aggregation. It uses the zero-sum property to cancel masking noise between different clients and restores the global statistical vector representing the number of times the edge appears. S24. The server performs logical binarization on the global statistical vector to generate a global adjacency bitmap, thereby eliminating statistical bias caused by different clients repeatedly storing the same edge. S25. The server divides the global adjacency bitmap into multiple logical data blocks, and adaptively selects an array container, bitmap container, or run-length container for compression encoding based on the sparse distribution of non-zero elements within the block, generating a global compressed adjacency bitmap of the nodes.

4. The cross-institutional global community search method for graph federations according to claim 1, characterized in that, The specific implementation method of step (3) is as follows: S31. For any node, the server obtains the initial precise global degree by counting the cardinality of the effective elements in the global compressed adjacency bitmap, puts all node indices into the corresponding degree bucket, and sets the current stripping threshold to the minimum degree of the entire graph. S32. The server checks all degree buckets whose degree is less than or equal to the current stripping threshold, extracts the set of nodes to be removed, assigns the global core count of the nodes in the set to the current stripping threshold, and marks them as removed. S33. For a removed node, the server uses an iterator in the global compressed adjacency bitmap to traverse the indices of all its non-removed neighbor nodes and decrements the degree of these neighbor nodes by 1. S34. If the degree of a neighboring node after the update drops to the current stripping threshold or lower, move it into the corresponding low-order degree bucket and add it to the set of nodes to be removed, and trigger a recursive cascading update and stripping operation. S35. If there are no removable nodes in the current level, increment the current stripping threshold and repeat steps S32~S34 until all nodes are assigned the global core count.

5. The cross-institutional global community search method for graph federations according to claim 1, characterized in that, The specific implementation method of step (4) is as follows: S41. The server defines the tree node of GCT as a triple containing a unique identifier, a core level, and a set of connected component nodes, and uses tree edges to depict the inclusion relationship of the contraction of lower-order connected components to higher-order connected components. S42. The server initializes a disjoint-set data structure for dynamically maintaining the connectivity between nodes, and forms each node into an independent set, and buckets all nodes in descending order according to the number of global cores; S43. Following the reverse traversal strategy of decreasing the core level from the largest core level to 0, for each newly activated node in the current level, enumerate its neighboring nodes using the global compressed adjacency bitmap. If the neighboring nodes are also active, perform a merge operation in the disjoint-setup. S44. After completing all merging operations at the current level, if the newly generated largest connected component is formed by merging one or more connected components from the previous level, then establish the corresponding parent-child relationship and generate a GCT. S45. The server attaches the node to the corresponding tree node based on the connected component to which the node ultimately belongs, and generates an inverted index to map the node index to the tree node position.

6. The cross-institutional global community search method for graph federations according to claim 1, characterized in that, The specific implementation method of step (5) is as follows: S51. The client receives a query request containing the original set of nodes of interest and the target threshold, performs a hash mapping on the original set of nodes using the shared session key, generates a de-identified query set, and sends it to the server. S52. After receiving the de-identified query set, the server uses a global mapping table to convert it into a set of consecutive integer indexes; S53. The server searches in the inverted index to quickly locate the GCT tree node on which the query node is attached, extracts all node indexes contained in the tree node and all its subtree nodes, forms an accurate query result set and returns it to the client. S54. The client uses the locally stored mapping table from the original identifier to the pseudo-random identifier to identify the real nodes in the query result set that belong to its own local view, thus completing the parsing of the target community results.

7. A computer device comprising a memory and a processor, wherein the memory stores a computer program, characterized in that: The processor is used to execute the computer program to implement the cross-agency global community search method for graph federation as described in any one of claims 1 to 6.

8. A computer-readable storage medium storing a computer program, characterized in that: When the computer program is executed by a processor, it implements the cross-agency global community search method for graph federation as described in any one of claims 1 to 6.

Images