Query method for closely associated transaction account group

Abstract

The invention belongs to the technical field of computers, and discloses a query method for a closely associated transaction account group, which comprises the following steps of: 1, extracting all connected k-trus communities in a global time interval of an account transaction network, and calculating a real time interval; step 2, carrying out forward evolution refinement; step 3, carrying out backward evolution refinement; step 4, constructing a DAG index structure of the time evolution community; step 5, querying the maximum connected k-trus community of the given account in a specified time interval by using the index; and step 6, returning a query result. According to the method, by constructing the account community structure diagram evolved in the time interval, the repeatedly stored community information is effectively compressed, and the expression ability and query efficiency of account community evolution in a cross-time range are improved. Through recursive stripping and sharing of edge sets among communities, minimum redundant community representation across multiple time windows is realized, and the storage overhead is remarkably reduced while the historical integrity of the communities is ensured.

Description

TECHNICAL FIELD

[0001] The present application belongs to the technical field of computer, more particularly, relates to a method for mining and searching associated transaction account groups based on structural density and time connectivity for a financial transaction network. BACKGROUND

[0002] In the process of financial transactions, illegal gambling and money laundering criminal groups often use a large number of accounts to conduct high-frequency and chain-like fund transfer operations in a short period of time to cover up illegal sources of funds. Such behavior often manifests as intensive transactions among multiple accounts in a short period of time, forming a ring-like or closed-loop transfer path, forming a so-called "money laundering chain" or "waterwheel" structure.

[0003] The K-truss community model is a classical graph mining method used to depict the dense relationships between nodes in a network. In a transaction network, accounts can be regarded as nodes in a graph, and transfer relationships can be regarded as edges. In the definition of the K-truss community model, there are edges (transfer relationships) between nodes (accounts), and k-truss depicts the close interaction relationship within the account group based on the triangular support characteristics of the transfer relationship between accounts, that is, each edge (transfer relationship) must simultaneously appear in (k-2) triangles composed of nodes and edges, thereby forming a dense subgraph structure with high cohesion. In other words, the k-truss community model can depict the highly dense subgraph structure formed between accounts, and is commonly used for group discovery in social networks, communication networks, and financial transaction networks.

[0004] However, the traditional K-truss community model is essentially a static structure model and does not include a time dimension. In the financial transaction scenario, if only the static k-truss decomposition is relied upon, the system can only identify whether there is a dense relationship between accounts, and cannot determine the specific time at which such a relationship occurred and its duration. This can cause two serious problems:

[0005] 1. Unable to distinguish between historical and current relationships: Some accounts may have formed highly dense transaction relationships in the past, but are no longer active currently. The static model will mistakenly confuse these historical relationships with currently active relationships, leading to distorted risk identification.

[0006] 2. Difficulty in discovering short-time high-risk behavior: Gambling and money laundering groups often operate funds intensively within a short time window, forming "time-sensitive" high-risk groups. If the time dimension is ignored, these short-time high-frequency dense groups cannot be accurately captured, thereby masking the true high-risk signals.

[0007] Taking a specific scenario as an example, suppose that accounts A, B and C jointly constitute a static k-truss group in a historical transaction network. High-frequency transactions between accounts A and B mainly occur a year ago, and after this fund operation, account A no longer participates in any similar transactions; while accounts B and C frequently transact with each other in the past month and form a ring or closed-loop fund transfer network in a short period of time, suspected of current active gambling money laundering activities. Since the traditional static model cannot distinguish the time of transaction occurrence, the system will mistakenly regard accounts A, B and C as a current high-risk active group, and cannot accurately identify the short-time group composed of B and C.

[0008] Therefore, in highly time-sensitive risk scenarios such as gambling money laundering, the structural density and time connectivity of the transaction network must be considered simultaneously to ensure that the communities mined are not only structurally dense, but also maintain collaborative transaction relationships within a specific time interval, so as to accurately identify the current active high-risk account community. SUMMARY

[0009] The purpose of the present application is to overcome the above technical problems existing in the prior art, fully consider the structural density and time connectivity (association within a time interval) of the transaction relationship between accounts in the financial transaction network, and propose an account community search method based on the time connectivity k-truss community model, which can realize efficient group behavior query of a specific account.

[0010] The present application models the accounts and transaction relationships in the financial transaction network as an evolution graph G=(V,E,T), where V={v1,v2,v3,...} represents the account set, E represents the transaction relationship set, T represents the timestamp set, each edge e E represents a fund transfer between accounts, and is associated with the transaction time t T.

[0011] The present application proposes a financial fraud account group detection method based on the time connectivity k-truss community model, which aims to overcome the defects in the prior art that only focus on structural density and ignore time characteristics and target account query requirements, and can efficiently mine high-risk account communities that are time-connected and contain a specific target account in the financial transaction evolution graph.

[0012] The time connectivity k-truss community in the present application must satisfy the following conditions:

[0013] (1) Structural density constraint (k-truss)

[0014] The support number support(e) of any transaction edge in the community is not less than (k-2), that is, each transaction edge participates in at least (k-2) triangle closed loop transaction structures, so as to ensure the high structural strength and tightness of the transaction relationship in the community. The triangle closed loop refers to a closed transaction loop formed between three accounts in the transaction network.

[0015] (2) Time connectivity (association maintenance in a time interval) and target account inclusion constraint

[0016] The community must include the specified target account v_q in a given time interval [t_start, t_end], and all accounts in the community must maintain association through the transaction edge in the time period, that is, there is a path between the target account v_q and any other account in the community formed by the transaction edge in the time period, so as to meet the time interval association maintenance and target account directional query requirements, and ensure the collaborative activity and traceability of the community in the time interval.

[0017] (3) Maximum constraint

[0018] The community must be a maximum subgraph, that is, there is no other larger subgraph that simultaneously satisfies the above structural density and time connectivity, target account inclusion merging constraints and contains the current community, to ensure that the mined community cannot be further expanded in the current time interval.

[0019] By introducing the above constraints, the present application can accurately and efficiently mine a high-structural-strength risk account group containing a target account that maintains stable cooperation in time in a financial transaction dynamic graph, and is widely applicable to anti-fraud investigation, anti-money laundering analysis, risk account tracking and financial compliance review scenes.

[0020] The present application proposes a new DAG structure index for the directed acyclic graph (DAG) structure of the time interval evolution relationship, which includes all community sets satisfying the time connectivity k-truss constraint in the entire transaction evolution graph, and can efficiently support the group query task of the target account. The specific technical solution steps are as follows:

[0021] Step 1, extract all connected k-truss communities in the global time interval of the account transaction network and calculate the actual time interval, on the global time interval [Ts, Te] of the account transaction network, use the k-truss decomposition algorithm to extract all connected subgraphs satisfying the support condition, to form an initial community set. At the same time, the earliest and latest time stamp of the transaction edge in each community is calculated to determine its actual effective time interval [ts_actual, te_actual].

[0022] Step 2, forward evolution, evolving from the time interval [Ts+1, Te] to the last possible time interval [Te, Te] in the forward direction, for example, from the time interval [1, 6] to [2, 6]... until the possible time interval [6, 6]. For each time slice [ts, Te], inherit the community of the previous interval, under the premise of inheriting validity, use the TPCA algorithm (Temporal Peel Connectivity Algorithm) to peel off the transaction edges that do not meet the conditions, update the support of the inherited community and extract new connected k-truss sub-communities, while recording the new real and valid time range.

[0023] Step 3, backward evolution, each time interval [ts, Te] generated from step 2 is pushed backward to the last possible time interval [ts, ts] in the backward direction, for example, from the time interval [1, 6] to [1, 5]... until the possible time interval [1, 1]. For each interval [ts, te], inherit the community of the next interval, judge its validity, and apply the TPCA algorithm to update the community structure to generate backward evolution k-truss sub-communities and recalculate their real and valid time range.

[0024] Step 4, build a directed acyclic graph (DAG) structure of the community evolution index. Sort all communities C[ts, te] in ascending order of start time and descending order of interval length. Establish parent-child relationships between real communities and their sub-communities in adjacent intervals, and eliminate edge set redundancy. For non-real generated communities (i.e., the time interval [ts, te] of C[ts, te] and the actual time interval [ts_actual, te_actual] are different) but structurally equivalent communities, associate their real communities and eliminate redundant sub-communities to build parent-child relationships. Delete communities without parent-child relationships and empty edge sets to finally obtain a compressed and redundant-free DAG index structure.

[0025] Step 5, query the maximum connected k-truss community of the target account based on the index. Input the target account, query time interval and k value, locate the community and time segment it belongs to through the index, and backtrack to the maximum ancestor community within the time range to finally determine the maximum connected k-truss community the target account belongs to within the query interval.

[0026] Step 6, return the query result.

[0027] Further, the specific implementation of each step is as follows:

[0028] Step 1: Extract all connected k-truss communities in the global time interval of the account transaction network and calculate the real time interval.

[0029] Step 1.1: Input the account transaction network evolution graph G = (V, E, T), where V = {v1, v2, v3, ...} is the set of accounts, E = {(u, v, t)} is the set of transaction edges with timestamp t, and T is the set of timestamps of all transactions, where the minimum timestamp and the maximum timestamp are Ts and Te, respectively.

[0030] Step 1.2: Extract k-truss communities within the time interval [Ts, Te].

[0031] Step 1.2.1: Within the time interval [Ts,Te], delete all transaction edges whose timestamps do not belong to this interval.

[0032] Step 1.2.2: In the remaining graph, calculate the support of each edge (i.e., the number of triangles it belongs to).

[0033] Step 1.2.3: Iteratively strip edges with support less than (k-2) until all remaining edges satisfy the k-truss condition.

[0034] Step 1.2.4: Extract all connected k-truss subgraphs Ci[Ts,Te] to form the initial connected community set C[Ts,Te].

[0035] Step 1.3: Calculate the actual time interval for each community Ci. For each transaction edge in a community, count the earliest and latest timestamps to obtain the actual active time interval [ts_actual, te_actual].

[0036] Step 2: Forward Evolution Refinement

[0037] Step 2.1: Inherit the community set from the previous interval. Starting from the time interval [Ts+1,Te] and ending at [Te,Te], for the time interval [ts,Te], inherit the community set from the previous time interval [ts-1,Te].

[0038] Step 2.2: Determine the validity of the community. For each inherited community, if the community's ts_actual is greater than ts, it means that the community is not valid in the current time interval and is skipped; otherwise, continue processing.

[0039] Step 2.3: Refine the communities. Within the time interval [ts, Te], perform the Temporal Peel Connectivity Algorithm (TPCA) operation on communities that meet the conditions in Step 2.2:

[0040] Step 2.3.1: Delete the edges whose timestamps do not belong to the time interval [ts,Te].

[0041] Step 2.3.2: Update the support of the affected edges on the calculated inherited community support.

[0042] Step 2.3.3: Iteratively remove edges that do not satisfy the k-truss condition and dynamically update the support of the affected edges.

[0043] Step 2.3.4: Extract connected k-truss subgraphs Ci[ts, Te] from the processed graph. Extract sub-communities C[ts, Te].

[0044] Step 2.4: Calculate the real time interval of each connected community Ci[ts, Te]. For each transaction edge in the community, count the earliest and latest timestamps to obtain the real active time interval [ts_actual, te_actual] of the community.

[0045] Step 3: Backward evolution refinement

[0046] Step 3.1: Inherit (reuse results) the community of the previous interval. For each C[ts, Te] obtained in step 2, start from the time interval [ts, Te-1] to [ts, ts], and for the time interval [ts, te], inherit the community set in the next time interval [ts, te+1].

[0047] Step 3.2: Judge community effectiveness. For each inherited community: if the community's te_actual is less than te, it means that the community is not effective within the current time interval, skip; otherwise, continue processing.

[0048] Step 3.3: Refine the community. In the time interval [ts, te], execute TPCA on the community that meets the conditions of step 3.2, re-extract the k-truss, and extract the sub-community C[ts, te].

[0049] Step 3.4: Calculate the real time interval of each community. For each transaction edge in the community, count the earliest and latest timestamps to obtain the real active time interval [ts_actual, te_actual] of the community.

[0050] Step 4: Build a DAG index structure for time-evolving communities

[0051] Step 4.1: Sort all time interval community sets. Sort all community sets C[ts, te] according to the following sorting rules: (1) If ts1 < ts2, then C[ts1, te1] is placed before C[ts2, te2]; (2) If ts1 = ts2, then sort according to the interval length te1-ts2 in descending order, i.e. longer time interval is placed in front. After sorting, a globally ordered community set sequence is obtained, denoted as C_sorted.

[0052] Step 4.2: Refinement propagation on sub-intervals, for each community interval C[ts,te] ∈ C_sorted, perform the following operations on all communities Ci[ts,te] within it:

[0053] (1) If this community is an actual community generated by the real window (i.e. [ts,te] == [ts_actual,te_actual], ts_actual and te_actual are the minimum and maximum timestamps of edges within this community):

[0054] Step 4.2.1: Find the subset communities of the edge set of Ci[ts,te] from its sub-intervals [ts+1,te] and [ts,te-1], denoted as C'.

[0055] Step 4.2.2: Add these C' as "child communities" of Ci[ts,te] to its children set.

[0056] Step 4.2.3: Remove all edges owned by C' from the edge set of Ci[ts,te] to prevent redundant duplication of edges.

[0057] (2) If this community is not an actual community generated by the real window (i.e. [ts,te] ≠ [ts_actual,te_actual], but its edge set is the same as Ci[ts_actual,te_actual]):

[0058] Step 4.2.4: Add the actual community Ci[ts_actual,te_actual] to C'.

[0059] Step 4.2.5: Similarly find the subset communities Ci' of its edge set in [ts+1,te] and [ts,te-1]: (1) If there exists a subset community Ci' == Ci[ts,te], but at this time Ci' has not been marked as a subset community (i.e. has no father), it is considered a redundant copy and is removed from the sub-interval; (2) If Ci' ≠ Ci[ts,te], add Ci' as a "child community" of Ci[ts,te], and remove the edges of Ci' from the edge set of Ci[ts,te] to prevent duplication.

[0060] Step 4.3: Repeat Step 4.2 until all communities in all intervals C[ts,te] have completed DAG structure construction.

[0061] Step 4.4: Re-traverse all C[ts,te], remove C[ts,te] that has no children, no father, and an empty edge set, and map the stored points v to Ci[ts,te] through the mapping relationship structure map to obtain the final index.

[0062] Step 5, query the maximum connected k-truss community of a given account in a specified time interval using the index.

[0063] Step 5.1: Based on the index structure constructed in step 4, input the target account v, query time interval [ts, te] and k value for lookup.

[0064] Step 5.2: Find Ci[ts1, te2] of target account v through map ([ts1, te2] is a subset of [ts, te]).

[0065] Step 5.3: Backtrack the parent community from Ci[ts1, te2] until the last ancestor community belonging to time interval [ts, te] is found.

[0066] Step 5.4: Return the entire account set in the subtree rooted at the ancestor community, which is the maximum connected k-truss community of the target account in the time interval.

[0067] Step 6, return the query result.

[0068] The present application has the following beneficial effects:

[0069] The present application effectively compresses the repeatedly stored community information by constructing the evolving account community structure graph (DAG index) in the time interval, improving the expression ability and query efficiency of account community evolution across time ranges. Through recursive stripping and sharing of community edge sets, the present application realizes the minimum redundant community representation across multiple time windows, significantly reducing storage overhead while ensuring community history integrity.

[0070] During construction, the present application sorts communities according to time window start time and span, and constructs a directed acyclic graph structure using the inclusion relationship between communities, so that community information under any time window can be inherited from the upper layer, thereby supporting fast multi-time period query and tracking.

[0071] In addition, the present application realizes on-demand tracing, time period aggregation, edge set reconstruction and other query operations based on community DAG structure, and is particularly suitable for account community evolution, cooperation trend analysis, and identification of core account communities. Compared with traditional windowed storage method, the present application has significant advantages in data expression, query response speed and storage efficiency, and can return more detailed and realistic account evolution community results, better meeting the dynamic evolution characteristics of real social networks. BRIEF DESCRIPTION OF DRAWINGS

[0072] In order to more clearly describe the technical process of the present application, the following briefly introduces the drawings required by the present application:

[0073] Figure 1 is the overall flowchart of the present application.

[0074] Figure 2 is an example of account transaction network, for example, account v3 and v4 are connected by a line with value 4, which represents that account v3 and v4 have a transaction at time 4.

[0075] Figure 3 is an example of all time k-truss solving process in account transaction network. The arrow represents that a new connected community set is obtained from a certain time k-truss connected community set.

[0076] Figure 4 is all time k-truss connected community sets obtained by solving.

[0077] Figure 5 is an example of DAG index.

[0078] The specific implementation is as follows:

[0079] The present application will be further described below in combination with the overall flowchart shown in the accompanying drawings. Figure 1

[0080] The query method of the closely related transaction account group of the present application comprises the following steps:

[0081] Step 1: Extract all connected k-truss communities in the global time interval of the account transaction network and calculate the real time interval.

[0082] Step 1.1: input the account transaction network evolution graph G=(V,E,T) as shown in Figure Two , wherein V={v1,v2,v3,...} represents the account set, wherein vi represents the account, E={(u,v,t)} is the transaction edge set with time stamp t, which represents that the account u and the account v have a transaction at t, and T is the time stamp set of all transactions;

[0083] Step 1.2: extract k-truss communities in the time interval [1,6];

[0084] Step 1.2.1: 1 and 6 are the minimum and maximum time stamps in the time interval [1,6], find the edges whose time stamps do not belong to [1,6] and delete them, that is, delete the edges whose time stamps are less than 1 or greater than 6.

[0085] ​Step 1.2.2: Calculate the support of each edge (i.e. the number of triangles each edge forms), support[(1,2),(1,3),(1,4),(2,3),(2,4),(3,4),(4,5),(4,6),(5,6),(5,7),(6,7),(6,8),(6,9),(7,8),(7,9)] = [2, 2, 2, 2, 2, 2, 1, 1, 2, 1, 3, 1, 1, 1, 1].

[0086] Step 1.2.3: Iteratively remove edges with support less than (k-2). When considering 3-truss, by definition each edge must participate in at least 3-2 = 1 triangle. Therefore, in the iterative removal process, edges with support less than 1 will be removed until all remaining edges satisfy the k-truss condition.

[0087] Step 1.2.4: Extract all connected k-truss communities using BFS or DFS. Discover a connected k-truss community

[0088] C1[1,6] = {(1,2),(1,3),(1,4),(2,3),(2,4),(3,4),(4,5),(4,6),(5,6),(5,7),(6,7),(6,8),(6,9),(7,8),(7,9)}, form the initial connected community set C[1,6].

[0089] Step 1.3: Calculate the real time interval of each community. For each transaction edge in the community, count the earliest and latest timestamp edges (v6, v8, 1) and (v4, v5, 6), obtaining the real active time interval [1, 6] of the community. Since the k-truss condition removes edges, it may cause some timestamps to have no edges.

[0090] Step 2: Forward evolution refinement

[0091] This step aims to inherit and refine the k-truss communities generated by the previous layer interval on different time windows, Figure 3 The figure shows the gradual evolution process from large interval to small interval, represented by blue interval, such as from C[1,6] to C[2,6], then to C[3,6], and finally to C[4,6] since the community set C[5,6] is empty.

[0092] Step 2.1: Inherit the communities of the previous interval

[0093] As Figure 4As shown, the time interval [2, 6] to be processed is solved, and the community set C[1, 6] constructed in the previous time interval [1, 6] is inherited. For the time interval [ts, te] to be processed, the community set constructed in the previous time interval [ts-1, te] is inherited. For example, when processing the interval [2, 6], the corresponding community C[1, 6] is obtained from [1, 6] as the initial input, denoted as the inherited community set.

[0094] Step 2.2: Determine community validity

[0095] 2.2.1 For each connected community Ci[1, 6] in the inherited community set, such as C1[1, 6], determine whether its real active start time ts_actual=1 is less than or equal to the current interval ts=2, indicating that the community is valid in the current time interval [2, 6], and continue processing.

[0096] 2.2.2 Repeat step 2.2.1, and find that all connected communities in C[1, 6] have been processed, and the loop terminates.

[0097] Step 2.3: Refine the community. For the community C1[1, 6] determined to be active in step 2.2, perform the Temporal Peel Connectivity Algorithm (TPCA) operation in the current time window [2, 6]:

[0098] Step 2.3.1: Delete edges (v6, v8, 1) and (v7, v9, 1) whose timestamps do not belong to [2, 6].

[0099] Step 2.3.2: Inherit the support array of the time interval [1, 6], update the support of the affected edges, and find that the support of (v7, v8) and (v6, v9) is updated from 1 to 0 minus 2 from the current value k.

[0100] Step 2.3.3: Iteratively delete (v7, v8, 2), (v6, v9, 2), and similarly dynamically update the support of the affected edges,

[0101] support[(1,2),(1,3),(1,4),(2,3),(2,4),(3,4),(4,5),(4,6),(5,6),(5,7),(6,7)]=(2,2,2,2,2,2,1,1,2,1,1), which satisfies the 3-truss condition.

[0102] Step 2.3.4: Extract the connected k-truss subgraph C1[2,6] = {(1,2), (1,3), (1,4), (2,3), (2,4), (3,4), (4,5), (4,6), (5,6), (5,7), (6,7)} from the processed graph. Extract the subcommunity C[2,6].

[0103] Step 2.4: Calculate the real time interval of each community

[0104] For each transaction edge in the connected community set C[2,6] obtained in step 2.3, such as C1[2,6], the earliest and latest timestamp edges are (v5, v6, 3) and (v4, v5, 6), obtaining the real active time interval [3, 6] of the community.

[0105] Step 2.5: Repeat steps 2.1-2.4 until the connected community set of the new time interval after inheriting the community is empty.

[0106] Step 3: Backward evolution refinement

[0107] This step aims to inherit and refine the k-truss communities generated in the next layer interval layer by layer on different time windows, Figure 3 The backward evolution process of the blue interval is shown, such as from C[1,6] to C[1,5], then to C[1,4], and finally to C[1,3]. Since there is no community set in C[1,2], the process ends.

[0108] Step 3.1: Inherit the community of the next interval

[0109] For example, when calculating C[1,4], C[1,4] inherits the next time community set C[1,5].

[0110] Step 3.2: Determine community validity

[0111] 3.2.1 For each connected community in the inherited community set, such as C1[1,5], determine its real active start time te_actual = 4, which is equal to the current interval te = 4, indicating that the community has no edges that need to be stripped within the current time window [1,5], and is directly added to C[1,4].

[0112] 3.2.2 Repeat step 3.2.1 until all connected communities in C[1,5] have been processed, and the loop terminates.

[0113] Step 3.3: Refine the community

[0114] In the time interval [1,4], for the communities determined to be valid in step 3.2, perform TPCA of step 2.3, and find that C1[1,4] and C2[1,4] are invalid, and TPCA does not need to be performed.

[0115] Step 3.4: Calculate the actual time interval of each community

[0116] For each transaction edge in a community, count the earliest and latest timestamps to get the actual valid time interval [ts_actual, te_actual] of the community. The actual time interval of C1[1,4] is [3,3], and the actual time interval of C2[1,4] is [4,4].

[0117] Step 3.5: Repeat steps 3.1-3.4 until the set of connected communities with new time intervals after inheriting communities is empty.

[0118] Step 3.6: Repeat steps 3.1-3.5 until the set of connected communities with new time intervals after inheriting communities is empty.

[0119] Step 4: Construct the DAG index structure of time-evolving communities, as shown in Figure 5 .

[0120] Step 4.1: Sort all time interval community sets

[0121] Sort all community sets C[ts,te] according to the following sorting rules: (1) If ts1<ts2, then C[ts2,te2] is placed before C[ts1,te1]; (2) If ts1=ts2, then sort according to the interval length te-ts in descending order, i.e., longer time intervals are placed first. After sorting, a globally ordered community set sequence is obtained, denoted as C_sorted:

[0122] C_sorted={C[1,6],C[2,6],C[1,5],C[3,6]…C[3,3]}.

[0123] Step 4.2: Refine and propagate sub-intervals

[0124] For each community interval C[ts,te]∈C_sorted after sorting, perform the following operations on all communities Ci[ts,te] within it:

[0125] (1) C1[1,6] is the actual community generated by the real window:

[0126] Step 4.2.1: Find C1[2,6], C1[1,5], and C2[1,5] from sub-intervals [2,6] and [1,5] as subsets of C1[1,6] community, set Ci'={C1[2,6],C1[1,5],C2[1,5]}.

[0127] Step 4.2.2: Add these Ci' as the "child community" of C1[1,6] to its child set;

[0128] Step 4.2.3: Remove all edges owned by Ci' from the edge set of C1[1,6] to prevent redundant storage of edges.

[0129] (2) C1[1,5] is not an actual community generated by the real window, and its real window is [4,4]:

[0130] Step 4.2.4: Find that C1[4,4] is a subset of the C1[1,5] community, and add the actual community C1[4,4] to Ci'.

[0131] Step 4.2.5: Similarly, find community subsets in sub-intervals [2,5] and [1,4], find C1[2,5] and C1[1,4], find that the edge set of C1[2,5] and C1[1,4] is the same as C1[1,5], C1[2,5] has a father C1[2,6], skip, C1[1,4] has no father, delete C1[1,4] from C[1,4], Ci' = {C1[4,4], C1[2,5]}, execute Step 4.2.2 and Step 4.2.3.

[0132] Step 4.3: Repeat Step 4.2 until the community in all intervals C[ts,te] is completed.

[0133] Step 4.4: Reiterate all C[ts,te], delete C1[1,4], C2[1,4], C1[4,6], C1[2,4], C2[2,4], C1[4,5], C1[3,4] and C2[3,4] which have no children, no fathers and empty edge sets, and map the stored points v to Ci[ts,te] to get the final index.

[0134] Step 5: Query the maximum connected k-truss community of a given account in a specified time interval using the index.

[0135] Step 5.1: On the basis of the index structure constructed in Step 4, input the target account v6 and the query time interval [1,5] and k value 3 for searching.

[0136] Step 5.2: Find C1[3,3] and C2[1,3] of the target account v6 through the map ([3,3] and [1,3] are subsets of [1,5])

[0137] Step 5.3: Reverse trace the parent community of C1[3,3] and C2[1,3] to find the last ancestor community C2[1,5] still belonging to the time interval [1,5].

[0138] Step 5.4: Return all the account sets in the sub-tree of the ancestor community as the root node, i.e., C2[1,5], C1[1,3], C1[2,3], C1[3,3]. The final edge set {(6,8), (6,9), (7,8), (7,9), (5,6), (5,7), (6,7)} is the maximum connected 3-truss community of the target account v6 in the time interval [1,5].

[0139] Step 6, return the query result.

Claims

1. A method for querying closely related groups of trading accounts, characterized in that... Includes the following steps: Step 1: Extract all connected k-truss communities within the global time interval of the account transaction network and calculate the real time interval; Step 2: Forward evolution refinement; Step 3: Backward evolution refinement; Step 4: Construct the DAG index structure of the time evolution community; Step 5: Use the index to query the maximum connected k-truss community for a given account within a specified time interval; Step 6: Return the query results.

2. The method for querying closely related transaction account groups as described in claim 1, characterized in that... Step 1 includes the following steps: Step 1.1: Input the account transaction network evolution graph G = (V, E, T), where V = {v1, v2, v3, ...} is the set of accounts, E = {(u, v, t)} is the set of transaction edges with timestamp t, T is the set of timestamps of all transactions, and the minimum and maximum timestamps are Ts and Te; Step 1.2: Extract k-truss communities within the time interval [Ts,Te]; Step 1.2.1: Within the time interval [Ts,Te], delete all transaction edges whose timestamps do not belong to this interval; Step 1.2.2: In the remaining graph, calculate the support of each edge; Step 1.2.3: Iteratively strip edges with support less than (k-2) until all remaining edges satisfy the k-truss condition; Step 1.2.4: Extract all connected k-truss subgraphs Ci[Ts,Te] to form the initial connected community set C[Ts,Te]; Step 1.3: Calculate the true time interval for each community Ci. For each community's transaction edges, count the earliest and latest timestamps to obtain the true active time interval for that community. [ts_actual,te_actual].

3. The method for querying closely related transaction account groups as described in claim 2, characterized in that... Step 2 includes the following steps: Step 2.1: Inherit the community set from the previous interval. Starting from the time interval [Ts+1,Te] and ending at [Te,Te], for the time interval [ts,Te], inherit the community set from the previous time interval [ts-1,Te]. Step 2.2: Determine the validity of the community. For each inherited community, if the community's ts_actual is greater than ts, it means that the community is not valid in the current time interval and is skipped; otherwise, continue processing. Step 2.3: Refine the communities. Within the time interval [ts, Te], perform the Temporal Connectivity Exfoliation (TPCA) operation on communities that meet the conditions in Step 2.2: Step 2.3.1: Delete edges whose timestamps do not belong to the time interval [ts,Te]. Step 2.3.2: Update the support of the affected edges based on the already calculated inheritance community support; Step 2.3.3: Iteratively remove edges that do not meet the k-truss condition, and dynamically update the support of the affected edges as well; Step 2.3.4: Extract the connected k-truss subgraph Ci[ts,Te] from the processed graph, and extract the sub-communities C[ts,Te]. Step 2.4: Calculate the true time interval of each connected community \(C_i[t_s, T_e]\). For the transaction edges in each community, count the earliest and latest timestamps to obtain the true active time interval \([t_{s\_actual}, t_{e\_actual}]\) of this community.

4. The method for querying closely related transaction account groups as described in claim 3, characterized in that... The said Step 3 includes the following steps: Step 3.1: Inherit the communities of the subsequent interval. For each \(C[t_s, T_e]\) obtained in Step 2, starting from the time interval \([t_s, T_e - 1]\) and ending at \([t_s, t_s]\), for the time interval \([t_s, t_e]\), inherit the set of communities in the subsequent time interval \([t_s, t_e + 1]\); Step 3.2: Judge the validity of the community. For each inherited community: If the \(t_{e\_actual}\) of the community is less than \(t_e\), it means that this community is not valid in the current time interval, and skip it; otherwise, continue to process; Step 3.3: Refine the community. In the time interval \([t_s, t_e]\), perform TPCA on the communities that meet the conditions of Step 3.2, re-strip the k-truss, and extract the sub-community \(C[t_s, t_e]\); Step 3.4: Calculate the true time interval of each community. For the transaction edges in each community, count the earliest and latest timestamps to obtain the true active time interval \([t_{s\_actual}, t_{e\_actual}]\) of this community.

5. The method for querying closely related transaction account groups as described in claim 4, characterized in that... The said Step 4 includes the following steps: Step 4.1: Sort all the time interval community sets. Sort all the community sets \(C[t_s, t_e]\) according to the following sorting rules: (1) If the time interval \(t_{s1}<t_{s2}\), then \(C[t_{s1}, t_{e1}]\) is ranked before \(C[t_{s2}, t_{e2}]\); (2) If \(t_{s1}=t_{s2}\), then sort in descending order according to the interval length \(t_{e1}-t_{s2}\). After sorting, obtain a globally ordered sequence of community sets, denoted as \(C_{sorted}\); Step 4.2: Perform refinement propagation on the sub-intervals. For each community interval \(C[t_s, t_e]\in C_{sorted}\) after sorting, perform the following operations on all the communities \(C_i[t_s, t_e]\) inside it: (1) If this community is the actual community generated by the true window, that is [t_s, t_e]==[t_{s\_actual}, t_{e\_actual}], where \(t_{s\_actual}\) and \(t_{e\_actual}\) are the minimum and maximum timestamps of the edges in this community: Step 4.2.1: Search for the subset communities of the edge set of \(C_i[t_s, t_e]\) from its sub-intervals \([t_s + 1, t_e]\) and \([t_s, t_e - 1]\), denoted as \(C'\); Step 4.2.2: Add \(C'\) as the child community of \(C_i[t_s, t_e]\) to its children set; Step 4.2.3: Remove all the edges owned by \(C'\) from the edge set of \(C_i[t_s, t_e]\); (2) If this community is not the actual community generated by the true window, that is [t_s, t_e]≠[t_{s\_actual}, t_{e\_actual}], and its edge set is the same as \(C_i[t_{s\_actual}, t_{e\_actual}]\): Step 4.2.4: Add the actual community \(C_i[t_{s\_actual}, t_{e\_actual}]\) to \(C'\); Step 4.2.5: Similarly, find the subset community Ci' of the edge set in [ts+1,te] and [ts,te-1]: (1) If there exists a sub-community Ci' == Ci[ts,te], but Ci' is not yet marked as a sub-community, it is considered a redundant copy and is deleted from the sub-interval; (2) If Ci' ≠ Ci[ts,te], Ci' is added as a child community of Ci[ts,te], and the edge of Ci' is removed from the edge set of Ci[ts,te]. Step 4.3: Repeat step 4.2 until all communities in interval C[ts,te] have completed the construction of the DAG structure; Step 4.4: Retrace through all C[ts,te], delete C[ts,te] with no children, no parent and empty edge set, and map the stored point v to Ci[ts,te] through the mapping relationship structure map to obtain the final index.

6. The method for querying closely related transaction account groups as described in claim 5, characterized in that... Step 5 includes the following steps: Step 5.1: Based on the index structure built in Step 4, input the target account v, the query time interval [ts, te], and the k value to perform the search; Step 5.2: Find Ci[ts1,te2] of the target account v using map ([ts1,te2] is a subset of [ts,te]); Step 5.3: Tracing back from Ci[ts1,te2] to its parent community until the last ancestor community still belonging to the time interval [ts,te] is found; Step 5.4: Return the set of all accounts in the subtree rooted at the ancestor community, which is the maximum connected k-truss community of the target account in this time interval.

Images