Action plan sample space search method based on sequential optimization

Abstract

The present invention discloses an action plan sample space search method based on ordinal optimization, which specifically relates to the field of simulated confrontation and is used to solve the problem of high-dimensional constraint verification in complex dynamic confrontation simulation scenarios. It provides a global perspective of topological dependency and influence by constructing a constraint coupling graph and an influence matrix; then, based on the graph's topological sorting and forward propagation algorithm, core constraints are verified first, candidate plans that violate key conditions are quickly filtered out, and the search space is narrowed; subsequently, by calculating the elasticity adjustment factor and setting the dynamic tolerance threshold, non-critical constraints are flexibly adjusted so that the plan generation can adapt to changes in the battlefield situation; then, the remaining constraints are encoded as Boolean logic expressions, and a symbolic execution engine is used to generate a data-free verification task tree, providing a decomposition basis for parallel processing; finally, with the help of GPU stream multiprocessors and CUDA warp-level instruction synchronization, efficient parallel verification is achieved, and a set of plans that meet all constraints is quickly output.

Description

Technical Field

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

[0002] In complex and dynamic confrontation simulation scenarios, the generation of action plans must meet numerous interconnected constraints regarding spatiotemporal coordination, resource matching, and task logic. For example, the movement paths of multiple agents must avoid pre-set restricted areas, the order of task execution must avoid time conflicts, and resource consumption must meet upper limits. Unexpected changes in the situation may require rapid and dynamic adjustments to the plan. These constraints often exhibit nonlinear coupling relationships, and even a small change in a single parameter can trigger a chain reaction, rendering the overall plan ineffective.

[0003] Existing verification methods for high-dimensional constraints face efficiency bottlenecks. Due to the complex interdependencies of the constraints, traditional exhaustive verification requires traversing all possible parameter combinations. This exponentially increases computational resource consumption with the number of constraints, making it difficult to meet real-time requirements. Furthermore, the implicit dependencies between multidimensional constraints make local adjustments prone to global conflicts. For example, a time delay in a particular action can affect resource allocation for other tasks, further exacerbating verification difficulties. This problem severely restricts the efficiency of constructing the solution sample space, causing the search for the optimal solution to enter a computational bottleneck, ultimately impacting 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 graph's topological sorting and forward propagation algorithm, the core constraints are verified first, and candidate plans that violate key conditions are quickly filtered out to narrow the search space; subsequently, by calculating the elasticity adjustment factor and setting the dynamic tolerance threshold, non-critical constraints are flexibly adjusted so that the plan generation can adapt to changes in the battlefield situation; thereafter, the remaining constraints are encoded as Boolean logic expressions, and a symbolic execution engine is used to generate a data-free verification task tree, providing a decomposition basis for parallel processing; finally, with the help of GPU stream 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:

[0007] 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;

[0008] S2. Based on the graph topology, the forward propagation algorithm is used to derive the reachability conditions of the root node constraints. The influence matrix is ​​used to dynamically adjust the verification priority and filter out candidate solutions that violate the core constraints.

[0009] S3. Calculate the elasticity adjustment factors for non-critical constraints based on the updated impact matrix, and set dynamic tolerance threshold intervals for low-impact constraints that are linked to the battlefield situation.

[0010] S4. Encode the remaining constraints as Boolean logic expressions and generate a verification task tree with path independence through the symbolic execution engine. Decompose the tree into atomic verification units without data dependencies.

[0011] 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 meet all constraints.

[0012] In a preferred embodiment, step S1 includes the following contents:

[0013] Constraints including time, space, resources and task logic are collected from the confrontation simulation scenario, abstracted into a set of constraint nodes, and a directed edge set is constructed by analyzing the dependencies between the constraints, thus forming an initial graph structure; then, the graph structure is processed using a graph neural network, and the node features are updated through a multi-layer message passing mechanism to extract the topological dependencies between the constraints; based on the updated graph structure, the betweenness centrality of each constraint node is calculated to evaluate its hub importance in the graph, and the dynamic conflict propagation rate is calculated by combining historical data and the dynamic characteristics of the battlefield situation to quantify the chain conflict effects caused by constraint changes; then, a weighted directed graph is generated through the features output by the graph neural network, in which the edge weights reflect the dependency strength; finally, the betweenness centrality, dynamic conflict propagation rate and edge weights are combined to construct and normalize the initial constraint influence matrix.

[0014] In a preferred embodiment, step S2 includes the following:

[0015] 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, starting from the root node, to deduce the must-reach condition of each constraint node along the topological sequence, and integrate the predecessor node and its own constraints through logical relationships; then, combined with the initial constraint influence matrix, the comprehensive influence of each constraint node is calculated, that is, the degree of its influence on other nodes is accumulated; then, the topological sequence is rearranged according to the comprehensive influence, and a priority queue is generated, giving priority to the constraint nodes with high influence; finally, the candidate solutions are represented as action parameter vectors, and the must-reach condition is verified in the order of the priority queue. If the must-reach condition of the high-impact constraint node is not met, the outgoing edge set of the weighted directed graph is used to quickly mark the relevant candidate solution subset as infeasible, thereby efficiently filtering out the candidate solutions that violate the core constraints.

[0016] In a preferred embodiment, step S3 includes the following contents:

[0017] 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.

[0018] In a preferred embodiment, S3.2-5, the elasticity adjustment factor is obtained by fusing the topological coupling strength index and the dynamic conflict entropy increase index, wherein the topological strength is calculated by multiplying the betweenness centrality and the attenuation contribution of the neighborhood constraint chain length, and the dynamic conflict index is obtained by combining the historical conflict frequency and the entropy change rate of the battlefield situation parameters; then, the topological strength is used as the convolution kernel to perform piecewise multi-scale convolution on the dynamic conflict index to extract features, and after adaptive gating screening, it is mapped to the adjustment factor through the hyperbolic tangent function to achieve nonlinear fusion of topological and dynamic features.

[0019] In a preferred embodiment, when S3.6 sets 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, the elasticity adjustment factor, and the battlefield situation function. The battlefield situation function uses the sigmoid function to process the enemy position and resource consumption rate parameters to generate dynamic indicators, ensuring that the tolerance interval is flexibly adjusted with the battlefield situation.

[0020] In a preferred embodiment, step S4 includes the following contents:

[0021] The core constraint set is the constraints that have not been flexibly adjusted, and the non-critical constraint set is the constraints that have been flexibly adjusted. These constraints are first encoded to form a Boolean logic expression, 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; then, the Boolean logic expressions of all constraints 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. The leaf nodes represent atomic constraints 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, the coverage ratio of each atomic verification unit is calculated, and redundant units with coverage below the preset threshold are eliminated; finally, a set of atomic verification units with no data dependence is generated.

[0022] In a preferred embodiment, step S5 includes the following contents:

[0023] First, the verification task tree is divided into layers, with the leaf layer containing atomic verification units without data dependencies. The atomic verification units in the leaf layer are then preferentially mapped to the GPU streaming multiprocessors, leveraging their path independence for parallel computation. Intermediate and root layer tasks are then gradually mapped after the child nodes are verified. A load balancing mechanism is employed to monitor the task queue length of the streaming multiprocessors and dynamically adjust task allocation to prevent overload. CUDA warp-level instruction synchronization is then used to configure warps into spatially adjacent atomic verification units. Synchronization primitives are then used to ensure consistency among threads within a warp when computing Boolean values. Furthermore, each streaming multiprocessor processes the atomic verification units in parallel and propagates the verification results back along the task tree, using atomic operations to ensure conflict-free aggregation of results across the streaming multiprocessors. A dynamic task scheduling mechanism is then introduced to prioritize atomic verification units with non-critical constraints based on an elastic adjustment factor, prioritizing high-priority tasks and dynamically adjusting their priorities 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 satisfy all constraints is output, enabling millisecond-level verification of tens of thousands of constraints through GPU parallel acceleration.

[0024] The technical effects and advantages of the action plan sample space search method based on sequential optimization of the present invention are as follows:

[0025] By constructing a constraint coupling graph and influence matrix, a global perspective of topological dependencies and influence is provided for subsequent analysis. Next, a graph-based topological sorting and forward propagation algorithm prioritizes verification of core constraints, rapidly filtering out candidate solutions that violate critical conditions, narrowing the search space and facilitating efficient screening. Subsequently, by calculating elasticity adjustment factors and setting dynamic tolerance thresholds, non-critical constraints are flexibly adjusted, enabling solution generation to adapt to battlefield changes. Furthermore, the remaining constraints are encoded as Boolean logic expressions, and a symbolic execution engine is used to generate a data-free verification task tree, providing a decomposition foundation for parallel processing. Finally, leveraging GPU streaming multiprocessors and CUDA warp-level instruction synchronization, efficient parallel verification of tens of thousands of constraints is achieved, rapidly outputting a set of solutions that satisfy all constraints. While ensuring solution feasibility, the computational complexity of traditional methods is reduced from exponential to linear growth. A dynamic relaxation mechanism effectively preserves the potential space for high-quality solutions, significantly improving the timeliness and strategic robustness of solution generation in complex adversarial scenarios, providing efficient and reliable technical support for real-time decision-making. BRIEF DESCRIPTION OF THE DRAWINGS

[0026] Figure 1 Schematic diagram of the flow of the action plan sample space search method based on sequential optimization of the present invention. DETAILED DESCRIPTION

[0027] The following will clearly and completely describe the technical solutions in the embodiments of the present invention in conjunction with the accompanying drawings. Obviously, the described embodiments are only part of the embodiments of the present invention, not all of the embodiments. Based on the embodiments of the present invention, all other embodiments obtained by ordinary technicians in this field without making creative efforts are within the scope of protection of the present invention.

[0028] Example 1: Figure 1 The present invention provides an action plan sample space search method based on sequential optimization, including:

[0029] 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.

[0030] S2. Based on the graph topology order, the forward propagation algorithm is used to derive the must-reach conditions of the root node constraints. The verification priority is dynamically adjusted in combination with the influence matrix to filter out candidate solutions that violate the core constraints.

[0031] S3. Based on the updated impact matrix, calculate the elastic adjustment factor of non-critical constraints and set a dynamic tolerance threshold range for low-impact constraints that is linked to the battlefield situation.

[0032] S4. Encode the remaining constraints as 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.

[0033] 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 meet all constraints.

[0034] In complex and dynamic adversarial simulation scenarios, the generation of action plans must address multiple interrelated constraints, including time, space, resources, and task logic. These constraints exhibit nonlinear coupling characteristics, making them difficult to efficiently handle with traditional methods. To improve the efficiency and robustness of plan generation, this paper proposes an action plan sample space search method based on ordinal optimization. Step S1, as the starting point of the entire process, aims to construct a constraint coupling graph and an initial constraint influence matrix through scenario data abstraction and structured analysis, providing a precise data foundation for subsequent steps (such as constraint verification and plan screening based on the graph topological order).

[0035] Step S1 includes the following contents:

[0036] S1.1, build node feature updates in the constraint coupling graph:

[0037] When using graph neural networks to process constraint-coupled graphs, node features are updated by integrating their own features with the influence of neighboring nodes. First, for each constraint node, information about its directly connected neighboring nodes is collected, and the influence of these neighboring nodes is transmitted to the constraint node through a message passing mechanism. Next, the received neighboring node information is fused with the constraint node's own features to generate a new feature representation. This fusion process is performed through multiple iterations, gradually extracting the topological dependencies between constraints and incorporating them into the features to reflect the node's association characteristics in the graph.

[0038] Constraint nodes are abstract units used to represent various constraints in the action plan generation process. Each node corresponds to a specific constraint, such as time constraints, space constraints, resource constraints, or task logic constraints, and is connected by directed edges to reflect the dependencies between constraints. For example, time constraints may depend on the order in which tasks are completed, 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 structure, complex constraint relationships can be systematically analyzed and processed, providing a basis for the verification and optimization of the plan.

[0039] S1.2, calculate the betweenness centrality of the constraint node:

[0040] Betweenness centrality assesses the criticality of each constraint node in connecting other nodes within the graph. The calculation begins by determining all the shortest paths connecting each pair of nodes in the graph. Then, the number of shortest paths passing through a particular constraint node is counted and compared to the total number of shortest paths. By summing these statistics for all node pairs in the graph, the betweenness centrality value for that constraint node is calculated. This value reflects the pivotal role of the constraint node in the global topology, with larger values ​​indicating greater importance.

[0041] S1.3, calculate the dynamic conflict propagation rate:

[0042] The dynamic conflict propagation rate is used to measure the extent to which a change in a constraint node may cause its neighboring nodes to fail. The specific calculation process is as follows: first, based on historical data or simulation experiments, the probability of neighboring nodes failing when the constraint node changes is estimated. Next, a weighted calculation is performed based on the dynamic sensitivity of the neighboring 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 impact of extreme values, nonlinear transformations are applied to these battlefield situation parameters, such as smoothing with a logarithmic function. Finally, the dynamic conflict propagation rate of the constraint node is calculated by calculating the weighted average, reflecting the propagation effect of the change.

[0043] S1.4, generate edge weights in a weighted directed graph structure:

[0044] The calculation of edge weights in weighted directed graphs relies on feature information extracted by graph neural networks. Specifically, for each directed edge, feature representations of the source and target nodes are extracted from the output of the graph neural network. These features are then mapped into edge weights using a predefined normalization function, ensuring that all weights fall within the range of 0 to 1. This weight represents the strength of the source node's dependency on the target node, with larger values ​​indicating a stronger dependency, thereby quantifying the interaction between constraints.

[0045] S1.5, output the initial constraint influence matrix:

[0046] The constraint influence matrix is ​​constructed by integrating the betweenness centrality, dynamic conflict propagation rate, and edge weight information of the constraint nodes. For each pair of constraint nodes, the betweenness centrality and dynamic conflict propagation rate of the source node are first obtained. These values ​​are then weighted and summed with the edge weights connecting the source and target nodes to obtain a preliminary influence value. The weighting coefficients used in this process are pre-set to balance the contributions of various factors. All calculated influence values ​​are then normalized to a range between 0 and 1. This matrix ultimately reflects the influence relationships between the constraint nodes, facilitating subsequent analysis and application.

[0047] In step S1, the topological dependencies between constraints are extracted through the 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 the constraint nodes and their dependencies, and the initial constraint influence matrix quantifies the degree of influence of each constraint node on the global. Based on this, step S2 uses the topological order of the weighted directed graph and the influence information of the initial constraint influence matrix to derive the must-reach conditions of the root node constraint, and by dynamically adjusting the verification priority, filter out candidate solutions that violate the core constraints, thereby providing an efficient set of candidate solutions for the elastic adjustment and subsequent verification of step S3.

[0048] Step S2 includes the following contents:

[0049] S2.1, derive the necessary conditions for the root node constraint:

[0050] When deriving the must-reach conditions of the root node constraints, the forward propagation method is adopted, starting from the root node set, and gradually moving forward along the topological sequence to calculate the must-reach conditions of each constraint node. The specific process is that for each constraint node, its must-reach condition is determined by the must-reach conditions of its predecessor node set. If the constraint node and the predecessor node have an AND logical relationship, then the must-reach condition of the node is the common satisfaction of the must-reach conditions of all predecessor nodes, combined with the constraint conditions of the constraint node itself; if the constraint node and the predecessor node have an OR logical relationship, then the must-reach condition of the node is the satisfaction of at least one of the must-reach conditions of all predecessor nodes, combined with the constraint conditions of the constraint node itself. For the root node, since it has no predecessor node, its must-reach condition is directly determined by the constraint conditions of the node itself. This process is carried out recursively to ensure that the must-reach condition of each constraint node can fully reflect all the prerequisites it depends on.

[0051] S2.2, calculate the comprehensive impact:

[0052] To adjust verification priorities, the comprehensive influence of each constraint node is calculated based on the initial constraint influence matrix. This calculation is performed by summing the influence values ​​of the constraint node on all other constraint nodes. This sum is the comprehensive influence of the constraint node, reflecting its overall impact on the entire constraint system. A higher comprehensive influence value indicates a more important constraint node in the constraint network.

[0053] S2.3, generate a priority queue:

[0054] Based on the calculated comprehensive impact, the constraint nodes in the topology sequence are rearranged to form a priority queue. Specifically, all constraint nodes are sorted from highest to lowest based on their comprehensive impact, ensuring that constraint nodes with higher comprehensive impact are placed at the front of the queue. This allows for priority processing during subsequent verification processes for those constraint nodes with the greatest impact on the system.

[0055] S2.4, filter candidate solutions that violate core constraints:

[0056] When filtering candidate solutions that violate core constraints, each candidate solution is first represented as a vector of action parameters. Then, the must-reach conditions of each constraint node are checked one by one in the order of the priority queue. The specific process is that for each constraint node in the priority queue, the action parameter vector of the candidate solution is evaluated to see whether it meets the must-reach condition of the node. If it is found that a candidate solution cannot meet the must-reach condition of the current constraint node, it is determined that the candidate solution violates the core constraint and is immediately removed from the candidate solution set. In addition, if a constraint node with a high comprehensive influence is not met, the subset of candidate solutions related to the node can be quickly identified based on the outgoing edge set of the node in the weighted directed graph, and marked as infeasible, thereby reducing the subsequent verification calculation amount.

[0057] Based on the weighted directed graph and initial constraint influence matrix provided in step S1, step S2 precisely derives the mandatory conditions for the root node constraints through topological sorting, forward propagation, and a priority queue mechanism. This process effectively filters out candidate solutions that violate core constraints. This process generates an optimized set of candidate solutions, providing reliable input for step S3, which calculates the elasticity adjustment factor based on the updated influence matrix. This significantly reduces the search space and improves the relevance and efficiency of subsequent verification.

[0058] Step S3 includes the following contents:

[0059] S3.1, update the influence matrix:

[0060] In the process of updating the influence matrix, based on the set of candidate solutions filtered out in step S2, the influence degree adjustment of each constraint node on other constraint nodes is calculated. The specific steps are: first obtain the original influence degree value recorded in the initial influence matrix, and then adjust the original influence degree value according to the ratio of the number of candidate solutions that violate the 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 the constraint, that is, the proportion of candidate solutions that do not violate the constraint. In this way, the adjusted influence degree value can reflect the actual influence strength of the constraint node in the current candidate solution set, ensuring that the influence matrix remains consistent with the latest state of the candidate solution set.

[0061] S3.2, Identify non-critical constraints:

[0062] To identify non-critical constraints, based on the verification priority queue generated in step S2, the constraint nodes ranked lower in the queue are identified as non-critical constraints. Specifically, a percentage threshold, such as 20%, is pre-set, and the constraint nodes ranked in the bottom 80% of the verification priority queue are classified as non-critical constraints. This classification ensures that subsequent elastic adjustments are primarily targeted at constraint nodes with less impact on the overall system, allowing for flexible adjustments to non-critical constraints while ensuring strict enforcement of core constraints.

[0063] S3.3, calculate the topological coupling strength index:

[0064] The topological coupling strength index is used to measure the hub role of each constraint node in a weighted directed graph. Its calculation process includes the following steps. First, the betweenness centrality value obtained in step S1 is used to indicate the importance of the constraint node in the connection path of the graph. At the same time, the length of the longest dependency path starting from the constraint node is calculated to evaluate its position in the dependency chain. In addition, a path attenuation factor less than 1 is introduced 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. This result comprehensively reflects the characteristics of the constraint node in the global topological structure.

[0065] S3.4, calculate the dynamic conflict entropy increase index:

[0066] The dynamic conflict entropy increase index (DCI) is used to assess the increase in system uncertainty caused by constraint node adjustments. Its calculation steps are as follows: First, using Monte Carlo simulation, the frequency of chain conflict events triggered by constraint node parameter adjustments in historical scenarios is counted. Then, combined with battlefield situation parameters, such as the movement speed of enemy units, an entropy change rate is calculated. This rate is obtained by applying a logarithmic transformation to the ratio of enemy speed to a preset speed limit to reflect the uncertainty introduced by battlefield dynamics. Finally, the frequency of historical conflict events is multiplied by the entropy change rate to obtain the dynamic conflict entropy increase index (DCI). This index reflects the characteristics of constraint adjustments during dynamic evolution.

[0067] S3.5, segmented dynamic convolution fusion calculation elastic adjustment factor:

[0068] The elasticity adjustment factor is calculated by fusing 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 convolution kernel function is designed, whose shape is determined by the magnitude of the topological coupling strength index. Then, a multi-scale sliding window convolution operation is performed on the time series data of the dynamic conflict entropy increase index. By adjusting the width of the Gaussian convolution kernel, conflict characteristics and topological coupling characteristics at different time scales are extracted. Next, an adaptive gating mechanism is used to filter the output of the convolution operation using a sigmoid function to highlight significant feature peaks. Finally, the filtered convolution output is mapped to the elasticity adjustment factor using the hyperbolic tangent function, thereby achieving a nonlinear spatiotemporal fusion of topological structural response and dynamic conflict evolution.

[0069] S3.6, set the dynamic tolerance threshold range:

[0070] A dynamic tolerance threshold interval is set for low-impact constraint nodes. The specific method is as follows. First, based on the updated influence matrix, the comprehensive influence of each constraint node is calculated, that is, the cumulative value of the node's influence on all other nodes. Then, for non-critical constraint nodes whose comprehensive influence is below the preset threshold, their tolerance threshold interval is determined. The lower limit of this interval is the product of the minimum basic tolerance value plus the elasticity adjustment factor and the battlefield situation function, and the upper limit is the maximum basic tolerance value plus the same product. The battlefield situation function is calculated using the sigmoid function based on the position and resource consumption rate of enemy units. This ensures that the tolerance interval can be dynamically adjusted according to changes in the battlefield situation, achieving flexible relaxation of constraints.

[0071] 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 a segmented dynamic convolution fusion method to generate a flexible adjustment factor. This sets a dynamic tolerance threshold range for low-impact constraints that is linked to the battlefield situation. This process ensures that constraint adjustments reflect topological dependencies and adapt to battlefield dynamics, providing a flexible and robust constraint adjustment foundation for Boolean logic expression encoding and verification task tree generation in step S4.

[0072] In step S3, based on the updated impact matrix, flexible adjustments to low-impact constraints are achieved by calculating elastic adjustment factors for non-critical constraints and setting dynamic tolerance thresholds linked to the battlefield situation. This adjustment provides clear constraint input for step S4, including elastically adjusted non-critical constraints and core constraints that maintain strict requirements. Based on this, step S4 further processes these constraints to generate atomic verification units suitable for parallel verification, laying the technical foundation for the efficient execution of step S5.

[0073] Step S4 includes the following contents:

[0074] S4.1, Coding of the remaining constraints:

[0075] Core constraint set: Constraints that have not been adjusted flexibly and must be strictly satisfied by candidate solutions.

[0076] Non-critical constraint set: Constraints that are adjusted flexibly and allowed to fluctuate within a dynamic tolerance threshold range.

[0077] When encoding the remaining constraints to form Boolean logic expressions, different processing methods are used for core constraints and non-critical constraints. For core constraints, the action parameter vector of the candidate solution must fully satisfy the constraint. Only in this case will its corresponding Boolean logic expression be judged as true; otherwise, it will be judged as false. For non-critical constraints, considering the dynamic tolerance threshold interval set in the previous step, when the action parameter vector satisfies the constraint within this interval, 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 through a logical AND operation to form a complete Boolean logic expression, ensuring that the candidate solution can simultaneously satisfy all constraints.

[0078] S4.2, Application of Symbolic Execution Engine:

[0079] When using a symbolic execution engine, the action parameters of a candidate solution are first treated as a set of symbolic variables, which serve as abstract representations of the action parameters. The symbolic execution engine analyzes the overall Boolean logic expression, explores all possible execution paths contained within it, 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 ensures that the overall Boolean logic expression holds for that path. These path conditions remain independent of each other, avoiding duplication between action parameters and laying the foundation for the subsequent decomposition of the verification task.

[0080] S4.3, build verification task tree:

[0081] In the process of constructing the verification task tree, the overall Boolean logic expression is used as the root node of the tree, and it is gradually decomposed according to the path conditions generated by the symbolic execution engine to form intermediate nodes and leaf nodes. Intermediate nodes represent the logical operations involved in the path conditions, such as logical AND operations or branch selection points, while leaf nodes represent single constraints that cannot be further decomposed, such as the Boolean logic expression of a specific constraint. The construction of the task tree ensures that each path from the root node to each leaf node corresponds to a unique path condition, and there is no overlap in the constraints between these paths, achieving path independence. This structure helps to decompose complex constraint logic into multiple units that can be processed separately.

[0082] S4.4, decomposed into atomic verification units:

[0083] 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, such as an action parameter that must be greater than a certain value or within a certain range. Due to the independence of each path, these atomic verification units do not share symbolic variables or logical dependencies, ensuring that there is no data association between them. This decomposition process is completed by traversing the task tree and collecting all leaf nodes, allowing each atomic verification unit to be independently verified.

[0084] S4.5, Constraint Coverage Evaluation:

[0085] In order to optimize the decomposed atomic verification units, a constraint coverage index is introduced for evaluation. The calculation process of the constraint coverage index is to first determine the feasible domain of the action parameters corresponding to each atomic verification unit, that is, the range of action parameter values ​​that meet the constraints of the unit; then, calculate the intersection ratio of this feasible domain 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 a coverage ratio greater than 0.1, atomic verification units with higher coverage are screened out, and those redundant or less influential units are eliminated, thereby further optimizing the task set and improving the efficiency of verification.

[0086] Based on the updated influence matrix and dynamic tolerance threshold intervals provided by step S3, step S4 successfully decomposes the complex constraints into a path-independent verification task tree through Boolean logic encoding and a symbolic execution engine, further generating atomic verification units without data dependencies. The introduction of constraint coverage evaluation ensures the effectiveness and targeted nature of the decomposed units. This process provides an efficient and independently executable task foundation for the parallel verification in step S5, adapting to the rapid verification requirements of high-dimensional constraints in battlefield situations.

[0087] In step S4, the remaining constraints are encoded as Boolean logic expressions through a symbolic execution engine, generating a path-independent verification task tree and decomposing it into atomic verification units without data dependencies. These atomic verification units provide the foundation for parallel processing in step S5, ensuring that subsequent verification tasks can be executed efficiently without introducing data races. Based on this, step S5 utilizes GPU streaming multiprocessors and CUDA warp-level instruction synchronization technology to meet the parallel verification requirements of 10,000 constraints and generate a set of candidate solutions that fully satisfy the constraints, supporting real-time decision-making in complex adversarial scenarios.

[0088] Step S5 includes the following contents:

[0089] S5.1, Task tree level mapping:

[0090] During the task tree hierarchical mapping process, the entire verification task tree must first be divided into multiple different levels. The bottom layer is called the leaf layer, which contains all the atomic verification units, that is, the most basic and indivisible task units. The top layer is called the root layer, which represents the final verification results. The specific mapping strategy is to prioritize allocating the atomic verification units in the leaf layer to the GPU's streaming multiprocessor. This allocation method utilizes the path independence between atomic verification units, allowing these units to be processed in parallel without interfering with each other. For tasks in the middle and root layers, they are gradually allocated to idle streaming multiprocessors after the child nodes below them complete verification. This ensures that the entire verification process proceeds step by step from the bottom layer to the top layer, ensuring that the calculations at each layer depend on the results of the lower layer.

[0091] S5.2, GPU streaming multiprocessor allocation:

[0092] When assigning tasks to GPU streaming multiprocessors, the atomic verification units in the leaf layer are first assigned to each streaming multiprocessor. Priority is given to processing the lowest-level tasks, as these tasks typically have no data dependencies and can be executed directly in parallel, maximizing the GPU's computing power. For tasks in the middle layer, they must wait until their child nodes below them complete verification before being assigned to idle streaming multiprocessors. To achieve task load balancing, the system monitors the task queue length of each streaming multiprocessor in real time. If the task queue length of a streaming multiprocessor exceeds 1.5 times the average task queue length of all streaming multiprocessors, subsequent tasks will no longer be assigned to this streaming multiprocessor and will instead be reallocated to a streaming multiprocessor with a shorter task queue. This adjustment mechanism can prevent overloading of some streaming multiprocessors, thereby improving overall processing efficiency.

[0093] S5.3, CUDA warp-level instruction synchronization:

[0094] In the CUDA architecture, a warp is an execution unit consisting of 32 threads, which achieve efficient collaboration through instruction-level synchronization mechanisms. In this step, warps within the same streaming multiprocessor are configured to specifically process logically related or spatially adjacent atomic verification units. This configuration can reduce communication overhead between threads and improve computing efficiency. To ensure that threads within a warp remain consistent when calculating the Boolean values ​​of atomic verification units, the system uses the synchronization primitives provided by CUDA to coordinate and 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 ​​based on the check results, indicating whether the parameters meet the constraints.

[0095] S5.4, Parallel Verification Execution:

[0096] During the parallel verification execution process, each streaming multiprocessor will process the assigned atomic verification units in parallel. The specific operation is to perform constraint checks on the parameters of the candidate solution to determine whether the Boolean value of each atomic verification unit is true or false. The verification results will be propagated back along the task tree from the leaf node to the root node. For the logical AND node, the Boolean value of its parent node will be judged to be true only when the Boolean values ​​of all child nodes are true. For the logical OR node, as long as the Boolean value of one child node is true, the Boolean value of its parent node will be judged to be true. In order to ensure that there is no conflict in the aggregation of results across streaming multiprocessors, the system uses CUDA's global memory and atomic operations to update the shared verification results through atomic comparison and exchange. This method can safely aggregate the calculation results of each streaming multiprocessor in a parallel environment.

[0097] S5.5, dynamic task scheduling mechanism:

[0098] The dynamic task scheduling mechanism relies on an elasticity adjustment factor, which is used to assign priority to atomic verification units of non-core constraints, thereby optimizing resource allocation. Specifically, atomic verification units of core constraints are always given the highest priority, while the priority of atomic verification units of non-core constraints is determined by the absolute value of the elasticity adjustment factor. The smaller the absolute value of the elasticity adjustment factor, the higher the priority of the corresponding atomic verification unit. High-priority tasks will be preferentially assigned to idle stream multiprocessors, while low-priority tasks will only be executed when resources are sufficient, thus ensuring that the verification of core constraints can be completed quickly. In addition, the system will update the elasticity adjustment factor in real time according to changes in the battlefield situation, and recalculate the priority of tasks based on the updated value, thereby dynamically adjusting the execution order of the task queue.

[0099] S5.6, output the set of candidate solutions that satisfy all constraints:

[0100] When outputting a fully constrained candidate solution set, a Boolean value of the root node of the task tree is judged to be true, indicating that the candidate solution satisfies all constraints. The system collects all verified candidate solutions to form the final candidate solution set. Thanks to the parallel computing power of the GPU, the verification process can be completed in a very short time, even when faced with tens of thousands of constraints. This efficient processing method supports real-time decision-making and ensures that candidate solutions that meet the requirements are quickly provided at critical moments.

[0101] The above formulas are all dimensionless and numerical calculations. The formulas are obtained by collecting a large amount of data and performing software simulation to obtain the most recent real situation. The preset parameters in the formulas are set by technicians in this field according to actual conditions.

[0102] It should be noted that the system of the present invention can be deployed on the device itself to realize embedded applications, and can also be run on a PC or other terminal with a user interface, thereby meeting a variety of hardware environments and usage requirements.

[0103] The above description is merely illustrative of certain exemplary embodiments of the present invention. It goes without saying that those skilled in the art will be able to modify the described embodiments in various ways without departing from the spirit and scope of the present invention. Therefore, the above drawings and description are illustrative in nature and should not be construed as limiting the scope of protection of the claims.

[0104] It should be noted that, in this document, if there are relational terms such as first and second, etc., 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 terms "comprises", "includes" or any other variations thereof are intended to cover non-exclusive inclusion, so that a process, method, article or device that includes a series of elements includes not only those elements, but also other elements not explicitly listed, or elements inherent to such process, method, article or device. In the absence of further limitations, an element defined by the phrase "comprises a ..." does not exclude the presence of other identical elements in the process, method, article or device that includes the element.

[0105] The above description is merely a specific embodiment of the present application, but the scope of protection of the present application is not limited thereto. Any changes or substitutions that can be easily conceived by a person skilled in the art within the technical scope disclosed in this application should be included in the scope of protection of this application. Therefore, the scope of protection of this application should be based on the scope of protection of the claims.

Claims

1. The action plan sample space search method based on sequential optimization is characterized by: Including steps: S1. Collect constraints, including time, space, resources, and task logic, from the database or sensor system of the adversarial simulation scenario. Use a graph neural network to extract the topological dependencies between the constraints. 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, the forward propagation algorithm is used to derive the reachability conditions of the root node constraints. The influence matrix is ​​used to dynamically adjust the verification priority and filter out candidate solutions that violate the core constraints. S3. Calculate the elasticity adjustment factors for non-critical constraints based on the updated impact matrix, and set dynamic tolerance threshold intervals for low-impact constraints that are linked to the battlefield situation. 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. The statistical and calculation steps are automatically performed by a computer based on the candidate solution verification results; S3.2-3.5, the elasticity adjustment factor is obtained by integrating the topological coupling strength index and the dynamic conflict entropy increase index. The elasticity adjustment factor is calculated in the processor according to a predetermined algorithm. The topological strength is calculated by multiplying the betweenness centrality and the neighborhood constraint chain length attenuation contribution. The dynamic conflict index is derived by combining the historical conflict frequency and the entropy change rate of the battlefield situation parameters. Then, the dynamic conflict index is subjected to piecewise multi-scale convolution using the topological strength as the convolution kernel to extract features. After adaptive gating and screening, it is mapped into a regulation factor through the hyperbolic tangent function to achieve nonlinear fusion of topological and dynamic features. S3.6 When setting the dynamic tolerance threshold interval, the comprehensive influence 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, the elasticity adjustment factor, and the battlefield situation function. The battlefield situation function uses the sigmoid function to process the enemy position and resource consumption rate parameters to generate dynamic indicators, ensuring that the tolerance interval can be flexibly adjusted according to the battlefield situation. S4. Encode the remaining constraints as Boolean logic expressions and generate a verification task tree with path independence through the symbolic execution engine. Decompose the tree into atomic verification units without data dependencies. 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 meet all constraints.

2. The method for searching the action plan sample space based on sequential optimization according to claim 1, characterized in that: Step S1 includes the following contents: Abstract the constraints including time, space, resources and task logic into a set of constraint nodes, and construct a set of directed edges by analyzing the dependencies between the constraints, thus forming the initial graph structure; Subsequently, the graph structure is processed using a graph neural network, and 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 by combining 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 dependency intensity. Finally, the betweenness centrality, dynamic conflict propagation rate and edge weights are combined to construct and normalize the initial constraint influence matrix.

3. The method for searching the action plan sample space based on sequential optimization according to claim 2, characterized in that: Step S2 includes the following contents: First, the constraint graph is topologically sorted by a computing device, a linear sequence of constraint nodes is generated using a topological sorting algorithm, and a set of root nodes is identified; Then, using the forward propagation algorithm, starting from the root node, the reachability conditions of each constraint node are derived along the topological sequence, integrating the predecessor nodes and the constraints themselves through logical relationships; then, combined with the initial constraint influence matrix, the comprehensive influence of each constraint node is calculated, that is, the cumulative influence of 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 the action plan sample space based on sequential optimization according to claim 1, 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, the symbolic execution engine in the computer is used to take the action parameters 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. The leaf nodes represent atomic constraint conditions 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, the coverage ratio of each atomic verification unit is calculated, and redundant units with coverage below the preset threshold are eliminated; finally, a set of atomic verification units without data dependence is generated.

5. The method for searching the action plan sample space based on sequential optimization according to claim 4, characterized in that: Step S5 includes the following contents: First, the verification task tree is divided into layers, with the leaf layer containing atomic verification units without data dependencies. The atomic verification units in the leaf layer are then preferentially mapped to the GPU streaming multiprocessors, leveraging their path independence for parallel computation. Intermediate and root layer tasks are then gradually mapped after the child nodes are verified. A load balancing mechanism is employed to monitor the task queue length of the streaming multiprocessors and dynamically adjust task allocation to prevent overload. CUDA warp-level instruction synchronization is then used to configure warps into spatially adjacent atomic verification units. Synchronization primitives are then used to ensure consistency among threads within a warp when computing Boolean values. Furthermore, each streaming multiprocessor processes the atomic verification units in parallel and propagates the verification results back along the task tree, using atomic operations to ensure conflict-free aggregation of results across the streaming multiprocessors. A dynamic task scheduling mechanism is then introduced to prioritize atomic verification units with non-critical constraints based on an elastic adjustment factor, prioritizing high-priority tasks and dynamically adjusting their priorities 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 satisfy all constraints is output, enabling millisecond-level verification of tens of thousands of constraints through GPU parallel acceleration.

Images