Apparatus and method for determining correspondence between two graph networks

Abstract

The present disclosure provides an apparatus and a method for determining a correspondence between two graph networks, the method comprising: identifying a first vector of a data structure that comprises two active elements, wherein first vectors that extend in a direction different from that of second vectors, the numbers of first vectors and second vectors corresponds to the numbers of vertices of the two graph networks, respectively, each element of the data structure corresponds to one vertex of each of the two graph networks, and each active element indicates a possibility of a vertex correspondence between the corresponding vertices of the two graph networks; randomly selecting an active element in the first vector and a second vector; updating another active element in the first vector and another second vector to become inactive; and determining whether the two graph networks corresponds to each other based on the updated data structure.

Description

APPARATUS AND METHOD FOR DETERMINING CORRESPONDENCE BETWEEN TWO GRAPH NETWORKSCROSS-REFERENCE TO RELATED APPLICATION

[0001] This application claims the benefit of priority of Singapore patent application no. 10202401083W, filed on 15 April 2024, the contents of which being hereby incorporated by reference in its entirety for all purposes.TECHNICAL FIELD

[0002] The present disclosure generally relates to an apparatus and a method for processing graph networks, more particularly, for determining a correspondence between two graph networks.BACKGROUND

[0003] A graph (or sub-graph) isomorphism or checking over unlabeled graphs is a nondeterministic-polynomial-complete (NP-complete) computational task in which two graph networks G and H are given as input, and one must determine whether H corresponds to a part of G, or, in other words, G contains a subgraph that is isomorphic to H. In the context of increasing data-driven applications and the growing adoption of graph-based data representation, subgraph-checking solvers have received significant attention, from academic researchers to industry practitioners and government regulators.

[0004] However, the issue of personal data privacy has emerged as a critical concern that could impede the successful deployment of subgraph checking solvers. Organizations are faced with the dilemma that, on the one hand, they are encouraged to provide subgraph checking as a service, but on the other hand, they could potentially be breaching the relevant data privacy regulations. For a more general case, if two participants of subgraph checking using their respective computing devices to perform the subgraph checking are mutually distrustful, standard solvers over plaintext are no longer applicable without a trusted third-party device. In scenarios where such trust assumptions are absent, a privacy-preserving subgraph checking (ppSGC) solver becomes a necessity to confidentially address subgraph checking instances.

[0005] In general, one can enhance the security of an algorithm over plaintext by constructing its oblivious variant using existing two-party computation (2PC) techniques. However, the nature of a subgraph-checking solver makes the conversion challenging. The reason is that the pattern, e.g., the frequency, of executing some 2PC operations may lead to severe leakage of the graph structure.

[0006] There is thus a need for an improved apparatus and an improved method for performing subgraph checking and determining a correspondence between two graph networks from two participants, which can preserve the privacy of the participants, for example, the distinct structures of the two graph networks from being leaked to the other participants, to address the above issues.

[0007] Furthermore, other desirable features and characteristics will become apparent from the subsequent detailed description and the appended claims, taken in conjunction with the accompanying drawings and this background of the disclosure.SUMMARY

[0008] According to a first aspect, the present disclosure provides a host device comprising: identifying one of a plurality of first vectors of a data structure that comprise two or more active elements, the plurality of first vectors extending in a direction different from that of a plurality of second vectors of the data structure, wherein the data structure has a number of first vectors corresponding to a number of first vertices of a first graph network and a number of second vectors corresponding to a number of second vertices of a second graph network, wherein each element of the data structure corresponds to a first vertex of the first vertices of the first graph network and a second vertex of the second vertices of the second graph network, and each active element has a non-zero value indicating a possibility of a vertex correspondence between the corresponding first and second vertices; randomly selecting a first element from the two or more active elements that is in a second vector of the plurality of second vectors of the data structure; updating a second element from the two or more active elements that is in another second vector of the plurality of second vectors to become inactive, wherein each inactive element has a zero-value indicating no possibility of the vertex correspondence between the corresponding first and second vertices; and determining whether the first graph network corresponds to at least a part of the second graph network based on the updated data structure.

[0009] According to a second aspect, the present disclosure provides an apparatus for determining a correspondence between two graph networks, comprising: at least one processor; and at least one memory including computer program code stored thereon and coupled to the at least one processor; the computer program code, when executed by the at least one processor, configured to cause the apparatus at least to: identify one of a plurality of first vectors of a data structure that has two or more active elements, the plurality of first vectors extending in a direction different from that of a plurality of second vectors of the data structure, wherein the data structure has a number of first vectors corresponding to a number of first vertices of a first graph network and a number of second vectors corresponding to a number of second vertices of a second graph network, wherein each element of the data structure corresponds to a first vertex of the first vertices of the first graph network and a second vertex of the second vertices of the second graph network, and each active clement has a non-zero value indicating a possibility of a vertex correspondence between the corresponding first and second vertices; randomly select a first element from the two or more active elements that is in a second vector of the plurality of second vectors of the data structure; update a second element from the two or more active elements that is in another second vector of the plurality of second vectors to become inactive, wherein each inactive element has a zero-value indicating no possibility of the vertex correspondence between the corresponding first and second vertices; and determine whether the first graph network corresponds to at least a part of the second graph network based on the updated data structure.BRIEF DESCRIPTION OF THE DRAWINGS

[0010] In the drawings, like reference characters generally refer to the same parts throughout the different views. The drawings are not necessarily to scale, emphasis instead generally being placed upon illustrating the principles of the invention. In the following description, various embodiments are described with reference to the following drawings, in which:FIGS. 1 A and IB show two illustrative examples of respective adjacency matrices MHand MGof two graph networks H and G , respectively, according to an embodiment of the present disclosure;FIG. 2A shows an example of a graph isomorphism represented by a bijection matrix M representing the two graph networks H and G of FIG. 1 according to an embodiment of the present disclosure;FIG. 2B shows an example matrix representing no vertex correspondence between two vertices of two graph networks;FIG. 3 shows five different exemplary bijection matrices;FIG. 4A shows a flow diagram illustrating an exemplary process of generating a prune matrix MP;FIG. 4B shows a flow diagram illustrating a process of generating possible bijections M by rows, where all values are secretly shared between two participants and operations are performed through conventional two-party computation (2PC) techniques;FIG. 5 shows a block diagram illustrating an apparatus for determining a correspondence between two graph networks according to various embodiments of the present disclosure;FIG. 6 shows a flow chart illustrating a method for determining a graph correspondence between two graph networks;FIG. 7 shows an overview of two processes for determining a correspondence of two graph networks according to some embodiments of the present disclosure, respectively;FIGS. 8A-8I show the initial matrix derived from the two graph networks G and H shown in FIGS. 1A and IB and the respective updated matrices after each step of a process for determining a graph correspondence according to an embodiment of the present disclosure;FIG. 8 J shows a diagram summarizing the process for determining the graph correspondence with respect to the matrices shown in FIGS. 8A-8I;FIGS. 9A to 9D and 10A to 10D show respective graphs illustrating example runtimes for each unit step and one round for varying numbers of vertices n and m of graph networks according to an embodiment of the present disclosure, respectively;FIGS. 1 1 A to 1 1D and 12A to 12D show respective graphs illustrating example communication costs of each unit step and one round for varying numbers of vertices n and m of graph networks according to an embodiment of the present disclosure, respectively;FIG. 13 shows a graph illustrating results of runtime of one round step in milliseconds (ms) on the selected Acquired Immunodeficiency Syndrome (AIDS) dataset for varying n and m using a conventional brute-force approach and the method according to some embodiments of the present disclosure, respectively;FIG. 14 shows a graph illustrating results of runtime of one round step in seconds (s) on the selected GitHub StarGazers dataset using the method according to some embodiments of the present disclosure;FIG. 15 shows examples of a personal data flow graph network and a malware data flow graph network used for social network analysis applications; andFIG. 16 shows examples of a personal protein-to-protein interaction (PPI) graph network and a virus PPI graph network used in bioinformatics applications for analysing biological networks and recurring patterns within the human immunology system.DETAILED DESCRIPTION

[0011] Embodiments described below in context of the apparatus arc analogously valid for the respective methods, and vice versa. Furthermore, it will be understood that the embodiments described below may be combined, for example, a part of one embodiment may be combined with a part of another embodiment.

[0012] It should be understood that the terms “on”, “over”, “top”, “bottom”, “down”, “side”, “back”, “left”, “right”, “front”, “lateral”, “side”, “up”, “down” etc., when used in the following description are used for convenience and to aid understanding of relative positions or directions, and not intended to limit the orientation of any device, or structure or any part of any device or structure In addition, the singular terms “a”, “an”, and “the” include plural references unless the context indicates otherwise. Similarly, the word “or” is intended to include “and” unless the context clearly indicates otherwise.

[0013] The following paragraphs describe a process of determining whether a graph network corresponds to at least a part of another graph network, which is also known as graph isomorphism verification, subgraph checking solver, or solving process over plaintext. A graph network (hereinafter referred to as “graph”) serves as a representation of a collection of interconnected objects, typically expressed as G = (V, E). In this notation, V signifies a set of objects referred to as vertices, while E represents a set of paired vertices, with each element termed as an edge.

[0014] The formal definition of the subgraph checking problem is shown in Question 1, as follows:[Question 1]

[0015] Furthermore, assuming a total order on vertices of a graph, say G, the graph can be specified by an adjacency matrix, say M, whole element specifies the number of connections from vertex i to vertex j.

[0016] FIGS. 1 A and IB show two illustrative examples of respective adjacency matrices MHand MGof two graph networks H and G, respectively, according to an embodiment of the present disclosure. The graph network II has three vertices A, B, C and the adjacency matrix MHof the graph network H is a 3 X 3 matrix with the numbers of row vectors and column vectors corresponding to its number of vertices (i.e., three). The graph network G has four vertices Q, R, S, T and the adjacency matrix Mcof the graph network G is a 4 X 4 matrix with the numbers of row vectors and column vectors corresponding to the number of vertices (i.e., four). Each element of the adjacency matrices MHand MGspecifies whether there is a connection between two vertices within the graph networks H and G , respectively. For example, as vertex A and vertex B are connected in graph network H , the elements corresponding to the connections between vertex A and vertex B at 1strow vector and 2ndcolumn vector, as well as at 2ndrow vector and 1stcolumn vector of the adjacency matrix MHare indicated as non-zero values, for example, values of 1; whereas as vertex B and vertex C are not connected in graph network H, the elements corresponding to the connections between vertex B and vertex C at 2ndrow vector and 3rdcolumn vector, as well as at 3rdrow vector and 2ndcolumn vector of the adjacency matrix MHhave zero value.

[0017] Relying on the representation of adjacency matrices, the sub-graph checking problem for determining whether a graph corresponds to at least a part of another graph and verifying a graph isomorphism can be generalized to Question 2 as follows:[Question 2]

[0018] FIG. 2A shows an example of a graph isomorphism represented by a bijection matrix M representing the two graph networks H and G of FIG. 1 according to an embodiment of the present disclosure. It is noted that the matrix M is a 3 X 4 matrix with a number of row vectors corresponding to a number of vertices of graph network H (i.c., three) and a number of column vectors corresponding to a number of vertices of graph network G (i.e., four). Each row vector represents a different vertex of graph network H and each column vector represents a different vertex of graph network G. As such, each element of the matrix M may correspond or map to one vertex of graph network H and one vertex of graph network G. In this embodiment, as the number of vertices of graph network H is less than then the number of vertices of graph network G representing the column vectors, the matrix M has a lesser number of row vectors than the number of column vectors correspondingly.

[0019] FIG. 2B shows an example matrix 250 representing no vertex correspondence between two vertices of two graph networks. The element highlighted by the dashed-line box corresponds to vertex A of a graph network E and vertex B of graph network F, and the matrix represents the two graph networks E, F. Each element corresponds to a vertex of the graph network E and a graph network F. In this example, the matrix 250 may be an initial all-one matrix and when it is identified or determined that vertex A of graph network E does not correspond to vertex B of graph network F, the corresponding element, illustrated using the dashed-line box in FIG. 2B is updated to become inactive, or ‘0’. Alternatively, if the element is updated to become inactive, this means that there is no possibility of a vertex correspondence between the corresponding vertices in graph network E and graph network F.

[0020] Returning to FIG. 2A, the matrix M defines a bijection if it has one single active element (e.g., with a non-zero value of “1”) in each row vector, mapping the vertices A, B, C of graph network H to the vertices Q, R,S of (a part of) graph network G, as illustrated by arrows 202, 204, 206, respectively. If, for all active elements in the adjacency matrix MHof graph network H shown in FIG. 1, the corresponding elements in a corresponding matrixderived from the bijection matrix Mand the adjacency matrix MGof graph networkG are also active, e.g., also hold as a non-zero value of “1”, a graph correspondence condition is met and this implies graph network H corresponds to at least a part of graph network G, that is, graph network H is a subgraph of graph network G.

[0021] In various embodiments below, an element in a matrix which has a non-zero value corresponds to an active element; and an element in a matrix which has a zero value corresponds to an inactive element. An active element indicates a possibility of a vertex correspondence between the corresponding vertices in the two graph networks forming the bijection matrix and an inactive clement indicates no possibility of a vertex correspondence between the corresponding vertices in the two graph networks forming the bijection matrix. For the sake of simplicity, binary values, either “1” or “0”, are used in a matrix, where the value “1” refers to an active element and the value “0” refers to an inactive element, ft is appreciated that other non-zero value other than 1 may be used instead.

[0022] FIG. 3 shows five different exemplary bijection matrices. In various embodiments below, the matrix is constructed such that the first vectors (e.g., row vectors) refer to vectors that represent the vertices of a graph network that has a lower number of vertices (e.g., graph network 77) thus the number / count of the first vectors is less than the number / count of the second vectors; and the condition of graph correspondence or bijection matrix may be mainly based on the first vectors (e.g., to have at least one single active element in each first vector). It is appreciated that the matrix M may be constructed differently, for example, the first vectors (e.g., row vectors) represent the vertices of graph network G with a higher number of vertices and second vectors (e.g., column vectors) represent the vertices of graph network H . For example, where graph network G (e.g., four) has more vertices than graph network H (e.g., three), the first vectors represent the vertices of graph network G and the second vectors represent the vertices of graph network H, the matrix M would be a 4 X 3 matrix and may define a bijection if it has one single active element (e.g., with a non-zero value of “1”) in each second vector.

[0023] The concept underpinning Question 2 and FIG. 2A gives rise to an approach for building a subgraph checking solver, which involves searching through all potential bijection matrices M, for example, using brute-force search, and subsequently verifying whether the corresponding matrix M' conforms to the graph correspondence condition.

[0024] Typically, one can generate potential bijections by examining row vectors and column vectors. An approach to protecting the privacy of the matrix values, “0” or “1” can be achieved by secretly sharing between two participants (e.g., computing devices, each configured to provide one of the graph networks and perform subgraph checking) and performing the generation through general secure two-party computation (2PC) techniques, which involves two parties, Poand jointly evaluating functions while keeping theirrespective inputs private through cryptographic techniques, such as binary garbled circuits built from oblivious transfer and encryption primitive.

[0025] FIG. 4A shows a flow diagram illustrating an exemplary process of generating a prune matrix MP. Pruning techniques may be employed to reduce the search space, which involves replacing some “1” with “0” in the initial matrix MI, i.e., an all-ones matrix, based on heuristics derived from input graphs. According to an embodiment of the present disclosure, a prune step may be carried out to reduce the search space based on respective degrees of vertices of graph networks computed by two parties, which will be described in further detail in FIG. 8B below.

[0026] FIG. 4B shows a flow diagram illustrating a process of generating possible bijections M by rows, where all values are secretly shared between two participants, and operations are performed through conventional 2PC techniques. The process may start from a pruned matrix MPwhich has been pruned from the initial matrix as illustrated in FIG. 4A.

[0027] In step (a), all possible vectors by row are identified, each possible vector referring to a possible vertex correspondence between a vertex of a graph and a vertex of another graph, where there is only a single active element or “1” in a row vector. Referring to Mp. as there is already a single active element “1” in the 1strow vector (row 1), there is only one possible vector for row 1. For 2ndrow vector (row 2), there are three possible vectors, and for 3rdrow vectors (row 3), there arc also three possible vectors. In step (b), all the possible vectors from each row are combined to form possible bijection matrices, each possible bijection matrix referring a possible graph correspondence between a graph and at least a part of another graph. Referring to MP, 9 different matrices may be constructed from the possible vectors. In step (c), unsatisfied matrices are removed based on the constraints that each row and column must contain only a single “1” to be a bijection matrix, and as a result, six possible bijection matrices M may be found from MP.

[0028] However, the execution patterns of specific 2PC operations as shown in FIG. 4B can result in leakage of the graph network structure. In particular, even when operations are conducted using 2PC technique in step (b), some information is leaked. Considering the following information is known to both participants: the number of vertices, i.e., graph network H has three vertices and graph network G has four vertices; the pruning method is used based on degree, and there is only one possible vector for row 1, while there are three possible vectors for row 2 and row 3. From the perspective of the participant in possession of graph network H, the following inferences can be made: (i) the maximum degree of a vertex in graph network Gis 3; (ii) in graph network G, there is only one vertex with a degree of at least 2; and (iii) among the vertices of graph network G, three of them have a degree of 1.

[0029] Hence, relying on the aforementioned three inferences, it becomes possible for the participants in possession of graph network H to reconstruct the distinctive structure of graph network G, and leads to substantial leakage of the graph structure. The extent of leakage in larger-scale subgraph-checking scenarios can become even more intricate.

[0030] Subgraph checking may be used in (i) network security applications to identify specific patterns or subgraphs that may indicate malicious activity, such as known attack patterns or a network intrusion; (ii) bioinformatics to analyse biological networks and identify recurring patterns or motifs within complex biological systems to understand biological processes and interactions, and (iii) social network analysis to analyze social network structure, identify common activity patterns or communities within the large social network and aid in targeted advertising or content recommendations. FIG. 15 shows examples of a personal data flow graph network and a malware data flow graph network used for social network analysis applications. FIG. 16 shows examples of a personal protcin-to-protcin interaction (PPI) graph network and a virus PPI graph network used in bioinformatics applications for analysing biological networks and recurring patterns within the human immunology system. All such applications require graph correspondence and isomorphism determination but at the same time may contain trade secrets and confidential information which the parties or data owner would wish to keep it to themselves, especially when they need to employ different parties or compare networks of different parties to process their data and graph to identify patterns of their interest.

[0031] Considering that graphs may contain sensitive information, studies have delved into privacy-preserving subgraph checking protocols to enable secure computations over graph data without compromising sensitive information.

[0032] The existing methods may rely on cryptographic techniques like homomorphic encryption or secure multi-party computation. For example, Fan et al. designed a structurepreserving subgraph checking method based on a public-key based cyclic group encryption in “Structure-Preserving Subgraph Query Services”, IEEE Transactions On Knowledge And Data Engineering, vol. 27, no. 8, pp. 2275-2290, 2015.” Zuo ct al. employed Bonch-Goh-Nissim homomorphic cryptosystem to allow cloud server to perform privacy-preserving subgraph checks for query users in “Privacy-Preserving Subgraph Matching Scheme With Authentication In Social Networks”, IEEE Transactions On Cloud. Computing, vol. 10, no. 3, pp. 2038-2049, 2020. Xu et al. encoded graphs as polynomials and encrypted them usingPaillier crypto system, allowing a verifier to perform an oblivious polynomial evaluation for subgraph checking in “Privacy Preserving Subgraph Matching Protocol For Two Parties”, International Journal of Foundations of Computer Science, vol. 30, no. 4, page 571-588, 2019. Ge et al. employed an order-revealing encryption technique with two non-colluding cloud servers for subgraph checking in “Privacy-Preserving Graph Matching Query Supporting Quick Subgraph Extraction”, IEEE Transactions On Dependable And Secure Computing, 2023. However, existing studies mainly focus on labeled graphs, where additional data complexities and privacy concerns may arise due to the need for explicit identifying labels. To address this issue, the present disclosure introduces the first privacy-preserving subgraph checking (ppSGC) solver, more particularly, for unlabeled graphs, which may extend the applicability of privacy-preserving graph algorithms for secure data analysis in environments where labeling data is impractical or privacy-invasive.

[0033] There is thus a need for an improved apparatus and an improved method for processing graph networks, performing subgraph checking, and determining a graph correspondence that can preserve the privacy of the participants, for example, the distinct structures of the graph networks from being leaked to the other participants.

[0034] Various embodiments according to the present disclosure describe a data-oblivious approach to conceal the execution patterns of 2PC operation to determine a correspondence between two graph networks. The design integrates secure two-party computation and oblivious algorithms in a backtrack-searching style with the plaintext solver to achieve privacypreserving subgraph checking.

[0035] Overall, to enable privacy-preserving exploration and verification in the search space, the general idea of our protocol is to first perform a privacy-preserving pruning algorithm to reduce the search space of possible bijection matrices and iteratively explore each possibility in a manner that maintains data and graph structure obliviousness to verify the isomorphism. To achieve this protocol, the following unit steps may be carried out: (i) Prune, (ii) Search, (iii) Decision, (iv) Propagation, (v) Check, and (vi) Backtrack. These unit steps are strategically combined into a round step in a data-oblivious manner, ensuring the attainment of execution pattern obliviousness in the processing method. In particular:• Prune: heuristically replacing some “1” with “0” in the initial matrix MIi.e., an all- ones matrix, based on degrees computed by respective participants in possession of the graph networks or heuristic derived from input graph to reduce the search space;• Search: scans the pruned matrix to find a row that only contains a single " 1 " and returns "l"’s index (i,j), indicating that vertex Vtin H maps to vertex Vj in G.• Decision: scans the pruned matrix to find a row that contains multiple "l"s and returns a randomly selected "l"’s indexindicating that vertex vi in His guessed to be mapped to vertex Vj in G.• Propagation: once a vertex correspondence between Viand Vj is determined, it is used to exclude the cases of other vertices in Hand G being mapped to these two vertices. This involves updating the values in row i and column j of the matrix to 0, except for position• Check: computes M!and checks the isomorphism according to Question 2 above when a possible bijection matrix is found.• Backtrack: backtracks to the point just before the last decision made and facilitates exploring other possible bijection matrices when the current bijection matrix does not satisfy subgraph isomorphism.

[0036] The Search, Decision, and Propagation steps are executed in each iteration to map each vertex in H to the respective vertex in G and trigger a Check step when a possible bijection matrix is found. If the verification is true, the process terminates. Otherwise, the Backtrack step is carried out to return to other possible bijection matrices, for example, the other possible bijection matrices that are not selected in the last Decision step. As the Search and Decision steps are executed in each iteration, the number of calls to the Search and Decision steps would not be known by other participants. Additionally, the result is determined from their returns according to a given priority, which then serves as an input of the Propagation step, the exact step being called is also hidden. In addition, integrating Check and Backtrack steps with the Search, Decision, and Propagation steps and employing an oblivious stack permit privacypreserving backtracking therefore further obfuscating the number of checks and backtrackings that have been called. Consequently, a round step comprising the Search, Decision, Propagation, Check, and Propagation ensures pattern obliviousness, and as such a round step is iteratively executed, a privacy-preserving method that an apparatus can execute for determining a correspondence between two graph networks, solving subgraph checking and verifying graph isomorphism is formed.

[0037] Standard 2PC techniques may be employed, wherein P0and P1,representing the two parties involved, utilize fundamental 2PC primitives such as binary garbled circuit (GC)constructed from oblivious transfer (OT) and encryption primitives. The two parties jointly evaluate functionalities constituting the subgraph-checking problem solver. The design ensures a fixed order of these functionalities, up to the length of the execution. After the protocol is fully executed, the final outputs can be revealed to either one or both parties.

[0038] Furthermore, the access patterns over all intermediary values arc data-oblivious, signifying that they are either fixed or randomized independently of the private protocol inputs. These intermediary values are securely stored and distributed between the two parties, ensuring information-theoretic security. This privacy preservation is accomplished using additional encryption primitives such as oblivious stack and random value samplers.

[0039] An oblivious stack is a data structure designed to maintain a sequence of elements while preserving privacy and ensuring data obliviousness. It is applied to manage the search space of possible bijection matrices. The following operations for the oblivious stack may be defined:• stackQ: initiates an oblivious stack, denoted as ObStack;• ObStack.CondPush(b, x): Takes a Boolean value b and an element x as input. If b = 1, the clement x is pushed onto the oblivious stack; otherwise, the operation is skipped; and• ObStack.CondPop(b): Take a Boolean value b as an input. If b — 1, the operation returns the top element from the oblivious stack when it is non-empty, otherwise, it returns 1. If b = 0, it returns 1' . Here, 1 and 1' are arbitrary but distinguishable special symbols.

[0040] By integrating 2PC techniques with a data oblivious search approach, a comprehensive graph correspondence determination method with a two-party privacy preserving subgraph checking solver over unlabelled graphs between two participants is achieved. This method offers a unique combination of data obliviousness and execution obliviousncss, ensuring confidentiality and privacy of the underlying graph structure throughout the checking process. Although various embodiments are illustrated with reference to a 2D matrix and the processes relating to two different vectors of the 2D matrix that extends in different directions (e.g., row vectors and column vectors), it is appreciated that the embodiments are not limited as such configurations. They are applicable to other data structures including data structures that have more than two dimensions and comprise two or more vectors which extends in different directions, respectively (e.g., x vectors, y vectors andz vectors in a 3D data structure). For example, the embodiments may be used to process a 2D data structure or matrix representing or extracted from higher-dimensional data structures.

[0041] FIG. 5 shows a block diagram illustrating an apparatus 500 for determining a correspondence between two graph networks according to various embodiments of the present disclosure. The apparatus may be a server apparatus and may comprise at least one processor 502 and at least one memory 504. For the sake of simplicity, only one processor and memory are shown in FIG. 5. The at least one memory 130 stores computer program code which is accessible by the at least one processor 120 necessary for the apparatus 500 to perform its designated operations and functions for determining a correspondence between two graph networks. The apparatus 500 can communicate with (e.g., transmit data to or receive data from) a computing device 512 (another apparatus), for example, through a wired or wireless connection. The apparatus 500 may comprise a transceiver for transmitting and receiving wireless signals and / or a connection interface in the form of a physical socket connectable to the computing device 512 for transmitting and receiving signals through a wire to perform the communication with the computing device 512. In some embodiments, the apparatus 500 has a first graph network stored in the at least one memory 504 while the computing device 512 stores a second graph network, and the second graph network or the information of the second graph network is received by the apparatus 500 from the computing device 512 and the apparatus 500 is then configured to determine a correspondence between the first graph network and the second graph network. Alternatively, the apparatus 500 may function as a coordinating apparatus for determining a correspondence between two graph networks stored in two external devices. In this case, the apparatus 500 may additionally communicate with (e.g., transmit data to or receive data from) yet another computing device or apparatus (not shown), and receive information of the first graph network from the another computing device and information of the second graph network from the computing device 512, and the apparatus 500 is then configured to determine a correspondence between the first graph network and the second graph network. The apparatus 500 may form part of a system for network security checks where a correspondence between a network graph received from the computing device 512 (e.g., client device or a server) and a known network graph indicating a malicious or intrusive network activity such as a known attack pattern or network intrusion is determined to detect similar malicious network activities in or exposed by the computing device 512. The apparatus 500 may form part of a system for analyzing biological networks where a correspondence between a biological network graph corresponding to a complex biologicalsystem received from the computing device 512 and a known or simpler biological network graph corresponding to a known compound, pattern or motifs to detect similar compound, recurring pattern or motifs within the biological system. The apparatus 500 may also form part of a system for analyzing large social network structures where two social network structures arc compared to identify common patterns or communities between them. The apparatus 500 may also be applied to analyze peeling chains or nested structures in the cryptocurrency transaction network for detections of financial fraud and money laundering.

[0042] FIG. 6 shows a flow chart illustrating a method 600 for determining a graph correspondence between two graph networks. The computer program code stored in the at least one memory 504, when executed by the at least one processor 502, may cause the apparatus 500 to perform the method to determine a graph correspondence between a first graph network (e.g., which is stored in the at least one memory 504 or which information is received from another computing device) and a second graph network (e.g., which information is received from the computing device 512). In particular, the method 600 may comprise, in step 602, identifying one of a plurality of first vectors (e.g., row vectors) of a data structure (e.g., matrix M representing two graph networks G, H } that comprise two or more active elements. The plurality of first vectors may extend in a direction that is different from that of a plurality of second vectors (e.g., column vectors) of the data structure, where the data structure has a number of first vectors corresponding to a number of first vertices of a first graph network (e.g., graph network H) and a number of second vectors corresponding to a number of second vertices of a second graph network (e.g., graph network G). For example, the directions that the plurality of first vectors and the plurality of second vectors extend may be perpendicular or orthogonal to each other. Each element of the data structure corresponds to a first vertex of the first vertices of the first graph network and a second vertex of the second vertices of the second graph network, and each active element has a non-zero value indicating a possibility of a vertex correspondence between the corresponding first and second vertices. Subsequent to step 602, the method 600 may further comprise a Decision step in step 604, which includes randomly selecting a first element from the two or more active elements that is in a second vector (e.g., 1stcolumn vector) of the plurality of second vectors of the data structure; in step 606 which includes updating a second element from the two or more active elements that is in another second vector (e.g., 2ndcolumn vector) of the plurality of vectors to be inactive, where each inactive element has a zero-value indicating no possibility of the vertex correspondence between the corresponding first and second vertices; and a Check step in step 608 whichincludes determining whether the first graph network corresponds to at least a part of the second graph network based on the updated data structure.

[0043] Additionally, the information of the second element or other active elements of the two or more active elements that are not selected in the Decision step and / or the data structure before the Decision and update were made may be stored in the at least one memory 504 for future use (e.g., in Backtrack step).

[0044] The computer program code stored in the at least one memory 504, when executed by the at least one processor 502, may be configured to further cause the apparatus 500 to, prior to identifying the one of the plurality of first vectors of the data structure (step 602), perform a Search step, which includes identifying a first vector (e.g., 1strow vector) from the plurality of first vectors of the data structure that has one single active element; and a Propagation step, which includes updating a third clement that is in a same second vector of the plurality of second vectors as that of the one single active element but in a different first vector (e.g., 2ndrow vector) of the plurality of first vectors from that of the one single active element to become inactive.

[0045] The computer program code stored in the at least one memory 504, when executed by the at least one processor 502, may be configured to further cause the apparatus 500 to, prior to identifying the one of the plurality of first vectors of the data structure (step 602), also perform a Prune step, which includes determining whether a first degree of the first vertex corresponding to an element of the data structure computed by a first computing device (e.g., the apparatus 500 or another computing device) is larger than a second degree of the second vertex corresponding to the element computed by the computing device 512; and update the element to become inactive in response to determining that the first degree is larger than the second degree. In one embodiment, a degree of a vertex refers to a number of edges that are connected to it. That said, a higher degree indicates that the vertex is connected to more other vertices network whereas a lower degree indicates that the vertex is connected to less other vertices in a graph network.

[0046] In some embodiments, in step 606, the computer program code stored in the at least one memory 504, when executed by the at least one processor 502, may be configured to further cause the apparatus 500 to perform a Propagation step which includes updating other active elements that is in the second vector but in other first vectors of the plurality of first vectors different from that of the first element to become inactive.

[0047] In some embodiments, during the Check step in step 608, the computer program code stored in the at least one memory 504, when executed by the at least one processor 502, may be configured to cause the apparatus 500 to determine whether a first corresponding data structure M' derived using a first adjacency data structure (e.g., adjacency matrix MG) constructed from the first graph network (e.g., graph network G) and the updated data structure (e.g., updated matrix M after prune, search, decision and / or propagation steps) corresponds to a second adjacency data structure (e.g., adjacency matrix MH) constructed from the second graph network (e.g., graph network H), wherein each element of the first adjacency data structure and the second adjacency indicates whether two of the first vertices and two of the second vertices are adjacent or connected in the first graph network and the second graph network, respectively.

[0048] According to various embodiments of the present disclosure, after the Check step 608 is carried out, and where in a negative determination that the first graph network corresponds to the at least the part of the second graph network, which means the bijection matrix (e.g., M1) resulted from the decision to select the first element in step 604 fails the graph correspondence test or condition, indicating that the first graph network is not a subgraph of the second graph network, the computer program code stored in the at least one memory 504, when executed by the at least one processor 502, may be configured to cause the apparatus 500 to perform a Backtrack step which includes returning the data structure (e.g., in a state or structure before the last Decision step were made), and another iteration of the Search / Decision, Propagation and Check steps (e.g., steps 602, 604 and 606) except that in this iteration of step 606, another active element (e.g., second element) different from the first element is selected and the first element and other active elements from the two or more active elements that is in different second vectors are updated to become inactive. The computer program code stored in the at least one memory 504, when executed by the at least one processor 502, may be configured to further cause the apparatus 500 to perform another Check step using the new bijection matrix (e.g., M2) formed from the decision to select the another active element (e.g., second element), to check the new bijection matrix meets the graph correspondence test or condition.

[0049] In some embodiments, for example, before or after any of the aforementioned steps, the computer program code stored in the at least one memory 504, when executed by the at least one processor 502, may be configured to cause the apparatus 500 to check and determine whether there is no active element in at least one of the plurality of first vectors, and in responseto such a result of determining that there is indeed no active element in at least one of the plurality of first vectors, determine or return a result that the first graph network does not correspond to the at least the part of the second graph network or the first graph network is not a subgraph of the second graph network.

[0050] In some embodiments, during step 602 to identify the one of the plurality of first vectors that comprise two or more active elements, the computer program code stored in the at least one memory 504, when executed by the at least one processor 502, may be configured to further cause the apparatus 500 to identify multiple first vectors (e.g., 1st, 2ndand 3rdrow vectors) of the plurality of first vectors, each of the multiple first vectors have respective two or more active elements; and randomly selecting, from the multiple first vectors, the one of the plurality of first vectors (e.g., 1strow vector). Additionally, when there were multiple first vectors having two or more active elements and one of the multiple first vectors was selected, and later when a Backtrack step is performed based on an active element of the selected first vector, e.g., after the Check step 608 and the bijection matrixresulted from the decision to select the first vector and the active element of the first vector in step 604 fails the graph correspondence test or condition, the computer program code stored in the at least one memory 504, when executed by the at least one processor 502, may be configured to cause the apparatus 500 to return the data structure (e.g., in a state or structure before the last Decision step were made), and another iteration of the Search / Decision, Propagation and Check steps (e.g., steps 602, 604 and 606) except that in this iteration of step 604, the computer program code stored in the at least one memory 504, when executed by the at least one processor 502, may be configured to cause the apparatus 500 to select another first vector (e.g., 3rdrow vector) and then select one active element of the two or more active elements of the another first vector in a second vector, and then update other active elements of the two or more active elements of the another first vectors in different second vectors to become inactive. The computer program code stored in the at least one memory 504, when executed by the at least one processor 502, may be configured to further cause the apparatus 500 to perform another Check step using the new bijection matrix (e.g., M2) formed from the decision to select the one active element of the another first vector, to check the new bijection matrix meets the graph correspondence test or condition.

[0051] An example process for determining a correspondence between two graph networks is described. The following notations are used in the following description. In particular, two parties will be denoted as Poand Pr, whose inputs are graph network H = (VH,EH) and graphnetwork G = (VG, EG) , respectively, where VHand Vcrespectively signify a set of objects referred to as vertices in graph network H and graph network G , while EHand EGrespectively represent a set of paired vertices, with each element termed as edge in in graph network H and graph network G. The number of vertices of graph network H is n, i.e., | VH| — n, while that of graph network G is m, i.e., | VG| = m. It is also assumed that the graph networks H and G have different number of vertices, more particularly, m > n. The adjacency matrix of a graph network x is represented as Mx. The mapping matrix after pruning is denoted as M. Therefore, the dimension of MH, MG, M are n X n , m X m and n X m , respectively. A summary of additional notations used are shown in Table 1 .[Table 1]

[0052] FIG. 7 shows an overview of a process 700 for determining a correspondence of two graph networks according to some embodiments of the present disclosure, respectively. The process 700 (hereinafter may be referred to “ppSGC Solver”) takes as input the public n, m, and iterative steps r, along with two private adjacency matrices MG, MHrepresenting two graph networks. The initial bijection matrix may be constructed from MG, MH, each element is mapped to a vertex of graph network G and graph network H, as shown in FIG. 7. It initializes an oblivious stack ObStack to manage the search space and a vector v2of length n with a summary value. V2is utilized to record the vertices in the smaller graph network H that have found correspondences. Algorithm 1 below shows an example algorithm used for the operations of the process 700.Prune

[0053] As shown in Algorithm 1, the first step of the process 700 is a Prune step 702 applied to compute the pruned matrix M containing all possible vertex correspondences. The Prune step 702 is employed to heuristically prune the initial bijection matrix to reduce the space of all possible bijection matrices. By way of example, the vertex degree is leveraged. Algorithm 2 below shows an example algorithm used during the Prune step 702. As shown in Algorithm 2, the algorithm takes as inputs each party's adjacency matrix MG, MH, and the number of vertices n, m. At the beginning, an all-one matrix M of dimension n X m is initialized. The algorithm then compares the degree of each vertex in graph H to the degree of each vertex in graph G. If there is a vertexVi in graph H and a vertex Vj in graph G that Vi's degree computed by the participant in possession of graph is larger than Vj's degree computed by participant in possession of graph G, then is set to 0, indicating that vertex Vicannot be mapped tothe vertex Vj.

[0054] Subsequently, the process 700 include iteratively executing the round step, which combines five unit steps Search step 704, Decision step 706, Propagation step 708, Check step 710 and Backtrack step 712, obliviously, to explore the possible bijection matrix M and verify the isomorphism and determine the graph correspondence under M.Search

[0055] In each round step, the process 700 include executing both Search step 704 and Decision step 706 to determine a vertex correspondence. The Search step 704 is dedicated to searching the unique one-to-one correspondence between vertices of G and H. Algorithm 3 below shows an example algorithm used during the Search step 704. As shown in Algorithm 3, this unit step scans each row of the matrix M to locate a row containing only a single "1 ". If there exists such a row, the algorithm returns a flag λL = 1 . along with two vectors v2and tq indicating the row index and column index of the found "1", respectively. Otherwise, it returns some dummy values.

[0056] If Search step 704 finds a specific one-to-one correspondence between a vertex in H and a vertex in G, i.e., λ = 1 or there is only one single active element “1” in the first vector (e.g., row vector), such correspondence will be determined in this round. Otherwise, if there is more than one active element in the first vector (e.g., row vector), Decision step 706 is carried out to select the correspondence.Decision

[0057] Algorithm 4 below shows an example algorithm used during the Decision step 706. During the Decision step 706, a possible correspondence (e.g., one of the active elements) is randomly selected and then the selection is returned. Algorithmically, this step identifies a row i containing multiple “1”, indicated by the weight ci> 1. A random value sampler (RVS) may be called out, to generate a random integer k such that k ≤ ci. Algorithm 5 below shows an example algorithm used as RVS. Algorithm 5 is a two-party random value generator.Algorithm 5 takes an inputwhich are privately selected by party Poand Pt, respectively, along with a secret value c shared between P0and P1. It outputs a random value k that k E [c] with the probability exceeding 1 — 2-w. A constant such as w = 32 may suffice to make the possibility of k > c negligible.1 1 . return k[Algorithm 5]

[0058] This RVS returns the row index and column index of the fc-th "1" in row i as the output. Moreover, considering there exist other possible correspondences for the vertex i selected by the Decision step 706, those possibilities are stored in the oblivious stack 720. In case the guessed correspondence does not satisfy subgraph isomorphism in Check step 710, the alternative correspondence stored in the oblivious stack 720 can be retrieved in Backtrack step 712 to explore other possible bijection matrices.

[0059] Additionally, according to the Decision algorithm 4, it is continually checked whether any row of M contains no active element. If such a row i was found, it means that the vertex in H cannot be mapped to any of the vertices in G So, it is impossible to find a subgraph in G isomorphic to H under such M . In this case, the process 700 may stop exploration at the current branch within the search space and backtrack to explore other possible bijection matrices. To handle this, a flag o' is set to trigger backtracking in the following Backtrack step 712.

[0060] In an embodiment, as shown in FIG. 7, a data selector MUX0707 may be used to select one of the outputs between the output of the Search step 704 and the output of the Decision step 706. If the output of the Decision step (e.g., a randomly selected one active element in the first vector) is accepted / selected, the current status M,v2, v2is pushed on the oblivious stack 720. Subsequently, Propagation step 708 is employed to update the matrix M for use as the input in Check step 710.

[0061] In particular, the nature of both Search and Decision algorithms is to find a correspondence between a vertex in graph H and a vertex in graph G . Once such a correspondence is determined, it excludes the possibility of other vertices in H and G being mapped to these two specific vertices, respectively. Therefore, it is essential to remove that possibility from the search space for the subsequent rounds of Search or Decision, which is the purpose of the Propagation step. Algorithm 6 below shows an example algorithm used during the Propagation step 708. For example, if vertex VpG VHcorresponding to vertex Vq∈ VGis determined (i.c., clementis selected), the index information and v2such that for

[0062] Given these as input, the Propagation Algorithm 6 updates M to ensure that there exists only a single 1 in both row p and column q, i.e., at point (p, q).

[0063] hi other words, given a determined vertex correspondence betweenand Vj, the step 708 updates other active elements in the same row i but in different columns and other active elements in the same column j but in different rows to “0” or inactive. All the values in row t and column j of the matrix M become inactive, except for position (i, 7).Check

[0064] When all vertices in graph H are mapped to corresponding vertices in graph G, i.e., each row of M contains exactly a single 1 , M becomes a possible bijection matrix. Tn particular, if it is determined thatin step 709 shown in FIG. 7, that is, the number of row vectors / indices having only a single active element is equal to the number of vertices of the smaller graph network H, this means that a possible bijection matrix M is found Then the next step is to check the isomorphism under the current M. Algorithm 7 below shows an example algorithm used during the Check step 710. Using Algorithm 7, a corresponding matrix M’ —M(MMG)Tis computed from the possible bijection matrix M the adjacency matrix Mcof graph network G and check for isomorphism, i.e., determine whether the position of active elements “1” in MHis also “1” in M'. If yes, the algorithm returns a private bit "1" indicating that a graph correspondence condition is met, thus a graph correspondence or isomorphism under M is found; otherwise, it returns a "0" bit, indicating that G does not contain a subgraph that is isomorphic to H, under the current M. However, if it is determined thatin step 709 shown in FIG. 7, the Check step 708 may take a dummy matrix for the computation of M' and return “No”.Backtrack

[0065] Notably, the Check step 710 is also executed in each round to hide the actual number of checks for privacy-preserving purpose. According to various embodiments of the present disclosure, when a matrix M does not satisfy isomorphism, we need a step to check if there are any other possible bijective matrices and jump to that search branch if so. Algorithm 8 below shows an example algorithm used during Backtrack step 712. Note that backtracking is possible when there is at least one decision row, where the ‘ 1’ in this row is selected by the Decision algorithm (Algorithm 4) within M. In this scenario, the algorithm reverts M and v2to the states just before the last decision correspondence is made and then removes the last decision correspondence from M. This is achieved by changing the ‘1’ at the position selected during the last decision step to ‘0’ and select one of the other “1” previously removed or updated asinactive and updating it to “1”. Tn particular, wherein a negative determination that H corresponds to at least a part of G, i.e., the Check step returns “0”, the status of the last Decision step last pushed to the oblivious stack 720 is retrieved from the oblivious stack720 and processed in Backtrack step 712 for the next iteration. Besides, the current M and v2may not be modified in the Backtrack step.

[0066] In an embodiment, as shown in FIG. 7, another data selector MUX1713 may be used to select one of the outputs between the output of the Check step 710 and the output of the Backtrack step 712. For example, if b (i.e., the output of Check step) equals to 1 , the output of the Check step 710 is selected and the step returns “YES”, otherwise, the Backtrack step 712 is carried out, and M and v2are updated. Tn some embodiments, the process 700 may be terminated when one of the following occurs: (a) if in the Check step 710, a subgraph isomorphism under an explored possible bijection matrix M is confirmed and the step returns “Yes”; (b) a value from an empty oblivious stack is popped in the Backtrack step 712, suggesting that there was no decision made or the iterations have run and checked through all alternative decisions; or (c) the pre-defined number of steps is reached (e.g., 1000 steps) and the processes do not return a result.

[0067] The following paragraphs describe an example model (e.g., a threat model) and the security associated with the process 700 for determining a correspondence between graphnetworks G, H, and also illustrate an evolution of the matrix through respective steps of the process 700 using the graph networks G, H in FIGS. 1A and IB as an example.

[0068] The process 700 involve two participants P0, P1collaboratively solve a subgraph checking problem. Notably, both participants know the number of vertices i.e., n and m, in each other’s private graph beforehand. Subsequently, their objective is to verify whether graph G owned contains a subgraph that is isomorphic to the graph H owned by P0. The processes according to the present disclosure can realize a privacy-preserving two-party subgraph checking protocol against semi-honest adversaries, where an adversarial party seeks to learn the information of another party’s private graph, such as the number of edges and its connectivity patterns, without deviating from the protocol.

[0069] Given the model, the security definition of the protocol may be formalized as Definition 1 as follows, where K is the security parameter:• There exists a simulator such that for any probabilistic polynomial-time(PPT) decision algorithm <A:where neglfj is a negligible function.[Definition 1]

[0070] FIGS. 8A-8I shows the initial matrix derived from the two graph networks G and H shown in FIGS. 1A and IB and the respective updated matrices after each step of a process for determining a graph correspondence (e.g., process 700) according to an embodiment of the present disclosure. FIG. 8J shows a diagram summarizing the process for determining the graph correspondence with respect to the matrices shown in FIGS. 9A-9I.

[0071] FIG. 8A shows an initial matrix representing the two graph networks G and H shown in FIGS. 1A and IB according to an embodiment of the present disclosure. Given the graph networks G and H and their adjacency matrices MG, MHshown in FIGS. 1A and IB, an initial all-ones bijection matrix of dimensions 3 x 4, denoted as M may be constructed, as shown in FIG. 8A.

[0072] Subsequently, both participants participate in executing the Prune step, e.g., using Algorithm 2, to heuristically prune the initial bijection matrix and thereby reduce the search space. It requires each participant to locally compute the degree of each vertex of their own graph, and then securely compare these degrees. If there is a vertex V[ in graph H and a vertex Vj in graph G satisfying that Vj’s degree is larger than Vj’s degree, is set to 0, indicatingthat the vertex cannot be mapped to the vertex Vj ∈ G.

[0073] FIG. 8B shows a Prune step and an example updated matrix after the Prune step is performed on the initial matrix of FIG. 8A according to an embodiment of the present disclosure. In this example, during the Prune step, P0computes the vertex degrees as {3,1,1} while P1computes the vertex degrees as {4, 1,1,1}. By comparison, it is determined based on the degree of first vertex V4of graph H computed by P0is larger than the degrees of second, third, and fourth vertices V2, V3, V4of graph G computed by P1, therefore the corresponding elements representing the corresponding vertices are updatedto be inactive with “0”. Emphasis on the update is highlighted using the dashed-line boxes in FIG. 8B.

[0074] After obtaining the pruned matrix, two participants start to explore the possible bijection matrices. To facilitate the process, two unit steps, namely a Search step and a Decision step, arc utilized to determine the node correspondence between two input graphs. The Search step is dedicated the unique one-to-one correspondence between vertices of G and H. During the Search step, each row of the pruned matrix to locate a row containing only a single activeelement “1”, e.g., using Algorithm 3. If there exists such a row, a flag A — 1 may be returned, along with two vectors v2' and vrindicating the row index and column index of the found active element “1”, respectively. Otherwise, dummy values may be returned.

[0075] FIG. 8C shows a Search step and an example updated matrix after the Search step is performed on the pruned matrix of FIG. 8B according to an embodiment of the present disclosure. In this example, the first row is found in the first search to have a single active element. The active element M [1] [1] in that row indicates that vertex A in graph H can only respond to vertex Q in graph G if there exists a subgraph isomorphism. The vertex correspondence between vertex A in graph H and vertex Q in graph G is illustrated by arrow 830.

[0076] FIG. 8D shows a first Propagation step and an example updated matrix after the first Propagation step is performed on the searched matrix of FIG. 8C according to an embodiment of the present disclosure. In this example, the active element M[l] [l] located in the 1strow vector and 1stcolumn vector, or point (1,1) which corresponds to the vertex A in graph H and vertex Q in graph G is determined. A Propagation step is then carried out, e.g., using algorithm 6, to update the searched matrix M to ensure that there exists only a single 1 in both 1sLrow vector and 1stcolumn vector at point (1,1). In particular, other active elements M[2] [l] and M[3] [1] which are in the same column but in different rows from that of the determined active element M[l] [1] are updated to become inactive. Emphasis on the update is highlighted using the dashed-line boxes in FIG. 8D.

[0077] v2is also computed after the first Propagation step by scanning each row and a Check step may be carried out to determine whether the number of rows that have only one single active element “1” in the updated matrix, i.e., |v2| is equal to the number of vertices of graph network H, i.e., n. In this example, | v2| is not equal to 3, indicating that a possible bijection matrix has not been found, and the process continues.

[0078] Subsequently, a Search step may be carried out again. To address cases where a vertex in H can be mapped to multiple vertices in G, i.e., having multiple active elements in a row vector, a Decision step may be carried out, e.g., using Algorithm 4, to randomly select one of the active elements, i.e., a possible correspondence and then returns the selection. Algorithmically, this step identifies a row i containing multiple active elements “1’, indicated by the weight ci> 1. Subsequently, an RVS may be called to generate an integer k such that k <≤Ci. This step then returns the row index and column index of the k-th “1” in row i as the output.

[0079] FIG. 8E shows a first Decision step and an example updated matrix after the first Decision step is performed on the updated matrix of FIG. 8D according to an embodiment of the present disclosure. In this example, it is identified, for example, from the updated matrix after the last Propagation step shown in FIG. 8D that a vertex in H can be mapped to three vertices in G, i.e., having three active elements in 3rdrow vector. It randomly selects the active element “1” in the 1stcolumn vector, e.g., using RVS, as a result of the selection indicating the vertex C in graph H is guessed to be mapped to vertex R in graph G. The selected active element is highlighted using the dashed-line box in FIG. 8E, and the (selected / guessed) vertex correspondence between vertex C in graph H and vertex R in graph G are illustrated by arrow 850. Considering there exist other possible bijection matrices for other vertices not selected by the first Decision step, the current matrix before updating the matrix in the subsequent Propagation step following the Decision step is stored in an oblivious stack so that those other possibilities, alternative correspondence, and other possible bijection matrices may be explored later, e.g., in the Backtrack step, in case the guessed correspondence in this first Decision step does not satisfy subgraph isomorphism.

[0080] FIG. 8F shows a second Propagation step and an example updated matrix after the second Propagation step is performed following a Decision step according to an embodiment of the present disclosure. In this example, the active element M[3] [2] located in the 3rdrow vector and 2ndcolumn vector, or point (3,2), which corresponds to the vertex C in graph H and vertex R in graph G is determined / selected in the Decision step. A Propagation step is then carried out, e.g., using algorithm 6, to update the matrix M to ensure that there exists only a single 1 in both the 3rdrow vector and the 2ndcolumn vector at point (3,2). In particular, other active elements M [2] [2] , M [3] [3] , and M [3] [4] which are in the same column but in different rows or in the same row but in different columns from that of the determined active element M[2] [3] are updated to become inactive. Emphasis on the update is highlighted using the dashed-line boxes in FIG. 8F.

[0081] v2is also computed after the second Propagation step by scanning each row and a Check step may be carried out to determine whether the number of rows that have only one single active element “1” in the updated matrix, i.e., |v2| is equal to the number of vertices of graph network H, i.e., n. In this example, |v2| is not equal to 3, indicating that a possible bijection matrix has not been found, and the process continues.

[0082] FIG. 8G shows a second Decision step and an example updated matrix after the second Decision step is performed on the updated matrix of FIG. 8F according to anembodiment of the present disclosure. In this example, it is identified, for example, from the updated matrix after the last Propagation step shown in FIG. 8F that a vertex in H can be mapped to two vertices in G, i.e., having two active elements in the 2ndrow vector. It randomly selects the active element “1” in the 3rdcolumn vector, e.g., using RVS, as a result of the selection indicating the vertex B in graph H is guessed to be mapped to vertex S in graph G. The selected active element is highlighted using the dashed-line box in FIG. 8G, and the (selected / guessed) vertex correspondence between vertex B in graph H and vertex S in graph G arc illustrated by arrow 870. Considering there exist other possible bijection matrices for other vertices not selected by the second Decision step, the current matrix before updating the matrix in the subsequent Propagation step following the second Decision step is stored in an oblivious stack so that those other possibilities, alternative correspondence, and other possible bijection matrices may be explored later, e.g., in the Backtrack step, in case the guessed correspondence of this second Decision step does not satisfy subgraph isomorphism.

[0083] FIG. 8G shows a thud Propagation step and an example updated matrix after the third Propagation step is performed following a second Decision step according to an embodiment of the present disclosure. In this example, the active element M[2] [3] located in the 2ndrow vector and the 3rdcolumn vector, or point (2,3), which corresponds to the vertex B in graph H and vertex S in graph G is determined / selected in the second Decision step. A Propagation step is the carried out, e.g., using algorithm 6, to update the matrix M to ensure that there exists only a single 1 in both the 2ndrow vector and the 3rdcolumn vector at point (2,3). In particular, the active element M [2] [4] which is in the in the same row but in different column from that of the determined active element M [2] [3] is updated to become inactive. Emphasis on the update is highlighted using the dashed-line box in FIG. 8H.

[0084] v2is again computed after the third Propagation step by scanning each row and a Check step may be carried out to determine whether the number of rows that have only one single active element “1” in the updated matrix, i.e., |v2| is equal to the number of vertices of graph network H, i.e., n. In this example, |v2| is equal to 3, the process may then proceed to carry out a subgraph isomorphism check (step 8 in FIGS. 81 and 8J).

[0085] A corresponding matrix M' = M(MMG)Tis computed and derived from the current matrix M after the third Propagation step and the adjacency matrix MGof graph network G. The corresponding matrix M'is compared against the adjacency matrix MHof graph network H. In particular, it is checked whether the position of active element “1” in MHis also “1” in M'. If the position of the active elements match, a private bit “ 1 ” or “yes” is returned, indicatingisomorphism and that H corresponds to at least a part of the G under the current M ; otherwise, it returns a “0” bit or “no”, indicating that Gdocs not contain a subgraph that is isomorphic to H under the current M.

[0086] If the current M does not satisfy isomorphism (“0” or “no”), a Backtrack step is carried out to check if there are any other possible bijection matrices and jump to that search branch if so. Note that backtracking is possible when there is at least one decision row, where the “1” in that row is selected by a previous Decision step within M. In this example, M and v2are reverted to the states just before the last decision correspondence is made. This may be achieved by popping or returning the previous stored M and V2before any element update during the second Decision step from the oblivious stack 860. Subsequently, the process continues by removing the last decision correspondence from M to explore alternative decision correspondence and other possible bijection matrices. This is achieved by changing the “1” at the position indicating the last decision correspondence (e.g., M[2] [3] at point (2,3)) to “0”. In other words, an alternative correspondence and other possible bijection matrices may be explored using another Search / Decision step with a selection of another active element (e.g., M[2] [4] which was in the same row but in a different column from that of the determined active element M [2] [3] and updated to become inactive during the last Decision step).

[0087] In some embodiments, during Backtracking step, the previous stored M and v2before any element update during the first Decision step from the oblivious stack 860 may be returned or retrieved, an alternative correspondence and other possible bijection matrices may be explored using another Decision step with a selection of another active element in the same row vector (e.g., 3rdrow vector) or a different row vector (e.g., 2ndrow vector).

[0088] The following paragraphs describe the complexity and security analysis of the process (protocol) for determining a graph correspondence between two graph networks according to an embodiment of the present disclosure.

[0089] The protocol may utilize a pruning method to reduce the search space of possible bijection matrices and then iterate through each possibility to find the result of a subgraph isomorphism problem. To securely iterate through possible bijection matrices, a combination of Search, Decision, Propagation, Check, and Backtrack steps may be carried out for several rounds. Consequently, the overall circuit complexity of the protocol may be computed as O(Pr + T(S + D + P + C + B)), T is the number of rounds, and Pr,S, D, P C, B represent the complexity of the step Prune, Search, Decision, Propagation, Check, and Backtrack, respectively. The round complexity O(T) of the protocol may be the same as the pruning-basedsubgraph checking solver over plaintext. By way of example, a vertex-degree-based pruning method may be employed, where the effectiveness of pruning is influenced by the number of vertices and the structures of the input graphs.

[0090] As mentioned earlier, during the Prune step, the parties may locally compute the weight of each nodc / vcrtcx in their graphs, and then securely compare these weights. Therefore, the circuit complexity of Prune step may be 0(nm) where n and m are the number of vertices of the two graph networks, respectively. The Search and Decision steps both involve scanning each row of the bijection matrix. During each scan, the sum of the row may be computed, and checks may be performed to determine whether the sum is equal to 0 or 1 in the Search step, or greater than 1 in the Decision step, for the corresponding returns. Additionally, the Decision step may require O(mn) time to run the RVS to randomly select a correspondence. Overall, the complexity of Search and Decision steps may be 0(2mn) and 0(3mn), respectively. Upon obtaining the Search or Decision result, the Propagation step may be carried out to update each element of the bijection matrix, incurring a circuit complexity of O(2mri) . The most time-consuming operations in the protocol may be primarily matrix multiplications in the Check step, resulting in a complexity of 0 (4nm2). Finally, the Backtrack step may be carried out to pop 0(2mn) bits value from the oblivious stack and use it to recover a be 0 (n)-bit vector and a be 0(nm)-bit bijection matrix. This step may cost a complexity of O(n log(n)). Table 4 below shows the number of distinct gates of secure 2PC operations, including AND, XOR, ADD (addition), SUB (subtraction), MUL (multiplication), EQ (equation), COMP (comparison), and SEL (selection) operations utilized in each step of the protocol, where n is the number of vertices of graph H and m is the number of vertices of graph m, and the empty indicates 0. Operations of the oblivious stack and random value sampler (RVS) are not included in Table 4.

[0091] Regarding the security analysis and the correctness of the protocol, it is evident that the matrix M obtained from the process according to an embodiment of the present disclosure, when |v2| = n is indeed a possible bijection matrix, where each row contains and only contains a single active element “1” and each column contains at most one “1”. Referring to FIG. 8A, the process may return “YES”, i.c., the Check step, for example, using Algorithm 7, returns b = 1, if and only if a = 0. It means that ,which equivalent to Considering that whenMcis an all-zero dummy matrix. Therefore, the existence of “1” in Mcmay be equivalent tofinding a possible bijection matrix M in the pruned search space satisfying the subgraph isomorphism.

[0092] The process may return “No” if and only if, after iterating over all possible bijection matrices, the value a obtained by inputting each possible bijection matrix into the Check step is non-zero. That is for each M' computed using the possible bijection matrix,satisfying thatbut . Therefore G does not contain asubgraph that is isomorphic to H.

[0093] In general, the security of the process according to various embodiments of the present disclosure relies on its pattern-oblivious construction, the secure two-party computation, and the standard composition results. The solving process is intricately designed such that data privacy is rigorously guaranteed in each step. For example, by leveraging the secure 2PC comparison, two participants arc allowed to compare their node degrees to reduce the search space in a privacy-preserving manner. Then the Search and Decision steps may enable a secure scan of the matrix and return a vertex correspondence in a data-oblivious manner. The Propagation step may perform secure EQUAL operations on values followed by secure AND operations on each element of the matrix to eliminate conflicting vertex correspondences. In the Check step, secure XOR, ADD, MUL, EQ, and SEL operations may be employed to implement a privacy-preserving variant of the approach described in Question 2 which is to first compute M' and then compareswith M' , facilitating isomorphism verification under the given ciphertext of the bijection matrix. Then, leveraging an oblivious stack, the Backtrack step may obliviously revert the status just before the last Decision step is executed, which facilitates the privacy-preserving exploration of possible bijections. In summary, during each step, an adversary (e.g., a semi-honest adversary or party) may not distinguish the view of the real execution of the step and the view of simulating the step that the inputs of honest participants are selected randomly and uniformly.

[0094] The execution of these steps may follow a pattern oblivious manner. This may be achieved by combining the five unit steps into a round step, wherein all five unit steps may be executed in a deterministic order in each round / itcration. The integration of the Search step and the Decision step with a result selector may allow the establishment of vertex correspondence in each round without leaking the information of the actual step called. The Search step, which may be part of the round step, may accept a dummy matrix as input when a possible bijection matrix is not found. This effectively conceals the number of executions of the Check step and the number of rounds between two consecutive checks. Similarly, the integration of theBacktrack also protects the information related to the number of possible bijection matrices explored and the number of rounds required to identify the next potential bijection matrices. As a result, with the method and apparatus of the present disclosure, the execution patterns may be concealed and the privacy and structure of two input graph networks may be preserved.

[0095] The following paragraphs describe some evaluation settings and results of the performance of the method and process for determining a correspondence between two graph networks according to some embodiments described herein.

[0096] The protocol is evaluated on a machine with two AMD EPYC 7763 64-Core Processors @ 3.5 GHz and 2 TB of RAM, running Ubuntu 22.04.3 LTS. The protocol is implemented using C++ using the EMP-toolkit which is a library of semi-honest two-party computation based on garbled circuits. Two participants are also simulated on a single machine with in-memory storage.

[0097] First, the performance of each unit step is evaluated, including Prune, Search, Decision, Propagation, Check, and Backtrack steps. Since each step is data-oblivious, its computational and communication costs are influenced by the number of vertices in the two input graphs, unrelated to the structure of the graphs. To measure the performance of each step, input graphs are randomly generated for various combinations of m ∈ {50,100,500,1000} and n G {l%m, 5%m ,10%m, 20%m, 30%m} (excluding cases where n < 3) . To facilitate the analysis, experiments are added for n = 20 when m = 50.

[0098] FIGS. 9A to 9D and 10A to 10D show respective graphs illustrating example runtimes for each unit step and one round for varying numbers of vertices n and m of graph networks according to an embodiment of the present disclosure, respectively. Table 5 below shows the runtime results in milliseconds for each unit step, where the time of a round step is the sum of the time spent on Search, Decision, Propagation, Check, and Backtrack steps. It is observed that the Prune step that performs n X m times comparison operations is the most efficient among the others. While, Check step may be the most time-consuming step, accounting for more than 90% of the total time. Additionally, the Backtracking step is the second most time-consuming operation. Compared to the time spent on Check and Backtrack steps, the runtimes of the Search, Decision and Propagation steps are almost negligible in one round step. These evaluation results verify the complexity analysis of each step. Overall, the protocol remains efficient. For example, when n = 5, m = 50, it takes approximately 1.3 seconds to execute one round.

[0099] The Performance of the protocol is also evaluated on real-world datasets, and compare it with that using a conventional brute-force approach which sequentially iterates over all ' possible bijection matrices to check for isomorphism, and in each iteration, a Search step is executed, taking a possible bijection matrix and an all-one vector of length n as inputs. [000100] By way of example, the Acquired Immunodeficiency Syndrome (AIDS) dataset is used to evaluate the performance of the protocol against that of a conventional brute-force approach. The dataset comes from the domain of small molecules, containing graph structured from the AIDS antiviral Screen Database of Active Compound, where molecules are represented as graphs clearly and simply: atoms arc depicted as nodes and covalent bonds arc represented as edges. Out of the 2000 available graphs, 700 were chosen based on the criterion that each graph should have more than six nodes. The average number of nodes and edges for the selected subset is 1 1 .03 and 1 1 .89, respectively.[000101] Additionally, the GitHub StarGazers dataset is also used to evaluate the performance of the protocol against that of a conventional brute-force approach. The GitHub StarGazers is derived from the domain of social networks, consisting of developers who have given stars to notable repositories in the field of machine learning and web development up until 19 August. From a total of 12,725 graphs, a subset of 71 was selected, each with the characteristic of having more than fifty nodes. The average number of nodes and edges for the selected subset is 66.66 and 678.44, respectively.[000102] For evaluation on these two datasets, small graphs with n = 5 are randomly generated following the respective edge distributions of the selected datasets. It is then checked whether there are isomorphic to a subgraph of each selected graph using the present protocol and the conventional brute-force approach.[000103] FIGS. 11A to 11D and 12A to 12D shows respective graphs illustrating example communication costs of each unit step and one round for varying numbers of vertices n and m of graph networks according to an embodiment of the present disclosure, respectively. From FIGS. 1 1 A to 1 ID, it is noted that the communication cost of each step increases as n grows. The communication cost of Prune, Search and Decision steps is much smaller compared to other steps. Specifically, for smaller graphs with m = 50 and n — 5, the communication cost remains below 1 MB for all three steps. The most communication-costly step may be the Check step, which may incur a cost of over 100 MB in this example when the larger graph contains 50 vertices. As shown in FIGS. 12A to 12D, the communication cost of the Check step accountsfor the majority of the communication cost of a round step, making that of other steps negligible.[000104] FIG. 13 shows a graph illustrating results of runtime of one round step in milliseconds (ms) on the selected AIDS dataset for varying n and m using a conventional brute-force approach and the method according to some embodiments of the present disclosure (herein referred to as “present method”), respectively. Table 2 below shows the same runtimes results on the selected AIDS dataset in milliseconds (ms) including the runtimes of the conventional brute-force approach as well as the average runtimes and the worst runtimes (worse cases) of the method according to some embodiments of the present disclosure. It is noted that the brute-force runtime is estimated by multiplying the number of steps bythe time taken for executing a Search step (averaged from ten repeated evaluations). As shown in FIG. 13, and Table 2, the runtime across all different m sizes of the method, even with the worst runtime (worst case), are significantly (at least two orders) less than the conventional brute-force approach. In particular, it is observed that the present protocol can solve the subgraph checking problem on the selected AIDS dataset in 850 seconds, which significantly outperforms the brute-force approach. When m < 15, the method according to the various embodiments takes an average of 100 s which is over 390 times faster than the brute-force approach.[Table 2][000105] FIG. 14 shows a graph illustrating results of runtime of one round step in seconds (s) on the selected GitHub StarGazers dataset using the method according to some embodiments of the present disclosure. Table 3 below shows the same runtime results of one round step in seconds (s) on the selected GitHub StarGazers dataset including the average runtimes and the worst runtimes (worse cases) of the method according to some embodiments of the present disclosure (herein referred to as “present method”).[Table 3][000106] The results arc estimated based on the time spent on each unit step and the number of rounds for checking subgraph isomorphism in the GitHub StarGazers subset. The latter information is evaluated using a plaintext version of the present method in Phyton. Due to the impracticably of the brute-force solver, the brute-force method results in unaffordable runtimes consumption to find the result, hence the runtimes were immeasurable, hence its results are omitted from Table 3 and FIG. 14. As shown in FIG. 14, the present method has the capability to process graph in a reasonable and measurable time. Despite the limited number of graphs available for each size in the GitHub StarGazcrcs dataset, the performance of the method according to the present disclosure remains impressive, practical, and faster than what would be expected with a brute-force strategy.[000107] The following paragraphs provide a brief review of other related work in two directions, namely (i) subgraph checking and (ii) privacy-preserving subgraph checking over labeled graphs.[000108] The subgraph checking or subgraph isomorphism problem has been a subject of extensive research, with methods broadly categorized into (i) exact solutions and (ii) approximate solutions. The former relies on heuristics to efficiently prune the search space, examples include Ullmann’s algorithm, VF2, and GraphQ Further enhancements involve exploring subspaces of graphs, as seen in TurboISO and VF3, which introduce weak rules to identify candidate subregions and then apply recursive match procedures. Other algorithms, like glndex, are designed based on graph indices and serve as filters to eliminate unnecessary graphs. The latter relies on approximation to improve efficiency. To elaborate, triangle counting is adopted for approximation, but it is challenging to generalize to large patterns. Random walks are also employed to count subgraph isomorphisms, but they may lead to errors with high probability. Graph simulation provides another approach to finding subgraph isomorphisms in cubic time but often fails in topology capturing.[000109] Various embodiments above illustrates a method and an apparatus for determining a correspondence between graphs using unlabeled graphs, in which individual vertices have no distinct identifications except through their adjacencies, by employing an oblivious stack to manage the search space and iterating through the search space through a combination of five unit steps, namely Search, Decision, Propagation, Check, and Backtrack steps, in a privacypreserving manner, such that the solver remain secure in a semi-honest model[000110] While the invention has been particularly shown and described with reference to specific embodiments, it should be understood by those skilled in the art that various changes, modification, variation in form and detail may be made therein without departing from the scope of the invention as defined by the appended claims. The scope of the invention is thus indicated by the appended claims and all changes which come within the meaning and range of equivalency of the claims are therefore intended to be embraced.Table 4 shows the number of distinct gates of secure 2PC operations, including AND, XOR, ADD (addition), SUB (subtraction), MUL (multiplication), EQ (equation), COMP (comparison), and SEL (selection) operations utilized in each step of the protocol, where n is the number of vertices of graph H and m is the number of vertices of graph m, and the empty indicates 0.[Table 4]Table 5 shows example runtimes in milliseconds for each unit step, where the time of a round step is the sum of the time spent on Search, Decision, Propagation, Check, and Backtrack steps.[Table 5]

Claims

CLAIMS1. A method for determining a correspondence between two graph networks, comprising: identifying one of a plurality of first vectors of a data structure that comprise two or more active elements, the plurality of first vectors extending in a direction different from to that of a plurality of second vectors of the data structure, wherein the data structure has a number of first vectors corresponding to a number of first vertices of a first graph network and a number of second vectors corresponding to a number of second vertices of a second graph network, wherein each element of the data structure corresponds to a first vertex of the first vertices of the first graph network and a second vertex of the second vertices of the second graph network, and each active element has a non-zero value indicating a possibility of a vertex correspondence between the corresponding first and second vertices; randomly selecting a first clement from the two or more active elements that is in a second vector of the plurality of second vectors of the data structure; updating a second element from the two or more active elements that is in another second vector of the plurality of second vectors to become inactive, wherein each inactive element has a zero-value indicating no possibility of the vertex correspondence between the corresponding first and second vertices; and determining whether the first graph network corresponds to at least a pail of the second graph network based on the updated data structure.

2. The method of claim 1, wherein, prior to identifying the one of the plurality of first vectors of the data structure, the method further comprising: identifying a first vector from the plurality of first vectors of the data structure that has one single active element; updating a third element that is in a same second vector of the plurality of second vectors as that of the one single active element but in a different first vector of the plurality of first vectors from that of the one single active element to become inactive.

3. The method of claim 2, wherein, prior to identifying the first vector from the plurality of first vectors of the data structure that has the one single active element, the method further comprising: determining whether a first degree of the first vertex corresponding to an clement of the data structure computed by a first computing device is larger than a second degree of the second vertex corresponding to the element computed by a second computing device; updating the element to become inactive in response to determining that the first degree is larger than the second degree.

4. The method of claim 2 or 3, wherein, subsequent to updating the second element or the third element, the method further comprising: calculating an updated number of first vectors that has the one single active element from the plurality of rows; and determining whether the updated number of first vectors is equal to the number of first vectors, wherein one of (i) the determining whether the first graph network corresponds to the at least the part of the second graph network based on the updated data structure or (ii) the identifying the one of the plurality of first vectors of the data structure that has the two or more active elements is carried out in response to a result of the determination of the updated number of first vectors.

5. The method of any one of claims 1 to 4, wherein the updating the second element to become inactive further comprises: updating a fourth element that is in the second vector but in a different first vector of the plurality of first vectors from that of the first clement to become inactive.

6. The method of any one of claims 1 to 5, wherein the determining whether the first graph network corresponds to the at least the part of the second graph network based on the updated data structure comprises: determining whether a first corresponding data structure derived using a first adjacency data structure constructed from the first graph network and the updated data structure corresponds to a second adjacency data structure constructed from the second graph network, wherein each element of the first adjacency data structure and the second adjacency indicates whether two of the first vertices and two of the second vertices are adjacent in the first graph network and the second graph network, respectively.

7. The method of any one of claims 1 to 6, wherein in a negative determination that the first graph network corresponds to the at least the part of the second graph network, the method further comprising: returning the data structure; identifying the one of the plurality of first vectors of the data structure that comprise the two or more active elements; selecting the second element; updating the first element to become inactive; and determining whether the first graph network corresponds to the at least the part of the second graph network based on the updated data structure subsequent to selecting the second element and updating the first element.

8. The method of any one of claims 1 to 7, further comprising: determining whether there is no active element in one or more first vectors of the plurality of first vectors; anddetermining that the first graph network does not correspond to the at least the part of the second graph network based on a result of determining that there is no active element in the one or more first vectors of the plurality of first vectors.

9. The method of any one of claims 1 to 8, wherein the identifying the one of the plurality of first vectors of the data structure that has the two or more active elements comprises: identifying two or more first vectors of the plurality of first vectors, each of the two or more first vectors having respective two or more active elements; and randomly selecting from the two or more first vectors the one of the plurality of first vectors.

10. The method of claim 9, wherein in a negative determination that the first graph network corresponds to the at least the part of the second graph network, the method further comprising: returning the data structure; selecting another first vector of the plurality of first vectors from the two or more first vectors; randomly selecting another first element from the respective two or more active elements in the another first vector that is in one of the plurality of second vectors of the data structure; updating another second element from the respective two or more active elements in the another first vector that is in a different second vector of the plurality of from the one of the plurality of second vectors to become inactive; and determining whether the first graph network corresponds to the at least the part of the second graph network based on the updated data structure subsequent to updating the another second element.

11. An apparatus for determining a correspondence between two graph networks, comprising at least one processor; and at least one memory including computer program code stored thereon and coupled to the at least one processor; the computer program code, when executed by the at least one processor, configured to cause the apparatus at least to: identify one of a plurality of first vectors of a data structure that has two or more active elements, the plurality of first vectors extending in a direction different from to that of a plurality of second vectors of the data structure, wherein the data structure has a number of first vectors corresponding to a number of first vertices of a first graph network and a number of second vectors corresponding to a number of second vertices of a second graph network, wherein each element of the data structure corresponds to a first vertex of the first vertices of the first graph network and a second vertex of the second vertices of the second graph network, and each active element has a non-zero value indicating a possibility of a vertex correspondence between the corresponding first and second vertices; randomly select a first element from the two or more active elements that is in a second vector of the plurality of second vectors of the data structure; update a second element from the two or more active elements that is in another second vector of the plurality of second vectors to become inactive, wherein each inactive element has a zero-value indicating no possibility of the vertex correspondence between the corresponding first and second vertices; and determine whether the first graph network corresponds to at least a part of the second graph network based on the updated data structure.

12. The apparatus of claim 11, wherein the computer program code, when executed by the at least one processor, configured to cause the apparatus at least to, prior to identifying the one of the plurality of first vectors of the data structure: identify a first vector from the plurality of first vectors of the data structure that has one single active clement; update a third element that is in a same second vector of the plurality of second vectors as that of the one single active element but in a different first vector of the plurality of first vectors from that of the one single active element to become inactive.

13. The apparatus of claim 12, wherein the computer program code, when executed by the at least one processor, configured to cause the apparatus at least to, prior to identifying the first vector from the plurality of first vectors of the data structure that has the one single active element: determine whether a first degree of the first vertex corresponding to an element of the data structure computed by a first computing device is larger than a second degree of the second vertex corresponding to the element computed by a second computing device; update the element to become inactive in response to determining that the first degree is larger than the second degree.

14. The apparatus of claim 12 or 13, wherein the computer program code, when executed by the at least one processor, configured to cause the apparatus at least to, subsequent to updating the second element or the third element: calculate an updated number of first vectors that has the one single active element from the plurality of rows; and determining whether the updated number of first vectors is equal to the number of first vectors, wherein one of (i) the determining whether the first graph network corresponds to the at least the part of the second graph network based on the updated data structure or (ii)the identifying the one of the plurality of first vectors of the data structure that has the two or more active elements is carried out in response to a result of the determination of the updated number of first vectors.

15. The apparatus of any one of claims 11 to 14, wherein the computer program code, when executed by the at least one processor, configured to further cause the apparatus at least to: update a fourth element that is in the second vector but in a different first vector of the plurality of first vectors from that of the first element to become inactive.

16. The apparatus of any one of claims 11 to 15, wherein the computer program code, when executed by the at least one processor, configured to cause the apparatus at least to: determine whether a first corresponding data structure derived using a first adjacency data structure constructed from the first graph network and the updated data structure corresponds to a second adjacency data structure constructed from the second graph network, wherein each element of the first adjacency data structure and the second adjacency indicates whether two of the first vertices and two of the second vertices are adjacent in the first graph network and the second graph network, respectively.

17. The apparatus of any one of claims 11 to 16, wherein the computer program code, when executed by the at least one processor, configured to cause the apparatus at least to, in a negative detennination that the second graph network corresponds to the at least the part of the first graph network: returning the data structure; identifying the one of the plurality of first vectors of the data structure that comprise the two or more active elements; select the second element;update the first element to become inactive; and determine whether the first graph network corresponds to the at least the part of the second graph network based on the updated data structure subsequent to selecting the second element and updating the first element.

18. The apparatus of any one of claims 11 to 17, wherein the computer program code, when executed by the at least one processor, configured to cause the apparatus at least to: determine whether there is no active element in one or more first vectors of the plurality of first vectors; and determine that the first graph network does not correspond to the at least the part of the second graph network based on a result of determining that there is no active element in the one or more first vectors of the plurality of first vectors.

19. The apparatus of any one of claims 11 to 18, wherein the computer program code, when executed by the at least one processor, configured to cause the apparatus at least to: identify two or more first vectors of the plurality of first vectors, each of the two or more first vectors having respective two or more active elements; and randomly selecting from the two or more first vectors the one of the plurality of first vectors.

20. The apparatus of claim 19, wherein the computer program code, when executed by the at least one processor, configured to cause the apparatus to, in response to determining that the second graph network does not correspond to the at least the part of the first graph network: returning the data structure;select another first vector of the plurality of first vectors from the two or more first vectors; randomly select another first element from the respective two or more active elements in the another first vector that is in one of the plurality of second vectors of the data structure; update another second element from the respective two or more active elements in the another first vector that is in a different second vector of the plurality of from the one of the plurality of second vectors to become inactive; and determine whether the first graph network corresponds to the at least the part of the second graph network based on the updated data structure subsequent to updating the another second element.

Images