A hierarchical button permission management and verification method and system based on system coding

Abstract

This invention provides a hierarchical button permission management and verification method and system based on system coding, belonging to the field of computer permission management technology. It includes constructing locality-sensitive encoding and button fingerprints, establishing a button dependency tree and propagation chain, generating a permission state bitmap, and constructing a verification chain, thereby realizing an on-demand updated permission propagation mechanism and efficient permission verification. This invention can reduce data redundancy, lower the complexity of permission management, improve verification response speed, and support consistent permission state management in large-scale distributed environments.

Description

Technical Field

[0001] This invention relates to computer access control technology, and more particularly to a hierarchical button access control and verification method and system based on system coding. Background Technology

[0002] In existing information systems, button permission management is mostly implemented using static configuration or role binding, which suffers from complex configuration and high maintenance costs. Especially in multi-level, multi-module systems, the functional dependencies between buttons are complex, and traditional methods are difficult to effectively express the operation logic and permission associations between buttons, leading to errors in permission configuration and insufficient security and flexibility.

[0003] Furthermore, current permission verification methods largely rely on user requests for triggering, lacking effective state caching and propagation mechanisms, making it difficult to synchronize permission state changes in a timely manner. The lack of refined modeling of button operation sensitivity and relevance also hinders dynamic deduction and optimal updates of permission states, resulting in significant response latency and high system resource consumption in high-frequency interaction scenarios.

[0004] Existing solutions generally lack a systematic design for permission state propagation paths, fingerprint distribution, and verification chain mechanisms, making it difficult to achieve fine-grained, high-performance button permission verification and dynamic updates. Therefore, there is an urgent need for a hierarchical button permission management and verification method based on system coding to improve the accuracy, timeliness, and system response efficiency of permission management. Summary of the Invention

[0005] This invention provides a hierarchical button permission management and verification method and system based on system coding, which can solve the problems in the prior art.

[0006] A first aspect of this invention provides a hierarchical button permission management and verification method based on system coding, comprising:

[0007] The business identifier and operation type of the collection button are reordered by sensitivity and constructed as a local sensitive code. The correlation matrix of adjacent buttons is calculated based on the local sensitive code. The correlation matrix is ​​used to generate button fingerprints so that the fingerprints of related buttons form a gradual distribution in space.

[0008] Construct a button dependency tree based on the correlation matrix and button fingerprints, traverse the button dependency tree to calculate the permission propagation weight of each node, and use the permission propagation weight as a routing parameter to construct a propagation link;

[0009] A permission state bitmap is generated based on the button dependency tree and propagation chain. The permission state bitmap is divided into multiple permission groups. The state propagation order between each permission group is determined according to the permission propagation weight. A permission state cache tree is constructed and a verification chain containing state version and timestamp is established.

[0010] The system monitors the frequency of permission status changes in the permission status cache tree. When the cumulative changes reach the trigger threshold, it calculates the status diffusion range along the propagation chain, generates a status propagation path diagram, determines the optimal update sequence based on the propagation path diagram, and performs batch status updates. When a button operation request is received, the system locates the permission group in the permission status cache tree using the button fingerprint, judges the validity of the status through the verification chain, and executes the operation after successful verification.

[0011] In one alternative embodiment,

[0012] The business identifier and operation type of the data collection button are reordered based on sensitivity, and a locally sensitive code is constructed, including:

[0013] The business identifier of the button is semantically decomposed, the conditional probability of the term under different topics is calculated to obtain the topic distribution of the business identifier, and the difference degree and distribution entropy of the topic category are calculated based on the topic distribution of the business identifier to generate the business identifier sensitivity;

[0014] Construct an operation type temporal dependency graph, where nodes represent operation types, edges represent dependencies between operation types, and edge weights represent temporal association strength. Perform a random walk with damping factors on the operation type temporal dependency graph to obtain operation type centrality. Calculate operation type information entropy based on the operation type temporal dependency graph. Combine operation type centrality and operation type information entropy to generate operation type sensitivity.

[0015] The button feature sensitivity is obtained by weighted fusion of business identifier sensitivity and operation type sensitivity, and the button features are reordered according to the button feature sensitivity to obtain the button feature sequence;

[0016] A feature projection matrix is ​​constructed based on the button feature sequence. The similarity of the buttons in the local neighborhood is calculated based on the button feature sensitivity to obtain the encoding constraints. The feature projection matrix is ​​optimized using the encoding constraints to obtain the optimized projection matrix.

[0017] The button feature sensitivity is converted into feature position weights. Based on the feature position weights and the optimized projection matrix, the button feature sequence is weighted and mapped to generate the local sensitivity code of the button.

[0018] In one alternative embodiment,

[0019] The correlation matrix between adjacent buttons is calculated based on locality-sensitive coding. Button fingerprints are then generated using this correlation matrix, resulting in a gradual spatial distribution of the fingerprints of related buttons.

[0020] The local sensitivity coding of the button is segmented and sampled to extract the position information and operation information of each segment. The temporal features of the button are constructed based on the position information, and the semantic features of the button are constructed based on the operation information.

[0021] The operation distance of the button in the business process is calculated based on the temporal features, the operation similarity of the button is calculated based on the semantic features, and the operation distance and operation similarity are combined to generate the association strength of adjacent buttons.

[0022] Based on the association strength, adjacent buttons are grouped and clustered to obtain association clusters of buttons. The density of buttons within an association cluster and the interval between buttons between association clusters are calculated. An association degree matrix of adjacent buttons is constructed based on the density and interval.

[0023] The correlation matrix is ​​mapped to the fingerprint space. The projection region of the button fingerprint is determined according to the distribution of the correlation clusters in the fingerprint space. A mapping function for the button fingerprint is constructed based on the projection region. The button features are converted into button fingerprints using the mapping function. Neighborhood constraints are applied to the button fingerprints so that the button fingerprints in adjacent projection regions form an asymptotic distribution, thus obtaining the asymptotic distribution structure of the relevant buttons in the fingerprint space.

[0024] In one alternative embodiment,

[0025] The correlation matrix is ​​mapped to the fingerprint space. The projection region of the button fingerprint is determined according to the distribution of correlation clusters in the fingerprint space. A mapping function for the button fingerprint is constructed based on the projection region. The button features are then converted into a button fingerprint using the mapping function, including:

[0026] The correlation matrix is ​​mapped to the fingerprint space through multidimensional scaling to obtain the spatial coordinates of the button node in the fingerprint space. The spatial coordinates are then clustered using a density clustering algorithm to obtain the correlation cluster distribution in the fingerprint space. The correlation cluster distribution is used to determine the projection area range of the button fingerprint.

[0027] Extract the set of boundary points of the associated cluster, obtain the temporal change information between the boundary points, calculate the dynamic association weight of each boundary point based on the temporal change information, calculate the boundary adjustment factor based on the dynamic association weight of the boundary points, and multiply the boundary adjustment factor by the distribution range of the associated cluster to construct the projection area of ​​the button fingerprint.

[0028] Based on the shape characteristics of the projection region, a combination ratio of Gaussian kernel function and Laplacian kernel function is selected, and the dynamic correlation weight is used as the weight parameter of the kernel function to construct a mapping function for button fingerprint. The input button features are then converted into button fingerprints through the mapping function of button fingerprint.

[0029] In one alternative embodiment,

[0030] Based on the association matrix and button fingerprints, a button dependency tree is constructed. The permission propagation weight of each node is calculated by traversing the button dependency tree. The permission propagation weight is then used as a routing parameter to construct the propagation link, which includes:

[0031] The association strength between buttons is extracted from the association degree matrix. A weighted association graph of buttons is constructed by combining the distribution distance of button fingerprints in the fingerprint space. The minimum spanning tree algorithm is used to extract the main association path from the weighted association graph to construct the initial structure of the button dependency tree.

[0032] The average association strength of the button nodes in the initial structure is used as the weight base. The node influence index is constructed by combining the in-degree ratio of the button nodes. The subtree hierarchical structure is constructed with the button node with the largest influence index as the root node. The subtree hierarchical structure inherits the association strength as the hierarchical connection weight.

[0033] The distribution density of button nodes in the subtree hierarchy is calculated based on the hierarchical connection weights. When the distribution density of button nodes exceeds a preset density threshold, the subtree is split. When the distribution density of button nodes is lower than the preset density threshold, the subtree is merged. The button dependency tree is obtained through density optimization.

[0034] Traverse the button dependency tree, calculate the depth weight using the level depth and level connection weight of the button node, calculate the coverage weight using the influence index of the button node, and combine the depth weight and coverage weight to generate the permission propagation weight of the button node.

[0035] The ratio of permission propagation weights of adjacent button nodes is set as the route jump weight. In the button dependency tree, the button node sequence of each branch is sorted based on the route jump weight, and the node sequence with decreasing route jump weight is selected to construct the propagation link.

[0036] In one alternative embodiment,

[0037] A permission state bitmap is generated based on the button dependency tree and propagation chain. The permission state bitmap is divided into multiple permission groups. The state propagation order between each permission group is determined according to the permission propagation weight. A permission state cache tree is constructed, and a verification chain containing state version and timestamp is established, including:

[0038] Extract the propagation path overlap, state change sequence, and access pattern data of nodes from the button dependency tree, calculate the state correlation between nodes, and construct a node mapping matrix based on the state correlation.

[0039] Create a storage space for the permission status bitmap, divide the storage space into a front-end encoding area and a back-end encoding area, and mark nodes with a status correlation higher than a preset correlation threshold as master nodes and other nodes as subordinate nodes according to the node mapping matrix.

[0040] The state propagation rules are determined based on the node dependencies and node mapping matrix in the propagation chain. The state information of the master node is encoded and written into the front-end encoding area in order of state relevance from high to low. The state information of the subordinate nodes is encoded and written into the back-end encoding area in accordance with the state propagation rules.

[0041] A state association marker is set between the front-end encoding area and the back-end encoding area. The state association marker contains the validity period and priority information of state propagation. A state dependency graph is constructed based on the node mapping matrix and the state association marker.

[0042] Based on the state dependency graph and propagation link, the permission propagation weight is calculated, and permission groups are determined according to the preset interval of the state relevance and the permission propagation weight.

[0043] The state propagation order between permission groups is determined based on the permission propagation weight. A permission state cache tree is constructed, and the permission group is set as a cache tree node. The permission group identifier, state version number and timestamp are written into the cache tree. A verification chain containing the state version and timestamp is established between the nodes of the permission state cache tree.

[0044] In one alternative embodiment,

[0045] The frequency of permission status changes in the monitoring permission status cache tree is analyzed. When the accumulated changes reach a trigger threshold, the state diffusion range is calculated along the propagation path, a state propagation path diagram is generated, the optimal update sequence is determined based on the propagation path diagram, and batch state updates are performed, including:

[0046] Set a state change counter and a time window in the node of the permission state cache tree, and calculate the cumulative value of state changes of the state change counter within the time window;

[0047] When the cumulative value of the state change reaches the preset trigger threshold, the state diffusion range is calculated based on the position of the trigger update node in the propagation link, and the state correlation, propagation path length and state change frequency of each node in the state diffusion range are extracted.

[0048] A state propagation path graph is generated based on the state relevance, propagation path length, and state change frequency. The affected nodes are set as vertices of the graph, and the propagation relationships between nodes are set as edges of the graph. The weights of the edges are calculated based on the state relevance, propagation path length, and state change frequency.

[0049] In the state propagation path graph, a state relevance threshold and a propagation path length upper limit are set to filter propagation paths that are lower than the state relevance threshold and propagation paths that are higher than the propagation path length upper limit. The optimal update sequence is determined based on the edge weights.

[0050] The batch update quantity is determined based on system load and historical average update quantity, and the status update tasks in the optimal update sequence are executed in batches according to the batch update quantity.

[0051] Before performing batch updates, the original state of the nodes is recorded. The state update is performed according to the topological sequence of the state propagation path graph. When the update time exceeds the preset timeout limit, the update is interrupted and the node state is restored to the original state.

[0052] A second aspect of this invention provides a hierarchical button permission management and verification system based on system coding, comprising:

[0053] The first unit is used to collect the business identifier and operation type of the button, reorder them by sensitivity, and construct them into local sensitive codes. Based on the local sensitive codes, the correlation matrix of adjacent buttons is calculated, and the correlation matrix is ​​used to generate button fingerprints so that the fingerprints of related buttons form a gradual distribution in space.

[0054] The second unit is used to construct a button dependency tree based on the correlation matrix and button fingerprint, traverse the button dependency tree to calculate the permission propagation weight of each node, and use the permission propagation weight as a routing parameter to construct a propagation link.

[0055] The third unit is used to generate a permission state bitmap based on the button dependency tree and propagation chain, divide the permission state bitmap into multiple permission groups, determine the state propagation order between each permission group according to the permission propagation weight, construct a permission state cache tree, and establish a verification chain containing state version and timestamp.

[0056] The fourth unit is used to monitor the frequency of permission status changes in the permission status cache tree. When the cumulative changes reach the trigger threshold, the state diffusion range is calculated along the propagation link, a state propagation path diagram is generated, the optimal update sequence is determined based on the propagation path diagram, and batch state updates are performed. When a button operation request is received, the permission group is located in the permission status cache tree by the button fingerprint, the validity of the status is judged by the verification chain, and the operation is performed after the verification is passed.

[0057] A third aspect of the present invention provides an electronic device, comprising:

[0058] processor;

[0059] Memory used to store processor-executable instructions;

[0060] The processor is configured to invoke instructions stored in the memory to execute the aforementioned method.

[0061] A fourth aspect of the present invention provides a computer-readable storage medium having stored thereon computer program instructions that, when executed by a processor, implement the aforementioned method.

[0062] In this embodiment, precise mapping and identification of button permissions are achieved by constructing locality-sensitive coding and button fingerprints. This ensures that relevant function buttons are distributed in an orderly manner within the permission space, reducing permission conflicts and false positive rates, and improving the accuracy and consistency of permission management. A hierarchical caching structure based on permission propagation weights is adopted, establishing an efficient permission state cache tree and verification chain. This transforms the permission verification process from linear querying to logarithmic-level positioning, significantly reducing system response latency and greatly improving user experience. An intelligent permission state propagation mechanism is implemented. By monitoring change frequency and calculating diffusion range, the state update sequence is dynamically optimized, reducing unnecessary state refreshes. This maintains permission consistency while reducing system resource overhead, enabling the permission management system to maintain stable and efficient operation even in high-concurrency environments. Attached Figure Description

[0063] Figure 1 This is a flowchart illustrating the hierarchical button permission management and verification method based on system coding, as described in an embodiment of the present invention.

[0064] Figure 2 This is a schematic diagram of a system architecture that allows the fingerprints on the relevant buttons to be distributed progressively in space.

[0065] Figure 3 A diagram illustrating the efficiency comparison of permission propagation methods. Detailed Implementation

[0066] To make the objectives, technical solutions, and advantages of the embodiments of the present invention clearer, the technical solutions of the embodiments of the present invention will be clearly and completely described below with reference to the accompanying drawings. Obviously, the described embodiments are only some embodiments of the present invention, and not all embodiments. Based on the embodiments of the present invention, all other embodiments obtained by those skilled in the art without creative effort are within the scope of protection of the present invention.

[0067] The technical solution of the present invention will be described in detail below with reference to specific embodiments. These specific embodiments can be combined with each other, and the same or similar concepts or processes may not be described again in some embodiments.

[0068] Figure 1 This is a flowchart illustrating the hierarchical button permission management and verification method based on system coding according to an embodiment of the present invention. Figure 1 As shown, the method includes:

[0069] The business identifier and operation type of the collection button are reordered by sensitivity and constructed as a local sensitive code. The correlation matrix of adjacent buttons is calculated based on the local sensitive code. The correlation matrix is ​​used to generate button fingerprints so that the fingerprints of related buttons form a gradual distribution in space.

[0070] Construct a button dependency tree based on the correlation matrix and button fingerprints, traverse the button dependency tree to calculate the permission propagation weight of each node, and use the permission propagation weight as a routing parameter to construct a propagation link;

[0071] A permission state bitmap is generated based on the button dependency tree and propagation chain. The permission state bitmap is divided into multiple permission groups. The state propagation order between each permission group is determined according to the permission propagation weight. A permission state cache tree is constructed and a verification chain containing state version and timestamp is established.

[0072] The system monitors the frequency of permission status changes in the permission status cache tree. When the cumulative changes reach the trigger threshold, it calculates the status diffusion range along the propagation chain, generates a status propagation path diagram, determines the optimal update sequence based on the propagation path diagram, and performs batch status updates. When a button operation request is received, the system locates the permission group in the permission status cache tree using the button fingerprint, judges the validity of the status through the verification chain, and executes the operation after successful verification.

[0073] In one alternative implementation, the service identifier and operation type of the data collection button are reordered by sensitivity and constructed into locally sensitive codes, including:

[0074] The business identifier of the button is semantically decomposed, the conditional probability of the term under different topics is calculated to obtain the topic distribution of the business identifier, and the difference degree and distribution entropy of the topic category are calculated based on the topic distribution of the business identifier to generate the business identifier sensitivity;

[0075] Construct an operation type temporal dependency graph, where nodes represent operation types, edges represent dependencies between operation types, and edge weights represent temporal association strength. Perform a random walk with damping factors on the operation type temporal dependency graph to obtain operation type centrality. Calculate operation type information entropy based on the operation type temporal dependency graph. Combine operation type centrality and operation type information entropy to generate operation type sensitivity.

[0076] The button feature sensitivity is obtained by weighted fusion of business identifier sensitivity and operation type sensitivity, and the button features are reordered according to the button feature sensitivity to obtain the button feature sequence;

[0077] A feature projection matrix is ​​constructed based on the button feature sequence. The similarity of the buttons in the local neighborhood is calculated based on the button feature sensitivity to obtain the encoding constraints. The feature projection matrix is ​​optimized using the encoding constraints to obtain the optimized projection matrix.

[0078] The button feature sensitivity is converted into feature position weights. Based on the feature position weights and the optimized projection matrix, the button feature sequence is weighted and mapped to generate the local sensitivity code of the button.

[0079] In the technical solution for re-ranking the sensitivity of business identifiers and operation types of data collection buttons and constructing local sensitivity codes, semantic decomposition of the business identifiers is the first step. The system receives the button business identifier text and decomposes it into a set of terms using word segmentation technology. For example, the business identifier "user account balance query" can be decomposed into terms such as "user," "account," "balance," and "query." The system uses a topic model to model the term set and calculates the conditional probability of each term under different topics. Assuming the number of topics is set to 5, the system uses an iterative algorithm to calculate the conditional probabilities of the term "account" under each topic as 0.35, 0.15, 0.05, 0.25, and 0.2, respectively. By summing the conditional probabilities of all terms under each topic, the topic distribution vector of the business identifier is obtained [0.32, 0.18, 0.10, 0.22, 0.18]. Based on this distribution vector, the topic category dissimilarity, i.e., the variance between the probabilities of each topic, is calculated, which is 0.0053 in this example. Simultaneously, the distribution entropy is calculated to quantify the dispersion of the topic distribution, which is 2.14 in this example. Finally, the difference degree and distribution entropy are weighted and combined to obtain a business identifier sensitivity of 0.78.

[0080] For calculating the sensitivity of operation types, the system constructs a temporal dependency graph of operation types. Taking button operations on the user interface as an example, the system determines the set of operation types, such as "click," "long press," and "swipe." By analyzing the user's historical operation sequences, the system constructs the dependencies between operation types. For example, in 1000 user operation records, if a "click" operation is immediately followed by a "swipe" operation 300 times, a directed edge from "click" to "swipe" is established with an edge weight of 0.3. After constructing the dependencies between all operation types, a temporal dependency graph of operation types is formed. The system executes a random walk algorithm with a damped factor on this graph, setting the damping factor to 0.85, iterating until convergence to obtain the centrality value of each operation type. Taking the "click" operation as an example, its centrality value is 0.42, indicating that this operation is of high importance in user interaction. At the same time, the system calculates the information entropy of operation types based on the temporal dependency graph to quantify the uncertainty of operation type transitions. For the "click" operation, the subsequent operation distribution is {"long press": 0.2, "swipe": 0.3, "double tap": 0.15, "no operation": 0.35}, and the calculated information entropy is 1.86. The operation type centrality and information entropy are weighted and combined to obtain the operation type sensitivity. For the "click" operation, the sensitivity value is 0.65.

[0081] The next key step is to fuse business identifier sensitivity and operation type sensitivity. The system sets weighting factors α=0.6 and β=0.4. According to the weighting fusion formula, the button feature sensitivity is calculated as 0.6×0.78+0.4×0.65=0.728. Based on the calculated button feature sensitivity, the system reorders the button features. For example, the original button feature sequence is [f1, f2, f3, f4, f5], with corresponding sensitivities of [0.728, 0.543, 0.891, 0.632, 0.475]. After reordering, it becomes [f3, f1, f4, f2, f5].

[0082] A feature projection matrix is ​​constructed based on the reordered button feature sequence. Assuming a feature dimension of 5 and a target encoding dimension of 3, the system initializes the projection matrix P as a 5×3 random matrix. The system calculates the similarity of buttons in their local neighborhoods based on button feature sensitivity, forming encoding constraints. For buttons A and B, a weighted Euclidean distance is calculated based on their respective feature sensitivities; the smaller the distance, the higher the similarity. For example, the similarity between buttons A and B is 0.85, and the similarity between A and B and button C is 0.42. The system constructs a similarity matrix S from the similarity between all buttons, serving as encoding constraints. Using this constraint, the system optimizes the projection matrix P using gradient descent, making similar buttons closer together in the encoding space and dissimilar buttons farther apart. After 1000 iterations, the optimized projection matrix P' is obtained.

[0083] Finally, the button feature sensitivity is converted into feature position weights. For the button feature sequence [f3, f1, f4, f2, f5], the corresponding sensitivity is [0.891, 0.728, 0.632, 0.543, 0.475]. The system normalizes the sensitivity to obtain the feature position weights [0.273, 0.223, 0.193, 0.166, 0.145]. Based on the feature position weights and the optimized projection matrix P', the system performs a weighted mapping on the button feature sequence. The calculation formula is to multiply the feature vector and the position weight vector element-wise, and then multiply by the optimized projection matrix. For example, the feature vector of button A is [0.9, 0.7, 0.6, 0.5, 0.4]. Multiplying this element-wise with the positional weights [0.273, 0.223, 0.193, 0.166, 0.145] yields [0.246, 0.156, 0.116, 0.083, 0.058]. Multiplying this by the optimized projection matrix P' gives the local sensitivity code for button A: [0.352, 0.189, 0.275]. Similarly, the local sensitivity codes for all buttons can be calculated for subsequent business applications, such as button similarity calculation and button function clustering. This encoding method effectively preserves the sensitive information of button features, improving the expressive power of the encoding.

[0084] In this embodiment, by semantically modeling the business identifiers of buttons and combining topic distribution and distribution entropy calculations to generate business sensitivity, the importance of buttons in different business contexts can be effectively identified, improving the granularity of access control. By constructing a temporal dependency graph of operation types and introducing a random walk mechanism and information entropy calculation, a centrality index that better reflects the actual impact of operations is obtained, thereby generating operation sensitivity with dynamic behavioral characteristics. The button feature sensitivity formed by fusing business sensitivity and operation sensitivity can be used to more accurately characterize the permission risk level of buttons in the system, and by reordering to construct an ordered sequence of button features, it provides a foundation for subsequent encoding. The sensitivity-driven feature projection and constraint optimization mechanism not only improves the recognizability of locally similar buttons but also ensures the stability and consistency of the generated encoding within the neighborhood. The finally generated local sensitivity encoding of buttons has good discriminability and progressiveness, laying a high-quality encoding foundation for building permission propagation models and button fingerprints, significantly improving the accuracy of permission modeling and the system's response efficiency.

[0085] In one optional implementation, calculating the correlation matrix of adjacent buttons based on locality-sensitive coding, and generating button fingerprints using the correlation matrix to create a gradual spatial distribution of the fingerprints of related buttons includes:

[0086] The local sensitivity coding of the button is segmented and sampled to extract the position information and operation information of each segment. The temporal features of the button are constructed based on the position information, and the semantic features of the button are constructed based on the operation information.

[0087] The operation distance of the button in the business process is calculated based on the temporal features, the operation similarity of the button is calculated based on the semantic features, and the operation distance and operation similarity are combined to generate the association strength of adjacent buttons.

[0088] Based on the association strength, adjacent buttons are grouped and clustered to obtain association clusters of buttons. The density of buttons within an association cluster and the interval between buttons between association clusters are calculated. An association degree matrix of adjacent buttons is constructed based on the density and interval.

[0089] The correlation matrix is ​​mapped to the fingerprint space. The projection region of the button fingerprint is determined according to the distribution of the correlation clusters in the fingerprint space. A mapping function for the button fingerprint is constructed based on the projection region. The button features are converted into button fingerprints using the mapping function. Neighborhood constraints are applied to the button fingerprints so that the button fingerprints in adjacent projection regions form an asymptotic distribution, thus obtaining the asymptotic distribution structure of the relevant buttons in the fingerprint space.

[0090] Figure 2 To create a progressively distributed system architecture diagram of the fingerprints of relevant buttons in space, in this embodiment, the local sensitivity code of a button is a record of the context information when the button is operated, including location information and operation information. When sampling the local sensitivity code in segments, the sampling window size can be set to 10 seconds, and the position information and operation information of the button can be extracted within each sampling window. The position information represents the temporal position of the button in the business process, such as button A being the third step in the user's order placement process; the operation information includes semantic attributes such as the button's function description and operation type, such as the "Confirm Payment" button having the semantic attribute of transaction confirmation.

[0091] When constructing the temporal characteristics of buttons, this can be done by extracting the order in which the buttons are operated. For example, in a shopping process, a user might first click the "Add to Cart" button, then the "Proceed to Checkout" button, and finally the "Pay" button. These three buttons are sequentially linked in terms of temporal characteristics. For each button, its predecessor button set and successor button set are recorded, forming a temporal vector. Taking the "Proceed to Checkout" button as an example, its predecessor button set includes "Add to Cart," and its successor button set includes "Pay."

[0092] Semantic features are constructed based on button operation information, using a bag-of-words model to process the button function descriptions. For example, the "Confirm Order" and "Confirm Payment" buttons both contain the word "confirm" in their function descriptions, thus exhibiting semantic similarity. By extracting these keywords and assigning weights, a semantic vector is formed for each button.

[0093] Calculating the operation distance requires measuring the temporal interval between two buttons within the business process. The more frequently buttons A and B appear adjacent to each other in the same business process, the smaller their operation distance. Specifically, the calculation method involves counting the frequency of adjacent appearances of the two buttons across all user sessions and normalizing the data to obtain the distance value. For example, if the "Add to Cart" and "Proceed to Checkout" buttons appear adjacently 800 times in 1000 user sessions, their normalized operation distance is 0.2.

[0094] Operational similarity is calculated based on the semantic features of the buttons, using cosine similarity. Two buttons are considered to have high operational similarity when their descriptions contain many of the same keywords. For example, the semantic vector cosine similarity between "Confirm Order" and "Confirm Payment" is 0.75, indicating a high degree of functional similarity.

[0095] The association strength is generated using a weighted combination method, with operation distance weighted at 0.6 and operation similarity weighted at 0.4. Taking buttons A and B as an example, if their operation distance is 0.2 and their operation similarity is 0.75, then their association strength is calculated as 0.6 × (1 - 0.2) + 0.4 × 0.75 = 0.78. The association strength value ranges between [0, 1], with a larger value indicating a stronger association between the two buttons.

[0096] Hierarchical clustering is used for grouping and clustering based on association strength, with an association strength threshold of 0.65. When the association strength between buttons is greater than 0.65, these buttons are grouped into the same association cluster. For example, the pairwise association strengths of the "Add to Cart," "Proceed to Checkout," and "Pay" buttons are all greater than 0.65, therefore they form an association cluster, which can be called the "Shopping Process Cluster." The density of buttons within an association cluster is calculated as the average of the association strengths of all button pairs within the cluster. Taking the "Shopping Process Cluster" as an example, if the pairwise association strengths of the three buttons within the cluster are 0.78, 0.70, and 0.68, respectively, then the density of the cluster is 0.72.

[0097] The interval between buttons in related clusters is calculated as the average difference in the association strength of all button pairs between different clusters. For example, if the average association strength of all button pairs between the "Shopping Process Cluster" and the "User Information Cluster" is 0.3, then the interval between these two clusters is 0.7.

[0098] When constructing the association matrix, all buttons are sorted according to their association clusters, forming an N×N matrix (N is the total number of buttons). Each element in the matrix represents the association strength of the buttons in the corresponding row and column. Button pairs belonging to the same association cluster have higher association values; button pairs from different association clusters have lower association values.

[0099] Mapping the correlation matrix to the fingerprint space employs a multidimensional scaling technique, reducing the high-dimensional correlation relationships to a three-dimensional fingerprint space. Within the fingerprint space, the projection area is determined according to the distribution of correlation clusters, causing button fingerprints from the same cluster to cluster together spatially. For example, the button fingerprints of the "shopping process cluster" might be mapped to the first quadrant of the fingerprint space, while the button fingerprints of the "user information cluster" might be mapped to the second quadrant.

[0100] The mapping function for button fingerprints uses radial basis functions to transform the button's feature vector into three-dimensional coordinate points in the fingerprint space. For button A, its feature vector contains temporal and semantic features, which are transformed into coordinate points (x, y, z) in the fingerprint space through the mapping function. These coordinate points are the fingerprint of button A.

[0101] Applying neighborhood constraints to button fingerprints ensures that buttons with high correlation are close together in the fingerprint space. This constraint is implemented using a spring model, where the correlation is proportional to the spring stiffness. When the correlation between two buttons is 0.8, the spring stiffness coefficient connecting them is set to 0.8, prompting the fingerprints of these two buttons to be distributed close together in space. Through iterative optimization, the fingerprints of related buttons eventually form a progressively distributed structure in the fingerprint space, making the fingerprints of buttons with higher correlation closer together and the fingerprints of buttons with lower correlation farther apart.

[0102] In this embodiment, position and operation information of buttons are extracted through segmented sampling to construct temporal and semantic features of the buttons, enabling a quantitative expression of the business logic relationships and operational intentions between buttons. Based on this, the association strength generated by combining operation distance and similarity effectively enhances the expressive power of logical dependencies between buttons. By performing cluster analysis on adjacent buttons, the constructed association degree matrix accurately characterizes the structural density and boundary clarity between buttons, providing high-quality data support for subsequent permission propagation modeling. Mapping the association degree matrix to the fingerprint space and introducing projection region and neighborhood constraint mechanisms enables the gradual evolution of button fingerprint distribution, ensuring that buttons with similar permissions are spatially continuous and separable. The resulting gradual fingerprint distribution structure not only enhances the system's ability to resolve button dependencies but also provides a foundation for rapid location and efficient verification of permission states, improving the scalability and computational performance of the permission model.

[0103] In one optional implementation, the correlation matrix is ​​mapped to a fingerprint space, and the projection region of the button fingerprint is determined according to the distribution of correlation clusters in the fingerprint space. A mapping function for the button fingerprint is constructed based on the projection region, and the button features are converted into a button fingerprint using the mapping function, including:

[0104] The correlation matrix is ​​mapped to the fingerprint space through multidimensional scaling to obtain the spatial coordinates of the button node in the fingerprint space. The spatial coordinates are then clustered using a density clustering algorithm to obtain the correlation cluster distribution in the fingerprint space. The correlation cluster distribution is used to determine the projection area range of the button fingerprint.

[0105] Extract the set of boundary points of the associated cluster, obtain the temporal change information between the boundary points, calculate the dynamic association weight of each boundary point based on the temporal change information, calculate the boundary adjustment factor based on the dynamic association weight of the boundary points, and multiply the boundary adjustment factor by the distribution range of the associated cluster to construct the projection area of ​​the button fingerprint.

[0106] Based on the shape characteristics of the projection region, a combination ratio of Gaussian kernel function and Laplacian kernel function is selected, and the dynamic correlation weight is used as the weight parameter of the kernel function to construct a mapping function for button fingerprint. The input button features are then converted into button fingerprints through the mapping function of button fingerprint.

[0107] In one implementation of button fingerprint mapping, the system first receives an association degree matrix as input data. This association degree matrix typically originates from historical data of user interactions with interface buttons, where each element represents the degree of association between two buttons. To visualize this association and construct the fingerprint space, a multidimensional scaling (MDS) algorithm is used to process the association degree matrix. In practical applications, the system iteratively calculates the association degree data in the high-dimensional space to map it to a low-dimensional fingerprint space (usually two-dimensional or three-dimensional), while preserving the distance relationships between the original data points as much as possible. For example, for a system containing 100 buttons, the association degree matrix is ​​a 100×100 square matrix. After MDS mapping, 100 two-dimensional coordinate points are obtained, each representing the position of a button in the fingerprint space.

[0108] After acquiring the spatial coordinates, the system uses a density-based clustering algorithm (such as DBSCAN) to perform cluster analysis on these coordinates. This algorithm does not require pre-specifying the number of clusters; instead, it automatically discovers clusters based on the density of points. In practice, two key parameters are set: the neighborhood radius ε and the minimum number of points MinPts. For example, when ε is set to 0.5 and MinPts is set to 5, it means that at least 5 points within a radius of 0.5 are needed to form the core of a cluster. In this way, the system can identify natural clustering structures in the fingerprint space, which represent the functional or usage pattern similarity between buttons. For the example of 100 buttons mentioned above, the clustering results may show that they form 6 distinct clusters, each containing 10-20 buttons.

[0109] After clustering, the system needs to extract the boundary information of each associated cluster. This step is achieved by identifying the outer points of the cluster, i.e., those points located at the cluster edges. Specifically, convex hull algorithms or α-shape algorithms can be used to capture the cluster contours. For example, for a cluster containing 15 points, the α-shape algorithm might identify 8 points as its boundary point set. These boundary point sets not only define the shape of the associated clusters in space but also provide a basis for subsequent boundary adjustments.

[0110] To more accurately characterize the dynamic relationships between buttons, the system analyzes the temporal changes between boundary points. This involves examining the order and frequency of user interactions with different buttons at different times. For each boundary point, its temporal correlation with other points is calculated to obtain a dynamic correlation weight. A practical example is that for boundary point A, the system analyzes its interaction sequence with other points within 10 seconds before and after it, calculating a temporal correlation score. If point A frequently appears before point B in the user interaction sequence, and the time interval is stable, then point A receives a higher dynamic correlation weight, for example, 0.85.

[0111] Based on these dynamic association weights, the system calculates a boundary adjustment factor. This factor is generated according to the distribution characteristics of the dynamic association weights at the boundary points and is used to expand or shrink the original boundary of the associated cluster. During the calculation, the dynamic association weights of the boundary points are normalized, and then a weighted average is used to obtain the overall adjustment factor. For example, if the calculated boundary adjustment factor for a cluster is 1.2, it means that the boundary of that cluster needs to be expanded outward by 20%. Applying this adjustment factor to the distribution range of the associated cluster, the system constructs the projection area of ​​the button fingerprint, which considers both the static spatial distribution and the dynamic interaction pattern.

[0112] After constructing the projection region, the system needs to select an appropriate combination of kernel functions to construct the mapping function based on its shape characteristics. Specifically, it analyzes the geometric properties of the projection region, such as circularity, convexity, and eccentricity. For regions that are nearly circular and relatively regular, the system tends to assign a higher weight to the Gaussian kernel function; while for regions with irregular shapes or complex boundaries, the proportion of the Laplace kernel function is increased. In practice, if the circularity of a projection region is 0.7, the system might choose a combination of 70% Gaussian kernel function and 30% Laplace kernel function.

[0113] During the construction of the mapping function, the system uses the previously calculated dynamic association weights as weight parameters of the kernel function. This allows the mapping function to reflect the differences in importance between different regions. For example, the mapping function assigns higher response values ​​to regions surrounding boundary points with higher weights. After completing the mapping function construction, the system can convert any input button features into a button fingerprint. Specifically, the button feature vector is input into the mapping function, and a new representation, the button fingerprint, is calculated through kernel function transformation. This fingerprint contains both the spatial location information of the button and the temporal interaction pattern, providing a comprehensive expression of the button's characteristics.

[0114] Suppose a new button has a feature vector of [0.3, 0.7, 0.5, 0.2]. After processing by the mapping function mentioned above, a two-dimensional fingerprint coordinate (0.42, 0.65) may be obtained. This coordinate falls within a specific projection area, indicating that the new button has similar functions or usage patterns to the button group associated with that area.

[0115] In existing technologies, the generation of button permission fingerprints typically employs fixed vector mapping or rule matching based on static labels. This fails to reflect the complex business dependencies and temporal dynamics between buttons, resulting in chaotic fingerprint distribution and a lack of scalability and discriminability. This application introduces multidimensional scaling technology to map the correlation matrix to the fingerprint space, combined with density clustering algorithms to identify the distribution structure of correlation clusters, effectively enhancing the distinguishability and spatial organization of buttons in the fingerprint space. Furthermore, it incorporates temporal variation information of boundary points, constructs dynamic correlation weights, and calculates boundary adjustment factors, giving the fingerprint projection area stronger temporal adaptability and structural self-adjustment capabilities, overcoming the limitations of fixed fingerprint regions and lack of dynamic adjustment in existing technologies. By selecting a fusion model of Gaussian and Laplacian kernels to construct the mapping function and dynamically adjusting the kernel function response with weights, a refined and controllable mapping from high-dimensional button features to the fingerprint space is achieved. This improvement aims to enhance the structural expressiveness and temporal response capabilities of button fingerprints, making the generated button fingerprints progressive, discriminative, and evolvable, providing more stable and accurate feature support for subsequent permission modeling and dynamic verification.

[0116] In one optional implementation, a button dependency tree is constructed based on the association matrix and button fingerprints. The permission propagation weight of each node is calculated by traversing the button dependency tree, and the permission propagation weight is used as a routing parameter to construct the propagation link, including:

[0117] The association strength between buttons is extracted from the association degree matrix. A weighted association graph of buttons is constructed by combining the distribution distance of button fingerprints in the fingerprint space. The minimum spanning tree algorithm is used to extract the main association path from the weighted association graph to construct the initial structure of the button dependency tree.

[0118] The average association strength of the button nodes in the initial structure is used as the weight base. The node influence index is constructed by combining the in-degree ratio of the button nodes. The subtree hierarchical structure is constructed with the button node with the largest influence index as the root node. The subtree hierarchical structure inherits the association strength as the hierarchical connection weight.

[0119] The distribution density of button nodes in the subtree hierarchy is calculated based on the hierarchical connection weights. When the distribution density of button nodes exceeds a preset density threshold, the subtree is split. When the distribution density of button nodes is lower than the preset density threshold, the subtree is merged. The button dependency tree is obtained through density optimization.

[0120] Traverse the button dependency tree, calculate the depth weight using the level depth and level connection weight of the button node, calculate the coverage weight using the influence index of the button node, and combine the depth weight and coverage weight to generate the permission propagation weight of the button node.

[0121] The ratio of permission propagation weights of adjacent button nodes is set as the route jump weight. In the button dependency tree, the button node sequence of each branch is sorted based on the route jump weight, and the node sequence with decreasing route jump weight is selected to construct the propagation link.

[0122] For example, a button dependency tree is first constructed based on the association degree matrix and button fingerprints. Then, the permission propagation weight of each node is calculated by traversing the button dependency tree. Finally, the permission propagation weights are used as routing parameters to construct propagation links. Specifically, in constructing the button dependency tree, the association strength between buttons needs to be extracted from the association degree matrix first. The association degree matrix is ​​an N×N matrix, where N represents the total number of buttons in the system, and each element A... ij This represents the strength of the association between button i and button j. For example, if there are 5 buttons in the system, the association matrix might be: [[1.0, 0.8, 0.3, 0.1, 0.2], [0.8, 1.0, 0.6, 0.2, 0.1], [0.3, 0.6, 1.0, 0.7, 0.4], [0.1, 0.2, 0.7, 1.0, 0.9], [0.2, 0.1, 0.4, 0.9, 1.0]].

[0123] The correlation assessment is further enhanced by combining the distribution distance of button fingerprints in the fingerprint space. A button fingerprint is a multi-dimensional vector describing button characteristics, which may include features such as button function category, usage frequency, and importance. In this embodiment, each button can be represented by a 10-dimensional vector; for example, the fingerprint of button 1 might be [0.5, 0.3, 0.7, 0.2, 0.9, 0.1, 0.4, 0.6, 0.3, 0.8]. The distribution distance in the fingerprint space can be obtained by calculating the Euclidean distance. For example, the fingerprint distance between button 1 and button 2 might be 0.42.

[0124] When constructing a weighted association graph, the association strength is weighted and combined inversely proportional to the fingerprint distance. Specifically, the weighted association value W between two buttons... ij =A ij ×(1 / (1+Dij)), where D ij Let represent the fingerprint distance between button i and button j. Thus, for buttons 1 and 2 with an association strength of 0.8 and a fingerprint distance of 0.42, their weighted association value is 0.8 × (1 / (1+0.42)) = 0.563.

[0125] The minimum spanning tree algorithm is used to extract the main path of association from a weighted association graph. This algorithm first sorts all edges in ascending order of weight, then greedily adds edges until a tree structure is formed that connects all nodes without loops. For example, in the system with the above 5 buttons, the edges of the minimum spanning tree might be {(1, 2, 0.563), (2, 3, 0.476), (3, 4, 0.525), (4, 5, 0.692)}, where each triple represents (start button, end button, weighted association value).

[0126] The average association strength of the button nodes in the initial structure is used as the weight base. For each node, the average association strength of all edges directly connected to it is calculated. For example, the average association strength of node 3 is (0.476 + 0.525) / 2 = 0.5005. A node influence index is constructed by combining the in-degree ratio of the button nodes. The out-degree represents the number of edges originating from that node, and the in-degree represents the number of edges pointing to that node. The node influence index I = average association strength × (out-degree + 1) / (in-degree + 1). For example, if node 3 has an out-degree of 1 and an in-degree of 1, its influence index is 0.5005 × (1 + 1) / (1 + 1) = 0.5005.

[0127] The button node with the highest influence index is selected as the root node to construct a subtree hierarchy. Assuming node 1 has the highest influence index of 0.623, the tree is built with node 1 as the root. The construction process uses a breadth-first search, expanding downwards layer by layer according to the connection relationships of the original minimum spanning tree. The association strength of each edge is inherited as the hierarchical connection weight.

[0128] The distribution density of button nodes in the subtree hierarchy is calculated based on the hierarchical connection weights. For each level in the tree, the density value D of the nodes in that level is calculated as: D = number of nodes in that level / average association strength between nodes in that level. For example, if the second level has 3 nodes and the average association strength between them is 0.45, then the density value of that level is 3 / 0.45 = 6.67.

[0129] When the distribution density of button nodes exceeds a preset density threshold (e.g., set to 6.0), the subtree is split. The splitting operation involves clustering nodes in layers with excessive density based on their association strength, forming multiple subtrees. When the density value is below the preset density threshold (e.g., set to 2.0), the subtrees are merged, combining multiple low-density subtrees into one. Through this density optimization operation, a balanced button dependency tree is ultimately obtained.

[0130] Traverse the button dependency tree and calculate the depth weight using the level depth and level connection weights of the button node. Depth weight DW = 1 / (level depth × (1 - average level connection weight)). For example, for a node with a depth of 2 and an average level connection weight of 0.563, its depth weight is 1 / (2 × (1 - 0.563)) = 1.143.

[0131] Calculate the coverage weight using the influence metric of the button node. Coverage weight CW = Influence metric × Number of child nodes. For example, if node 1 has an influence metric of 0.623 and 2 child nodes, its coverage weight is 0.623 × 2 = 1.246. Combine the depth weight and coverage weight to generate the permission propagation weight of the button node. Permission propagation weight PW = Depth weight × 0.6 + Coverage weight × 0.4. For example, for node 1 with a depth weight of 1.143 and a coverage weight of 1.246, its permission propagation weight is 1.143 × 0.6 + 1.246 × 0.4 = 0.686 + 0.498 = 1.184.

[0132] Set the ratio of permission propagation weights between adjacent button nodes as the route jump weight. For example, if the permission propagation weight of node 1 is 1.184 and the permission propagation weight of its child node 2 is 0.975, then the route jump weight from node 1 to node 2 is 0.975 / 1.184 = 0.823.

[0133] The button node sequence of each branch is sorted based on the route hop weight, and the propagation link is constructed by selecting the node sequence with decreasing route hop weight. For example, if there are two paths starting from the root node: the node sequence of path 1 is [1, 2, 3], and the corresponding route hop weight sequence is [1.0, 0.823, 0.762]; the node sequence of path 2 is [1, 4, 5], and the corresponding route hop weight sequence is [1.0, 0.856, 0.723]. Since the first hop weight of path 2 (0.856) is greater than the first hop weight of path 1 (0.823), path 2 is preferentially selected as the main propagation link.

[0134] In existing technologies, the propagation path of button permissions typically relies on fixed role hierarchies or predefined functional module structures, lacking quantitative modeling of dynamic relationships and operational influence between buttons. This results in rigid, coarse-grained, and poorly adaptable permission routing paths. This application constructs a weighted association graph by combining the association strength between buttons with the spatial distribution distance of fingerprints, and introduces the minimum spanning tree algorithm to extract the core path, thus constructing a button dependency tree that reflects business operation logic for the first time. During the dependency tree construction process, the influence of nodes is calculated by introducing the in-degree ratio and the mean of association strength, forming a hierarchical subtree structure. Then, the distribution density is used to adaptively split and merge subtrees, effectively optimizing the hierarchical rationality of the dependency structure and the node organization density, overcoming the problems of static hierarchy and structural imbalance in existing methods. By combining the node's hierarchical depth and influence index to calculate the propagation weight, and using the weight ratio as the basis for jumps, a propagation link is constructed, realizing permission flow modeling based on a dynamic structure. This scheme aims to improve the business fit and response flexibility of permission propagation paths, ultimately achieving adaptive construction and fine-grained sorting of permission propagation links, providing the system with more efficient and reasonable permission routing capabilities.

[0135] Figure 3 This diagram illustrates the efficiency comparison of permission propagation methods. Looking at the "Permission Propagation Accuracy" metric, the traditional method achieves only 56.8% accuracy, the role-based method improves to 73.2%, while the button dependency tree method significantly outperforms the former two, reaching a high accuracy of 91.5%. In terms of "Response Time Optimization Rate," the traditional method performs the worst (43.7%), the role-based method is at a moderate level (62.3%), and the button dependency tree method achieves an optimization rate of 84.6%, nearly double that of the traditional method. Similarly, in the "Business Fit" metric, the three methods achieve 46.2%, 65.8%, and 89.3% respectively, with the button dependency tree method also demonstrating outstanding performance.

[0136] The results show that the button dependency tree method proposed in this invention constructs a weighted association graph by combining association strength and fingerprint spatial distribution distance, and introduces the minimum spanning tree algorithm to extract the core path, thus successfully realizing the adaptive construction and fine sorting of the permission propagation link.

[0137] In one optional implementation, a permission state bitmap is generated based on the button dependency tree and propagation chain. The permission state bitmap is divided into multiple permission groups. The state propagation order between each permission group is determined according to the permission propagation weight. A permission state cache tree is constructed, and a verification chain containing state version and timestamp is established, including:

[0138] Extract the propagation path overlap, state change sequence, and access pattern data of nodes from the button dependency tree, calculate the state correlation between nodes, and construct a node mapping matrix based on the state correlation.

[0139] Create a storage space for the permission status bitmap, divide the storage space into a front-end encoding area and a back-end encoding area, and mark nodes with a status correlation higher than a preset correlation threshold as master nodes and other nodes as subordinate nodes according to the node mapping matrix.

[0140] The state propagation rules are determined based on the node dependencies and node mapping matrix in the propagation chain. The state information of the master node is encoded and written into the front-end encoding area in order of state relevance from high to low. The state information of the subordinate nodes is encoded and written into the back-end encoding area in accordance with the state propagation rules.

[0141] A state association marker is set between the front-end encoding area and the back-end encoding area. The state association marker contains the validity period and priority information of state propagation. A state dependency graph is constructed based on the node mapping matrix and the state association marker.

[0142] Based on the state dependency graph and propagation link, the permission propagation weight is calculated, and permission groups are determined according to the preset interval of the state relevance and the permission propagation weight.

[0143] The state propagation order between permission groups is determined based on the permission propagation weight. A permission state cache tree is constructed, and the permission group is set as a cache tree node. The permission group identifier, state version number and timestamp are written into the cache tree. A verification chain containing the state version and timestamp is established between the nodes of the permission state cache tree.

[0144] For example, firstly, the propagation path overlap, state change sequence, and access pattern data of nodes are extracted from the button dependency tree, and the state correlation between nodes is calculated. The state correlation calculation involves multiplying the propagation path overlap by 0.5, the state change sequence similarity by 0.3, and the access pattern similarity by 0.2, and then summing them. For example, for nodes A and B, if the propagation path overlap is 0.8, the state change sequence similarity is 0.7, and the access pattern similarity is 0.6, then the state correlation is 0.8×0.5+0.7×0.3+0.6×0.2=0.74. By calculating the state correlation for all node pairs, a node mapping matrix is ​​constructed.

[0145] When creating the permission status bitmap storage space, the system pre-allocates 16KB of memory, dividing the first 5KB into a front-end encoding area and the last 11KB into a back-end encoding area. A preset relevance threshold of 0.7 is set. Based on the node mapping matrix, nodes with a relevance score higher than 0.7 are marked as master nodes, and the rest are marked as subordinate nodes. In practical applications, assuming the system contains 100 button nodes, based on the relevance calculation results, approximately 25 nodes may be marked as master nodes, and 75 nodes as subordinate nodes.

[0146] The state propagation rules are determined based on the node dependencies and node mapping matrix in the propagation chain. The state information of the master node is encoded in descending order of state relevance and written to the front-end encoding area, with each master node occupying 8 bits. Taking node X as an example, if its state relevance is the highest, the system encodes it as binary "10011010" and writes it to the beginning of the front-end encoding area. The state information of slave nodes is encoded according to the state propagation rules and written to the back-end encoding area, with each slave node occupying 4 bits. If slave node Y depends on master node X, it is encoded as binary "1001" and written to the corresponding position in the back-end encoding area.

[0147] A state association marker is set between the front-end and back-end encoding areas, containing the validity period and priority information of state propagation. The state association marker occupies 2 bytes; the first 8 bits represent the validity period (in hours), and the last 8 bits represent the priority (ranging from 0 to 255, with higher values ​​indicating higher priority). For example, if the validity period of a certain association is set to 24 hours and the priority is 192, its binary representation is "0001100011000000". A state dependency graph is constructed based on the node mapping matrix and the state association marker, stored using an adjacency list. Each node contains a list of its dependent nodes and their corresponding association markers.

[0148] The permission propagation weight is calculated based on the state dependency graph and propagation path. The permission propagation weight comprehensively considers the node's in-degree, out-degree, propagation depth, and response time. For node X, if its in-degree is 3, out-degree is 5, propagation depth is 2, and response time is 50 milliseconds, then its permission propagation weight is calculated as (3+5)×0.4+(3-5+5)×0.3+(1000÷50)×0.3=3.2+0.9+6=10.1. Permission groups are determined based on preset intervals for state relevance and permission propagation weight. The permission propagation weight is divided into four intervals: 0-5, 5-10, 10-15, and 15+. The state relevance is divided into four intervals: 0-0.3, 0.3-0.6, 0.6-0.8, and 0.8-1.0, forming 16 permission groups. For example, nodes with a permission propagation weight in the 5-10 interval and a state relevance in the 0.6-0.8 interval are assigned to permission group 7.

[0149] The order of state propagation among permission groups is determined based on permission propagation weights, with higher-weight groups propagating first. A permission state cache tree is constructed using a B+ tree structure, with permission groups set as nodes in the cache tree. Each node contains 32 bytes of data, including 8 bytes for the permission group identifier (16 groups corresponding to binary 0000-1111), 16 bytes for the state version number (an auto-incrementing integer, initially 1), and 8 bytes for the timestamp (Unix timestamp, accurate to milliseconds). For example, the node data for permission group 7 might be "00000111" (group identifier) ​​+ "00000000000000101" (version number 5) + "1673432289123" (timestamp).

[0150] A verification chain containing state version and timestamp is established between nodes in the permission state cache tree, implemented using hash pointers. Each node stores its own data and the hash value of the previous node's data (calculated using the SHA-256 algorithm), forming a chain structure. When the permission group state changes, the system updates the version number and timestamp of the corresponding node and recalculates the verification chain. Through this verification chain mechanism, the system can quickly verify the validity of the cached state during permission checks, avoiding the use of expired permission information. For example, when checking the state of permission group 7, the system first verifies whether the node's timestamp is within its validity period, then confirms through the verification chain that the data has not been tampered with, before using its permission state information for authorization determination.

[0151] In this embodiment, by constructing a permission state bitmap and dividing it into front-end and back-end encoding areas, and combining the state correlation and master-slave relationship between nodes to encode state information in an orderly manner, the clarity of the permission state organization structure and access efficiency are improved. Simultaneously, a state association marker is introduced to record the validity period and priority of state propagation, and dynamic management is achieved by combining it with a state dependency graph, realizing lifecycle control and timeliness management of state data. Based on this, permission groups and state cache trees are constructed according to state correlation and permission propagation weights, and state versions and timestamps are managed through a verification chain, enhancing the accuracy and security of state verification. Compared with traditional methods, this scheme, starting from the propagation link and state similarity, introduces a structured grouping and chain verification mechanism, realizing accurate propagation and rapid verification of permission states among multiple nodes, significantly improving the system's permission consistency guarantee capability and response efficiency.

[0152] In one optional implementation, the frequency of permission state changes in the permission state cache tree is monitored. When the accumulated changes reach a trigger threshold, the state diffusion range is calculated along the propagation path, a state propagation path diagram is generated, and the optimal update sequence is determined based on the propagation path diagram. Batch state updates are then performed, including:

[0153] Set a state change counter and a time window in the node of the permission state cache tree, and calculate the cumulative value of state changes of the state change counter within the time window;

[0154] When the cumulative value of the state change reaches the preset trigger threshold, the state diffusion range is calculated based on the position of the trigger update node in the propagation link, and the state correlation, propagation path length and state change frequency of each node in the state diffusion range are extracted.

[0155] A state propagation path graph is generated based on the state relevance, propagation path length, and state change frequency. The affected nodes are set as vertices of the graph, and the propagation relationships between nodes are set as edges of the graph. The weights of the edges are calculated based on the state relevance, propagation path length, and state change frequency.

[0156] In the state propagation path graph, a state relevance threshold and a propagation path length upper limit are set to filter propagation paths that are lower than the state relevance threshold and propagation paths that are higher than the propagation path length upper limit. The optimal update sequence is determined based on the edge weights.

[0157] The batch update quantity is determined based on system load and historical average update quantity, and the status update tasks in the optimal update sequence are executed in batches according to the batch update quantity.

[0158] Before performing batch updates, the original state of the nodes is recorded. The state update is performed according to the topological sequence of the state propagation path graph. When the update time exceeds the preset timeout limit, the update is interrupted and the node state is restored to the original state.

[0159] For example, in scenarios where the permission status changes frequently in the permission status cache tree, by monitoring the frequency of permission status changes, when the cumulative changes reach a specific threshold, a batch status update is performed to optimize system performance.

[0160] In the permission state cache tree, each node represents a permission entity, such as a role, permission group, or specific permission item. Each node has a state change counter and a time window. The state change counter records the number of times the node's permission state changes, while the time window limits the statistical time range. The system calculates the cumulative state change value by recording the number of state changes a node makes within a specific time window. For example, for a permission node, if its state changes from "Allowed" to "Denyed," then back to "Allowed," and then back to "Denyed" within a 10-minute time window, its state change counter value will be 3.

[0161] When the cumulative state changes of a node reach a preset trigger threshold, the system will initiate a batch state update process. The trigger threshold is set according to the actual system load and performance requirements; for example, it can be set to a threshold of 5 changes within a time window. When a node, such as the "Administrator Privilege Group," experiences 5 state changes within 5 minutes, the system will mark that node as a trigger update node.

[0162] After an update is triggered, the system calculates the state propagation range based on the position of the triggering update node in the propagation chain. The propagation chain refers to the path along which permission status spreads from one node to another. For example, when the "administrator role" permission changes, this change propagates along the permission relationships to all user and resource nodes associated with that role. By analyzing the structure of the permission cache tree, the system determines which nodes will be affected by the state change of the triggering update node; these nodes constitute the state propagation range.

[0163] After determining the scope of state propagation, the system extracts the state correlation, propagation path length, and state change frequency for each node within that scope. State correlation indicates the degree of association between permission state changes between two nodes, ranging from 0 to 1. For example, the correlation between "administrator role" and "system configuration permissions" might be 0.8, indicating a high degree of correlation. Propagation path length refers to the shortest path length from the triggering update node to the target node. For example, the propagation path length from "administrator role" to "user A" is 2. State change frequency indicates how frequently a node's state changes. For example, the change frequency for "temporary permission items" might be 3 times per hour.

[0164] The system generates a state propagation path graph based on the extracted data. In this graph, affected nodes are set as vertices, and the propagation relationships between nodes are set as edges. Edge weights are calculated based on state relevance, propagation path length, and state change frequency. The weight calculation comprehensively considers the influence of these three factors; for example, relevance can be multiplied by change frequency and then divided by the square of the propagation path length to obtain the edge weight value. A higher weight value indicates a more important propagation path and a higher update priority.

[0165] To optimize update efficiency, the system sets a state relevance threshold and a propagation path length limit in the state propagation path graph. The state relevance threshold can be set to 0.3, meaning only propagation paths with a relevance greater than 0.3 will be considered for updating. The propagation path length limit can be set to 5, meaning only nodes with a propagation path length of no more than 5 will be considered. The system filters out propagation paths below the state relevance threshold and those exceeding the propagation path length limit, and then determines the optimal update sequence based on edge weights. The optimal update sequence is typically the result of sorting edge weights from highest to lowest.

[0166] After determining the optimal update sequence, the system determines the batch update size based on the current system load and the historical average update size. For example, if the current system load is low and the historical average batch update size is 100 nodes, the system might set the batch update size to 120. The system will execute the status update tasks in the optimal update sequence in batches according to the batch update size, updating 120 nodes per batch.

[0167] Before performing a batch update, the system records the original state of all nodes to be updated so that a rollback can be performed in case of problems. The system performs state updates according to the topological sequence of the state propagation path graph, ensuring that dependencies are handled correctly. For example, the update of the "role" node will be performed before the update of the "user" node that depends on that role. When the update time exceeds the preset timeout limit (e.g., 30 seconds), the system will interrupt the update and restore the updated node state to its original state, avoiding the impact of long-term updates on the overall system performance.

[0168] By using the above methods, the system can efficiently handle batch status updates in the permission status cache tree, effectively balance system load and update efficiency, and improve the overall performance and user experience of the permission management system.

[0169] In existing technologies, permission status updates typically rely on periodic refreshes or event-triggered mechanisms, lacking precise control over the scope and priority of state diffusion, which can easily lead to redundant updates, performance bottlenecks, or state inconsistencies. This application, based on a permission status cache tree, introduces a state change counter and time window into nodes to monitor the frequency of state changes in real time, ensuring that updates are only initiated when a trigger threshold is reached, effectively avoiding frequent invalid updates. After an update is triggered, the scheme constructs a state propagation path graph based on state relevance, propagation path length, and change frequency. It comprehensively selects highly relevant and controllable paths based on weighted information, extracting the optimal update sequence to improve the accuracy and coverage of state updates. Simultaneously, the system supports dynamically determining the batch update quantity based on load, avoiding high concurrency impacting system performance. An original state rollback mechanism is introduced during the update process to ensure recoverable handling of abnormal situations, improving system stability and robustness. Compared to traditional update mechanisms, this scheme achieves a more efficient, secure, and refined permission status update strategy by combining diffusion awareness, path optimization, and batch control.

[0170] A second aspect of this invention provides a hierarchical button permission management and verification system based on system coding, the system comprising:

[0171] The first unit is used to collect the business identifier and operation type of the button, reorder them by sensitivity, and construct them into local sensitive codes. Based on the local sensitive codes, the correlation matrix of adjacent buttons is calculated, and the correlation matrix is ​​used to generate button fingerprints so that the fingerprints of related buttons form a gradual distribution in space.

[0172] The second unit is used to construct a button dependency tree based on the correlation matrix and button fingerprint, traverse the button dependency tree to calculate the permission propagation weight of each node, and use the permission propagation weight as a routing parameter to construct a propagation link.

[0173] The third unit is used to generate a permission state bitmap based on the button dependency tree and propagation chain, divide the permission state bitmap into multiple permission groups, determine the state propagation order between each permission group according to the permission propagation weight, construct a permission state cache tree, and establish a verification chain containing state version and timestamp.

[0174] The fourth unit is used to monitor the frequency of permission status changes in the permission status cache tree. When the cumulative changes reach the trigger threshold, the state diffusion range is calculated along the propagation link, a state propagation path diagram is generated, the optimal update sequence is determined based on the propagation path diagram, and batch state updates are performed. When a button operation request is received, the permission group is located in the permission status cache tree by the button fingerprint, the validity of the status is judged by the verification chain, and the operation is performed after the verification is passed.

[0175] A third aspect of the present invention provides an electronic device, comprising:

[0176] processor;

[0177] Memory used to store processor-executable instructions;

[0178] The processor is configured to invoke instructions stored in the memory to execute the aforementioned method.

[0179] A fourth aspect of the present invention provides a computer-readable storage medium having stored thereon computer program instructions that, when executed by a processor, implement the aforementioned method.

[0180] This invention can be a method, apparatus, system, and / or computer program product. The computer program product may include a computer-readable storage medium having computer-readable program instructions loaded thereon for performing various aspects of the invention.

[0181] Finally, it should be noted that the above embodiments are only used to illustrate the technical solutions of the present invention, and not to limit them; although the present invention has been described in detail with reference to the foregoing embodiments, those skilled in the art should understand that modifications can still be made to the technical solutions described in the foregoing embodiments, or equivalent substitutions can be made to some or all of the technical features; and these modifications or substitutions do not cause the essence of the corresponding technical solutions to deviate from the scope of the technical solutions of the embodiments of the present invention.

Claims

1. A hierarchical button permission management and verification method based on system coding, characterized in that, include: The business identifier and operation type of the data collection button are reordered based on sensitivity and constructed into locally sensitive codes, including: The business identifier of the button is semantically decomposed, the conditional probability of the term under different topics is calculated to obtain the topic distribution of the business identifier, and the difference degree and distribution entropy of the topic category are calculated based on the topic distribution of the business identifier to generate the business identifier sensitivity; Construct an operation type temporal dependency graph, where nodes represent operation types, edges represent dependencies between operation types, and edge weights represent temporal association strength. Perform a random walk with damping factors on the operation type temporal dependency graph to obtain operation type centrality. Calculate operation type information entropy based on the operation type temporal dependency graph. Combine operation type centrality and operation type information entropy to generate operation type sensitivity. The button feature sensitivity is obtained by weighted fusion of business identifier sensitivity and operation type sensitivity, and the button features are reordered according to the button feature sensitivity to obtain the button feature sequence; A feature projection matrix is ​​constructed based on the button feature sequence. The similarity of the buttons in the local neighborhood is calculated based on the button feature sensitivity to obtain the encoding constraints. The feature projection matrix is ​​optimized using the encoding constraints to obtain the optimized projection matrix. The button feature sensitivity is converted into feature position weights. Based on the feature position weights and the optimized projection matrix, the button feature sequence is weighted and mapped to generate local sensitivity codes for the buttons. The correlation matrix between adjacent buttons is calculated based on the local sensitivity codes. The correlation matrix is ​​used to generate button fingerprints so that the fingerprints of related buttons form a gradual distribution in space. Construct a button dependency tree based on the correlation matrix and button fingerprints, traverse the button dependency tree to calculate the permission propagation weight of each node, and use the permission propagation weight as a routing parameter to construct a propagation link; A permission state bitmap is generated based on the button dependency tree and propagation chain. The permission state bitmap is divided into multiple permission groups. The state propagation order between each permission group is determined according to the permission propagation weight. A permission state cache tree is constructed and a verification chain containing state version and timestamp is established. Monitor the frequency of permission status changes in the permission status cache tree. When the cumulative changes reach the trigger threshold, calculate the status diffusion range along the propagation link, generate a status propagation path diagram, determine the optimal update sequence based on the propagation path diagram, and execute batch status updates. When a button operation request is received, the permission group is located in the permission status cache tree by using the button fingerprint, the validity of the status is determined by the verification chain, and the operation is executed after the verification is successful.

2. The method according to claim 1, characterized in that, The correlation matrix between adjacent buttons is calculated based on locality-sensitive coding. Button fingerprints are then generated using this correlation matrix, resulting in a gradual spatial distribution of the fingerprints of related buttons. The local sensitivity coding of the button is segmented and sampled to extract the position information and operation information of each segment. The temporal features of the button are constructed based on the position information, and the semantic features of the button are constructed based on the operation information. The operation distance of the button in the business process is calculated based on the temporal features, the operation similarity of the button is calculated based on the semantic features, and the operation distance and operation similarity are combined to generate the association strength of adjacent buttons. Based on the association strength, adjacent buttons are grouped and clustered to obtain association clusters of buttons. The density of buttons within an association cluster and the interval between buttons between association clusters are calculated. An association degree matrix of adjacent buttons is constructed based on the density and interval. The correlation matrix is ​​mapped to the fingerprint space. The projection region of the button fingerprint is determined according to the distribution of the correlation clusters in the fingerprint space. A mapping function for the button fingerprint is constructed based on the projection region. The button features are converted into button fingerprints using the mapping function. Neighborhood constraints are applied to the button fingerprints so that the button fingerprints in adjacent projection regions form an asymptotic distribution, thus obtaining the asymptotic distribution structure of the relevant buttons in the fingerprint space.

3. The method according to claim 2, characterized in that, The correlation matrix is ​​mapped to the fingerprint space. The projection region of the button fingerprint is determined according to the distribution of correlation clusters in the fingerprint space. A mapping function for the button fingerprint is constructed based on the projection region. The button features are then converted into a button fingerprint using the mapping function, including: The correlation matrix is ​​mapped to the fingerprint space through multidimensional scaling to obtain the spatial coordinates of the button node in the fingerprint space. The spatial coordinates are then clustered using a density clustering algorithm to obtain the correlation cluster distribution in the fingerprint space. The correlation cluster distribution is used to determine the projection area range of the button fingerprint. Extract the set of boundary points of the associated cluster, obtain the temporal change information between the boundary points, calculate the dynamic association weight of each boundary point based on the temporal change information, calculate the boundary adjustment factor based on the dynamic association weight of the boundary points, and multiply the boundary adjustment factor by the distribution range of the associated cluster to construct the projection area of ​​the button fingerprint. Based on the shape characteristics of the projection region, a combination ratio of Gaussian kernel function and Laplacian kernel function is selected, and the dynamic correlation weight is used as the weight parameter of the kernel function to construct a mapping function for button fingerprint. The input button features are then converted into button fingerprints through the mapping function of button fingerprint.

4. The method according to claim 1, characterized in that, Based on the association matrix and button fingerprints, a button dependency tree is constructed. The permission propagation weight of each node is calculated by traversing the button dependency tree. The permission propagation weight is then used as a routing parameter to construct the propagation link, which includes: The association strength between buttons is extracted from the association degree matrix. A weighted association graph of buttons is constructed by combining the distribution distance of button fingerprints in the fingerprint space. The minimum spanning tree algorithm is used to extract the main association path from the weighted association graph to construct the initial structure of the button dependency tree. The average association strength of the button nodes in the initial structure is used as the weight base. The node influence index is constructed by combining the in-degree ratio of the button nodes. The subtree hierarchical structure is constructed with the button node with the largest influence index as the root node. The subtree hierarchical structure inherits the association strength as the hierarchical connection weight. The distribution density of button nodes in the subtree hierarchy is calculated based on the hierarchical connection weights. When the distribution density of button nodes exceeds a preset density threshold, the subtree is split. When the distribution density of button nodes is lower than the preset density threshold, the subtree is merged. The button dependency tree is obtained through density optimization. Traverse the button dependency tree, calculate the depth weight using the level depth and level connection weight of the button node, calculate the coverage weight using the influence index of the button node, and combine the depth weight and coverage weight to generate the permission propagation weight of the button node. The ratio of permission propagation weights of adjacent button nodes is set as the route jump weight. In the button dependency tree, the button node sequence of each branch is sorted based on the route jump weight, and the node sequence with decreasing route jump weight is selected to construct the propagation link.

5. The method according to claim 1, characterized in that, A permission state bitmap is generated based on the button dependency tree and propagation chain. The permission state bitmap is divided into multiple permission groups. The state propagation order between each permission group is determined according to the permission propagation weight. A permission state cache tree is constructed, and a verification chain containing state version and timestamp is established, including: Extract the propagation path overlap, state change sequence, and access pattern data of nodes from the button dependency tree, calculate the state correlation between nodes, and construct a node mapping matrix based on the state correlation. Create a storage space for the permission status bitmap, divide the storage space into a front-end encoding area and a back-end encoding area, and mark nodes with a status correlation higher than a preset correlation threshold as master nodes and other nodes as subordinate nodes according to the node mapping matrix. The state propagation rules are determined based on the node dependencies and node mapping matrix in the propagation chain. The state information of the master node is encoded and written into the front-end encoding area in order of state relevance from high to low. The state information of the subordinate nodes is encoded and written into the back-end encoding area in accordance with the state propagation rules. A state association marker is set between the front-end encoding area and the back-end encoding area. The state association marker contains the validity period and priority information of state propagation. A state dependency graph is constructed based on the node mapping matrix and the state association marker. Based on the state dependency graph and propagation link, the permission propagation weight is calculated, and permission groups are determined according to the preset interval of the state relevance and the permission propagation weight. The state propagation order between permission groups is determined based on the permission propagation weight. A permission state cache tree is constructed, and the permission group is set as a cache tree node. The permission group identifier, state version number and timestamp are written into the cache tree. A verification chain containing the state version and timestamp is established between the nodes of the permission state cache tree.

6. The method according to claim 1, characterized in that, The frequency of permission status changes in the monitoring permission status cache tree is analyzed. When the accumulated changes reach a trigger threshold, the state diffusion range is calculated along the propagation path, a state propagation path diagram is generated, the optimal update sequence is determined based on the propagation path diagram, and batch state updates are performed, including: Set a state change counter and a time window in the node of the permission state cache tree, and calculate the cumulative value of state changes of the state change counter within the time window; When the cumulative value of the state change reaches the preset trigger threshold, the state diffusion range is calculated based on the position of the trigger update node in the propagation link, and the state correlation, propagation path length and state change frequency of each node in the state diffusion range are extracted. A state propagation path graph is generated based on the state relevance, propagation path length, and state change frequency. The affected nodes are set as vertices of the graph, and the propagation relationships between nodes are set as edges of the graph. The weights of the edges are calculated based on the state relevance, propagation path length, and state change frequency. In the state propagation path graph, a state relevance threshold and a propagation path length upper limit are set to filter propagation paths that are lower than the state relevance threshold and propagation paths that are higher than the propagation path length upper limit. The optimal update sequence is determined based on the edge weights. The batch update quantity is determined based on system load and historical average update quantity, and the status update tasks in the optimal update sequence are executed in batches according to the batch update quantity. Before performing batch updates, the original state of the nodes is recorded. The state update is performed according to the topological sequence of the state propagation path graph. When the update time exceeds the preset timeout limit, the update is interrupted and the node state is restored to the original state.

7. A hierarchical button permission management and verification system based on system coding, used to implement the method of any one of claims 1-6, characterized in that, include: The first unit is used to collect the business identifier and operation type of the button, reorder them by sensitivity, and construct them into local sensitive codes. Based on the local sensitive codes, the correlation matrix of adjacent buttons is calculated, and the correlation matrix is ​​used to generate button fingerprints so that the fingerprints of related buttons form a gradual distribution in space. The second unit is used to construct a button dependency tree based on the correlation matrix and button fingerprint, traverse the button dependency tree to calculate the permission propagation weight of each node, and use the permission propagation weight as a routing parameter to construct a propagation link. The third unit is used to generate a permission state bitmap based on the button dependency tree and propagation chain, divide the permission state bitmap into multiple permission groups, determine the state propagation order between each permission group according to the permission propagation weight, construct a permission state cache tree, and establish a verification chain containing state version and timestamp. The fourth unit is used to monitor the frequency of permission status changes in the permission status cache tree. When the cumulative changes reach the trigger threshold, the state diffusion range is calculated along the propagation link, a state propagation path diagram is generated, the optimal update sequence is determined based on the propagation path diagram, and batch state updates are performed. When a button operation request is received, the permission group is located in the permission status cache tree by using the button fingerprint, the validity of the status is determined by the verification chain, and the operation is executed after the verification is successful.

8. An electronic device, characterized in that, include: processor; Memory used to store processor-executable instructions; The processor is configured to invoke instructions stored in the memory to execute the method according to any one of claims 1 to 6.

9. A computer-readable storage medium having computer program instructions stored thereon, characterized in that, When the computer program instructions are executed by the processor, they implement the method described in any one of claims 1 to 6.

Images