Action scheme sample space search method based on ordinal optimization

Abstract

The invention discloses an action scheme sample space search method based on ordinal optimization, particularly relates to the field of simulated confrontation, is used for solving the problem of high-dimensional constraint verification in a complex dynamic confrontation simulation scene, and provides a global view angle of topological dependence and influence degree by constructing a constraint coupling map and an influence degree matrix; thirdly, on the basis of a topological sorting and forward propagation algorithm of the atlas, preferably verifying core constraints, quickly filtering candidate schemes violating key conditions, and reducing a search space; then, through calculating an elastic adjustment factor and setting a dynamic tolerance threshold value, flexibly adjusting non-key constraints, so that the scheme generates adaptive battlefield situation changes; afterwards, residual constraints are coded into a Boolean logic expression, a verification task tree without data dependence is generated by utilizing a symbolic execution engine, and a decomposition basis is provided for parallel processing; finally, efficient parallel verification is achieved by means of GPU stream multiprocessor and CUDAwarp-level instruction synchronization, and a scheme set meeting full constraints is rapidly output.

Description

Technical Field

[0001] The present invention relates to the field of simulated confrontation, and more specifically, to a method for searching action plan sample space based on sequential optimization. Background Art

[0002] In complex and dynamic confrontation simulation scenarios, the generation of action plans needs to meet a large number of interrelated spatiotemporal coordination, resource matching and task logic constraints. For example, the movement paths of multiple agents need to avoid preset restricted areas, the order of task execution needs to avoid time conflicts, resource consumption needs to meet the upper limit requirements, and sudden changes in the situation may require rapid dynamic adjustment of the plan. These constraints often show nonlinear coupling relationships, and a small change in a parameter may trigger a chain reaction, causing the global plan to fail.

[0003] In the prior art, there is an efficiency bottleneck in the verification methods for high-dimensional constraints. Due to the complex correlation of constraints, traditional exhaustive verification needs to traverse all possible parameter combinations. The consumption of computing resources grows exponentially with the number of constraints, making it difficult to meet real-time requirements. At the same time, the implicit dependencies between multi-dimensional constraints make local adjustments prone to global conflicts. For example, the time delay of an action may affect the resource allocation of other tasks, further exacerbating the difficulty of verification. This problem seriously restricts the efficiency of constructing the solution sample space, causing the optimal solution search process to fall into a computing bottleneck, ultimately affecting the response speed and decision-making quality of strategy optimization in adversarial simulations.

[0004] In order to solve the above problems, a technical solution is now provided. Summary of the invention

[0005] In order to overcome the above-mentioned defects of the prior art, an embodiment of the present invention provides an action plan sample space search method based on ordinal optimization, which provides a global perspective of topological dependency and influence by constructing a constraint coupling graph and an influence matrix; then, based on the topological sorting and forward propagation algorithm of the graph, the core constraints are verified first, and the candidate plans that violate the key conditions are quickly filtered out to narrow the search space; then, by calculating the elasticity adjustment factor and setting the dynamic tolerance threshold, the non-critical constraints are flexibly adjusted so that the plan generation can adapt to the changes in the battlefield situation; then, the remaining constraints are encoded as Boolean logic expressions, and a data-free verification task tree is generated using a symbolic execution engine to provide a decomposition basis for parallel processing; finally, with the help of GPU streaming multiprocessors and CUDA warp-level instruction synchronization, efficient parallel verification is achieved, and a set of plans that meet all constraints is quickly output to solve the problems raised in the above-mentioned background technology.

[0006] To achieve the above object, the present invention provides the following technical solutions: S1. Extract the topological dependencies between constraints through a graph neural network, calculate the betweenness centrality and dynamic conflict propagation rate of each constraint node, generate a weighted directed graph structure, and output the initial constraint influence matrix; S2. Based on the topological order of the graph spectrum, use the forward propagation algorithm to deduce the necessary reachability conditions of the root node constraints, dynamically adjust the verification priority in combination with the influence matrix, and filter out the candidate solutions that violate the core constraints; S3. According to the updated influence matrix, calculate the elastic adjustment factor of non-critical constraints, and set a dynamic tolerance threshold interval linked to the battlefield situation for low-influence constraints; S4. Encode the remaining constraint conditions into a Boolean logic expression, generate a verification task tree with path independence through a symbolic execution engine, and decompose it into atomic verification units without data dependencies; S5. Map the atomic verification units to the GPU streaming multiprocessors according to the task tree levels, complete the parallel verification of tens of thousands of constraints based on the CUDA warp-level instruction synchronization, and output the candidate solution set that satisfies all constraints.

[0007] In a preferred embodiment, step S1 includes the following: Collect constraint conditions including time, space, resources, and task logic from the adversarial simulation scenario, abstract them into a set of constraint nodes, and construct a set of directed edges by analyzing the dependencies between the constraints, thus forming an initial graph structure; Subsequently, use a graph neural network to process the graph structure, update the node features through a multi-layer message passing mechanism to extract the topological dependencies between the constraints; Based on the updated graph structure, calculate the betweenness centrality of each constraint node to evaluate its hub importance in the graph spectrum, and at the same time calculate the dynamic conflict propagation rate in combination with the dynamic characteristics of historical data and the battlefield situation, which is used to quantify the chain conflict effect caused by constraint changes; Then, generate a weighted directed graph through the features output by the graph neural network, where the edge weights reflect the dependence intensity; Finally, construct and normalize the initial constraint influence matrix by integrating the betweenness centrality, dynamic conflict propagation rate, and edge weights.

[0008] In a preferred embodiment, step S2 includes the following: First, use the topological sorting algorithm to generate a linear sequence of constraint nodes and identify the set of root nodes. Then, adopt the forward propagation algorithm. Starting from the root nodes, deduce the necessary conditions for each constraint node along the topological sequence, and integrate the precursor nodes and their own constraints through logical relationships. Next, combine the initial constraint influence matrix to calculate the comprehensive influence degree of each constraint node, that is, accumulate its influence on other nodes. Subsequently, rearrange the topological sequence according to the comprehensive influence degree to generate a priority queue, and preferentially process the constraint nodes with high influence degrees. Finally, represent the candidate solutions as action parameter vectors, and verify the necessary conditions in the order of the priority queue. If the necessary conditions of the constraint nodes with high influence degrees are not met, use the out-edge set of the weighted directed graph to quickly mark the relevant candidate solution subsets as infeasible, so as to efficiently filter out the candidate solutions that violate the core constraints.

[0009] In a preferred embodiment, step S3 includes the following contents: S3.1, when updating the influence matrix, based on the set of candidate solutions filtered in step S2, calculate the proportion of each constraint node being violated, and multiply the original value of the initial influence matrix by the adjustment factor to generate an updated matrix reflecting the actual influence intensity of the constraint nodes in the current solution set.

[0010] In a preferred embodiment, for S3.2 - 5, the elastic adjustment factor is obtained by fusing the topological coupling strength index and the dynamic conflict entropy increase index. Among them, the topological strength is calculated by multiplying the betweenness centrality and the decay contribution of the neighborhood constraint chain length. The dynamic conflict index is obtained by combining the historical conflict frequency and the entropy change rate of the battlefield situation parameters. Subsequently, using the topological strength as the convolution kernel, perform piecewise multi-scale convolution on the dynamic conflict index, extract features, and map them to the adjustment factor through the hyperbolic tangent function after adaptive gating screening, realizing the non-linear fusion of topological and dynamic features.

[0011] In a preferred embodiment, when setting the dynamic tolerance threshold interval in S3.6, calculate the comprehensive influence degree of the constraint nodes based on the updated influence matrix. For non-critical constraints with a comprehensive influence lower than the threshold, set the lower and upper limits of the tolerance interval as the sum of the basic tolerance value and the product of the elastic adjustment factor and the battlefield situation function. The battlefield situation function generates a dynamic index by processing the enemy position and resource consumption rate parameters through the sigmoid function, ensuring that the tolerance interval is flexibly adjusted according to the battlefield situation.

[0012] In a preferred embodiment, step S4 includes the following contents: The core constraint set consists of constraints that have not been elastically adjusted, and the non-critical constraint set consists of constraints that have been elastically adjusted. First, these constraint conditions are encoded to form a Boolean logic expression, where the core constraints require the action parameter vector to satisfy the conditions, and the non-critical constraints allow floating within the dynamic tolerance threshold range; subsequently, all the Boolean logic expressions of the constraints are combined into an overall Boolean logic expression through logical AND operations; then, a symbolic execution engine is introduced, taking the action parameters as symbolic variables, exploring all the execution paths of the overall Boolean logic expression, and generating a set of mutually independent path condition sets; on this basis, a verification task tree is constructed, with the overall Boolean logic expression as the root node, decomposed into intermediate nodes and leaf nodes according to the path conditions, and the leaf nodes represent atomic constraint conditions that cannot be further decomposed; then, by traversing the verification task tree, the leaf nodes are extracted as atomic verification units, and the task set is optimized through constraint coverage evaluation, specifically calculating the coverage ratio of each atomic verification unit, and eliminating redundant units with coverage below the preset threshold; finally, a set of atomic verification units without data dependencies is generated.

[0013] In a preferred embodiment, step S5 includes the following: First, the verification task tree is divided by level, where the leaf level contains atomic verification units without data dependencies; then, the atomic verification units at the leaf level are preferentially mapped to the GPU streaming multiprocessors, and their path independence is used to achieve parallel computing, while the tasks at the intermediate and root levels are gradually mapped after the verification of the child nodes is completed; at the same time, a load balancing mechanism is adopted to monitor the length of the task queue of the streaming multiprocessors, and the task allocation is dynamically adjusted to prevent overload; then, using CUDA warp-level instruction synchronization, the warp is configured with spatially adjacent atomic verification units, and synchronization primitives are used to ensure the consistency of the threads within the warp when calculating Boolean values; on this basis, each streaming multiprocessor processes the atomic verification units in parallel, and the verification results are propagated backward along the task tree, using atomic operations to ensure conflict-free result aggregation across streaming multiprocessors; then, a dynamic task scheduling mechanism is introduced, assigning priorities to the atomic verification units of non-critical constraints based on the elastic adjustment factor, preferentially processing high-priority tasks, and dynamically adjusting the priorities as the battlefield situation changes; finally, when the Boolean value of the root node of the task tree is true, a candidate solution set that satisfies all constraints is output, and millisecond-level verification of tens of thousands of constraints is achieved through GPU parallel acceleration.

[0014] The technical effects and advantages of the action plan sample space search method based on order optimization of the present invention: By constructing a constraint coupling graph and an influence matrix, a global perspective of topological dependence and influence is provided for subsequent analysis. Then, based on the topological sorting of the graph and the forward propagation algorithm, the core constraints are verified first, and the candidate solutions that violate the key conditions are quickly filtered, narrowing the search space and creating conditions for efficient screening. Subsequently, by calculating the elastic adjustment factor and setting the dynamic tolerance threshold, the non-critical constraints are flexibly adjusted to make the solution generation adapt to the changes in the battlefield situation. Further, the remaining constraints are encoded into Boolean logic expressions, and a symbol execution engine is used to generate a verification task tree without data dependence, providing a decomposition basis for parallel processing. Finally, with the help of GPU streaming multiprocessors and CUDA warp-level instruction synchronization, the efficient parallel verification of tens of thousands of constraints is realized, and the solution set that satisfies all constraints is quickly output. On the premise of ensuring the feasibility of the solution, the computational complexity of the traditional method is reduced from exponential to linear growth, and at the same time, the potential high-quality solution space is effectively retained through the dynamic relaxation mechanism, significantly improving the timeliness and strategy robustness of solution generation in complex confrontation scenarios, and providing efficient and reliable technical support for real-time decision-making. Brief Description of the Drawings

[0015] Figure 1 It is a schematic flowchart of the method for searching the sample space of the action plan based on order optimization of the present invention. Detailed Embodiments

[0016] Next, the technical solutions in the embodiments of the present invention will be clearly and completely described in conjunction with the accompanying drawings in the embodiments of the present invention. Obviously, the described embodiments are only a part of the embodiments of the present invention, rather than all the embodiments. Based on the embodiments of the present invention, all other embodiments obtained by those of ordinary skill in the art without creative efforts shall fall within the protection scope of the present invention.

[0017] Embodiment 1: Figure 1 The method for searching the sample space of the action plan based on order optimization of the present invention is given, including: S1. Extract the topological dependence relationship between constraints through a graph neural network, calculate the betweenness centrality and dynamic conflict propagation rate of each constraint node, generate a weighted directed graph structure and output the initial constraint influence matrix.

[0018] S2. Based on the topological order of the graph, use the forward propagation algorithm to deduce the necessary conditions of the root node constraints, and dynamically adjust the verification priority in combination with the influence matrix to filter the candidate solutions that violate the core constraints.

[0019] S3. According to the updated influence matrix, calculate the elastic adjustment factor of the non-critical constraints, and set a dynamic tolerance threshold interval linked to the battlefield situation for the low-influence constraints.

[0020] S4. Encode the remaining constraints into a Boolean logic expression, generate a verification task tree with path independence through a symbolic execution engine, and decompose it into atomic verification units without data dependencies.

[0021] S5. Map the atomic verification units to the GPU streaming multiprocessors according to the task tree levels, complete the parallel verification of tens of thousands of constraints based on CUDA warp-level instruction synchronization, and output a candidate solution set that satisfies all constraints.

[0022] In a complex and dynamic adversarial simulation scenario, the generation of action plans needs to handle various interrelated constraints, including time, space, resources, and task logic, etc. These constraints exhibit non-linear coupling characteristics, and traditional methods are difficult to handle efficiently. To improve the efficiency and robustness of plan generation, the present invention proposes a method for searching the sample space of action plans based on order optimization. Step S1, as the starting link of the entire process, aims to construct a constraint coupling graph and an initial constraint influence degree matrix through scenario data abstraction and structured analysis, providing an accurate data basis for subsequent steps (such as constraint verification and plan screening based on the topological order of the graph).

[0023] Step S1 includes the following contents: S1.1, Update of node features in the construction of the constraint coupling graph: When using a graph neural network to process the constraint coupling graph, the update of node features is completed by integrating its own features and the influence of neighbor nodes. First, for each constraint node, collect the information of its directly connected neighbor nodes, and transfer the influence of these neighbor nodes to this constraint node through a message passing mechanism. Then, fuse the received neighbor node information with the features of this constraint node itself to generate a new feature representation. This fusion process is executed through multiple layers of iteration, gradually extracting the topological dependence relationship between constraints and integrating it into the features to reflect the association characteristics of nodes in the graph.

[0024] Constraint nodes are abstract units used to represent various limiting conditions in the process of action plan generation. Each node corresponds to a specific constraint, such as time limit, space limit, resource limit, or task logic limit, and is connected by directed edges to reflect the dependence relationship between constraints. For example, time constraints may depend on the task completion order, and resource constraints may be affected by multiple task requirements. At the same time, these nodes not only contain the type and parameter information of the constraints, but also integrate the dynamic characteristics of the battlefield situation, such as the position and speed of enemy units. By constructing constraint nodes and their topological structures, complex constraint relationships can be systematically analyzed and processed, providing a basis for plan verification and optimization.

[0025] S1.2, Calculate the betweenness centrality of constraint nodes: Betweenness centrality is used to evaluate the criticality of each constrained node in connecting other nodes throughout the graph. During specific calculations, for each pair of nodes in the graph, all the shortest paths connecting them are first determined. Then, the number of shortest paths passing through a specific constrained node is counted and compared with the total number of all shortest paths. By aggregating the statistical results for all node pairs in the graph, the betweenness centrality value of the constrained node is calculated. This value reflects the hub role of the constrained node in the global topological structure, and the larger the value, the higher its importance.

[0026] S1.3, Calculate the dynamic conflict propagation rate: The dynamic conflict propagation rate is used to measure the degree to which neighbor nodes may fail when a certain constrained node changes. The specific calculation process is as follows: First, based on historical data or simulation experiments, estimate the probability of neighbor nodes failing when the constrained node changes. Then, perform weighted processing in combination with the dynamic sensitivity of the neighbor nodes, where the dynamic sensitivity is determined by battlefield situation parameters, such as the speed and resource consumption rate of enemy units. To reduce the influence of extreme values, apply a non-linear transformation to these battlefield situation parameters, such as using a logarithmic function for smoothing. Finally, calculate the weighted average to obtain the dynamic conflict propagation rate of the constrained node, reflecting the propagation effect of the change.

[0027] S1.4, Generate the edge weights in the weighted directed graph structure: The calculation of edge weights in a weighted directed graph depends on the feature information extracted by a graph neural network. Specifically, for each directed edge, extract the feature representations of the source node and the target node from the output of the graph neural network. Then, through a pre-defined normalization function, map these features to edge weights, ensuring that all weight values fall within the range of 0 to 1. This weight value represents the dependence strength of the source node on the target node, and the larger the value, the stronger the dependence relationship between the two, thereby quantifying the interaction between constraints.

[0028] S1.5, Output the initial constraint influence matrix: The construction of the constraint influence matrix combines the betweenness centrality, dynamic conflict propagation rate, and edge weight information of the constrained nodes. During specific calculations, for each pair of constrained nodes, first obtain the betweenness centrality and dynamic conflict propagation rate of the source node, and perform a weighted sum with the edge weight connecting the source node and the target node to obtain a preliminary influence value. The coefficients used in the weighting process are pre-set to balance the contribution ratios of various factors. Subsequently, normalize all the calculated influence values so that their value range is controlled between 0 and 1. This matrix ultimately reflects the influence relationship between the constrained nodes, facilitating subsequent analysis and application.

[0029] In step S1, the topological dependencies between constraints are extracted through a graph neural network, a weighted directed graph structure is constructed, and an initial constraint influence matrix is generated. These data provide a clear structured basis for step S2, where the weighted directed graph describes the topological characteristics of constraint nodes and their dependencies, and the initial constraint influence matrix quantifies the influence degree of each constraint node on the whole. Based on this, step S2 uses the topological order of the weighted directed graph and the influence degree information of the initial constraint influence matrix to deduce the necessary conditions for the root node constraints, and filters the candidate solutions that violate the core constraints by dynamically adjusting the verification priorities, so as to provide an efficient candidate solution set for the elastic adjustment and subsequent verification in step S3.

[0030] Step S2 includes the following: S2.1, deduce the necessary conditions for the root node constraints: When deducing the necessary conditions for the root node constraints, a forward propagation method is adopted. Starting from the root node set, it gradually advances forward along the topological sequence to calculate the necessary conditions for each constraint node. The specific process is as follows: for each constraint node, its necessary conditions are determined by the necessary conditions of its predecessor node set. If the logical relationship between this constraint node and its predecessor nodes is AND, then the necessary conditions for this node are the joint satisfaction of the necessary conditions of all predecessor nodes, combined with the constraint conditions of this constraint node itself; if the logical relationship between this constraint node and its predecessor nodes is OR, then the necessary conditions for this node are that at least one of the necessary conditions of all predecessor nodes is satisfied, combined with the constraint conditions of this constraint node itself. For the root node, since it has no predecessor nodes, its necessary conditions are directly determined by the constraint conditions of this node itself. This process is carried out recursively to ensure that the necessary conditions for each constraint node can fully reflect all the prerequisite conditions it depends on.

[0031] S2.2, calculate the comprehensive influence degree: In order to adjust the verification priorities, based on the initial constraint influence matrix, the comprehensive influence degree of each constraint node is calculated. The specific calculation method is to accumulate the influence degree values of this constraint node on all other constraint nodes to obtain a total value. This total value is the comprehensive influence degree of this constraint node, which reflects the overall influence degree of this node on the entire constraint system. The larger the value of the comprehensive influence degree, the higher the importance of this constraint node in the constraint network.

[0032] S2.3, generate a priority queue: According to the calculated comprehensive influence degree, re - arrange the constraint nodes in the topological sequence to generate a priority queue. The specific steps are as follows: Arrange all constraint nodes in descending order according to their comprehensive influence degree, ensuring that the constraint nodes with higher comprehensive influence degree are arranged at the front of the queue. In this way, during the subsequent verification process, those constraint nodes with greater impact on the system can be processed preferentially.

[0033] S2.4, Filter candidate solutions that violate the core constraints: When filtering candidate solutions that violate the core constraints, first represent each candidate solution in the vector form of action parameters. Then, in the order of the priority queue, check the reachability conditions of each constraint node one by one. The specific process is as follows: For each constraint node in the priority queue, evaluate whether the action parameter vector of the candidate solution satisfies the reachability condition of this node. If it is found that a certain candidate solution cannot meet the reachability condition of the current constraint node, it is determined that this candidate solution violates the core constraint and is immediately removed from the candidate solution set. In addition, if a constraint node with a higher comprehensive influence degree is not satisfied, based on the out - edge set of this node in the weighted directed graph, the subset of candidate solutions related to this node can be quickly identified and marked as infeasible, thereby reducing the subsequent verification calculation amount.

[0034] Step S2 is based on the weighted directed graph and the initial constraint influence degree matrix provided by step S1. Through topological sorting, forward - propagation algorithm, and priority - queue mechanism, the reachability conditions of the root - node constraints are accurately deduced, and candidate solutions that violate the core constraints are efficiently filtered. The processing result generates an optimized candidate solution set, which provides a reliable input for step S3 to calculate the elastic adjustment factor based on the updated influence degree matrix. At the same time, it significantly reduces the search space and improves the pertinence and efficiency of subsequent verification.

[0035] Step S3 includes the following contents: S3.1, Update the influence degree matrix: During the process of updating the influence degree matrix, based on the candidate solution set filtered in step S2, calculate the adjustment of the influence degree of each constraint node on other constraint nodes. The specific steps are as follows: First, obtain the original influence degree value recorded in the initial influence degree matrix, and then adjust the original influence degree value according to the ratio of the number of candidate solutions that violate this constraint node to the total number of candidate solutions counted in step S2. The adjustment method is to multiply the original influence degree value by an adjustment factor, which is equal to 1 minus the proportion of candidate solutions that violate this constraint, that is, the proportion of candidate solutions that do not violate this constraint. In this way, the adjusted influence degree value can reflect the actual influence intensity of the constraint node in the current candidate solution set, ensuring that the influence degree matrix is consistent with the latest state of the candidate solution set.

[0036] S3.2, Identify non-critical constraints: To identify non-critical constraints, based on the verification priority queue generated in step S2, the constraint nodes ranked at the back are determined as non-critical constraints. Specifically, a percentage threshold is preset, such as 20%, and then the constraint nodes ranked in the last 80% of the verification priority queue are classified as non-critical constraints. This classification method ensures that subsequent flexible adjustments mainly target those constraint nodes with less impact on the overall system, thus allowing flexible adjustments to non-critical constraints on the premise of ensuring strict enforcement of core constraints.

[0037] S3.3, Calculate the topological coupling strength index: The topological coupling strength index is used to measure the hub role of each constraint node in the weighted directed graph, and its calculation process includes the following steps. First, use the betweenness centrality value obtained in step S1 to represent the importance of the constraint node on the connection path in the graph; at the same time, calculate the length of the longest dependency path starting from this constraint node to evaluate its position in the dependency chain; in addition, introduce a path attenuation factor less than 1, so that the longer the dependency path, the smaller its contribution to the final index, and the contribution size is calculated in an exponentially decreasing manner. Finally, the topological coupling strength index is obtained by multiplying the betweenness centrality value by the sum of the attenuation contributions of all dependency paths, and this result comprehensively reflects the characteristics of the constraint node in the global topological structure.

[0038] S3.4, Calculate the dynamic conflict entropy increase index: The dynamic conflict entropy increase index is used to evaluate the increase in system uncertainty caused by the adjustment of constraint nodes, and its calculation steps are as follows. First, through the Monte Carlo simulation method, count the occurrence frequency of the chain conflict events triggered by the parameter adjustment of this constraint node in the historical solutions; then, combine the battlefield situation parameters, such as the moving speed of enemy units, to calculate an entropy change rate, which is obtained by taking the logarithmic transformation of the ratio of the enemy speed to the preset speed upper limit to reflect the uncertainty brought by the battlefield dynamics; finally, multiply the frequency of historical conflict events by the entropy change rate to obtain the dynamic conflict entropy increase index, which can reflect the characteristics of constraint adjustment in the dynamic evolution process.

[0039] S3.5, Segment-based dynamic convolution fusion to calculate the flexible adjustment factor: The calculation of the elastic adjustment factor fuses the topological coupling strength index and the dynamic conflict entropy increase index through a piecewise dynamic convolution method. The specific process is as follows. First, based on the topological coupling strength index, a Gaussian-shaped convolution kernel function is designed, and the shape of this function is determined by the magnitude of the topological coupling strength index. Then, multi-scale sliding window convolution operations are performed on the time series data of the dynamic conflict entropy increase index. By adjusting the width of the Gaussian convolution kernel, conflict features and topological coupling features at different time scales are extracted. Next, an adaptive gating mechanism is adopted, and the output of the convolution operation is screened through the sigmoid function to highlight the significant feature peaks. Finally, the hyperbolic tangent function is used to map the screened convolution output to the elastic adjustment factor, thereby realizing the non-linear spatio-temporal fusion of topological structure response and dynamic conflict evolution.

[0040] S3.6. Set the dynamic tolerance threshold interval: Set the dynamic tolerance threshold interval for the constraint nodes with low influence. The specific method is as follows. First, based on the updated influence matrix, calculate the comprehensive influence degree of each constraint node, that is, the cumulative result of the influence degree values of this node on all other nodes. Then, for the non-critical constraint nodes whose comprehensive influence degree is lower than the preset threshold, determine their tolerance threshold intervals. The lower limit of this interval is the minimum basic tolerance plus the product of the elastic adjustment factor and the battlefield situation function, and the upper limit is the maximum basic tolerance plus the same product. Among them, the battlefield situation function is calculated by the sigmoid function using the positions and resource consumption rates of enemy units, so as to ensure that the tolerance interval can be dynamically adjusted according to the changes in the battlefield situation and realize the flexible relaxation of constraints.

[0041] Based on the influence matrix updated in step S2, step S3 calculates the topological coupling strength index and the dynamic conflict entropy increase index, and uses the piecewise dynamic convolution fusion method to generate the elastic adjustment factor, and sets a dynamic tolerance threshold interval linked to the battlefield situation for the low-influence constraints. This processing ensures that the constraint adjustment reflects both topological dependencies and adapts to the dynamic changes in the battlefield, providing a flexible and robust constraint adjustment basis for the Boolean logic expression encoding and verification task tree generation in step S4.

[0042] In step S3, based on the updated influence matrix, by calculating the elastic adjustment factor of non-critical constraints and setting a dynamic tolerance threshold interval linked to the battlefield situation, the flexible adjustment of low-influence constraints has been realized. This adjustment provides clear constraint condition inputs for step S4, including non-critical constraints after elastic adjustment and core constraints that maintain strict requirements. Based on this, step S4 further processes these constraint conditions to generate atomic verification units suitable for parallel verification, laying a technical premise for the efficient execution of step S5.

[0043] Step S4 includes the following: S4.1, Encoding of Remaining Constraint Conditions: Core Constraint Set: Constraints that have not undergone elastic adjustment and require candidate solutions to strictly satisfy.

[0044] Non-Critical Constraint Set: Constraints that have undergone elastic adjustment and are allowed to float within the dynamic tolerance threshold range.

[0045] In the process of encoding the remaining constraint conditions to form a Boolean logic expression, different processing methods are adopted for core constraints and non-critical constraints respectively. For core constraints, it is required that the action parameter vector of the candidate solution must fully satisfy the constraint condition. Only in this case, the corresponding Boolean logic expression will be judged as true, otherwise it will be judged as false. For non-critical constraints, considering the dynamic tolerance threshold range set in the previous steps, when the action parameter vector satisfies the constraint condition within this range, its Boolean logic expression is judged as true, otherwise it is false. Finally, the Boolean logic expressions of all core constraints and non-critical constraints are connected by logical AND operations to form a complete Boolean logic expression, ensuring that the candidate solution can satisfy all constraint conditions simultaneously.

[0046] S4.2, Application of Symbolic Execution Engine: When using the symbolic execution engine, first regard the action parameters of the candidate solution as a set of symbolic variables, which are abstract representations of the action parameters. The symbolic execution engine analyzes the overall Boolean logic expression, explores all possible execution paths contained therein, and generates a corresponding set of path conditions for each path. Each path condition is a constraint expression that describes the specific value range of the symbolic variables and is used to ensure that the overall Boolean logic expression holds on this path. These path conditions are independent of each other, avoiding duplicate associations between action parameters and laying the foundation for subsequent decomposition of the verification task.

[0047] S4.3, Construction of Verification Task Tree: In the process of constructing the verification task tree, use the overall Boolean logic expression as the root node of the tree, and gradually decompose it according to the path conditions generated by the symbolic execution engine to form intermediate nodes and leaf nodes. Intermediate nodes represent the logical operation parts involved in the path conditions, such as the point of logical AND operation or branch selection, while leaf nodes represent single constraint conditions that cannot be further decomposed, such as the Boolean logic expression of a specific constraint. The construction of the task tree ensures that a path from the root node to each leaf node corresponds to a unique path condition, and the constraint conditions between these paths do not overlap, realizing the independence of the paths. This structure helps to decompose complex constraint logic into multiple units that can be processed separately.

[0048] S4.4, Decomposition into Atomic Verification Units: When decomposing the verification task tree into atomic verification units, all leaf nodes are extracted from the task tree and defined as atomic verification units. Each atomic verification unit is an independent Boolean logic expression representing a specific constraint condition, such as an action parameter must be greater than a certain specific value or within a certain specific range. Due to the independence between paths, there are no shared symbolic variables or logical interdependencies among these atomic verification units, ensuring no data association between them. This decomposition process is completed by traversing the task tree and collecting all leaf nodes, enabling each atomic verification unit to be verified independently.

[0049] S4.5, Constraint Coverage Evaluation: To optimize the decomposed atomic verification units, a constraint coverage metric is introduced for evaluation. The calculation process of the constraint coverage metric is as follows: First, determine the feasible region of the action parameter corresponding to each atomic verification unit, that is, the range of action parameter values that satisfy the unit's constraint conditions; then, calculate the intersection ratio of this feasible region and the complete action parameter range of the candidate solution, which is called the coverage ratio. The higher the coverage ratio, the greater the impact of the atomic verification unit on the candidate solution and the more important it is. By setting a threshold, such as the coverage ratio being greater than 0.1, atomic verification units with higher coverage are selected, and those redundant or with less impact are removed, thereby further optimizing the task set and improving the efficiency of verification.

[0050] Step S4 is based on the updated influence matrix and dynamic tolerance threshold interval provided by step S3. Through Boolean logic encoding and a symbolic execution engine, complex constraints are successfully decomposed into a verification task tree with path independence, and further generate data-independent atomic verification units. The introduction of constraint coverage evaluation ensures the effectiveness and pertinence of the decomposed units. This processing provides an efficient and independently executable task basis for the parallel verification in step S5, meeting the rapid verification requirements of high-dimensional constraints in the battlefield situation.

[0051] In step S4, the remaining constraint conditions are encoded as Boolean logic expressions through a symbolic execution engine to generate a verification task tree with path independence and decomposed into data-independent atomic verification units. These atomic verification units provide a basis for parallel processing in step S5, ensuring that subsequent verification tasks can be efficiently executed without introducing data competition. Based on this, step S5 uses GPU streaming multiprocessors and CUDA warp-level instruction synchronization technology to generate a candidate solution set that satisfies all constraints for the parallel verification requirements of tens of thousands of constraints, providing support for real-time decision-making in complex confrontation scenarios.

[0052] Step S5 includes the following: S5.1, Task Tree Hierarchical Mapping: During the process of hierarchical mapping of the task tree, it is first necessary to divide the entire verification task tree into multiple different levels. The bottommost level is called the leaf level, which contains all atomic verification units, that is, the most basic and indivisible task units. The topmost level is called the root level, which represents the final verification result. The specific mapping strategy is to preferentially allocate the atomic verification units in the leaf level to the streaming multiprocessors of the GPU. This allocation method takes advantage of the path independence between atomic verification units, enabling these units to be processed in parallel without interference from each other. For the tasks in the intermediate and root levels, after the verification of their subordinate child nodes is completed, they are gradually allocated to the idle streaming multiprocessors. This can ensure that the entire verification process progresses step by step in the order from the bottom to the top, ensuring that the calculations at each level depend on the results of the lower level.

[0053] S5.2, GPU Streaming Multiprocessor Allocation: When allocating tasks to the GPU streaming multiprocessors, first allocate the atomic verification units in the leaf level to each streaming multiprocessor. The allocation priority is to process the tasks at the bottommost level because these tasks usually have no data dependencies and can be directly executed in parallel, thus maximizing the utilization of the GPU's computing power. For the tasks in the intermediate level, after the verification of their subordinate child nodes is completed, these tasks are allocated to the idle streaming multiprocessors. To achieve task load balancing, the system will monitor the task queue lengths of each streaming multiprocessor in real time. If the task queue length of a certain streaming multiprocessor exceeds 1.5 times the average task queue length of all streaming multiprocessors, then subsequent tasks will not be allocated to this streaming multiprocessor but will be reallocated to the streaming multiprocessor with a shorter task queue. This adjustment mechanism can avoid the overload of some streaming multiprocessors, thereby improving the overall processing efficiency.

[0054] S5.3, CUDA Warp-Level Instruction Synchronization: In the CUDA architecture, a warp is an execution unit composed of 32 threads, and these threads achieve efficient cooperation through an instruction-level synchronization mechanism. In this step, the warps within the same streaming multiprocessor are configured to specifically process logically related or spatially adjacent atomic verification units. This configuration method can reduce the communication overhead between threads and improve the computing efficiency. To ensure that the threads within a warp are consistent when calculating the boolean values of atomic verification units, the system uses the synchronization primitives provided by CUDA for coordination to avoid result conflicts caused by parallel execution. Specifically, the threads within each warp will check the parameters of the candidate solutions in parallel and output the corresponding boolean values according to the check results, indicating whether the parameter meets the constraint conditions.

[0055] S5.4, Parallel Verification Execution: During the parallel verification execution, each streaming multiprocessor processes the assigned atomic verification units in parallel. The specific operation is to perform constraint checks on the parameters of the candidate solutions to determine whether the Boolean value of each atomic verification unit is true or false. The verification results are propagated backward along the task tree from the leaf nodes to the root node. For a logical AND node, the Boolean value of its parent node is determined to be true only when the Boolean values of all child nodes are true. For a logical OR node, the Boolean value of its parent node is determined to be true as long as the Boolean value of one of the child nodes is true. To ensure that there are no conflicts in the result aggregation across streaming multiprocessors, the system uses the global memory and atomic operations of CUDA to update the shared verification results through atomic compare-and-swap. This method can safely aggregate the calculation results of each streaming multiprocessor in a parallel environment.

[0056] S5.5, Dynamic task scheduling mechanism: The mechanism of dynamic task scheduling depends on a flexible adjustment factor, which is used to assign priorities to the atomic verification units with non-core constraints, thereby optimizing resource allocation. Specifically, the atomic verification units with core constraints are always assigned the highest priority, while the priorities of the atomic verification units with non-core constraints are determined according to the absolute value of the flexible adjustment factor. The smaller the absolute value of the flexible adjustment factor, the higher the priority of the corresponding atomic verification unit. High-priority tasks are preferentially assigned to idle streaming multiprocessors, while low-priority tasks are executed only when resources are sufficient, which can ensure that the verification of core constraints can be completed quickly. In addition, the system updates the flexible adjustment factor in real time according to the changes in the battlefield situation and recalculates the task priorities according to the updated value, thereby dynamically adjusting the execution order of the task queue.

[0057] S5.6, Output the candidate solution set that fully satisfies the constraints: When outputting the candidate solution set that fully satisfies the constraints, when the Boolean value of the root node of the task tree is determined to be true, it means that the candidate solution satisfies all the constraints. The system collects all the candidate solutions that pass the verification to form the final candidate solution set. Thanks to the parallel computing power of the GPU, even in the face of tens of thousands of constraint conditions, the verification process can be completed in a very short time. This efficient processing method can support the need for real-time decision-making and ensure that candidate solutions that meet the conditions can be quickly provided at critical moments.

[0058] The above formulas are all dimensionless and take their numerical calculations. The formula is obtained by collecting a large amount of data for software simulation to get a formula closest to the real situation. The preset parameters in the formula are set by technicians in this field according to the actual situation.

[0059] It should be noted that the system of the present invention can be deployed on the device itself to achieve embedded applications, or can also run on a PC or other terminal with a user interface, so as to meet various hardware environments and usage requirements.

[0060] Only some exemplary embodiments of the present invention have been described above by way of illustration. Undoubtedly, for those of ordinary skill in the art, without departing from the spirit and scope of the present invention, the described embodiments can be modified in various different ways. Therefore, the above drawings and description are illustrative in nature and should not be construed as limiting the protection scope of the claims of the present invention.

[0061] It should be noted that in this text, if there are relational terms such as first and second, they are only used to distinguish one entity or operation from another entity or operation, and do not necessarily require or imply any such actual relationship or order between these entities or operations. Moreover, the term "comprising", "including" or any other variant thereof is intended to cover non-exclusive inclusion, so that a process, method, article or device including a series of elements not only includes those elements, but also includes other elements not expressly listed, or further includes elements inherent to such process, method, article or device. Without further limitation, an element defined by the statement "including a..." does not exclude the existence of additional identical elements in the process, method, article or device including the element.

[0062] As described above, the above is only the specific implementation manner of the present application, but the protection scope of the present application is not limited thereto. Any person skilled in the art within the technical scope disclosed by the present application can easily think of changes or substitutions, which should all be covered within the protection scope of the present application. Therefore, the protection scope of the present application shall be subject to the protection scope of the claims.

Claims

1. The method for searching the action plan sample space based on sequential optimization is characterized by: Includes steps: S1. Extract the topological dependencies between constraints through graph neural networks, calculate the betweenness centrality and dynamic conflict propagation rate of each constraint node, generate a weighted directed graph structure and output the initial constraint influence matrix; S2. Based on the graph topology order, the forward propagation algorithm is used to derive the must-reach conditions of the root node constraints, and the verification priority is dynamically adjusted in combination with the influence matrix to filter out candidate solutions that violate the core constraints; S3. Calculate the elastic adjustment factor of the non-critical constraints according to the updated influence matrix, and set a dynamic tolerance threshold interval linked to the battlefield situation for the low-impact constraints; S4. Encode the remaining constraints into Boolean logic expressions, generate a verification task tree with path independence through the symbolic execution engine, and decompose it into atomic verification units without data dependence; S5. Map the atomic verification units to the GPU streaming multiprocessor according to the task tree level, synchronously complete the parallel verification of 10,000-level constraints based on CUDA warp-level instructions, and output a set of candidate solutions that satisfy all constraints.

2. The method for searching action plan sample space based on sequential optimization according to claim 1, characterized in that: Step S1 includes the following contents: Collect constraints including time, space, resources and task logic from the adversarial simulation scenario, abstract them into constraint node sets, and construct directed edge sets by analyzing the dependencies between constraints, thus forming the initial graph structure; Subsequently, the graph structure is processed by using a graph neural network, and the node features are updated through a multi-layer message passing mechanism to extract the topological dependencies between constraints. Based on the updated graph structure, the betweenness centrality of each constraint node is calculated to evaluate its hub importance in the graph. At the same time, the dynamic conflict propagation rate is calculated in combination with historical data and the dynamic characteristics of the battlefield situation to quantify the chain conflict effects caused by constraint changes. Afterwards, a weighted directed graph is generated through the features output by the graph neural network, in which the edge weights reflect the intensity of dependency. Finally, the initial constraint influence matrix is ​​constructed and normalized by combining the betweenness centrality, dynamic conflict propagation rate and edge weights.

3. The method for searching action plan sample space based on sequential optimization according to claim 2 is characterized in that: Step S2 includes the following contents: First, a topological sorting algorithm is used to generate a linear sequence of constraint nodes and identify the root node set. Then, a forward propagation algorithm is used to deduce the necessary conditions for each constraint node along the topological sequence, starting from the root node, and integrating the predecessor node and its own constraints through logical relationships. Next, the initial constraint influence matrix is ​​combined to calculate the comprehensive influence of each constraint node, that is, to accumulate its influence on other nodes. Subsequently, the topological sequence is rearranged according to the comprehensive influence to generate a priority queue, and the constraint nodes with high influence are processed first. Finally, the candidate solutions are represented as action parameter vectors, and the must-reach conditions are verified in the order of the priority queue. If the must-reach conditions of the high-impact constraint nodes are not met, the outgoing edge set of the weighted directed graph is used to quickly mark the relevant subset of candidate solutions as infeasible, thereby efficiently filtering out the candidate solutions that violate the core constraints.

4. The method for searching action plan sample space based on sequential optimization according to claim 3 is characterized in that: Step S3 includes the following contents: S3.1, when updating the influence matrix, based on the set of candidate solutions filtered in step S2, calculate the proportion of each constraint node that is violated, and multiply the original value of the initial influence matrix by the adjustment factor to generate an updated matrix that reflects the actual influence strength of the constraint nodes in the current solution set.

5. The method for searching action plan sample space based on sequential optimization according to claim 4 is characterized in that: S3.2-5, the elasticity adjustment factor is obtained by integrating the topological coupling strength index and the dynamic conflict entropy increase index, where the topological strength is calculated by multiplying the betweenness centrality and the neighborhood constraint chain length attenuation contribution, and the dynamic conflict index is obtained by combining the historical conflict frequency and the entropy change rate of battlefield situation parameters; Subsequently, the dynamic conflict index is subjected to piecewise multi-scale convolution with the topological strength as the convolution kernel to extract features. After adaptive gating screening, it is mapped into an adjustment factor through the hyperbolic tangent function to achieve nonlinear fusion of topological and dynamic features.

6. The method for searching action plan sample space based on sequential optimization according to claim 5, characterized in that: S3.6 When setting the dynamic tolerance threshold interval, the comprehensive influence degree of the constraint node is calculated based on the updated influence matrix. For non-critical constraints whose comprehensive influence is lower than the threshold, the lower and upper limits of the tolerance interval are set to the sum of the basic tolerance value multiplied by the elasticity adjustment factor and the battlefield situation function. The battlefield situation function generates dynamic indicators by processing the enemy position and resource consumption rate parameters through the sigmoid function to ensure that the tolerance interval is flexibly adjusted with the battlefield situation.

7. The method for searching action plan sample space based on sequential optimization according to claim 6, characterized in that: Step S4 includes the following contents: The core constraint set is the constraints that have not been adjusted flexibly, and the non-critical constraint set is the constraints that have been adjusted flexibly. First, these constraints are encoded to form Boolean logic expressions, where the core constraints require the action parameter vector to meet the conditions, while the non-critical constraints are allowed to float within the dynamic tolerance threshold range; Subsequently, all constrained Boolean logic expressions are combined into an overall Boolean logic expression through logical AND operations; then, a symbolic execution engine is introduced, and the action parameters are used as symbolic variables to explore all execution paths of the overall Boolean logic expression and generate a set of independent path condition sets; on this basis, a verification task tree is constructed, with the overall Boolean logic expression as the root node, and decomposed into intermediate nodes and leaf nodes according to the path conditions, and the leaf nodes represent atomic constraints that cannot be decomposed any further; then, by traversing the verification task tree, the leaf nodes are extracted as atomic verification units, and the task set is optimized through constraint coverage evaluation, specifically calculating the coverage ratio of each atomic verification unit, and eliminating redundant units with coverage below the preset threshold; finally, a set of atomic verification units without data dependence is generated.

8. The method for searching action plan sample space based on sequential optimization according to claim 7, characterized in that: Step S5 includes the following contents: First, the verification task tree is divided into levels, in which the leaf layer contains atomic verification units without data dependence; then the atomic verification units of the leaf layer are preferentially mapped to the GPU stream multiprocessor, and its path independence is used to achieve parallel computing, while the tasks of the middle layer and the root layer are gradually mapped after the verification of the child nodes is completed; at the same time, a load balancing mechanism is used to monitor the length of the task queue of the stream multiprocessor, and dynamically adjust the task allocation to prevent overload; then, CUDA warp-level instruction synchronization is used to configure the warp as spatially adjacent atomic verification units, and the consistency of threads in the warp when calculating Boolean values ​​is ensured by synchronization primitives; on this basis, each stream multiprocessor processes the atomic verification unit in parallel, and the verification results are back-propagated along the task tree, and atomic operations are used to ensure that the aggregation of results across stream multiprocessors is conflict-free; then a dynamic task scheduling mechanism is introduced, and priorities are given to atomic verification units with non-critical constraints based on elastic adjustment factors, high-priority tasks are processed first, and priorities are dynamically adjusted as the battlefield situation changes; finally, when the Boolean value of the root node of the task tree is true, a set of candidate solutions that meet all constraints is output, and millisecond-level verification of tens of thousands of constraints is achieved through GPU parallel acceleration.

Images