An incremental dynamic hypergraph matching method centered on overlap

Abstract

The application belongs to the technical field of pattern matching and mining under the hypergraph data model, and particularly relates to an incremental dynamic hypergraph matching method centered on overlap, which comprises: on the basis of OHMiner, when the data of a pattern hypergraph changes, partial updating is performed on OIG; when a hyperedge is inserted, new overlap relationships brought by the new hyperedge are calculated, and the new overlap relationships are added to OIG as new nodes in an incremental manner, and the same nodes are merged; when the data of a target hypergraph changes dynamically, DDAL is updated incrementally, and pattern matching is performed in an incremental manner; when a new hyperedge is added, the existing partial matching affected by the new hyperedge is searched in a partial matching state storage library, each partial matching instance is incrementally expanded, and the size of a new overlap is calculated; the size of the new overlap is compared with a requirement in an execution plan to verify, and invalid candidates are discarded, which is incremental pruning. The application introduces a brand-new computing paradigm for dynamic hypergraph matching, and optimizes the performance of dynamic pattern matching.

Description

Technical Field

[0001] This invention belongs to the technical field of pattern matching and mining under the hypergraph data model, and more specifically, relates to an incremental dynamic hypergraph matching method centered on overlap. Background Technology

[0002] Hypergraphs, as a generalization of graphs, can naturally model multi-party relationships, not just traditional binary relationships. This ability gives them a significant advantage in dealing with complex systems, such as chemical reactions, interpersonal communication, or interactions in biological networks, which often involve multiple entities. In these domains, pattern matching is often defined as a sub-hypergraph isomorphism problem, which is itself an NP-complete problem.

[0003] While various solutions exist in existing technologies, most fail to effectively address the challenges posed by dynamic environments. Traditional batch processing algorithms, such as those based on subgraph isomorphism, require recalculating all matches from scratch when the data graph (or hypergraph) undergoes a small-scale update. This full recalculation process is costly and lacks scalability, especially for large-scale graphs that are frequently updated, where the computational cost is even greater. Some research attempts to develop incremental algorithms for graph data, but these typically achieve optimal performance only for specific graph patterns (such as DAGs) or specific types of updates (such as single-edge insertions / deletions), and their technical approaches do not consider the multi-edge overlap relationships unique to hypergraphs.

[0004] Furthermore, while other methods known as dynamic hypergraphs exist, their objectives differ from hypergraph pattern matching. For example, some research focuses on Dynamic Hypergraph Structure Learning, aiming to dynamically optimize the hypergraph structure itself based on data features or labels, rather than searching for predefined pattern instances. Although these methods also handle dynamic changes, their core task is to optimize the hypergraph representation to support the learning task, not pattern matching. This fundamental difference in technical approaches results in a significant gap in the existing technology: the lack of an efficient and general-purpose incremental system specifically designed for pattern matching on dynamic hypergraphs.

[0005] Traditional pattern matching algorithms typically employ a match-by-vertex or match-by-hyperedge framework, recursively mapping vertices of the query hypergraph to vertices or hyperedges of the data hypergraph. This approach treats hyperedges merely as validation conditions rather than core computational units, resulting in a large search space and high computational cost. Its paradigmatic shortcomings make it difficult to perform efficient incremental updates in dynamic environments. Summary of the Invention

[0006] To address the aforementioned deficiencies or improvement needs of existing technologies, this invention provides an incremental dynamic hypergraph matching method centered on overlap, aiming to introduce a novel computational paradigm for dynamic hypergraph matching and fundamentally optimize the performance of dynamic pattern matching.

[0007] To achieve the above objectives, according to one aspect of the present invention, an incremental dynamic hypergraph matching method centered on overlap is provided, comprising:

[0008] The system receives a specified pattern hypergraph and an initial target hypergraph from the user; it stores the initial target hypergraph in a dynamic degree-aware data storage structure DDAL to describe the degree of hyperedges and the connectivity between them; based on the user-specified pattern hypergraph, it constructs and maintains the corresponding overlapping intersection graph OIG and generates a matching execution plan; based on the matching execution plan and DDAL, it performs parallel pattern matching on the target hypergraph and maintains a partial matching state repository to save all subgraph instances that may evolve into complete matches.

[0009] Specifically, when the data of the specified pattern hypergraph changes, the OIG is partially updated: when a hyperedge is inserted, the new overlap relationship brought about by the new hyperedge is calculated and added to the OIG as a new node increment, while merging identical nodes to maintain no redundancy; when a hyperedge is deleted, all affected nodes in the OIG are located and removed; when a hyperedge is modified, the hyperedge modification is regarded as a combination of atomic operations of deletion and insertion.

[0010] When the target hypergraph data changes dynamically, DDAL is updated incrementally and pattern matching is performed incrementally. Incremental pattern matching is performed as follows: When a new hyperedge is added, existing partial matches suspected of being affected by the addition of the new hyperedge are retrieved from the partial matching state repository and recorded as candidate partial matching instances. Each candidate partial matching instance is incrementally expanded, and the newly generated overlap size is calculated. The new overlap size is compared and verified with the matching requirements in the execution plan in conjunction with the current DDAL. Invalid candidate partial matching instances are discarded, and valid partial matching instances are retained. This is incremental pruning. When a hyperedge is deleted, all partial matches containing the deleted hyperedge are located in the partial matching state repository and removed.

[0011] Furthermore, when a hyperedge is added to the pattern hypergraph, all hyperedges in the new hypergraph are traversed first, and a node is added for each newly added hyperedge in the first layer of the OIG. The overlap relationship between the newly added hyperedge and the original hyperedge is obtained, i.e., the adjacency relationship. Then, based on the adjacency relationship of the newly added hyperedge, combined with the group-based pruning technique, the OIG node formed by the overlap of the newly added hyperedge node and the original hyperedge is added to the corresponding group in the next layer of the OIG. Next, within the group, each newly added OIG node is added to the corresponding group in the next layer below, and so on, until the corresponding group in the current layer has only one OIG node left and cannot be merged further, thus obtaining a new OIG and storing the incremental update information.

[0012] When deleting a hyperedge in a pattern hypergraph, the hyperedges in the hypergraph are first traversed. In the first layer of the OIG, the first-level OIG node corresponding to each deleted hyperedge is found and used as the deletion starting point. In the second layer, the group of OIG nodes associated with the starting point is determined. In each group, all second-level OIG nodes that are directly related to the deleted hyperedge node are removed and used as the new deletion starting point. In the third layer, the group of second-level OIG nodes is determined and all OIG nodes that are directly related to the second-level OIG node are removed and used as the deletion starting point. This process is repeated layer by layer until all OIG nodes that are directly or indirectly related to the deleted hyperedge node are removed from the OIG, resulting in a new OIG, and the incremental update information is stored.

[0013] When a hyperedge is modified in a pattern hypergraph, it is considered an atomic operation, which is a combination sequence of adding and deleting hyperedges. First, the original hyperedge is deleted, and then the modified new hyperedge is inserted.

[0014] Furthermore, the implementation of retrieving existing partial matches potentially affected by the addition of superedges in the partial matching state repository is as follows:

[0015] Query the current DDAL to find all neighboring superedges of the newly added superedge e in the target supergraph. Based on the degree of the neighboring superedges of the superedge with the same degree as the newly added superedge e in the pattern supergraph, filter all the neighboring superedges of the newly added superedge e using the same degree as the criterion. Search the partial matching state repository for all partially matching instances of neighboring superedges containing e that meet the requirements after filtering. These instances are candidate partially matching instances that may be expanded by e, and are denoted as candidate partially matching instances. Complete the existing partial matching that may be affected by the addition of the superedge.

[0016] Furthermore, the implementation method for incremental expansion and comparison verification of each candidate partial matching instance is as follows:

[0017] Add the new superedge e to each candidate partial matching instance m' to form a new partial matching m'' = m' ∪{e};

[0018] Instead of recalculating all overlaps of m'', we incrementally calculate the new overlaps between the newly added hyperedge e and the existing hyperedges in m'; we compare the cardinality size of these new overlaps with the newly added nodes at the corresponding positions in the updated OIG; if any overlap does not meet the condition, the entire m'' is pruned immediately; otherwise, m'' is verified as a new valid partial match and added to the partial match state repository.

[0019] Furthermore, the incremental update method for DDAL is as follows: When a new hyperedge is added, the degree of the new hyperedge e is calculated, and the new hyperedge e is added to the list in DDAL corresponding to that degree. All vertices contained in the new hyperedge e are traversed. For each vertex v, all associated hyperedges of v are traversed, which are the new neighbors of the new hyperedge. For each neighboring hyperedge e_neighbor, it is added to the group corresponding to d(e_neighbor) in the group adjacency list of the new hyperedge e. At the same time, e is added to the group corresponding to d(e) in the group adjacency list of e_neighbor. When a hyperedge is deleted, all deleted hyperedges are removed from DDAL.

[0020] According to another aspect of the present invention, an overlap-centric incremental dynamic hypergraph matching system is provided, which performs the incremental dynamic hypergraph matching method as described above, including: a dynamic, redundancy-free compiler, a parallel execution and incremental pruning engine, and a dynamic degree-aware data storage.

[0021] The dynamic, non-redundant compiler analyzes the user-specified pattern hypergraph, constructs and maintains the OIG and the corresponding matching guidance plan; the parallel execution and incremental pruning engine executes the guidance plan and maintains a partial matching state repository; and the dynamic degree-aware data storage stores and provides graph data for the target hypergraph.

[0022] According to another aspect of the present invention, an electronic device is provided, including a memory and a processor, the memory storing a computer program, the processor executing the computer program to implement the steps of the method described above.

[0023] According to another aspect of the invention, a computer-readable storage medium is provided, the computer-readable storage medium including a stored computer program, wherein, when the computer program is run by a processor, it controls the device where the storage medium is located to perform the steps of the method described above.

[0024] According to another aspect of the invention, a computer program product is provided, comprising a computer program or instructions that, when executed by a processor, implement the steps of the method described above.

[0025] In summary, compared with the prior art, the technical solutions conceived by this invention have the following main advantages:

[0026] 1. This invention proposes an overlap-centric incremental dynamic hypergraph matching method, essentially a novel overlap-centric incremental model. It effectively addresses the pattern matching problem of dynamic hypergraphs by fully utilizing the significant overlap similarity inherent in hypergraph pattern mining (i.e., multiple vertices in overlapping hyperedges share the same associated hyperedge) and the incremental characteristics of the model. Specifically, when performing dynamic hypergraph pattern matching, the hypergraph frequently undergoes additions, deletions, and modifications over time. When the pattern hypergraph changes, the overlap index graph (OIG) in the compiler is incrementally modified based on these changes, rather than directly reconstructing the entire OIG. Furthermore, a topological order for pattern matching and an overlap-centric execution plan are generated. When the target hypergraph data changes, the DDAL is incrementally updated, and pattern matching is performed incrementally. Specifically, the candidate OIG nodes in the execution plan are verified against the nodes in the pattern OIG. During this process, incremental pruning is performed based on whether the characteristics of newly added OIG nodes match those of nodes in the pattern OIG, thereby reducing unnecessary computation and verification overhead. Furthermore, the method dynamically updates the original storage structure in real time based on the updates to the target hypergraph, avoiding the reconstruction of the storage structure and greatly reducing computational overhead. This invention introduces a completely new computational paradigm for dynamic hypergraph matching, fundamentally optimizing the performance of dynamic pattern matching. Attached Figure Description

[0027] Figure 1 A flowchart of an incremental dynamic hypergraph matching method centered on overlap provided in an embodiment of the present invention;

[0028] Figure 2 This is a diagram of the overall architecture of OIDHMiner provided in an embodiment of the present invention;

[0029] Figure 3 A diagram illustrating a dynamic, redundancy-free compiler architecture provided in this embodiment of the invention;

[0030] Figure 4 This is a diagram of the parallel execution and incremental pruning engine architecture provided in an embodiment of the present invention;

[0031] Figure 5This is a diagram of a dynamic degree-aware data storage structure provided in an embodiment of the present invention;

[0032] Figure 6 A schematic diagram of a mode hypergraph provided in an embodiment of the present invention;

[0033] Figure 7 Provided for embodiments of the present invention Figure 6 Corresponding OIG diagram;

[0034] Figure 8 Provided for embodiments of the present invention Figure 6 A schematic diagram of a hypergraph after adding a hyperedge;

[0035] Figure 9 Provided for embodiments of the present invention Figure 8 Corresponding OIG diagram;

[0036] Figure 10 Provided for embodiments of the present invention Figure 6 A diagram showing the hypergraph after removing hyperedges;

[0037] Figure 11 Provided for embodiments of the present invention Figure 10 Corresponding OIG diagram;

[0038] Figure 12 A schematic diagram of a target hypergraph provided in an embodiment of the present invention;

[0039] Figure 13 This is a schematic diagram illustrating the update process of the adjacency list in DDAL provided in an embodiment of the present invention;

[0040] Figure 14 This is an updated DDAL schematic diagram provided for an embodiment of the present invention. Detailed Implementation

[0041] To make the objectives, technical solutions, and advantages of this invention clearer, the invention will be further described in detail below with reference to the accompanying drawings and embodiments. It should be understood that the specific embodiments described herein are merely illustrative and not intended to limit the invention. Furthermore, the technical features involved in the various embodiments of this invention described below can be combined with each other as long as they do not conflict with each other.

[0042] Example 1

[0043] An incremental dynamic hypergraph matching method centered on overlap includes:

[0044] The system receives a specified pattern hypergraph and an initial target hypergraph from the user; it stores the initial target hypergraph in a dynamic degree-aware data storage structure DDAL to describe the degree of hyperedges and the connectivity between them; based on the user-specified pattern hypergraph, it constructs and maintains the corresponding overlapping intersection graph OIG and generates a matching execution plan; based on the matching execution plan and DDAL, it performs parallel pattern matching on the target hypergraph and maintains a partial matching state repository to save all subgraph instances that may evolve into complete matches.

[0045] Specifically, when the data of the specified pattern hypergraph changes, the OIG is partially updated: when a hyperedge is inserted, the new overlap relationship brought about by the new hyperedge is calculated and added to the OIG as a new node increment, while merging identical nodes to maintain no redundancy; when a hyperedge is deleted, all affected nodes in the OIG are located and removed; when a hyperedge is modified, the hyperedge modification is regarded as a combination of atomic operations of deletion and insertion.

[0046] When the target hypergraph data changes dynamically, DDAL is updated incrementally and pattern matching is performed incrementally. Incremental pattern matching is performed as follows: When a new hyperedge is added, existing partial matches suspected of being affected by the addition of the new hyperedge are retrieved from the partial matching state repository and recorded as candidate partial matching instances. Each candidate partial matching instance is incrementally expanded, and the newly generated overlap size is calculated. The new overlap size is compared and verified with the matching requirements in the execution plan in conjunction with the current DDAL. Invalid candidate partial matching instances are discarded, and valid partial matching instances are retained. This is incremental pruning. When a hyperedge is deleted, all partial matches containing the deleted hyperedge are located in the partial matching state repository and removed.

[0047] The entire method can be found in [reference]. Figure 1 In DDAL, each hyperedge is grouped according to its degree, and a list of connected hyperedges is maintained for each hyperedge, with the list grouped according to the hyperedge degree. When the schema hypergraph changes, an overlap-centric execution plan is generated based on the latest OIG topology, containing "overlapping execution order" and "overlapping constraints".

[0048] To better understand the method of this embodiment, the meanings of several technical terms will now be explained.

[0049] OIDHMiner: An overlap-centric incremental system for pattern matching in dynamic hypergraphs

[0050] Hypergraph: A generalized graph structure consisting of a set of vertices and a set of hyperedges. Unlike traditional graphs, a hyperedge in a hypergraph can connect any number of vertices, naturally modeling multi-party relationships in the real world.

[0051] Hyperedge: An edge in a hypergraph that can contain two or more vertices and can naturally model multi-party relationships.

[0052] Dynamic Hypergraph: A hypergraph data structure in which vertices or hyperedges change over time through insertion, deletion, and modification.

[0053] Pattern matching is the process of finding all subgraph instances in a data hypergraph that have the same topological structure as a given pattern hypergraph. It is often defined as the sub-hypergraph isomorphism problem.

[0054] Incremental algorithm: An algorithm that responds to queries or maintains results by locally calculating and updating data based on local changes, rather than performing a global recalculation.

[0055] Overlap-centric approach: Shifts the computational focus to the overlap relationships between hyperedges and uses the hyperedges as the basic computational unit.

[0056] Overlapping Intersection Graph (OIG): This is a directed acyclic general graph where each node represents a hyperedge or an overlap. An edge from A to B indicates that B is formed by intersecting A with another node that has an outgoing edge directly connected to B.

[0057] This embodiment proposes an overlap-centric incremental dynamic hypergraph matching method, named OIDHMiner (i.e., an overlap-centric incremental system for dynamic hypergraph pattern matching), aiming to efficiently handle dynamic hypergraph pattern matching. Hypergraphs, as a generalized form of graphs, can naturally model multi-party relationships. In real-world applications, data is often represented by hypergraph structures and changes dynamically over time, enabling better handling of complex system problems. However, most existing hypergraph pattern matching methods rely on static, batch processing paradigms. When the hypergraph undergoes frequent updates (such as hyperedge insertion, deletion, and modification), these methods become inefficient because they require recalculation from scratch. OIDHMiner effectively solves this technical challenge by introducing an overlap-centric incremental execution model. This method can be divided into three core components (such as...) Figure 2 As shown): a dynamic, redundancy-free compiler, a parallel execution and incremental pruning engine, and a dynamic degree-aware data storage. The dynamic, redundancy-free compiler is responsible for generating the overlapping intersection graph (OIG) of the hypergraph, and generating pattern overlap sequences and execution plans based on its OIG. It can also adjust the OIG, pattern overlap sequences, and execution plans in a timely manner to adapt to the dynamic changes of the hypergraph, such as... Figure 3As shown. The parallel execution and incremental pruning engine is responsible for performing pattern matching in parallel according to the execution plan, and using the stored partial matching results to perform efficient incremental checks and pruning on new hyperedges, such as... Figure 4 As shown. Dynamic degree-aware data storage is a hash-based data structure that optimizes the storage and access of hypergraph degree value-related information to accelerate dynamic update operations, such as... Figure 5 As shown, when the hypergraph structure changes, OIDHMiner can locally adjust and update these components, thereby avoiding large-scale redundant calculations and greatly improving processing efficiency and system real-time performance. It is particularly suitable for fields such as social network analysis, bioinformatics, and cybersecurity.

[0058] The method proposed in this embodiment belongs to the field of computer science, particularly the technical scope of data structures, algorithms, and high-performance computing. Specifically, this embodiment involves pattern matching and mining techniques under the hypergraph data model, and how to efficiently perform these tasks in a constantly changing dynamic data environment. This technology is of great value in analyzing complex multilateral relationship data, and its applications are wide-ranging, including but not limited to fraud detection and community discovery in social networks, gene and protein interaction analysis in bioinformatics, abnormal behavior identification in cybersecurity, and traffic flow prediction.

[0059] In its implementation, when OIDHMiner first starts working, it accepts a user-inputted pattern hypergraph and an initial dynamic hypergraph as input. The initial dynamic hypergraph is stored in a dynamic degree-aware data storage structure, which describes the degree of hyperedges and the connectivity between them. This degree-aware data storage structure groups hyperedges according to their degree (number of vertices) and maintains a list of connected hyperedges for each hyperedge, grouped by degree to facilitate efficient matching of the first vertex in the overlap sequence and efficient pruning operations. Next, the user-inputted pattern hypergraph is input into a dynamic, non-redundant compiler for analysis, constructing an Overlapping Intersection Graph (OIG). Based on this, an overlap execution order and an overlap-centric execution plan are generated. During the construction of the OIG, group-based pruning techniques are used to reduce redundant computations in empty overlaps. Finally, the parallel execution and incremental pruning engine identifies all embeddings in the target hypergraph based on the generated overlap-centric execution plan and stores them in the result set.

[0060] When the target hypergraph changes, the method first modifies the relationships between hyperedges in the dynamic degree-aware data storage structure based on the changes in the degree (number of hyperedges) and hyperedge relationships of the target hypergraph. Next, it incrementally modifies the original OIG constructed by the dynamic, redundancy-free compiler, rather than directly reconstructing the entire OIG graph, significantly reducing cost and overhead. Then, it generates an overlap-centric execution plan based on the updated OIG. Finally, the parallel execution and incremental pruning engines identify all embeddings in the updated hypergraph and make corresponding changes to the result set based on the new overlap-centric execution plan and incremental pruning.

[0061] More specifically, this embodiment configures a dynamic, redundancy-free compiler to efficiently address the impact of constantly changing structures of dynamic hypergraphs on OIG construction and execution plans. Specifically, to reduce the computational overhead of directly reconstructing the OIG, the dynamic, redundancy-free compiler incrementally modifies the original OIG, enabling corresponding modifications to the OIG for different operations involving the addition, deletion, and modification of hyperedges. This maximizes the reuse of intermediate results and minimizes computational load.

[0062] As a preferred implementation, when a hyperedge is added to the hypergraph, all hyperedges in the new hypergraph are first traversed. A node is added to each newly added hyperedge in the first layer of the OIG. The overlap relationship (adjacency relationship) between the newly added hyperedge and the original hyperedges is obtained. Then, based on the adjacency relationship of the newly added hyperedges, combined with group-based pruning techniques, the OIG nodes formed by the overlap between the newly added hyperedge node and the original hyperedge are added to the corresponding group in the next layer of the OIG. Next, within each group, the OIG nodes formed by the overlap between each newly added OIG node and all the original OIG nodes in the group are added to the corresponding group in the next layer, and so on, until only one OIG node remains in the corresponding group of the current layer, preventing further merging. This results in a new OIG, and the incremental update information is stored. This incremental OIG modification method not only reduces the overhead of redundant calculations but also eliminates the influence of empty overlaps, maintaining the relative independence between each group.

[0063] When deleting a hyperedge in a hypergraph, the process first traverses the hyperedges. In the first layer of the OIG (Optical Integer Graph), the corresponding first-level OIG node is found and used as the deletion starting point. In the second layer, the group containing the OIG node associated with this starting point is determined. Within each group, all second-level OIG nodes directly related to the deleted hyperedge node are added; these second-level OIG nodes become the new deletion starting points. In the third layer, the group containing the second-level OIG nodes is determined, and within each group, all OIG nodes directly related to the second-level OIG nodes are added. This process continues layer by layer until all OIG nodes directly or indirectly related to the deleted hyperedge node (i.e., all their descendant nodes) are removed from the OIG, resulting in a new OIG, and incremental update information is stored. This operation only affects OIG nodes directly related to the deleted hyperedge, thus ensuring update efficiency.

[0064] When a hyperedge in a hypergraph is modified, such as by adding or deleting a vertex within it, it is treated as a sequence of atomic operations (i.e., adding and deleting a hyperedge). Specifically, the existing hyperedge is first deleted, and then the modified new hyperedge is inserted. This approach ensures the consistency and simplicity of update operations.

[0065] Finally, the dynamic, non-redundant compiler regenerates the pattern-matching topological order and the overlap-centric execution plan based on the updated OIG and the topological order of the nodes in the OIG, and uses it as input for the parallel execution and incremental pruning engine.

[0066] In summary, the Dynamic Redundancy-Free Compiler, one of the core modules of the OIDHMiner system, focuses on dynamically updating the Overlapping Index Graph (OIG) to adapt to changes in the hypergraph and can incrementally generate new pattern overlap sequences and execution plans based on this.

[0067] To better illustrate the impact of different hyperedge operations on OIG and the detailed steps for modifying OIG, examples are given regarding overlapping hyperedges and the inclusion of vertices in the initial hypergraph.

[0068] like Figure 6 As shown, the initial hypergraph contains four hyperedges (e1, e2, e3, e4), where hyperedge e1 contains vertices u1, u2, u5, u6, hyperedge e2 contains vertices u1, u2, u3, u4, hyperedge e3 contains vertices u3, u4, u5, u6, u7, u8, and hyperedge e4 contains vertices u7, u8, u9, u10.

[0069] First, each hyperedge is placed as an OIG node at the top level of the OIG (i.e., stored in the layer vertex LV structure). Then, the relationship between each pair of hyperedge nodes is explored. If there is an overlap, the vertices of the overlapping part are added as a node in the next layer, and the arrow of this pair of nodes points to the newly added node. Next, identical vertices in the next layer are merged to avoid redundant intersection calculations between them in the remaining layers. Then, the vertices of the next layer are stored in the LV, and the nodes of the previous layer in the LV are cleared. The above steps are repeated until the LV is empty. Finally, based on the above steps, we obtain... Figure 6 OIG in Hypergraph, such as Figure 7 As shown.

[0070] During the OIG construction process, it is necessary to eliminate the influence of empty overlap. Therefore, a group-based OIG pruning method is adopted, which uses the disconnection relationship of the current layer node to prune the disconnection relationship of the remaining layer nodes.

[0071] For example, in Figure 6 In the example, e4 is connected to e3, but not to e1 or e2. Then, the nodes in the same layer are divided into several groups, where the predecessor nodes of each group are interconnected. Thus, only the disconnection relationships within a group need to be determined, since the disconnection relationships between groups are already determined by their predecessor groups. For example, consider two groups in the second layer (group 2 and group 3). The predecessor nodes O1, O2, and O3 of group 2 {O5, O6, O7} overlap pairwise, thus they are classified into the same group. However, since the overlap between e2 and e4 is empty, the overlap between O7 and O8 is also empty and they are not classified into the same group.

[0072] (A) Add hyperedge

[0073] S1: Add a top-level super-edge node to generate subsequent overlapping nodes.

[0074] First, add the newly added hyperedge node to the first layer of OIG nodes. Then, add all the nodes formed by the overlap between the newly added hyperedge node and the original hyperedge node to the second layer of nodes. However, these nodes are still in an ungrouped state at this time.

[0075] S2: Add the newly added overlapping nodes of the second layer to the corresponding group and extend the OIG nodes downwards.

[0076] Iterate through all newly added overlapping nodes in the second layer, recording all their predecessor superedge nodes (excluding the newly added superedge node). If these nodes completely match all predecessor nodes in a certain group in the second layer, add all newly added overlapping nodes to that group. Otherwise, group the portion of the newly added overlapping nodes that is a maximal subset of each pair of connected predecessor nodes into a new group. This divides all newly added overlapping nodes into several new groups, thus maintaining the grouping property that the predecessor nodes in each group are interconnected. Next, for groups where newly added overlapping nodes exist, add overlapping nodes of the newly added overlapping nodes with other nodes to the next layer, merging identical nodes into one node, until only one node remains in the group and no more nodes can be added to the next layer.

[0077] For example, Figure 8 The newly added hyperedge is e5, which contains vertices u7, u8, u11, and u12. It only overlaps with e7 and e8 of e3 and e4. Therefore, its newly added overlapping nodes, excluding the newly added hyperedge node, include all its predecessor hyperedge nodes O3 and O4, which are exactly the same as the predecessor nodes in group G3. Therefore, all newly added overlapping nodes are added to this group. Next, overlapping nodes of each pair of nodes in G3 are added to the third layer. It is found that three nodes can be merged into one node, thus satisfying the termination condition. Therefore, the addition of nodes in OIG is complete.

[0078] If OIG is not modified in this incremental manner, it will increase a lot of redundant computational overhead.

[0079] Reason: Dynamic hypergraphs change constantly over time (with the addition, deletion, and modification of hyperedges, etc.), causing the corresponding OIG (Object-Initial Geographic Indicator) to also change over time. If the OIG is reconstructed using the OIG construction algorithm every time the hypergraph changes, and the updated hypergraph only partially modifies the original OIG (i.e., the updated OIG only modifies a portion of the original OIG), then there will be redundant OIG computational overhead for the unchanged parts. This redundant construction overhead will be even more significant when the hypergraph is large. However, using an incremental modification approach can greatly reduce redundant computational costs, thereby improving overall computational efficiency.

[0080] S3: Reassign the node ID to the updated OIG node.

[0081] In the updated OIG, newly added nodes do not have a unique identifier—a node ID. Furthermore, to maintain the order of node IDs in the OIG graph, each OIG node is re-identified using a breadth-first traversal. The final updated OIG is as follows: Figure 9 As shown.

[0082] (B) Delete hyperedges

[0083] S4: Delete all related nodes of the node whose superedge was deleted.

[0084] In the first layer of vertices, find the hyperedge vertex that is about to be deleted and add it to queue Q (to store the OIG node that is about to be deleted). Then, enter a loop, pop the head node of queue Q, add its child nodes to queue Q, and then remove the head node from the OIG. Repeat the above steps until the queue is empty, thus completing the deletion of all related nodes.

[0085] For example, in Figure 6 Delete e4 from the base, such as Figure 10 As shown. In the first layer of nodes, find the vertex O4 that is to be deleted and add it to the queue Q. Then, enter the loop phase: pop the head element O4 from the queue, add its child node O8, and delete O4; then pop the head element O8 from the queue, its child nodes are empty, and delete O8; if the queue is empty, terminate the deletion operation and complete the deletion of the relevant nodes.

[0086] S5: Reassign node IDs to the updated OIG nodes.

[0087] In the updated OIG, newly added nodes do not have a unique identifier—a node ID. Furthermore, to maintain the order of node IDs in the OIG graph, each OIG node is re-identified using a breadth-first traversal. The final updated OIG is as follows: Figure 11 As shown.

[0088] (C) Modify the hyperedge.

[0089] S6: Treating adding and deleting superedges as atomic operations, modifying a superedge is a combination sequence of atomic operations (i.e., deleting the modified superedge and then adding it again). The specific implementation steps can refer to the steps for adding and deleting superedges described above.

[0090] In addition to building and updating OIG, the dynamic, non-redundant compiler also performs overlap-centric execution plan generation, with the following specific steps:

[0091] S7: Generate a pattern matching order based on topological sorting.

[0092] The pattern matching order is generated based on the topological order of the nodes in the updated OIG.

[0093] by Figure 11For example, when expanding O1, only O1 can be matched. However, when expanding O2, since its predecessor node has already been matched, O4 can be matched. Similarly, when expanding O3, since its predecessor node has already been matched, we can match O5 and O6. Therefore, the overlapping order of the example OIG is {O1, O2O, 4, O3, O5, O6}.

[0094] S8: Generate an execution plan centered on overlaps.

[0095] The updated OIG pattern and the pattern overlap order are combined to form a sequence of set operations and comparison operations organized in the overlap order. This sequence is used to compute the candidate set for each vertex in the overlapping graph, which is the overlap-centric execution plan. In OIG, the execution plans for hyperedge vertices and overlapping vertices guide candidate generation and candidate verification in the hypergraph matching process, respectively.

[0096] Furthermore, and more specifically, the method in this embodiment is configured with a parallel execution engine that supports incremental processing. This engine maintains a dynamic partial matching state store to track all currently valid embedding instances that are partially isomorphic to the pattern. When the hypergraph changes, the engine receives incremental update information from the non-redundant compiler and incrementally expands and prunes the stored partial matching state based on this information. Its core idea is:

[0097] 1) State persistence: Maintaining valid partial matches during hypergraph changes to avoid redundant computation;

[0098] 2) Incremental verification: Only the local matches affected by the changes are re-verified or expanded;

[0099] 3) Collaborative pruning: Working closely with a dynamic, non-redundant compiler, it utilizes updated OIG information for early pruning, greatly reducing invalid computational paths.

[0100] 4) A parallel computing module is used to distribute different initial matches or branches affected by different update events to multiple computing units to execute the above incremental processing in parallel.

[0101] As a preferred implementation method, the specific implementation steps are as follows, wherein the step numbers follow the execution step numbers of the dynamic, non-redundant compiler to reflect the flow of the entire method.

[0102] S9: State Initialization: On the initial hypergraph H(t0), the engine uses the static OHMiner algorithm to complete a full pattern mining operation and stores all found partial and full matches in the state repository.

[0103] S10: Handle the super-edge insertion event (ΔE = +e).

[0104] A. Candidate Matching Retrieval

[0105] When the engine receives a new hyperedge e, it first queries the current DDAL to find all neighboring hyperedges of the new hyperedge e in the target hypergraph. Based on the degree of the neighboring hyperedges of the new hyperedge e with the same degree in the mode hypergraph, the engine filters all the neighboring hyperedges of the new hyperedge e, using the same degree as the criterion. The engine then searches the partial matching state repository for all partially matching instances of neighboring hyperedges containing e that meet the requirements after filtering. These instances are candidate partially matching instances that may be expanded by e, and are denoted as candidate partially matching instances. This completes the existing partial matching that may be affected by the addition of the hyperedge.

[0106] B. Incremental Expansion and Verification

[0107] For each candidate partial match instance m', the engine attempts to add e to it to form a new partial match m'' = m' ∪ {e}.

[0108] C. Overlapping pruning (core)

[0109] Instead of recalculating all overlaps in m'', the engine incrementally calculates the new overlaps between the new hyperedge e and existing hyperedges in m'. The engine immediately compares the cardinality (size) of these new overlaps with the requirements (new nodes) for the corresponding positions in the updated OIG pattern provided by the compiler. If any overlap does not meet the condition (e.g., |e ∩ e_i| ≠ |pe_j ∩ pe_k|), the entire m'' is immediately pruned. Otherwise, m'' is validated as a new valid partial match and added to the state repository.

[0110] S11: Handle the super-edge deletion event (ΔE = -e).

[0111] A. State invalidation

[0112] The engine receives the deleted hyperedge e and performs a query directly in the partial matching state store to find all partial matching instances containing the hyperedge e.

[0113] B. Batch Removal

[0114] Mark all these instances as invalid and remove them from storage. This operation is simple and efficient, with complexity proportional to the number of matching instances containing 'e'.

[0115] S12: Parallel execution.

[0116] The engine employs task-level parallelism. Each initial candidate superedge, or each incremental expansion branch triggered by an update event, can be encapsulated as an independent task. These tasks are placed in a shared queue and executed in parallel by a group of worker threads through dynamic scheduling (such as work stealing), fully utilizing multi-core resources to process continuous data streams. Parallelism hides the latency of individual incremental verification tasks, significantly improving the system's throughput and response speed in dynamic environments.

[0117] Furthermore, more specifically, the method in this embodiment configures a dynamic degree-aware data storage. This dynamic degree-aware storage structure, through degree-based grouping and maintaining a grouped adjacency list, enables the execution engine to quickly skip a large number of hyperedges that do not meet degree constraints during candidate generation, significantly reducing the search space and providing efficient data supply for dynamic hypergraph pattern mining. For example, for... Figure 12 The hypergraph can calculate and store data as shown in Table 1.

[0118] Table 1 Figure 12 DAL of Instance Hypergraph

[0119]

[0120] S13: Initialization process:

[0121] The system loads an initial static snapshot of the hypergraph and calculates the degree d(e) for each hyperedge e. Then, it constructs the main hash table DAL_Map: { degree -> list of hyperedges}. Simultaneously, it constructs a grouped adjacency list for each hyperedge e: grouping all its neighboring hyperedges adj(e) according to their degrees, resulting in a structure of the form { degree_i -> [neighborswith degree_i]}.

[0122] S14: Handling the super-edge insertion event (ΔE = +e):

[0123] A. Calculate degrees

[0124] Calculate the degree d(e) of the new hyperedge e.

[0125] B. Update the main structure

[0126] Add e to the list corresponding to DAL_Map[d(e)].

[0127] C. Update adjacency information

[0128] Iterate through all vertices contained in `e`. For each vertex `v`, iterate through all associated hyperedges of `v` (i.e., new neighbors of `e`). For each neighbor hyperedge `e_neighbor`, add it to the group corresponding to `d(e_neighbor)` in `e`'s grouped adjacency list. Simultaneously, add `e` to the group corresponding to `d(e)` in `e_neighbor`'s grouped adjacency list. These update operations are local, affecting only the new hyperedge itself and its neighboring hyperedges, making them extremely efficient.

[0129] For example, a new hyperedge e6 (degree 4) is added, which contains vertex vx. vx was originally associated with hyperedges e1 (degree 6) and e2 (degree 8). After the update: DAL_Map[4] contains e6; the adjacency list of e6 adds groups 6:[e1] and 8:[e2]; at the same time, the adjacency list of e1 adds e6 to group 4:, and the adjacency list of e2 also adds e6 to group 4:. The adjacency list update process is as follows Figure 13 As shown.

[0130] The comparison chart of DAL_MAP before and after the update is as follows: Figure 14 As shown.

[0131] S15: Handle the edge deletion event (ΔE = -e):

[0132] A. Update the main structure

[0133] Remove e from the list corresponding to DAL_Map[d(e)].

[0134] B. Update adjacency information

[0135] Iterate through all neighbor superedges of e (which can be obtained from its grouped adjacency list). For each neighbor superedge e_neighbor, remove e from the group corresponding to d(e) in its grouped adjacency list.

[0136] C. Cleaning

[0137] Clean up and free up storage space for e itself.

[0138] S16: Handle vertex events (causing changes in hyperedge degree) (ΔV).

[0139] This is the most complex case, where inserting or deleting a vertex v will affect the degree of all superedges E_v containing v.

[0140] A. Mark

[0141] Label all e ∈ E_v, and their degree d(e) will become d'(e).

[0142] B. Atomic Update

[0143] For each affected hyperedge e, execute:

[0144] a) Remove e from DAL_Map[d(e)].

[0145] b) Add e to DAL_Map[d'(e)].

[0146] c) Notify all neighbors of e's superedge: the neighbors need to remove e from the original d(e) group in their adjacency list and add it to the new d'(e) group.

[0147] d) Update e's own degree label.

[0148] By changing the degree grouping, the filtering information required for candidate generation is automatically maintained. However, at the same time, a single vertex update may trigger a chain reaction of degree changes and adjacency information updates for a large number of hyperedges (write amplification). Carefully designed batch processing strategies are needed to mitigate the performance impact.

[0149] S17: Query interface.

[0150] Provides efficient query interfaces for the execution engine, such as: get_hyperedges_by_degree(k): directly returns DAL_Map[k]. get_neighbors_with_degree(e, k): directly accesses the grouped adjacency list of e and returns all neighbor hyperedges under group k, without traversing the entire adjacency list and performing degree filtering, which is a huge advantage compared to traditional storage structures.

[0151] To better illustrate the effectiveness of the method of the present invention, the following practical examples are given:

[0152] The core value of OIDHMiner in real-time risk control and anti-fraud systems

[0153] 1. Real-time financial transaction risk control

[0154] Application Scenario: A large payment platform needs to monitor hundreds of thousands of transactions per second in real time to detect fraud patterns such as credit card fraud, cash-out schemes, and money laundering. These patterns typically involve multiple entities (users, merchants, devices, IP addresses) colluding through complex relationships within a short period, making them naturally suitable for hypergraph modeling (user-transaction-merchant, forming hyperedges). Traditional systems based on static graphs or rule engines cannot handle dynamic streaming data and face bottlenecks such as high computational latency and slow pattern matching. However, by introducing OIDHMiner as a real-time pattern matching engine, the following improvements are achieved:

[0155] Performance improvement: Dynamic incremental matching reduces the latency of suspicious pattern detection from minutes to milliseconds, achieving true real-time blocking.

[0156] Memory optimization: Partial matching state storage and DDAL's incremental update mechanism significantly reduce system memory usage compared to the full recalculation scheme, allowing for longer transaction time windows for analysis.

[0157] Improved accuracy: Precise matching based on overlapping structures avoids false alarms based on statistical features, significantly improving fraud detection accuracy.

[0158] Product advantages:

[0159] Payment platforms have significantly reduced the average amount of loss from fraudulent transactions;

[0160] The risk control team no longer needs to write thousands of hard rules; they only need to draw a fraud pattern hypergraph, and the system can automatically identify variant attacks.

[0161] It supported a dramatic increase in business volume without requiring a large-scale expansion of the risk control system.

[0162] 2. Real-time updates and mining of biomedical knowledge graphs

[0163] Application scenarios:

[0164] Biomedical research institutions have constructed a vast knowledge graph containing complex many-to-many relationships between entities such as drugs, proteins, diseases, and side effects (e.g., a drug treats a disease and causes multiple side effects by acting on multiple protein targets). Thousands of new papers are published daily, generating new knowledge connections (new hyperedges). Researchers need to instantly determine whether this new knowledge matches certain important patterns (such as known drug reuse patterns or side effect warning patterns). This is addressed by introducing OIDHMiner as a real-time reasoning engine for the knowledge graph.

[0165] Incremental mining: After the relations (new hyperedges) extracted from new papers are input into the system, there is no need to re-mine the entire graph. OIDHMiner can complete the matching and verification of new knowledge with existing patterns in seconds.

[0166] Complex pattern matching: It can efficiently match complex patterns containing multiple entities (such as "drug A-target group B-pathway C-disease D"), with a matching speed that is orders of magnitude faster than traditional static graph queries.

[0167] Interpretability: The matching results directly correspond to the overlapping relationships in the OIG pattern, providing researchers with interpretable matching paths rather than "black box" results.

[0168] Product advantages:

[0169] Researchers have found that the time to find new indications for potential drugs has been shortened from months to days.

[0170] Drug safety monitoring teams can identify potential drug side effect signals earlier through literature, enabling early warning.

[0171] This transforms the knowledge graph from a static database into a "living" system capable of digesting new knowledge and generating insights in real time.

[0172] 3. Cloud infrastructure security monitoring

[0173] Application scenarios:

[0174] Cloud service providers need to monitor the dynamic access relationships between entities (VMs, containers, Pods, users, APIs) within their vast infrastructure to detect attack patterns such as lateral movement, privilege escalation, and data leakage. These relationships are constantly changing, forming a highly dynamic hypergraph. By introducing OIDHMiner as the brain of security threat detection:

[0175] Real-time response: Any new access relationship established (hyperedge insertion) or revoked (hyperedge deletion) will trigger the engine's incremental processing flow, completing a pattern matching check in a very short time.

[0176] Resource efficiency: The DDAL structure enables the engine to perform exceptionally well when querying "all entities connected to a suspicious VM with high connectivity," resulting in extremely high efficiency and significantly reduced CPU load. Reduced false alarms: Precise hypergraph isomorphic matching effectively reduces threshold-based false alarms, significantly increasing the proportion of valid alarms while reducing the number of alarms.

[0177] Product advantages:

[0178] The cloud platform provides customers with near real-time security threat detection capabilities, which has become its core competitive advantage.

[0179] The Security Operations Team (SOC) has shifted its focus from sifting through massive amounts of alerts to investigating specific threat events, resulting in a significant increase in efficiency.

[0180] Example 2

[0181] An overlap-centric incremental dynamic hypergraph matching system executes the incremental dynamic hypergraph matching method as described in Embodiment 1, including: a dynamic, redundancy-free compiler, a parallel execution and incremental pruning engine, and a dynamic degree-aware data storage.

[0182] The dynamic, non-redundant compiler analyzes the user-specified pattern hypergraph, constructs and maintains the OIG and the corresponding matching guidance plan; the parallel execution and incremental pruning engine executes the guidance plan and maintains a partial matching state repository; and the dynamic degree-aware data storage stores and provides graph data for the target hypergraph.

[0183] The relevant technical solutions are the same as above, and will not be repeated here.

[0184] Example 3

[0185] This application also relates to an electronic device, including a memory and a processor, wherein the memory stores a computer program, and the processor executes the computer program to implement the steps of the method described above.

[0186] The electronic device can be a desktop computer, laptop, handheld computer, or cloud server, etc. The processor can be a Central Processing Unit (CPU), or other general-purpose processors, digital signal processors (DSPs), application-specific integrated circuits (ASICs), field-programmable gate arrays (FPGAs), or other programmable logic devices, discrete gate or transistor logic devices, discrete hardware components, etc. The memory can be used to store computer programs and / or modules. The processor performs various functions of the electronic device by running or executing the computer programs and / or modules stored in the memory, and by accessing data stored in the memory.

[0187] The relevant technical solutions are the same as above, and will not be repeated here.

[0188] Example 4

[0189] This application also relates to a computer-readable storage medium having a computer program stored thereon, which, when executed by a processor, implements the steps of the method described above.

[0190] Specifically, the memory may include high-speed random access memory, as well as non-volatile memory, such as hard disks, RAM, plug-in hard disks, smart media cards (SMC), secure digital (SD) cards, flash cards, at least one disk storage device, flash memory device, or other volatile solid-state storage devices.

[0191] The relevant technical solutions are the same as above, and will not be repeated here.

[0192] Example 5

[0193] This application provides a computer program product or computer program that includes computer instructions stored in a computer-readable storage medium. A processor of a computer device reads the computer instructions from the computer-readable storage medium and executes the computer instructions, causing the computer device to perform the steps of the method described in the above embodiments of this application.

[0194] The relevant technical solutions are the same as above, and will not be repeated here.

[0195] Those skilled in the art will readily understand that the above description is merely a preferred embodiment of the present invention and is not intended to limit the present invention. Any modifications, equivalent substitutions, and improvements made within the spirit and principles of the present invention should be included within the scope of protection of the present invention.

Claims

1. An incremental dynamic hypergraph matching method centered on overlap, characterized in that, include: Receive user input for a specified mode hypergraph and an initial target hypergraph; The initial target hypergraph is stored in a dynamic degree-aware data storage structure DDAL to describe the degree of hyperedges and the connectivity between them. Based on the user-specified pattern hypergraph, the overlapping intersection graph OIG corresponding to the pattern hypergraph is constructed and maintained, and a matching execution plan is generated accordingly. Based on the matching execution plan and DDAL, parallel pattern matching is performed on the target hypergraph, and a partial matching state repository is maintained to save all subgraph instances that may evolve into complete matches. Specifically, when the data of the specified pattern hypergraph changes, the OIG is partially updated: when a hyperedge is inserted, the new overlap relationship brought about by the new hyperedge is calculated and added to the OIG as a new node increment, while merging identical nodes to maintain no redundancy; when a hyperedge is deleted, all affected nodes in the OIG are located and removed; when a hyperedge is modified, the hyperedge modification is regarded as a combination of atomic operations of deletion and insertion. When the target hypergraph data changes dynamically, DDAL is updated incrementally and pattern matching is performed incrementally. Incremental pattern matching is performed as follows: When a new hyperedge is added, existing partial matches suspected of being affected by the addition of the new hyperedge are retrieved from the partial matching state repository and recorded as candidate partial matching instances. Each candidate partial matching instance is incrementally expanded, and the newly generated overlap size is calculated. The new overlap size is compared and verified with the matching requirements in the execution plan in conjunction with the current DDAL. Invalid candidate partial matching instances are discarded, and valid partial matching instances are retained. This is incremental pruning. When a hyperedge is deleted, all partial matches containing the deleted hyperedge are located in the partial matching state repository and removed.

2. The incremental dynamic hypergraph matching method as described in claim 1, characterized in that, When a new hyperedge is added to the pattern hypergraph, all hyperedges in the new hypergraph are traversed first. In the first layer of the OIG, a node is added for each newly added hyperedge. The overlap relationship between the newly added hyperedge and the original hyperedge is obtained, i.e., the adjacency relationship. Then, based on the adjacency relationship of the newly added hyperedge, combined with group-based pruning techniques, the OIG node formed by the overlap of the newly added hyperedge node and the original hyperedge is added to the corresponding group in the next layer of the OIG. Next, within the group, each newly added OIG node is added to the corresponding group in the next layer below, and so on, until the corresponding group in the current layer has only one OIG node left and cannot be merged further. A new OIG is obtained, and the incremental update information is stored. When deleting a hyperedge in a pattern hypergraph, the hyperedges in the hypergraph are first traversed. In the first layer of the OIG, the first-level OIG node corresponding to each deleted hyperedge is found and used as the deletion starting point. In the second layer, the group of OIG nodes associated with the starting point is determined. In each group, all second-level OIG nodes that are directly related to the deleted hyperedge node are removed and used as the new deletion starting point. In the third layer, the group of second-level OIG nodes is determined and all OIG nodes that are directly related to the second-level OIG node are removed and used as the deletion starting point. This process is repeated layer by layer until all OIG nodes that are directly or indirectly related to the deleted hyperedge node are removed from the OIG, resulting in a new OIG, and the incremental update information is stored. When a hyperedge is modified in a pattern hypergraph, it is considered an atomic operation, which is a combination sequence of adding and deleting hyperedges. First, the original hyperedge is deleted, and then the modified new hyperedge is inserted.

3. The incremental dynamic hypergraph matching method as described in claim 1, characterized in that, The implementation of retrieving existing partial matches suspected of being affected by the addition of hyperedges from the partial matching state repository is as follows: Query the current DDAL to find all neighboring superedges of the newly added superedge e in the target supergraph. Based on the degree of the neighboring superedges of the superedge with the same degree as the newly added superedge e in the pattern supergraph, filter all the neighboring superedges of the newly added superedge e using the same degree as the criterion. Search the partial matching state repository for all partially matching instances of neighboring superedges containing e that meet the requirements after filtering. These instances are candidate partially matching instances that may be expanded by e, and are denoted as candidate partially matching instances. Complete the existing partial matching that may be affected by the addition of the superedge.

4. The incremental dynamic hypergraph matching method as described in claim 3, characterized in that, The implementation method for incremental expansion and comparison verification of each candidate partial matching instance is as follows: Add the new superedge e to each candidate partial matching instance m' to form a new partial matching m'' = m' ∪ {e}; Incrementally calculate the new overlap between the newly added hyperedge e and the existing hyperedges in m'; compare the cardinality size of the new overlap with the newly added node at the corresponding position of the overlap in the updated OIG; If any overlap does not satisfy the condition, the entire m'' is pruned immediately; otherwise, m'' is verified as a new valid partial match and added to the partial match state repository.

5. The incremental dynamic hypergraph matching method as described in claim 1, characterized in that, The incremental update method for DDAL is as follows: When a new hyperedge is added, the degree of the new hyperedge e is calculated, and the new hyperedge e is added to the list in DDAL corresponding to that degree. All vertices contained in the new hyperedge e are traversed. For each vertex v, all associated hyperedges of v are traversed, which are the new neighbors of the new hyperedge. For each neighbor hyperedge e_neighbor, it is added to the group corresponding to d(e_neighbor) in the group adjacency list of the new hyperedge e. At the same time, e is added to the group corresponding to d(e) in the group adjacency list of e_neighbor. When a hyperedge is deleted, all deleted hyperedges are removed from DDAL.

6. An incremental dynamic hypergraph matching system centered on overlap, characterized in that, The incremental dynamic hypergraph matching method as described in any one of claims 1 to 5 includes: a dynamic, redundancy-free compiler, a parallel execution and incremental pruning engine, and a dynamic degree-aware data storage. The dynamic, non-redundant compiler analyzes the user-specified pattern hypergraph, constructs and maintains the OIG and the corresponding matching guidance plan; the parallel execution and incremental pruning engine executes the guidance plan and maintains a partial matching state repository; and the dynamic degree-aware data storage stores and provides graph data for the target hypergraph.

7. An electronic device comprising a memory and a processor, wherein the memory stores a computer program, characterized in that, When the processor executes the computer program, it implements the steps of the method as described in any one of claims 1 to 5.

8. A computer-readable storage medium, characterized in that, The computer-readable storage medium includes a stored computer program, wherein the computer program, when executed by a processor, controls the device on which the storage medium is located to perform the steps of the method as described in any one of claims 1 to 5.

9. A computer program product, comprising a computer program or instructions, characterized in that, When the computer program or instructions are executed by a processor, they implement the steps of the method as described in any one of claims 1 to 5.

Images