A method, device and equipment for pruning a combat rule execution graph based on dynamic situation awareness, and a storage medium

Abstract

This invention provides a method, apparatus, device, and storage medium for pruning wargame rule execution graphs based on dynamic situational awareness. It transforms discrete rules into pruningable topological objects by parsing massive amounts of rules into an initial global rule directed graph composed of three types of nodes and three types of edges, and establishing a feature-node inverted index. Real-time battlefield situations are mapped to feature vectors, and affected atomic condition nodes are located using the inverted index. Coarse-grained filtering is achieved through Boolean logic matching and bottom-up propagation marking. Node weights are calculated based on an environment inhibition function, and the activation probability of the propagation path is multiplied along dependent edges. Low-probability paths with accumulated weights below a dynamic threshold are pruned, and conflict resolution is performed before execution based on mutually exclusive and priority edges. The pruned dynamic execution subgraph is topologically sorted and executed in parallel, thereby achieving situation-aware filtering and probabilistic reasoning from global rules to the minimum effective execution subgraph within milliseconds.

Description

Technical Field

[0001] This invention relates to the field of wargaming and simulation technology, and in particular to a method, apparatus, device, and storage medium for pruning wargaming rule execution graphs based on dynamic situational awareness. Background Technology

[0002] Wargaming and simulation technology, as a crucial support for modern military training, combat rehearsals, and strategic decision-making, hinges on the construction and operation of its adjudication engine. Based on pre-set military doctrines, operational rules, and battlefield environment parameters, the adjudication engine performs logical judgments and status updates on various action outcomes of simulated entities (including but not limited to attack hit determination, movement feasibility analysis, supply interruption detection, and communication link effectiveness assessment). As modern warfare evolves towards multi-domain collaboration and intelligence, the rule base of wargaming systems has rapidly expanded from hundreds to tens of thousands of rules, and it needs to respond in real-time to multi-dimensional situational changes in complex and ever-changing battlefield environments.

[0003] Currently, the implementation schemes of the rule adjudication engine in wargaming simulation systems mainly include hard-coded logic schemes, static script and linear matching schemes, and index tree-based rule retrieval schemes. Among them, the hard-coded logic scheme directly embeds the rule logic into the program source code, which has poor flexibility and high maintenance costs; the static script and linear matching scheme improves configuration flexibility, but requires traversing the entire rule base and matching each rule in each simulation time step, with a computational complexity of O(N); the index tree-based scheme uses static attributes for pre-filtering, but can only build an index based on a single or a few static attributes.

[0004] The aforementioned existing technologies share a common and fundamental technical problem when facing the complex scenarios of modern wargaming: the existing rule adjudication engines adopt a static, full, and Boolean rule matching mode, which cannot perform context-aware dynamic filtering and probabilistic reasoning on massive rule bases based on multi-dimensional coupled real-time battlefield situations within milliseconds. This results in a massive number of invalid rule judgments and a waste of computing resources in large-scale concurrent simulation scenarios.

[0005] Specifically, the fundamental problem in existing technologies manifests in the following three interrelated aspects: First, the rule matching process is detached from the battlefield situation. Regardless of whether the current terrain is plains or mountains, sunny or rainy, the system must traverse the entire rule base for conditional judgment, making it impossible to pre-filter the rule space based on situational characteristics before execution. Second, the rule activation determination adopts a black-and-white Boolean mode, which cannot quantify the coupling and inhibition effects of various environmental factors (terrain, weather, electromagnetic, etc.) on the probability of rule triggering. This results in the complete execution of rule paths that are almost impossible in physics, such as "optical guided attack rules under heavy rain and superimposed electromagnetic interference," leading to deviating from common sense in physics. Third, the dependencies and mutual exclusions between rules lack a prior topological expression and resolution mechanism. Conflict detection is postponed to post-processing after rule triggering, causing logical oscillations and inconsistent adjudication.

[0006] In view of the above, this application is hereby submitted. Summary of the Invention

[0007] This invention discloses a method, apparatus, device, and storage medium for pruning wargaming rule execution graphs based on dynamic situational awareness. It aims to solve the problems of low rule matching efficiency, poor environmental adaptability, and delayed conflict resolution caused by the lack of dynamic situational awareness and probabilistic reasoning capabilities in existing wargaming rule adjudication engines in large-scale real-time simulation scenarios.

[0008] The first embodiment of the present invention provides a method for pruning the rule execution graph of wargames based on dynamic situational awareness, including: The wargame rule file is parsed, and the atomic conditions, logical operators and actions in each rule are mapped to atomic condition nodes, compound logical nodes and action execution nodes respectively. The three types of nodes are connected by dependency edges, mutual exclusion edges and priority edges to construct an initial global rule directed graph. At the same time, an inverted index from feature name to the atomic condition node is established. At each simulation time step, battlefield snapshot data is collected, entity attributes, environmental parameters and global state are extracted and mapped into real-time situation feature vectors, and the set of atomic condition nodes affected by the real-time situation feature vectors is located through the inverted index. Boolean logic matching is performed on the set of atomic condition nodes to mark them as live nodes, dead nodes, or uncertain nodes. Boolean logic propagation marking is performed on the composite logic nodes from bottom to top to remove dead nodes and their associated invalid edges, thus obtaining candidate subgraphs. For non-dead nodes in the candidate subgraph, the current environment weight is calculated based on the environment inhibition function. The activation probability is passed layer by layer from the atomic condition node to the action execution node along the dependent edge. The cumulative weight of each execution path is calculated. The path with the cumulative weight lower than the dynamic threshold is subjected to topology pruning. The conflict nodes are pre-resolved based on the mutual exclusion edge and the priority edge to obtain the dynamic execution subgraph. The dynamic execution subgraph is sorted by directed acyclic graph topology and divided into parallel execution blocks. The logic of the action execution nodes in each execution block is executed sequentially and the wargaming state is updated.

[0009] The second embodiment of the present invention provides a wargaming rule execution graph pruning device based on dynamic situational awareness, comprising: The rule graph construction unit is used to parse the wargame rule file, map the atomic conditions, logical operators and actions in each rule to atomic condition nodes, compound logical nodes and action execution nodes respectively, and connect the three types of nodes through dependency edges, mutual exclusion edges and priority edges to construct an initial global rule directed graph, and at the same time establish an inverted index from feature name to the atomic condition node; The situation feature vectorization unit is used to collect battlefield snapshot data at each simulation time step, extract entity attributes, environmental parameters and global state and map them into real-time situation feature vectors, and locate the set of atomic condition nodes affected by the real-time situation feature vectors through the inverted index. The active node marking unit is used to perform Boolean logic matching on the set of atomic condition nodes, mark them as live nodes, dead nodes or uncertain nodes, and perform Boolean logic propagation marking on the composite logic nodes from bottom to top, remove dead nodes and their associated invalid edges, and obtain candidate subgraphs; The dynamic topology pruning unit is used to calculate the current environmental weight of the non-dead nodes in the candidate subgraph based on the environmental inhibition function, pass the activation probability layer by layer from the atomic condition node to the action execution node along the dependent edge, calculate the cumulative weight of each execution path, perform topology pruning on the path with the cumulative weight lower than the dynamic threshold, and perform pre-resolution of conflict nodes based on the mutual exclusion edge and the priority edge to obtain the dynamic execution subgraph. The topology sorting execution unit is used to perform directed acyclic graph topology sorting and parallel execution block division on the dynamic execution subgraph, and sequentially execute the logic of the action execution nodes in each execution block and update the wargaming state.

[0010] The third embodiment of the present invention provides a wargaming rule execution graph pruning device based on dynamic situation awareness, characterized in that it includes a memory and a processor, wherein the memory stores a computer program, and the computer program can be executed by the processor to implement a wargaming rule execution graph pruning method based on dynamic situation awareness as described in any of the above embodiments.

[0011] The fourth embodiment of the present invention provides a computer-readable storage medium, characterized in that it stores a computer program, which can be executed by the processor of the device where the computer-readable storage medium is located, to implement a wargaming rule execution graph pruning method based on dynamic situational awareness as described in any of the above embodiments.

[0012] Based on the present invention, a method, apparatus, device, and storage medium for pruning wargame rule execution graphs based on dynamic situational awareness are provided. This invention parses massive rules into an initial global rule directed graph composed of three types of nodes and three types of edges, and establishes a feature-node inverted index, transforming discrete rules into pruningable topological objects. It maps real-time battlefield situations into feature vectors and locates affected atomic condition nodes through the inverted index, avoiding full graph traversal. Coarse-grained filtering is achieved through Boolean logic matching and bottom-up propagation marking. Node weights are calculated based on an environmental inhibition function, and the activation probability of the propagation path is multiplied along dependent edges to prune low-probability paths with accumulated weights below a dynamic threshold. Simultaneously, conflict resolution is performed before execution based on mutually exclusive edges and priority edges. The pruned dynamic execution subgraph is topologically sorted and executed in parallel, thereby achieving situation-aware filtering and probabilistic reasoning from global rules to the minimum effective execution subgraph within milliseconds. Attached Figure Description

[0013] Figure 1 This is a flowchart illustrating a wargaming rule execution graph pruning method based on dynamic situational awareness, provided in the first embodiment of the present invention. Figure 2 This is a schematic diagram of a module of a wargaming rule execution graph pruning device based on dynamic situational awareness, provided in the second embodiment of the present invention. Detailed Implementation

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

[0015] To better understand the technical solution of the present invention, the embodiments of the present invention will be described in detail below with reference to the accompanying drawings.

[0016] This invention discloses a method, apparatus, device, and storage medium for pruning wargaming rule execution graphs based on dynamic situational awareness. It aims to solve the problems of low rule matching efficiency, poor environmental adaptability, and delayed conflict resolution caused by the lack of dynamic situational awareness and probabilistic reasoning capabilities in existing wargaming rule adjudication engines in large-scale real-time simulation scenarios.

[0017] Please see Figure 1 The first embodiment of the present invention provides a wargaming rule execution graph pruning method based on dynamic situational awareness, which can be executed by a wargaming rule execution graph pruning device based on dynamic situational awareness (hereinafter referred to as pruning device or system), specifically, by one or more processors within the pruning device, to at least implement the following steps: S101, parse the wargame rule file, map the atomic conditions, logical operators and actions in each rule to atomic condition nodes, compound logical nodes and action execution nodes respectively, and connect the three types of nodes through dependency edges, mutual exclusion edges and priority edges to construct an initial global rule directed graph, and at the same time establish an inverted index from feature name to the atomic condition node; In this embodiment, the wargame rule file written by the rule designer is first read. This file can be described using the domain-specific language or extended XML format defined in this invention. The rule parser performs lexical and syntactic analysis on the rule file according to the preset BNF paradigm or XMLSchema, generating an abstract syntax tree corresponding to each rule. Taking an air strike rule as an example, its condition part is "UAV type AND distance to target less than 5.0 AND non-rainstorm weather AND (optical guidance OR radar guidance)", and the action part is "calculate hit probability" and "apply damage". Based on this, the parser identifies four indivisible condition judgments, three logical operators, and two actions.

[0018] Subsequently, the node mapping subunit maps the above parsing results into three types of graph nodes: each indivisible condition judgment (such as "distance from target less than 5.0") is mapped to an atomic condition node, whose attributes include the feature name "distance from target", the operator "less than", the expected value "5.0", and a unique node ID; each logical operator of type AND, OR, or NOT is mapped to a composite logical node, where the root node in this example is of type AND and has 4 incoming edges (corresponding to 4 sub-conditions), and the OR node nested inside it has 2 incoming edges (corresponding to the two sub-conditions of optical guidance and radar guidance). If it contains the NOT operator, its number of incoming edges is fixed at 1; each action is mapped to an action execution node, whose attributes include action type, parameter list (such as weapon model, target type), and the rule ID to which it belongs.

[0019] The edge connection subunit establishes connections between the three types of nodes: using directed solid arrows as dependency edges, the four atomic condition nodes are respectively pointed to their respective root AND composite logic nodes, the nested OR composite logic nodes are pointed to their parent AND nodes, and the root AND nodes are pointed to the two action execution nodes; for two rules that are explicitly declared to belong to the same mutual exclusion group in the rule definition (for example, the "ground strike" and "reconnaissance mission" rules of the same UAV cannot be triggered at the same time), a bidirectional dashed arrow indicating the mutual exclusion level is established between the action execution nodes of the two rules as a mutual exclusion edge, with the mutual exclusion level ranging from 1 to 5; for two rules with priority differences in the rule definition, a unidirectional solid arrow indicating the priority difference is established from the action execution node of the higher priority rule to the action execution node of the lower priority rule as a priority edge.

[0020] After completing the node mapping and edge connection for all rules, the rule graph construction unit generates an initial global rule directed graph containing all possible rules. At this point, all nodes in the graph are marked as inactive, awaiting activation determination in subsequent steps based on real-time conditions. Simultaneously, the index construction subunit traverses all atomic condition nodes, extracts their feature names, and builds an inverted index. The index structure is "feature name, set of atomic condition nodes referencing that feature". For example, all atomic condition nodes referencing the "weather" feature are grouped under the same index entry. This inverted index is stored in memory so that subsequent steps can quickly locate the affected node set by feature name, avoiding a full traversal of the global directed graph.

[0021] Through the above, the massive number of rules that originally existed in the form of discrete text are transformed into directed graphs with explicit topological structures, and the dependencies, mutual exclusions and priority relationships between rules are visualized and expressed in the form of graph edges.

[0022] S102, at each simulation time step, collect battlefield snapshot data, extract entity attributes, environmental parameters and global state and map them into real-time situation feature vectors, and locate the set of atomic condition nodes affected by the real-time situation feature vectors through the inverted index; After the initial global rule-directed graph is constructed, a snapshot of the current battlefield is taken at each simulation time step. The interval between these time steps can be set to milliseconds or seconds depending on the simulation accuracy requirements. Following the aforementioned example of the air strike rule, assuming the current simulation scenario involves a Blue Force drone swarm attempting to strike a Red Force target in mountainous terrain, heavy rain, and strong electromagnetic interference, the situation feature vectorization unit extracts relevant data from the entity management module, environment module, and global state module of the simulation engine.

[0023] Specifically, the system first extracts the entity attributes participating in the simulation from the entity management module, including the current position coordinates, remaining health, equipment model, and distance from the target of each UAV. For example, it obtains that the distance of a certain UAV in the current formation from the target is 3.5 kilometers and the equipment model is a certain type of mounting platform. Secondly, it extracts environmental parameters from the environment module, including terrain type (value is mountainous), weather type (value is heavy rain), and electromagnetic interference level (value is level 5, corresponding to extremely strong interference). Finally, it extracts global status information from the global status module, including the current simulation stage and the supply line connectivity status.

[0024] After data extraction is completed, the situation feature vectorization unit performs a feature mapping operation to transform the unstructured or semi-structured snapshot data into a standardized real-time situation feature vector F. This vector is organized in the form of key-value pairs of "feature name-feature value". For example, F contains elements such as f_distance=3.5, f_terrain="mountain", f_weather="heavy rain", f_electronic_level=5, and f_unit_type="drone". All feature names are strictly consistent with the feature names identified in the rule parsing stage of step S1 to ensure the correspondence of subsequent matching.

[0025] Subsequently, the inverted index built in memory is invoked to perform a query operation on each feature name in the real-time situation feature vector F. Specifically, for the feature name f_weather, the set of all atomic condition nodes referencing the "weather" feature is located through index lookup, including multiple atomic condition nodes such as "weather equals sunny", "weather equals heavy rain", and "weather does not equal fog". For the feature name f_electronic_level, the set of all atomic condition nodes referencing the "electromagnetic level" feature is located. And so on, the union operation is performed on the set of atomic condition nodes corresponding to all feature names to obtain the set of atomic condition nodes Affected_CNodes that are affected by the current situation in the current time step. This set is the scope of the subsequent Boolean logic matching. Compared with the traditional approach of matching all atomic condition nodes one by one in the initial global rule directed graph, this step uses the inverted index to precisely limit the matching scope to a subset directly related to the current situation, significantly reducing the computational scale of subsequent processing.

[0026] S103, perform Boolean logic matching on the set of atomic condition nodes, mark them as live nodes, dead nodes or uncertain nodes, and perform Boolean logic propagation marking on the composite logic nodes from bottom to top, remove dead nodes and their associated invalid edges, and obtain candidate subgraphs; The set of affected atomic condition nodes is located through an inverted index. Boolean logic matching is performed on each atomic condition node in this set, comparing the pre-stored operators and expected values ​​in the atomic condition node with the feature values ​​of the corresponding feature names in the real-time situation feature vector. Continuing with the previous embodiment, for the atomic condition node "weather equals sunny," since f_weather="heavy rain" in the real-time situation feature vector, the comparison result is not satisfied, and the node is marked as a dead node; for the atomic condition node "weather equals heavy rain," the comparison result is satisfied, and the node is marked as a live node; for the atomic condition node "distance from target less than 5.0," since f_distance=3.5 satisfies this condition, it is marked as a live node; if the feature name referenced by an atomic condition node does not appear in the real-time situation feature vector or the corresponding feature value is undefined (e.g., the working status of a certain type of detection equipment is not reported), then the node is marked as an uncertain node, and in subsequent processing, it is conservatively considered a live node by default.

[0027] After marking the atomic condition nodes, the composite logic nodes are marked using a post-order traversal strategy, propagating Boolean logic layer by layer from bottom to top. Specifically, first, all the deepest nested composite logic nodes in the graph are identified (i.e., composite logic nodes whose inputs are all atomic condition nodes). Starting from this layer, the state is propagated layer by layer towards its parent node until the root composite logic node that is directly connected to the action execution node is reached. For the OR type composite logic node "Optical Guidance OR Radar Guidance" in this embodiment, assuming that its two atomic conditional child nodes are marked as live nodes and dead nodes respectively, it is marked as a live node according to the OR type rule - when any child node is a live node, the whole node is marked as a live node. For the root AND type composite logic node above it, its four inputs are "UAV type" (live), "distance from target less than 5.0" (live), "non-rainstorm weather" (since the child node "rainstorm weather" of the NOT type node is a live node, the NOT node is a dead node according to the NOT inversion rule), and the aforementioned "Optical Guidance OR Radar Guidance" OR node (live). According to the AND type rule - when any child node is a dead node, the whole node is marked as a dead node - the root composite logic node is marked as a dead node. For another example, for an AND node in another rule, if all its child nodes are live nodes, it is marked as a live node. If there are uncertain nodes but no dead nodes, it is conservatively marked as an uncertain node.

[0028] For rules with multiple nested composite logic nodes (e.g., complex rules with the condition expression "(AANDB)OR(NOTC)"), the hierarchical order of post-order traversal is strictly followed: the first level completes the state marking of atomic condition nodes A, B, and C; the second level calculates the state of the inner AND type composite logic node based on the states of A and B, and calculates the state of the NOT type composite logic node based on the state of C; the third level takes the states of the aforementioned two inner nodes as input and calculates the state of the outermost OR composite logic node according to the OR type rule. This hierarchical propagation order ensures that the states of all child nodes of each composite logic node are determined when it is marked, avoiding state dependency confusion.

[0029] After marking all nodes, a cleanup operation is performed on the nodes marked as dead nodes and their associated edges in the graph: when an atomic condition node is marked as a dead node, its dependent edges pointing to the upper-level composite logic nodes are handled by the aforementioned propagation rules; when a composite logic node is marked as a dead node, its connected downstream action execution nodes are directly marked as dead nodes because the conditions cannot be met; when an action execution node is marked as a dead node, the mutual exclusion edges it participates in are temporarily unconstrained (because the node will no longer execute, the mutual exclusion relationship is meaningless), and the priority edges it emits no longer constrain the target node; all dead nodes and their invalid associated edges are removed from the graph, resulting in a candidate subgraph containing only live nodes and uncertain nodes and their valid edges.

[0030] S104, for the non-dead nodes in the candidate subgraph, calculate the current environment weight based on the environment inhibition function, pass the activation probability layer by layer from the atomic condition node to the action execution node along the dependent edge, calculate the cumulative weight of each execution path, perform topology pruning on the paths with cumulative weights lower than the dynamic threshold, and perform pre-resolution on conflict nodes based on the mutual exclusion edge and the priority edge to obtain the dynamic execution subgraph. In this embodiment, probabilistic deep pruning based on environmental factors is performed on all non-dead nodes (i.e., live nodes and uncertain nodes). The core mechanism of this step is: the multidimensional real-time situation is quantified into the current environmental weight of the node through the environmental suppression function, and the activation probability is passed layer by layer from the atomic condition node to the action execution node along the dependent edge. Finally, topology pruning is performed on low-probability execution paths and potential conflicts are resolved in advance.

[0031] First, the environment suppression function is called on each non-dead node in the candidate subgraph to calculate the current environment weight. The environment suppression function is a mapping function that takes the current environment state and the target node as input and the current environment weight as output. Its specific calculation formula is w_current=w_base×α_terrain×β_weather×γ_electronic. Continuing with the previous embodiment, for a specific action execution node, its rule definition explicitly specifies priority=8, and the maximum priority in the rule base is priority_max=10. Therefore, the base weight w_base=8 / 10=0.8. For the terrain coefficient α_terrain, the preset terrain-rule association lookup table is consulted, and the α_terrain value corresponding to the "air strike" rule under "mountain" terrain is 0.8. For the weather coefficient β_weather, the preset weather-rule association lookup table is consulted, and the β_weather value corresponding to the "optical guidance" rule under "heavy rain" weather is 0.05. For the electromagnetic environment coefficient γ_electronic, the preset electromagnetic-rule association lookup table is consulted, and the γ_electronic value corresponding to the "data link communication" rule under electromagnetic level 5 is 0.05. Substituting these values ​​into the calculation formula, the current environment weight of this node is obtained as w_current=0.8×0.8×0.05×0.05=0.0016. If the real-time situation feature vector simultaneously matches the "heavy rain superimposed with enhanced electromagnetic interference" combination in the preset coupling correction rules (this combination has a greater additional suppression effect on data link-type rules than the product of the suppression of the two independently), then a coupling correction coefficient δ (e.g., δ=0.5) is introduced for further correction, resulting in w_current=0.0016×0.5=0.0008, and the result is truncated to the [0,1] interval. The three association lookup tables of terrain-rules, meteorological-rules, and electromagnetic-rules are all pre-annotated by domain experts before system deployment and stored in the configuration database of the adjudication module for runtime invocation.

[0032] After calculating the current environment weights of each node, the activation probabilities are passed layer by layer along the dependency edges from the root atomic condition node to the action execution node. The corresponding probability aggregation operation is performed according to the type of the composite logic node: for AND type composite logic nodes, the cumulative path weight is equal to the product of the weights of all input sub-paths, reflecting the probabilistic meaning that "all sub-conditions must be true simultaneously"; for OR type composite logic nodes, the cumulative path weight is equal to the maximum value of the weights of all input sub-paths, reflecting the probabilistic meaning that "at least one sub-condition is sufficient"; for NOT type composite logic nodes, the cumulative path weight is equal to 1 minus the weight of its sub-paths, reflecting the meaning of probability inversion. Finally, the cumulative weight of the entire execution path from the root atomic condition node to the target action execution node is the product of the weights of each node on the path. Continuing with the previous embodiment, for a typical "optical guidance plus data link communication" execution path, its cumulative weight W_path = 0.0008, far below the dynamic threshold.

[0033] Subsequently, the cumulative weight of each execution path is compared with the dynamic threshold θ, and topology pruning is performed on paths with cumulative weights lower than the dynamic threshold. The dynamic threshold is set using a three-layer mechanism: the first layer is the system default value θ=0.01; the second layer is set according to rule categories, for example, a lower threshold of 0.001 is set for critical combat rules to ensure that they can still be triggered in extreme cases, and a higher threshold of 0.05 is set for regular movement rules to improve pruning efficiency; the third layer applies the corresponding threshold multiplier according to the user's preset precise mode, standard mode, or fast mode (precise mode multiplier 0.1, standard mode multiplier 1.0, fast mode multiplier 5.0), which the user can select according to the usage scenario before the simulation begins. In addition to the static settings mentioned above, a sliding window is maintained to collect pruning effect feedback data for the most recent N time steps (e.g., N=100). If the pruned path is manually corrected in subsequent simulations or causes result deviation, the threshold is automatically lowered to reduce pruning intensity. If the system frame rate is lower than the target value, the threshold is automatically raised to enhance pruning intensity. Furthermore, the dynamic threshold value after each adjustment is strictly limited to [0.5×θ_current, 2.0×θ_current], where θ_current is the current value of the dynamic threshold before the adjustment, preventing drastic fluctuations in the threshold between adjacent time steps. In this embodiment, since W_path=0.0008 is lower than the threshold θ=0.01, the execution path is determined to be highly unlikely and removed from the graph.

[0034] For special cases where some rules have an extremely low probability of triggering under the current situation but would have a significant strategic impact once triggered, this step sets up a special handling mechanism: For rules explicitly marked as true using the Black Swan attribute in a domain-specific language or extended XML format, or rules that meet preset heuristic conditions (including any one of the following: action type belonging to a strategic category, rule priority higher than a set threshold such as priority greater than or equal to 9, rule involving global state changes), even if their cumulative path weight is lower than the dynamic threshold, they will not be pruned, but their action execution nodes will be marked as low priority. Action execution nodes marked as low priority will be executed after ordinary action execution nodes at the same level in the subsequent topology sorting in step S5, and their execution can be delayed when the system resource utilization exceeds a preset threshold (e.g., thread pool saturation or CPU utilization consistently higher than 90%). In this embodiment, the candidate subgraph includes a "full-band electromagnetic suppression" rule marked with the Black Swan attribute. Although its cumulative path weight is lower than the threshold, it is still retained and marked as low priority, making it convenient as an alternative in subsequent deductions.

[0035] After pruning low-probability paths, conflict pairs in the candidate subgraph connected by mutually exclusive edges, where both ends of the action execution node are live nodes, are pre-resolved. The following priority order is used to judge the conflict pairs: when the priorities of the action execution nodes at both ends of the mutually exclusive edge are different, the higher priority node is retained and the lower priority node is pruned; when the priorities at both ends are the same, the conflict pairs are handled according to the mutual exclusion level marked on the mutually exclusive edge: when the mutual exclusion level is 1, both are retained and a warning log is recorded; when the mutual exclusion level is 2 or 3, the node with the smaller rule ID is retained; when the mutual exclusion level is 4 or 5, both are marked as dead nodes and a system alarm is triggered to prompt manual intervention. After making the node pruning decision, a sharing check is performed on the preceding dependency chain of the pruned node: starting from the node executing the action to be pruned, tracing back along the dependency edges to the root atomic condition node, checking the outgoing edge connections of each node in the dependency chain—if the outgoing edge of the node only connects to the pruned node, it is determined to be an exclusive node and removed from the graph; if the outgoing edge of the node also connects to other live nodes (i.e., the node is shared by multiple rules), it is determined to be a shared node and retained, only removing the dependency edge pointing to the pruned node. This sharing check process is executed recursively until the root atomic condition node is reached or a shared node is encountered. For example, if rule A (priority=8) and rule B (priority=5) are mutually exclusive and share the same atomic condition node "distance from target is less than 5.0", retain A and prune B's action execution node. Continue to check B's composite logic node and find that its outgoing edge only connects to B's action execution node, so remove the composite logic node. Then check the shared atomic condition node and find that its outgoing edge also connects to A's composite logic node, so retain it and only remove the dependency edge that points to B's composite logic node.

[0036] S105, perform directed acyclic graph topology sorting and parallel execution block division on the dynamic execution subgraph, and sequentially execute the logic of the action execution nodes in each execution block and update the wargaming state.

[0037] The dynamic execution subgraph is subjected to directed acyclic graph topology sorting and parallel execution block partitioning to ensure that rules are executed correctly according to dependencies and to maximize the utilization of system computing resources.

[0038] The Kahn algorithm is used to sort the dynamic execution subgraph: First, the in-degree of each node in the graph is counted, and all nodes with an in-degree of 0 (i.e., root nodes that do not depend on any other nodes, usually atomic condition nodes) are added to the ready queue. Then, all nodes are sequentially taken out of the ready queue for processing, and the in-degree of their successor nodes is decremented by 1. If the in-degree of a successor node becomes 0, it is added to the ready queue for the next round. This process is repeated until the ready queue is empty, finally resulting in a linear sequence of nodes S=[n1,n2,...,n k ], where if node n i Dependency node n j Therefore, j must be less than i, thus ensuring the correctness of the dependency relationship. For example, for a rule chain that "first calculates movement consumption, then calculates remaining fuel, and finally determines whether resupply is needed", the three nodes must appear in the sequence in the above order.

[0039] Parallel execution block partitioning is performed concurrently with topological sorting: all nodes in the ready queue during each iteration of the Kahn algorithm are grouped into the same parallel execution block. Nodes within the same execution block have no dependencies (otherwise, they could not all have an in-degree of 0 simultaneously), thus allowing for parallel execution. Two-way control is implemented on the size of the execution blocks: if an execution block contains only one node, it is executed serially without starting parallel threads to avoid the additional overhead of thread creation and context switching; if the number of nodes in an execution block exceeds a preset threshold T_max, it is evenly divided into multiple sub-blocks to avoid a single execution block consuming too many resources. The initial value of T_max is set to four times the number of physical CPU cores (e.g., 32 on an 8-core CPU), and is dynamically adjusted based on the real-time CPU utilization of the system—T_max is reduced when CPU utilization is consistently above 80% to alleviate the load, and T_max is increased when CPU utilization is consistently below 30% to fully utilize idle computing power.

[0040] The execution of each parallel execution block is scheduled using a thread pool model: the initial size of the thread pool is equal to the number of physical CPU cores. Each parallel execution block is encapsulated as a task and submitted to the task queue of the thread pool. Multiple subtasks within the same execution block can be picked up and executed concurrently by different worker threads. Parallel execution blocks are synchronized through a barrier mechanism—that is, the (i+1)th execution block is executed only after all tasks in the i-th execution block have been completed, ensuring that dependencies are not broken. Subtasks within a block do not require synchronization because they have no dependencies. When the action type of an action execution node is vectorizable (e.g., batch ballistic calculation, hit rate determination of a large number of entities, or other highly homogeneous operations), the tasks of that execution block are submitted to the GPU for parallel computation. High throughput processing is achieved through CUDA or OpenCL kernel functions, and synchronization between CPU threads and the GPU is achieved through an asynchronous event mechanism. In the aforementioned embodiments, for the few rule nodes retained after pruning in step S4, they are grouped into the same topology layer and executed quickly through a thread pool. This updates the entity state, damage results, and global state of the wargame. Simultaneously, the audit log records the dynamic execution subgraph structure generated at this time step, the ID of the pruned branch and the pruning reason (e.g., "insufficient environmental weight, W_path=0.0008 is lower than the threshold θ=0.01", "mutual exclusion elimination, mutually exclusive with a certain rule and with low priority", etc.), the execution status of the black swan rule, and the time consumption statistics of each execution block. The time consumption statistics are fed back to the sliding window as feedback input for the dynamic threshold adaptive adjustment.

[0041] After completing the execution of this time step, if the simulation continues to the next time step, it is activated to avoid a full reconstruction of the dynamic execution subgraph. The incremental update unit first calculates the cosine similarity between the real-time situation feature vector F_t of the current time step and the real-time situation feature vector F_t-1 of the previous time step according to the formula similarity=(F_t·F_{t-1}) / (||F_t||×||F_{t-1}||). When the similarity is greater than or equal to the preset similarity threshold sim_threshold (default value is 0.95), it is determined that the situation change is small and the incremental update mode is activated. This threshold can be adjusted by the user according to the specific simulation scenario. For large-scale combat scenarios with drastic situation changes, it can be reduced to 0.85 to encourage the system to perform full reconstruction more frequently to ensure accuracy. For relatively stable standoff phases, it can be increased to 0.98 to maximize the reuse of historical results.

[0042] In incremental update mode, F_t is first compared element-wise with F_{t-1} to identify the changed feature subset ΔF. Then, an inverted index is built in memory to locate the corresponding set of atomic condition nodes for each changed feature in ΔF. A union operation is performed on these sets to obtain the set of atomic condition nodes Affected_CNodes affected in the current time step. Starting from this set, all reachable downstream nodes are collected by traversing forward along the dependency edges (towards the action execution node). The traversal terminates when: reaching the action execution node (because it is a leaf node with no subsequent dependency edges), or reaching a composite logic node whose inputs are all unaffected (its state will not change due to upstream changes). This forms the affected subgraph G_affected.

[0043] After identifying the affected subgraph, only the Boolean logic marking in step S103 and the probability weight calculation and pruning in step S104 are re-executed for G_affected. For the parts of the dynamically executed subgraph not covered by G_affected (i.e., unaffected regions), the node states, weight values, and topological sorting results from the previous time step are directly reused. Consistency is checked using the node version number. Each node maintains a version number from the last updated time step. During reuse, if a node's version is less than the current time step t and it is not in G_affected, its state remains valid. When finally merging the reused and refreshed parts, consistency is checked for the states of nodes at both ends of the boundary edges (i.e., the dependent edges connecting the two parts). If inconsistencies are found (e.g., a composite logic node in the reused region expects a certain atomic condition node to be a live node, but this node becomes a dead node after the refresh), the composite logic node is included in the refresh scope and recalculated.

[0044] To avoid the management overhead of incremental updates exceeding the benefits of full reconstruction, a degradation strategy is set: when the number of atomic condition nodes in the affected subgraph exceeds 50% of the total number of atomic condition nodes in the candidate subgraph, incremental updates are abandoned and the rule graph construction unit is directly triggered to perform full reconstruction from step S101 to step S105.

[0045] Please see Figure 2 The second embodiment of the present invention provides a wargaming rule execution graph pruning device based on dynamic situational awareness, comprising: The rule graph construction unit 201 is used to parse the wargame rule file, map the atomic conditions, logical operators and actions in each rule to atomic condition nodes, compound logical nodes and action execution nodes respectively, and connect the three types of nodes through dependency edges, mutual exclusion edges and priority edges to construct an initial global rule directed graph, and at the same time establish an inverted index from feature name to the atomic condition node; The situation feature vectorization unit 202 is used to collect battlefield snapshot data at each simulation time step, extract entity attributes, environmental parameters and global state and map them into real-time situation feature vectors, and locate the set of atomic condition nodes affected by the real-time situation feature vectors through the inverted index. The active node marking unit 203 is used to perform Boolean logic matching on the set of atomic condition nodes, mark them as live nodes, dead nodes or uncertain nodes, and perform Boolean logic propagation marking on the composite logic nodes from bottom to top, remove dead nodes and their associated invalid edges, and obtain candidate subgraphs. The dynamic topology pruning unit 204 is used to calculate the current environmental weight of the non-dead nodes in the candidate subgraph based on the environmental inhibition function, pass the activation probability layer by layer from the atomic condition node to the action execution node along the dependent edge, calculate the cumulative weight of each execution path, perform topology pruning on the paths with cumulative weights lower than the dynamic threshold, and perform pre-resolution of conflict nodes based on the mutual exclusion edge and the priority edge to obtain the dynamic execution subgraph. The topology sorting execution unit 205 is used to perform directed acyclic graph topology sorting and parallel execution block division on the dynamic execution subgraph, and sequentially execute the logic of the action execution nodes in each execution block and update the wargaming state.

[0046] The third embodiment of the present invention provides a wargaming rule execution graph pruning device based on dynamic situation awareness, characterized in that it includes a memory and a processor, wherein the memory stores a computer program, and the computer program can be executed by the processor to implement a wargaming rule execution graph pruning method based on dynamic situation awareness as described in any of the above embodiments.

[0047] The fourth embodiment of the present invention provides a computer-readable storage medium, characterized in that it stores a computer program, which can be executed by the processor of the device where the computer-readable storage medium is located, to implement a wargaming rule execution graph pruning method based on dynamic situational awareness as described in any of the above embodiments.

[0048] Based on the present invention, a method, apparatus, device, and storage medium for pruning wargame rule execution graphs based on dynamic situational awareness are provided. This invention parses massive rules into an initial global rule directed graph composed of three types of nodes and three types of edges, and establishes a feature-node inverted index, transforming discrete rules into pruningable topological objects. It maps real-time battlefield situations into feature vectors and locates affected atomic condition nodes through the inverted index, avoiding full graph traversal. Coarse-grained filtering is achieved through Boolean logic matching and bottom-up propagation marking. Node weights are calculated based on an environmental inhibition function, and the activation probability of the propagation path is multiplied along dependent edges to prune low-probability paths with accumulated weights below a dynamic threshold. Simultaneously, conflict resolution is performed before execution based on mutually exclusive edges and priority edges. The pruned dynamic execution subgraph is topologically sorted and executed in parallel, thereby achieving situation-aware filtering and probabilistic reasoning from global rules to the minimum effective execution subgraph within milliseconds.

[0049] Exemplary examples show that the computer program described in the third and fourth embodiments of the present invention can be divided into one or more modules, which are stored in the memory and executed by the processor to complete the present invention. The one or more modules can be a series of computer program instruction segments capable of performing specific functions, which describe the execution process of the computer program in implementing a wargaming rule execution graph pruning device based on dynamic situational awareness. For example, the apparatus described in the second embodiment of the present invention.

[0050] The processor referred to can be a Central Processing Unit (CPU), or other general-purpose processors, digital signal processors (DSPs), application-specific integrated circuits (ASICs), field-programmable gate arrays (FPGAs), or other programmable logic devices, discrete gate or transistor logic devices, discrete hardware components, etc. The general-purpose processor can be a microprocessor or any conventional processor. This processor is the control center of the aforementioned wargaming rule execution graph pruning method based on dynamic situation awareness, connecting various parts of the method through various interfaces and lines.

[0051] The memory can be used to store the computer program and / or modules. The processor, by running or executing the computer program and / or modules stored in the memory, and by calling the data stored in the memory, implements various functions of a wargaming rule execution graph pruning method based on dynamic situational awareness. The memory may mainly include a program storage area and a data storage area. The program storage area may store the operating system, at least one application program required for a function (such as sound playback function, text conversion function, etc.), etc.; the data storage area may store data created according to the use of the mobile phone (such as audio data, text message data, etc.). In addition, the memory may include high-speed random access memory, and may also include non-volatile memory, such as hard disk, memory, plug-in hard disk, smart media card (SMC), secure digital (SD) card, flash card, at least one disk storage device, flash memory device, or other volatile solid-state storage device.

[0052] If the implemented module is implemented as a software functional unit and sold or used as an independent product, it can be stored in a computer-readable storage medium. Based on this understanding, all or part of the processes in the above embodiments of the present invention can also be implemented by a computer program instructing related hardware. The computer program can be stored in a computer-readable storage medium, and when executed by a processor, it can implement the steps of the various method embodiments described above. The computer program includes computer program code, which can be in the form of source code, object code, executable files, or certain intermediate forms. The computer-readable medium can include: any entity or device capable of carrying the computer program code, recording media, USB flash drives, portable hard drives, magnetic disks, optical disks, computer memory, read-only memory (ROM), random access memory (RAM), electrical carrier signals, telecommunication signals, and software distribution media, etc. It should be noted that the content included in the computer-readable medium can be appropriately added or removed according to the requirements of legislation and patent practice in the jurisdiction. For example, in some jurisdictions, according to legislation and patent practice, computer-readable media do not include electrical carrier signals and telecommunication signals.

[0053] It should be noted that the device embodiments described above are merely illustrative. The units described as separate components may or may not be physically separate, and the components shown as units may or may not be physical units; that is, they may be located in one place or distributed across multiple network units. Some or all of the modules can be selected to achieve the purpose of this embodiment according to actual needs. Furthermore, in the accompanying drawings of the device embodiments provided by this invention, the connection relationships between modules indicate that they have communication connections, which can be specifically implemented as one or more communication buses or signal lines. Those skilled in the art can understand and implement this without any creative effort.

[0054] The above description is merely a preferred embodiment of the present invention, but the scope of protection of the present invention is not limited thereto. Any variations or substitutions that can be easily conceived by those skilled in the art within the technical scope disclosed in the present invention should be included within the scope of protection of the present invention. Therefore, the scope of protection of the present invention should be determined by the scope of the claims.

Claims

1. A dynamic situation awareness based wargame rule execution graph pruning method, characterized in that, include: The wargame rule file is parsed, and the atomic conditions, logical operators and actions in each rule are mapped to atomic condition nodes, compound logical nodes and action execution nodes respectively. The three types of nodes are connected by dependency edges, mutual exclusion edges and priority edges to construct an initial global rule directed graph. At the same time, an inverted index from feature name to the atomic condition node is established. At each simulation time step, battlefield snapshot data is collected, entity attributes, environmental parameters and global state are extracted and mapped into real-time situation feature vectors, and the set of atomic condition nodes affected by the real-time situation feature vectors is located through the inverted index. Boolean logic matching is performed on the set of atomic condition nodes to mark them as live nodes, dead nodes, or uncertain nodes. Boolean logic propagation marking is performed on the composite logic nodes from bottom to top to remove dead nodes and their associated invalid edges, thus obtaining candidate subgraphs. For non-dead nodes in the candidate subgraph, the current environment weight is calculated based on the environment inhibition function. The activation probability is passed layer by layer from the atomic condition node to the action execution node along the dependent edge. The cumulative weight of each execution path is calculated. The path with the cumulative weight lower than the dynamic threshold is subjected to topology pruning. The conflict nodes are pre-resolved based on the mutual exclusion edge and the priority edge to obtain the dynamic execution subgraph. The dynamic execution subgraph is sorted by directed acyclic graph topology and divided into parallel execution blocks. The logic of the action execution nodes in each execution block is executed sequentially and the wargaming state is updated.

2. The method of claim 1, wherein, The process of mapping the atomic conditions, logical operators, and actions in each rule to atomic condition nodes, composite logic nodes, and action execution nodes, respectively, is as follows: Each indivisible condition judgment is mapped to an atomic condition node, the attributes of which include feature name, operator, expected value, and node ID; each logical operator of type AND, OR, or NOT is mapped to a composite logical node, wherein the number of incoming edges of the composite logical node of type AND and OR is equal to the number of its operands, and the composite logical node of type NOT has only one incoming edge; each action in each rule is mapped to an action execution node, the attributes of which include action type, parameter list, and the ID of the rule to which it belongs; The dependency edges are directed solid lines, and the connection relationships include the atomic condition node pointing to its own composite logic node, the nested sub-composite logic node pointing to its parent composite logic node, and the top-level composite logic node of the rule pointing to the action execution node it triggers; the mutual exclusion edges are bidirectional dashed lines marked with mutual exclusion levels, connecting the action execution nodes of two rules belonging to the same mutual exclusion group; the priority edges are unidirectional solid lines marked with priority difference values, pointing from the action execution node of the higher priority rule to the action execution node of the lower priority rule.

3. The method of claim 1, wherein, The Boolean logic propagation marking is performed on the composite logic node from bottom to top, specifically as follows: A post-order traversal strategy is adopted, starting from the deepest nested composite logic node and propagating the state layer by layer to its parent node until the root composite logic node directly connected to the action execution node is reached. For the composite logic node of type AND, it is marked as a dead node when any child node is a dead node, as a live node when all child nodes are live nodes, and as an uncertain node when there are uncertain nodes but no dead nodes. For the composite logical node of type OR, it is marked as a dead node when all child nodes are dead nodes, as a live node when any child node is a live node, and as an uncertain node when there is an uncertain node and no live node. For the composite logic node of type NOT, it is marked as a live node when the child node is a dead node, marked as a dead node when the child node is a live node, and still marked as an indeterminate node when the child node is an indeterminate node.

4. The method of claim 1, wherein, The calculation of the current environmental weight based on the environmental inhibition function is as follows: The environmental suppression function is a mapping function that takes the current environmental situation and the target node as input and the current environmental weight as output. Its specific calculation formula is as follows: w_current=w_base×α_terrain×β_weather×γ_electronic Where w_current is the current environmental weight; w_base is the base weight; α_terrain is the terrain coefficient; β_weather is the weather coefficient; and γ_electronic is the electromagnetic environment coefficient. When the real-time situation feature vector matches the preset coupling correction rule, the coupling correction coefficient δ is introduced to correct the calculation formula of the environment suppression function as w_current=w_base×α_terrain ×β_weather×γ_electronic×δ, and the final result of the current environment weight is truncated to the interval [0, 1].

5. The method of claim 1, wherein, The activation probability is passed layer by layer along the dependency edge from the atomic condition node to the action execution node, and the cumulative weight of each execution path is calculated, specifically as follows: For the composite logic node of type AND, its cumulative path weight is equal to the product of the weights of all input sub-paths; For the composite logic node of type OR, its cumulative path weight is equal to the maximum value of the weights of all input sub-paths; For the composite logical node of type NOT, its cumulative path weight is equal to 1 minus its sub-path weight; The dynamic threshold is set according to the rule category, and the corresponding threshold multiplier is applied according to the user's preset precise mode, standard mode or fast mode; at the same time, the pruning effect of the most recent N time steps is statistically analyzed by sliding window, and the dynamic threshold is adaptively adjusted within the range of [0.5×θ_current, 2.0×θ_current], where θ_current is the current value of the dynamic threshold before the current adjustment action occurs.

6. The method of claim 1, wherein, The pre-resolution of conflict nodes based on the mutual exclusion edges and the priority edges specifically involves: When the priorities of the action execution nodes at both ends of the mutual exclusion edge are different, the high-priority node is retained and the low-priority node is pruned. When the priority of the action execution nodes at both ends of the mutual exclusion edge is the same, they are processed according to the mutual exclusion level marked on the mutual exclusion edge: when the mutual exclusion level is level 1, both are retained and a warning log is recorded; when the mutual exclusion level is level 2 or level 3, the one with the smaller rule ID is retained; when the mutual exclusion level is level 4 or level 5, both are marked as dead nodes and a system alarm is triggered. When pruning the action execution node, a shared check is performed on its preceding dependency chain: starting from the action execution node to be pruned, trace back along the dependency edge. If the outgoing edge of a node in the dependency chain only connects to the pruned node, remove it from the graph. If the outgoing edge of the node also connects to other live nodes, keep the node and only remove the dependency edge pointing to the pruned node. Recursively execute until the root atomic condition node is reached or a shared node is encountered.

7. The method of claim 1, wherein, The dynamic execution subgraph is subjected to directed acyclic graph topology sorting and parallel execution block partitioning, specifically as follows: The Kahn algorithm is used to perform topological sorting on the dynamic execution subgraph, and all nodes in the ready queue in each iteration of the algorithm are grouped into the same parallel execution block. When a parallel execution block contains only one node, it is executed serially. When the number of nodes in a parallel execution block exceeds a preset threshold, it is evenly divided into multiple sub-blocks. The initial value of the preset threshold is 4 times the number of CPU cores, and it is dynamically adjusted according to the real-time CPU utilization of the system. The thread pool scheduling mode is adopted, and the parallel execution blocks are synchronized through barriers. Subtasks within the same parallel execution block do not need to be synchronized. When the action type of the action execution node is vectorizable, the task of the parallel execution block is submitted to the GPU for parallel computing.

8. A wargaming rule execution graph pruning device based on dynamic situational awareness, characterized in that, include: The rule graph construction unit is used to parse the wargame rule file, map the atomic conditions, logical operators and actions in each rule to atomic condition nodes, compound logical nodes and action execution nodes respectively, and connect the three types of nodes through dependency edges, mutual exclusion edges and priority edges to construct an initial global rule directed graph, and at the same time establish an inverted index from feature name to the atomic condition node; The situation feature vectorization unit is used to collect battlefield snapshot data at each simulation time step, extract entity attributes, environmental parameters and global state and map them into real-time situation feature vectors, and locate the set of atomic condition nodes affected by the real-time situation feature vectors through the inverted index. The active node marking unit is used to perform Boolean logic matching on the set of atomic condition nodes, mark them as live nodes, dead nodes or uncertain nodes, and perform Boolean logic propagation marking on the composite logic nodes from bottom to top, remove dead nodes and their associated invalid edges, and obtain candidate subgraphs; The dynamic topology pruning unit is used to calculate the current environmental weight of the non-dead nodes in the candidate subgraph based on the environmental inhibition function, pass the activation probability layer by layer from the atomic condition node to the action execution node along the dependent edge, calculate the cumulative weight of each execution path, perform topology pruning on the path with the cumulative weight lower than the dynamic threshold, and perform pre-resolution of conflict nodes based on the mutual exclusion edge and the priority edge to obtain the dynamic execution subgraph. The topology sorting execution unit is used to perform directed acyclic graph topology sorting and parallel execution block division on the dynamic execution subgraph, and sequentially execute the logic of the action execution nodes in each execution block and update the wargaming state.

9. A wargaming rule execution graph pruning device based on dynamic situational awareness, characterized in that, The system includes a memory and a processor. The memory stores a computer program that can be executed by the processor to implement a wargaming rule execution graph pruning method based on dynamic situational awareness as described in any one of claims 1 to 7.

10. A computer-readable storage medium, characterized in that, The device contains a computer program that can be executed by a processor of the device where the computer-readable storage medium is located, to implement a wargaming rule execution graph pruning method based on dynamic situational awareness as described in any one of claims 1 to 7.

Images