A verification method to ensure the consistency of entity behavior in distributed virtual environment
By classifying entities in a distributed virtual environment and introducing perspective features, designing task execution and concurrent execution, combined with theorem proof tool, the problem of cumbersomeness and low automation in the existing technology of multi-entity behavior modeling and verification is solved. Improve the reliability and verification efficiency of entity behavior.
Patent Information
- Application Number
- CN202411110301.X
- Authority / Receiving Office
- CN · China
- Patent Type
- Patents(China)
- Current Assignee / Owner
- Filing Date
- 2024-08-14
- Publication Date
- 2024-11-19
- Estimated Expiration
- 2044-08-14
AI Technical Summary
The existing technology lacks task-based multi-entity behavior modeling and verification in distributed virtual environments, resulting in cumbersome manual derivation verification and low degree of automation, resulting in low reliability of multi-entity behavior.
By classifying entities into static and dynamic entities, and introducing perspective features into dynamic entities, designing single-task and multi-task concurrent execution, analyzing the access status of entity behavior to the virtual environment, dividing them into three types of execution branches, and using theorem to prove the auxiliary Tools verify entity behavior consistency.
It improves the flexibility and adaptability of the model, simplifies verification complexity, improves the pertinence and efficiency of verification, reduces the workload of manual derivation, and enhances the reliability of verification results.
Smart Images

Figure CN118644645B_ABST
Abstract
Description
Technical Field
[0001] The present application relates to the field of distributed virtual reality technology, and in particular to a verification method for ensuring the consistency of entity behavior in a distributed virtual environment. Background Art
[0002] A distributed virtual environment (DVE) is a network-based virtual environment in which multiple users in different physical environments are connected through the network and participate in a virtual reality environment at the same time, interacting with other users and sharing information. Compared with traditional concurrent systems, distributed virtual environments are similar in concurrency and real-time performance, while the unique features of distributed virtual environments are the user perspective and multi-person collaborative experience. With the continuous updating and iteration of computer hardware and software, research on distributed virtual environments has made significant progress in recent years. Driven by the concept of the metaverse, virtual reality technology has been widely used in various industries. However, there is still little research on the reliability of distributed virtual environments, and it is difficult to ensure the consistency of DVE multi-entities.
[0003] Based on description logic and tasks, the distributed virtual environment system is modeled and the system reliability is verified. The description theory and description model of the collaborative behavior of virtual group organizations are established. However, there are problems such as the modeling rules are relatively complex, the verification of the correctness of the model is done manually, and the degree of automation is not high. Based on the interactive collaborative object formalization technology to simulate the interaction in virtual reality applications, the object-oriented idea is used to describe the structure and static aspects of the DVE system, and the Petri net is used to describe the dynamic behavior of the system. Manual proof is performed through the model detection method, but there is a problem that only a single user of the virtual environment can be modeled and related properties can be verified, and the degree of verification automation is not high. Therefore, the existing technology does not have task-based multi-entity behavior modeling and verification, manual derivation and verification are cumbersome, and the degree of verification automation is not high, resulting in the problem of low reliability of multi-entity behavior in distributed virtual environments. Summary of the invention
[0004] Based on this, the present application proposes a verification method to ensure the consistency of entity behavior in a distributed virtual environment, aiming to solve the problem that the existing technology lacks task-based multi-entity behavior modeling and verification, manual derivation and verification are cumbersome and the degree of verification automation is not high, resulting in low reliability of verifying multi-entity behavior in a distributed virtual environment.
[0005] A first aspect of the present application provides a verification method for ensuring the consistency of entity behavior in a distributed virtual environment, the verification method comprising:
[0006] Modeling entities in a distributed virtual environment, classifying entities into static entities and dynamic entities, adding viewing angle features to the dynamic entities based on the static entities, and determining the authority of entity behavior according to the viewing angle features;
[0007] Modeling tasks in a distributed virtual environment, designing single-task execution and multi-task concurrent execution, wherein the multi-task concurrent execution is designed as entity collaboration behaviors between multiple single tasks, and both the single-task execution and multi-task concurrent execution processes include task selection, task activation entities and entity behaviors;
[0008] Based on the entity behavior of the task, the access status of multiple entity behaviors to the virtual environment under the task is analyzed to divide them into three types of execution branches, namely, different entity behaviors in executing a single task, the same entity behavior in executing multiple tasks, and different entity behaviors in executing multiple tasks;
[0009] Use theorem proving auxiliary tools to construct proof theorems to verify the entity behavior consistency of each type of execution branch.
[0010] Compared with the prior art, the present application provides a verification method for ensuring the consistency of entity behavior in a distributed virtual environment. The method clearly classifies entities into static entities and dynamic entities, and introduces perspective features in dynamic entities, so that the model can more accurately reflect the complexity and diversity in the real world. The introduction of perspective features allows the system to adjust the authority of entity behavior according to different observation angles, thereby enhancing the flexibility and adaptability of the model; the introduction of task modeling, especially the design of single-task execution and multi-task concurrent execution, makes the behavior in DVE no longer disordered or random, but has clear goals and constraints. This helps to more accurately simulate and predict the behavior pattern of entities under specific tasks; by analyzing the access status of multiple entity behaviors to the virtual environment under the task, and dividing them into three types of execution branches, a detailed division of complex behavior scenarios is achieved. This classification method not only simplifies the complexity of verification, but also improves the pertinence and efficiency of verification; by using theorem proof auxiliary tools to verify the consistency of entity behavior of each type of execution branch, the workload of manual derivation and verification is greatly reduced, and the degree of automation of the verification process is improved. At the same time, the theorem proof method has strict logic and accuracy, and can effectively ensure the reliability of the verification results. Therefore, this method can solve the problem that the existing technology lacks task-based multi-entity behavior modeling and verification, manual derivation and verification are cumbersome and the degree of verification automation is not high, resulting in low reliability of verifying multi-entity behavior in distributed virtual environments.
[0011] As an optional implementation manner of the first aspect, the step of modeling entities in the distributed virtual environment, classifying the entities into static entities and dynamic entities, adding a viewing angle feature to the dynamic entity on the basis of the static entity, and determining the authority of the entity behavior according to the viewing angle feature includes:
[0012] Define characteristics and behavior rules for static entities and dynamic entities respectively:
[0013] Static entities are defined as static appearance parts that constitute the virtual environment, cannot be actively moved, and can be accessed and modified by dynamic entities;
[0014] A dynamic entity is defined as a static entity with a viewing angle feature added thereto. The entity can move actively and has the authority to determine the entity behavior according to the viewing angle feature. The entity behavior has multiple execution behaviors, and the entity behavior is used to modify the entity attributes and return the modification results.
[0015] As an optional implementation of the first aspect, the implementation process of the concurrent execution of multiple tasks includes:
[0016] Implement multi-task concurrent execution by designing and modifying task list functions and multi-task concurrent functions;
[0017] The task list modification function is used to dequeue the completed tasks and mark the task that has been successfully executed at a certain moment as the next behavior of this task, so as to obtain the task list at a certain moment and the real-time status of each task;
[0018] The multi-task concurrent function is used to retrieve and execute each marked behavior in the task list, interact with the virtual environment and modify the state through entity behavior to execute the tasks in the task list that are in the execution state.
[0019] As an optional implementation manner of the first aspect, the single-task execution and multi-task concurrent execution processes both include the steps of task selection, task activation entity and entity behavior, including:
[0020] Through task selection, the user entity is designed to select the task to be performed in the task list;
[0021] Activate the entity through the task to enter the ready state according to the selected task and activate the user entity and the task body required to execute the task, the task body includes multiple different entities;
[0022] Through entity behavior, the entity part of the task body is executed, and multiple different entities that are activated collaborate to complete the target task through corresponding execution behaviors.
[0023] As an optional implementation of the first aspect, the task-based entity behavior analyzes the access status of multiple entity behaviors to the virtual environment based on the task to divide the steps into three types of execution branches, namely, executing different entity behaviors in a single task, executing the same entity behavior in multiple tasks, and executing different entity behaviors in multiple tasks, including:
[0024] When two or more different entities need to be activated to access and modify the same virtual environment simultaneously during the execution of a task, the different entity behaviors of the single task are executed;
[0025] When two or more different tasks need to activate the same entity to access and modify the same virtual environment at the same time during the execution of two or more different tasks, the same entity behavior of multiple tasks is executed;
[0026] When two or more different tasks are executed simultaneously and two or more different entities need to be activated to access and modify the same virtual environment at the same time, different entity behaviors of multiple tasks are executed.
[0027] As an optional implementation manner of the first aspect, the step of using a theorem proving auxiliary tool to construct a proof theorem to verify the entity behavior consistency of each type of execution branch includes:
[0028] Construct proof Theorem 1 to verify the consistency of different entity behaviors in executing a single task: determine multiple different entity behaviors, determine that multiple different entity behaviors are located in the same task t, and determine that the entity labels in the task body of task t are in order; when there is only task t in the execution task list, the execution of the concurrent behavior function will not obtain multiple different entity behaviors at the same time, which shows that the different entity behaviors in executing a single task are consistent;
[0029] Construct proof Theorem 2 to verify the consistency of the same entity behavior when executing multiple tasks: Determine that the entity labels of the task bodies in two or more different tasks are in order, determine that the activation and access bits of the virtual environment are in the initial state, determine that the same entity behavior and each task contain part of the execution behavior, determine that the operation object of the entity behavior is the virtual environment and the execution of the entity behavior will not change the access bit of the virtual environment; when there are two or more different tasks in the execution task list, the behavior list obtained is the same entity behavior, and when one task accesses the virtual environment, other tasks will wait for the execution operation of the virtual environment and will not modify the environment attributes, which shows that the same entity behavior when executing multiple tasks is consistent;
[0030] Construct proof Theorem 3 to verify the consistency of different entity behaviors in executing multiple tasks: determine that the entity labels of the task bodies in two or more different tasks are in order, determine that the activation and access bits of the virtual environment are in the initial state, determine two or more entity behaviors and each task contains partial execution behaviors, determine that the operation object of the entity behavior is the virtual environment and the execution of the entity behavior will not change the access bit of the virtual environment; when there are two or more different tasks in the execution task list, the obtained behavior list is two or more entity behaviors, when one task accesses the virtual environment, other tasks will wait for the execution operation on the virtual environment and will not modify the environment attributes, which indicates that the different entity behaviors in executing multiple tasks are consistent.
[0031] A second aspect of an embodiment of the present application provides a verification system for ensuring the consistency of entity behavior in a distributed virtual environment, the verification system comprising:
[0032] An entity modeling module is used to model entities in a distributed virtual environment, classify entities into static entities and dynamic entities, and add viewing angle features to the dynamic entities based on the static entities, and determine the authority of entity behavior according to the viewing angle features;
[0033] A task modeling module is used to model tasks in a distributed virtual environment, design single-task execution and multi-task concurrent execution, wherein the multi-task concurrent execution is designed as entity collaboration behavior between multiple single tasks, and both the single-task execution and multi-task concurrent execution processes include task selection, task activation entity and entity behavior;
[0034] The execution classification module is used for analyzing the access status of multiple entity behaviors to the virtual environment based on the task-based entity behaviors, so as to classify them into three types of execution branches, namely, different entity behaviors in executing a single task, the same entity behaviors in executing multiple tasks, and different entity behaviors in executing multiple tasks.
[0035] The behavior verification module is used to use theorem proving auxiliary tools to construct proof theorems to verify the entity behavior consistency of each type of execution branch.
[0036] As an optional implementation of the second aspect, the behavior verification module includes a first theorem verification unit, a second theorem verification unit, and a third theorem verification unit, wherein:
[0037] The first theorem verification unit is used to construct the proof of Theorem 1 to verify the consistency of different entity behaviors in executing a single task: determine multiple different entity behaviors, determine that multiple different entity behaviors are located in the same task t, and determine that the entity labels in the task body of task t are in order; when there is only task t in the execution task list, the execution of the concurrent behavior function will not obtain multiple different entity behaviors at the same time, indicating that the different entity behaviors in the single task are consistent;
[0038] The second theorem verification unit is used to construct the proof of Theorem 2 to verify the consistency of the same entity behavior when executing multiple tasks: determine that the entity labels of the task bodies in two or more different tasks are in order, determine that the activation and access bits of the virtual environment are in the initial state, determine that the same entity behavior and each task contain part of the execution behavior, determine that the operation object of the entity behavior is the virtual environment and the execution of the entity behavior will not change the access bit of the virtual environment; when there are two or more different tasks in the execution task list, the behavior list obtained is the same entity behavior, when one task accesses the virtual environment, other tasks will wait for the execution operation of the virtual environment and will not modify the environment attributes, which indicates that the same entity behavior when executing multiple tasks is consistent;
[0039] The third theorem verification unit is used to construct the proof of Theorem 3 to verify the consistency of different entity behaviors in executing multiple tasks: determine that the entity labels of the task bodies in two or more different tasks are in order, determine that the activation and access bits of the virtual environment are in the initial state, determine two or more entity behaviors and each task contains partial execution behaviors, determine that the operation object of the entity behavior is the virtual environment and the execution of the entity behavior will not change the access bit of the virtual environment; when there are two or more different tasks in the execution task list, the obtained behavior list is two or more entity behaviors, when one task accesses the virtual environment, other tasks will wait for the execution operation on the virtual environment and will not modify the environment attributes, which indicates that the different entity behaviors in executing multiple tasks are consistent.
[0040] A third aspect of an embodiment of the present application provides a computer device, which includes a memory, a processor, and a processing program stored in the memory and executable on the processor, wherein the processing program, when executed by the processor, implements the above-mentioned verification method for ensuring the consistency of entity behavior in a distributed virtual environment.
[0041] A fourth aspect of an embodiment of the present application provides a storage medium, on which a processing program is stored. When the processing program is executed by a processor, the above-mentioned verification method for ensuring the consistency of entity behavior in a distributed virtual environment is executed.
[0042] Additional aspects and advantages of the present application will be given in part in the following description, and in part will become apparent from the following description, or will be understood through the embodiments of the present application. BRIEF DESCRIPTION OF THE DRAWINGS
[0043] Figure 1 A flowchart of a verification method for ensuring the consistency of entity behavior in a distributed virtual environment proposed in the first embodiment of the present application;
[0044] Figure 2 A diagram of the entity collaboration process in a distributed virtual environment for task execution in the first implementation of this application;
[0045] Figure 3 This is a process diagram of different entity behaviors in executing a single task in the first implementation of the present application;
[0046] Figure 4 This is a diagram of the same entity behavior process of performing multiple tasks in the first implementation of the present application;
[0047] Figure 5 A diagram showing the behavior of different entities performing multiple tasks in the first implementation of the present application;
[0048] Figure 6 A diagram showing the relevant lemmas and their dependencies required to prove Theorem 2 in the first implementation of this application;
[0049] Figure 7 A schematic diagram of the structure of a verification system for ensuring the consistency of entity behavior in a distributed virtual environment proposed in the second embodiment of the present application.
[0050] The following specific implementation methods will further illustrate the present application in conjunction with the above-mentioned drawings. DETAILED DESCRIPTION
[0051] In order to facilitate understanding of the present application, the present application will be described more fully below with reference to the relevant drawings. Several embodiments of the present application are provided in the drawings. However, the present application can be implemented in many different forms and is not limited to the embodiments described herein. On the contrary, the purpose of providing these embodiments is to make the disclosure of the present application more thorough and comprehensive.
[0052] Unless otherwise defined, all technical and scientific terms used herein have the same meaning as those commonly understood by those skilled in the art to which this application belongs. The terms used herein in the specification of this application are only for the purpose of describing specific embodiments and are not intended to limit this application. The term "and / or" used herein includes any and all combinations of one or more of the related listed items.
[0053] In order to illustrate the technical solution described in this application, a specific embodiment is provided below for illustration.
[0054] See also Figure 1, is a flow chart of a verification method for ensuring the consistency of entity behavior in a distributed virtual environment proposed in the first embodiment of the present application, and the proposed method includes:
[0055] S01: Modeling entities in a distributed virtual environment, classifying entities into static entities and dynamic entities, adding viewing angle features to the dynamic entities based on the static entities, and determining the authority of entity behavior according to the viewing angle features.
[0056] It should be noted that entities mainly refer to virtual objects in DVE, which can be divided into two categories: dynamic entities and static entities. The two have different roles and functions in DVE. Dynamic entities are active and changeable, and can actively move and interact, while static entities are relatively fixed and stable, and are mainly used to build virtual environment scenes.
[0057] Specifically, characteristics and behavior rules are defined for static entities and dynamic entities respectively:
[0058] Static entities are defined as static appearance parts that constitute the virtual environment, cannot be actively moved, and can be accessed and modified by dynamic entities;
[0059] A dynamic entity is defined as a static entity with a viewing angle feature added thereto. The entity can move actively and has the authority to determine the entity behavior according to the viewing angle feature. The entity behavior has multiple execution behaviors, and the entity behavior is used to modify the entity attributes and return the modification results.
[0060] Exemplarily, entities, dynamic entities, static entities and entity behaviors are respectively defined functionally, and the functional definition process includes the following steps.
[0061] S011: Functional definition of entities:
[0062] datatype entity =
[0063] static static_entity |
[0064] dynamic dynamic_entity
[0065] Provide the inductive type datatype entity to define entities, and use the static and dynamic keywords to distinguish dynamic entities from static entities.
[0066] S012: Define static entities in a functional way, represented by a four-tuple:
[0067] type_synonym static_entity = "entity_name × (attr_name × attr_value)list × is_activated × is_visited"
[0068] Among them, type_synonym indicates the variable declaration keyword, static_entity is a static entity, entity_name indicates the static entity name, (attr_name, attr_value)list indicates the list of static entity attributes, attr_name is the attribute name of the entity, attr_value is the attribute value of the entity, is_acticated and is_visited respectively represent the activation bit and visit bit of the entity, the activation bit can judge the activation status of the entity, and the entity visit bit is used to understand the visit status of the entity at a certain moment.
[0069] S013: Define a dynamic entity in a functional way, represented by a two-tuple:
[0070] type_synonym viewpoint="view_type × behavior list"
[0071] type_synonym indicates a variable declaration keyword, viewpoint indicates the entity perspective, and the two elements in the view_type and behavior list tuples indicate different view types and the list of behaviors that can be performed by the view. The interaction capability and permissions of an entity are determined by the behaviors that can be performed by the view.
[0072] S014: Functional definition of entity behavior:
[0073] fun entity_behavior ::"behavior entity entity"where"
[0074] entity_behavior beh (static e) = static (beh_body beh e)"|"
[0075] entity_behavior beh (dynamic e) = dynamic (connect (beh_body beh (fst(e))) (snd(e)))"
[0076] definition beh_body ::"behavior entity_attr entity_attr "where"
[0077] beh_body beh attr = fst(snd(beh)) attr"
[0078] In the first line of functional definition, fun is the function definition keyword, entity_behavior is the function name, behavior and entity represent the function input behavior and entity respectively, and entity "where" represents the function output type.
[0079] In the second and third lines of functional definition, during the execution of the function, the input variables are behavior beh and entity e, respectively, and the entities are divided into static entities (static e) and dynamic entities (dynamic e). The connect function connects the entity attributes and viewpoints of the dynamic entity to reconstruct a dynamic entity. The input of the function entity_behavior is behavior beh and entity e. For static entities, it corresponds to the attributes of the entity itself, so the beh_body behavior function is directly executed and the entity type is returned; for dynamic entities, its entity attributes are other elements excluding the viewpoint parameters. The tuple fst and snd basic operations are used to extract the corresponding entity attributes and viewpoint elements respectively, and after executing the behavior function, the connect function is used to connect the entity attributes and viewpoint elements and return them as the entity type.
[0080] In the fourth line of functional definition, the function keyword is used to define the function. The beh_body function represents the behavior body part that executes the behavior. Its input behavior and entity_attr are behavior attributes and entity attributes respectively, and the output is the entity_attr entity attribute.
[0081] In the fifth line of functional definition, the function beh_body uses the tuple fst and snd operations to extract the behavior body beh_body in behavior, takes the entity attributes as the input of the beh_body function, executes the function and returns the entity attributes.
[0082] S02: Modeling tasks in a distributed virtual environment, designing single-task execution and multi-task concurrent execution, wherein the multi-task concurrent execution is designed as entity collaboration behavior between multiple single tasks, and both single-task execution and multi-task concurrent execution processes include task selection, task activation entity and entity behavior.
[0083] like Figure 2 As shown, it is a diagram of the entity collaboration process in a distributed virtual environment for task execution.
[0084] Specifically, through task selection, the user entity is designed to select the task to be performed in the task list;
[0085] Activate the entity through the task to enter the ready state according to the selected task and activate the user entity and the task body required to execute the task, the task body includes multiple different entities;
[0086] Through entity behavior, the entity part of the task body is executed, and multiple different entities that are activated collaborate to complete the target task through corresponding execution behaviors.
[0087] Exemplarily, the execution process of tasks, task selection, task activation entities and entity behaviors are defined respectively, and the definition process includes the following steps.
[0088] S021: Define the task in a functional way, represented by a four-tuple:
[0089] type_synonym task = "(task_name × task_state × task_body ×constraint_time)"
[0090] Among them, task_name indicates the task name, task_state indicates the task state, and constraint_time indicates the time constraint. For the task_body part, there is the following definition:
[0091] The task body stores a series of behaviors required for task execution and regulates the entire task execution process, represented by a list of two tuples. Its functional definition is as follows:
[0092] type_synonym task_body = "(entity × behavior) list"
[0093] S022: Functional definition of task selection:
[0094] fun choose_task :: " dynamic_entity task_name task list task"where"
[0095] choose_task de tn [ ] = null_task"|"
[0096] choose_task de tn (t#ts) = (if choose_cond tn t then t else choose_task de tn ts)"
[0097] As shown in the code, the choose_cond function is used to determine whether the target input by the user matches the task in the task list. When the task list is empty or all tasks in the task list do not match the task name tn input by the user, the function returns an empty task; when there is a task that meets the conditions in the task list, the function outputs the task.
[0098] S023: Define the task activation entity steps:
[0099] When user entity E1 chooses to execute a single task T1, the execution of task T1 requires the use of entity behaviors of entities E2 and E3. Step 1: After user entity E1 selects task T1, user entity E1 is activated. Step 2: Activate each entity in the task body in sequence according to the execution sequence of the behaviors according to the entity behavior list in the task body. In this embodiment, the entity activation order in the entity behavior list of the task body is E2 and E3. Step 3: When all entity behaviors in the task body are executed, reset the activation bit of user entity E1 and the task execution ends.
[0100] When the user entity chooses to execute multiple tasks, it is necessary to implement multi-task concurrent execution by designing and modifying the task list function and the multi-task concurrent function; the task list modification function is used to dequeue the completed tasks, and mark the task that has successfully executed the behavior at a certain moment to point to the next behavior of this task, so as to obtain the task list at a certain moment and the real-time status of each task; the multi-task concurrent function is used to take out each marked behavior in the task list and execute it, and interact with the virtual environment and modify the status through entity behavior to execute the tasks in the task list that are in the execution state.
[0101] S024: Functional definition of entity behavior:
[0102] function execute_multitasks ::"task list DVE DVE"where"
[0103] execute_multitasks [ ] [ ]= [ ]"|"
[0104] execute_multitasks [ ] (e#es) = (e#es)"|"
[0105] execute_multitasks (t#ts) (e#es) =
[0106] execute_multitasks (modify_tasklist (t#ts) (e#es)) (modify_DVE (t#ts)(e#es))"
[0107] apply auto by (metis list.exhaust surj_pair)
[0108] In the first line of functional definition, the function keyword is used to define the recursive function, the main function execute_multitasks is the entity name, the inputs are task list and DVE, which are the task list and virtual environment respectively, and DVE "where" means that the output DVE is the modified virtual environment.
[0109] In the second, third, and fourth lines of the function definition, when the input task list and DVE are empty, they are represented by “[ ] [ ]”, and the function returns empty, that is, [ ]; when the task list is empty, it is represented by “[ ](e#es)”, and (e#es) is returned; when both the tasklist and DVE are not empty, it is represented by “(t#ts) (e#es)”, and the function is recursively operated.
[0110] In the fifth line of functional definition, modify_tasklist indicates that the task list for each operation is updated; modify_DVE indicates that the virtual environment after each operation is updated. The modify_DVE function implements two functions: modifying the activation status of the user entity corresponding to the task that has been removed from the list; taking out and executing each marked behavior in (t#ts). The exit of this recursive function is that all tasks in (t#ts) are executed and the DVE after the interaction is returned.
[0111] In the sixth line of functional definition, the termination proof of the function uses the apply system keyword, introduces the auto rule, and automatically simplifies it. Finally, the by keyword is used to introduce the (metis list.exhaust surj_pair) statement proof. Metis is a system call list.exhaust surj_pair, which are all system built-in rules.
[0112] S03: Task-based entity behaviors analyze the access status of multiple entity behaviors to the virtual environment based on the task, and divide them into three types of execution branches, namely, different entity behaviors in executing a single task, the same entity behavior in executing multiple tasks, and different entity behaviors in executing multiple tasks.
[0113] Specifically, when two or more different entities need to be activated to access and modify the same virtual environment simultaneously during the execution of a task, different entity behaviors of a single task are executed; for example, Figure 3 As shown, it is a diagram of the behavior process of different entities in performing a single task.
[0114] When two or more different tasks need to activate the same entity to access and modify the same virtual environment at the same time during the execution of two or more different tasks, the same entity behavior of multiple tasks is executed; for example, Figure 4 The figure shows the behavior process diagram of the same entity performing multiple tasks.
[0115] When two or more different tasks are executed simultaneously and two or more different entities need to be activated to access and modify the same virtual environment at the same time, different entity behaviors of the multiple tasks are executed. Figure 5 As shown, it is a diagram of the behavior process of different entities performing multiple tasks.
[0116] S04: Use theorem proving assistance tools to construct proof theorems to verify the entity behavior consistency of each type of execution branch.
[0117] Use Isabelle / HOL theorem proving assistant tool to construct proof theorems, which can be divided into S041, S042 and S043.
[0118] S041: Construct proof of Theorem 1 to verify the consistency of different entity behaviors in executing a single task: determine multiple different entity behaviors, determine that multiple different entity behaviors are in the same task t, and determine that the entity labels in the task body of task t are in order; when there is only task t in the execution task list, the execution of the concurrent behavior function will not obtain multiple different entity behaviors at the same time, which shows that the different entity behaviors in the execution of a single task are consistent; for details, please refer to Figure 3 .
[0119] For example, the construction process of proving Theorem 1 is defined as follows:
[0120] theorem excl_Cond1:
[0121] assumes "no_eq_beh beh1 beh2"
[0122] "include_beh t beh1 ∧ include_beh t beh2"
[0123] "prop_T t"
[0124] shows"(cont_beh beh1 (get_behlist [t]) ∧ cont_beh beh2 (get_behlist[t])) = 0"
[0125] The theorem keyword is the theorem declaration keyword, excl_Cond1 is the theorem name, assumes indicates the premise assumption, and shows indicates the proof of the conclusion.
[0126] The assumptions are as follows: 1. beh1 and beh2 represent behaviors, and the no_eq_beh function indicates that beh1 and beh2 are different behaviors. 2. t represents a task, and the two include_beh functions indicate that task t contains beh1 and t contains beh2, respectively. ∧ indicates AND. 3. prop_T indicates that task t conforms to the basic properties of tasks, that is, the behavior labels in the task body are in order.
[0127] The conclusion is: get_behlist represents the behavior list obtained during task execution, cont_beh represents the judgment of whether beh1 and beh2 belong to the behavior list executed by task t, and the result of the AND of the two is 0, indicating that the results on both sides will not be simultaneous, ensuring that the behaviors of different entities in a single task are consistent.
[0128] Proof Theorem 1 shows that when there is only task t in the task list, the execution of the concurrent behavior function get_behlist will not obtain behaviors beh1 and beh2 at the same time. This result ensures that the behaviors of different entities in a single task are consistent. The prerequisites for the proof objectives are: beh1 and beh2 are different behaviors; beh1 and beh2 are in the same task t; task t satisfies that the behavior labels in its task body are in order.
[0129] S042: Construct proof of Theorem 2 to verify the consistency of the same entity behavior when executing multiple tasks: Determine that the entity labels of the task bodies in two or more different tasks are in order, determine that the activation and access bits of the virtual environment are in the initial state, determine that the same entity behavior and each task contains part of the execution behavior, determine that the operation object of the entity behavior is the virtual environment and the execution of the entity behavior will not change the access bit of the virtual environment; when there are two or more different tasks in the execution task list, the behavior list obtained is the same entity behavior, and when a task accesses the virtual environment, other tasks will wait for the execution operation of the virtual environment and will not modify the environment attributes, which indicates that the same entity behavior when executing multiple tasks is consistent; for details, please refer to Figure 4 .
[0130] For example, the construction process of proving Theorem 2 is defined as follows:
[0131] theorem excl_Cond2:
[0132] assumes "prop_T t1 ∧ prop_T t2 ∧ prop_E e"
[0133] "eq_beh beh1 beh2 ∧ no_eq_task t1 t2"
[0134] "include_beh t1 beh1 ∧ include_beh t2 beh2"
[0135] "beh_obj beh1 e ∧ beh_obj beh2 e ∧ beh_re beh1 e"
[0136] shows"get_behlist [t1,t2] = [beh1,beh2]⟹ multitasks_con [t2] [is_exet1 e]= [is_exe t1 e]"
[0137] The theorem keyword is the theorem declaration keyword, excl_Cond1 is the theorem name, assumes indicates the premise, and shows indicates the proof of the conclusion.
[0138] The assumptions are as follows: 1. t1 and t2 represent tasks, e represents entity, prop_T represents that tasks t1 and t2 satisfy the basic properties of tasks, and prop_E represents that entities satisfy the basic properties of entities; 2. beh1 and beh2 represent behaviors, t1 and t2 represent tasks, eq_beh represents that beh1 and beh2 are the same behaviors, and no_eq_task represents that tasks t1 and t2 are different; 3. include_beh represents that task t1 includes beh1, and t2 includes beh2; 4. e represents entity, beh_obj represents that the operation object of beh1 is entity e, and the operation object of beh2 is e, and the beh_re function represents the properties that e must satisfy during the execution of behavior beh1, that is, the execution of beh1 will not change the access bit of e.
[0139] The conclusion is: the get_behlist function obtains the task list behavior and obtains the behavior list, that is, after executing the function in the task list where t1 and t2 are located, the behavior list is obtained as beh1 and beh2. Is_exe indicates that task t1 is accessing entity e, and the multitask execution function multitasks_con executes t2. When operating the entity being accessed [is_exe t1 e], it waits and does not modify the entity. This ensures the consistency of the behavior of the same entity in multiple tasks.
[0140] Since the resource mutual exclusion of two and multiple tasks is the same, only the execution of two tasks is shown here.
[0141] Proof Theorem 2 shows that there are t1 and t2 in the execution task list, and the behavior list obtained at a certain moment is beh1 and beh2. When t1 is accessing the virtual environment e, task t2 will wait for the operation on e and will not modify the resource attributes. The premise of this theorem is: the behavior labels in the t1 and t2 task bodies are in order and the activation and access bits of e are in the initial state; beh1 and beh2 are the same behavior; t1 contains beh1 and t2 contains beh2; the operation objects of beh1 and beh2 are e and the execution of beh1 will not change the access bit of e.
[0142] The relevant lemmas and their dependencies required to prove Theorem 2 are as follows Figure 6 shown.
[0143] Lemma 1 (task_state_eq): The behavior acquisition get_behlist function obtains the behaviors of t1 and t2 as beh1 and beh2 respectively. The access of task t1 to the virtual environment e is equivalent to the access of behavior beh1 to e.
[0144] Lemma 2 (get_beh_uni): The behavior acquisition get_behlist function obtains the behaviors of t1 and t2 as beh1 and beh2 respectively. A single task takes out one behavior at a time, and task t1 obtains the corresponding behavior beh1, and task t2 obtains the corresponding behavior beh2.
[0145] Lemma 3 (beh_exe_excl): When the virtual environment e is being accessed by the entity behavior beh1 corresponding to task t1, the behavior list executing the virtual environment will wait and will not modify the resource attributes.
[0146] Lemma 4 (task_exe_excl): The get_behlist function obtains behaviors t1 and t2 as beh1 and beh2 respectively. The virtual environment e is accessed by the entity behavior beh1. Executing task t2 will not modify the resource attributes.
[0147] S043: Construct proof of Theorem 3 to verify the consistency of different entity behaviors in executing multiple tasks: Determine that the entity labels of the task bodies in two or more different tasks are in order, determine that the activation and access bits of the virtual environment are in the initial state, determine that two or more entity behaviors and each task contains part of the execution behavior, determine that the operation object of the entity behavior is the virtual environment and the execution of the entity behavior will not change the access bit of the virtual environment; when there are two or more different tasks in the execution task list, the obtained behavior list is two or more entity behaviors, when one task accesses the virtual environment, other tasks will wait for the execution operation of the virtual environment and will not modify the environment attributes, which indicates that the different entity behaviors in executing multiple tasks are consistent; for details, please refer to Figure 5 .
[0148] For example, the construction process of proving Theorem 3 is defined as follows:
[0149] theorem excl_Cond3:
[0150] assumes "prop_T t1 ∧ prop_T t2 ∧ prop_E e"
[0151] "no_eq_beh beh1 beh2 ∧ no_eq_task t1 t2"
[0152] "include_beh t1 beh1 ∧ include_beh t2 beh2"
[0153] "beh_obj beh1 e ∧ beh_obj beh2 e ∧ beh_re beh1 e"
[0154] shows"get_behlist [t1,t2] = [beh1,beh2]⟹ multitasks_con [t2] [is_exet1 e]= [is_exe t1 e]"
[0155] The theorem keyword is the theorem declaration keyword, excl_Cond1 is the theorem name, assumes indicates the premise, and shows indicates the proof of the conclusion.
[0156] The assumptions are as follows: 1. t1 and t2 represent tasks, e represents entity, prop_T represents that tasks t1 and t2 satisfy the basic properties of tasks, and prop_E represents that entities satisfy the basic properties of entities. 2. beh1 and beh2 represent behaviors, t1 and t2 represent tasks, no_eq_beh represents that beh1 and beh2 are different behaviors, and no_eq_task represents that tasks t1 and t2 are different. 3. include_beh represents that task t1 includes beh1, and t2 includes beh2. 4. e represents entity, beh_obj represents that the operation object of beh1 is entity e, and the operation object of beh2 is e. The beh_re function represents the properties that e must satisfy during the execution of behavior beh1, that is, the execution of beh1 will not change the access bit of e.
[0157] The conclusion is: get_behlist function gets the task list behavior and obtains the behavior list, that is, after executing this function in the task list where t1 and t2 are located, the behavior list is obtained as beh1 and beh2. Is_exe indicates that task t1 is accessing entity e, and the multitask execution function multitasks_con executes t2. When operating the entity being accessed [is_exe t1 e], it waits and does not modify the entity. This ensures the consistency of the behavior of different entities in multitasks.
[0158] The only difference between Proof Theorem 3 and Proof Theorem 2 is that beh1 and beh2 are different behaviors. The proof process is similar to Proof Theorem 2, and the proof can be completed using a similar proof method. After completing the verification of the three types of situations, the consistency of entity behavior based on the task can be guaranteed. The use of the Isabelle / HOL theorem proving tool improves the degree of automation of verification and ensures the correctness and reliability of modeling.
[0159] In summary, the present application provides a verification method for ensuring the consistency of entity behavior in a distributed virtual environment. The method clearly classifies entities into static entities and dynamic entities, and introduces perspective features in dynamic entities, so that the model can more accurately reflect the complexity and diversity in the real world. The introduction of perspective features allows the system to adjust the authority of entity behavior according to different observation angles, thereby enhancing the flexibility and adaptability of the model; the introduction of task modeling, especially the design of single-task execution and multi-task concurrent execution, makes the behavior in DVE no longer disordered or random, but has clear goals and constraints. This helps to more accurately simulate and predict the behavior pattern of entities under specific tasks; by analyzing the access status of multiple entity behaviors to the virtual environment under the task, and dividing them into three types of execution branches, a detailed division of complex behavior scenarios is achieved. This classification method not only simplifies the complexity of verification, but also improves the pertinence and efficiency of verification; by using theorem proof auxiliary tools to verify the consistency of entity behavior of each type of execution branch, the workload of manual derivation and verification is greatly reduced, and the degree of automation of the verification process is improved. At the same time, the theorem proof method has strict logic and accuracy, which can effectively ensure the reliability of the verification results. Therefore, this method can solve the problem that the existing technology lacks task-based multi-entity behavior modeling and verification, manual derivation and verification are cumbersome and the degree of verification automation is not high, resulting in low reliability of verifying multi-entity behavior in distributed virtual environments.
[0160] See also Figure 7 , which is a schematic diagram of the structure of a verification system for ensuring the consistency of entity behavior in a distributed virtual environment proposed in the second embodiment of the present application, the verification system includes:
[0161] The entity modeling module 10 is used to model entities in the distributed virtual environment, classify entities into static entities and dynamic entities, and add viewing angle features to the dynamic entities based on the static entities, and determine the authority of entity behavior according to the viewing angle features;
[0162] Specifically, the entity modeling module 10 includes a static entity modeling unit 101 and a dynamic entity modeling unit 102, wherein:
[0163] The static entity modeling unit 101 is used to define the static entity as a static appearance part constituting the virtual environment, which cannot be actively moved and can be accessed and modified by the dynamic entity;
[0164] The dynamic entity modeling unit 102 is used to define a dynamic entity as an entity that adds viewing features based on a static entity, can move actively, and has the authority to determine the entity behavior based on the viewing features. The entity behavior includes multiple execution behaviors, and the entity behavior is used to modify the entity attributes and return the modification results.
[0165] The task modeling module 20 is used to model tasks in a distributed virtual environment, design single-task execution and multi-task concurrent execution, wherein the multi-task concurrent execution is designed as entity collaboration behavior between multiple single tasks, and the single-task execution and multi-task concurrent execution processes both include task selection, task activation entity and entity behavior;
[0166] Specifically, the task modeling module 20 includes a task selection unit 201, a task activation entity unit 202 and an entity behavior unit 203, wherein:
[0167] A task selection unit 201 is used to design a user entity to select a task to be performed in a task list;
[0168] The task activation entity unit 202 is used to enter the ready state according to the selected task and activate the user entity and the task body required to execute the task, and the task body includes a plurality of different entities;
[0169] The entity behavior unit 203 is used to execute the entity part of the task body, and enables the activated multiple different entities to collaborate to complete the target task through corresponding execution behaviors.
[0170] An execution classification module 30 is used to analyze the access status of multiple entity behaviors to the virtual environment based on the entity behaviors under the task, so as to classify the execution branches into three types, namely, different entity behaviors in executing a single task, the same entity behaviors in executing multiple tasks, and different entity behaviors in executing multiple tasks;
[0171] Specifically, the execution classification module 30 includes a first execution classification unit 301, a second execution classification unit 302 and a third execution classification unit 303, wherein:
[0172] The first execution classification unit 301 is used to execute different entity behaviors of a single task when two or more different entities need to be activated to access and modify the same virtual environment at the same time during the execution of a task;
[0173] The second execution classification unit 302 is used to execute the same entity behavior of multiple tasks when two or more different tasks need to activate the same entity to access and modify the same virtual environment at the same time during the execution of the two or more different tasks;
[0174] The third execution classification unit 303 is used to execute different entity behaviors of multiple tasks when two or more different tasks need to be activated to access and modify the same virtual environment at the same time during the simultaneous execution of two or more different tasks.
[0175] The behavior verification module 40 is used to use theorem proving auxiliary tools to construct proof theorems to verify the entity behavior consistency of each type of execution branch;
[0176] Specifically, the behavior verification module 40 includes a first theorem verification unit 401, a second theorem verification unit 402 and a third theorem verification unit 403, wherein:
[0177] The first theorem verification unit 401 is used to construct a proof theorem 1 to verify the consistency of different entity behaviors in executing a single task: determine multiple different entity behaviors, determine that the multiple different entity behaviors are located in the same task t, and determine that the entity labels in the task body of task t are in order; when there is only task t in the execution task list, the execution of the concurrent behavior function will not obtain multiple different entity behaviors at the same time, indicating that the different entity behaviors in the execution of the single task are consistent;
[0178] The second theorem verification unit 402 is used to construct the proof of theorem 2 to verify the consistency of the same entity behavior of executing multiple tasks: determine that the entity labels of the task bodies in two or more different tasks are in order, determine that the activation and access bits of the virtual environment are in the initial state, determine that the same entity behavior and each task contain part of the execution behavior, determine that the operation object of the entity behavior is the virtual environment and the execution of the entity behavior will not change the access bit of the virtual environment; when there are two or more different tasks in the execution task list, the behavior list obtained is the same entity behavior, when a task accesses the virtual environment, other tasks will wait for the execution operation of the virtual environment and will not modify the environment attributes, which indicates that the same entity behavior of executing multiple tasks is consistent;
[0179] The third theorem verification unit 403 is used to construct the proof of Theorem 3 to verify the consistency of different entity behaviors in executing multiple tasks: determine that the entity labels of the task bodies in two or more different tasks are in order, determine that the activation and access bits of the virtual environment are in the initial state, determine two or more entity behaviors and each task contains partial execution behaviors, determine that the operation object of the entity behavior is the virtual environment and the execution of the entity behavior will not change the access bit of the virtual environment; when there are two or more different tasks in the execution task list, the obtained behavior list is two or more entity behaviors, when one task accesses the virtual environment, other tasks will wait for the execution operation on the virtual environment and will not modify the environment attributes, which indicates that the different entity behaviors in executing multiple tasks are consistent.
[0180] On the other hand, the present application also proposes a computer device, which includes a memory, a processor, and a processing program stored in the memory and executable on the processor. When the processing program is executed by the processor, the above-mentioned verification method for ensuring the consistency of entity behavior in a distributed virtual environment is implemented.
[0181] On the other hand, the present application further proposes a storage medium on which a processing program is stored. When the processing program is executed by a processor, the above-mentioned verification method for ensuring the consistency of entity behavior in a distributed virtual environment is executed.
[0182] In the description of this specification, the description with reference to the terms "one embodiment", "some embodiments", "example", "specific example", or "some examples" means that the specific features, structures, materials or characteristics described in conjunction with the embodiment or example are included in at least one embodiment or example of the present application. In this specification, the schematic representation of the above terms does not necessarily refer to the same embodiment or example. Moreover, the specific features, structures, materials or characteristics described may be combined in any one or more embodiments or examples in a suitable manner.
[0183] The above-mentioned embodiments only express several implementation methods of the present application, and the descriptions thereof are relatively specific and detailed, but they cannot be understood as limiting the scope of the present application. It should be pointed out that, for a person of ordinary skill in the art, several variations and improvements can be made without departing from the concept of the present application, and these all belong to the protection scope of the present application. Therefore, the protection scope of the present application shall be subject to the attached claims.
Claims
1. A verification method for ensuring the consistency of entity behavior in a distributed virtual environment, characterized in that: The verification method comprises: Modeling entities in a distributed virtual environment, classifying entities into static entities and dynamic entities, adding viewing angle features to the dynamic entities based on the static entities, and determining the authority of entity behavior according to the viewing angle features; Modeling tasks in a distributed virtual environment, designing single-task execution and multi-task concurrent execution, wherein the multi-task concurrent execution is designed as entity collaboration behaviors between multiple single tasks, and both the single-task execution and multi-task concurrent execution processes include task selection, task activation entities and entity behaviors; Based on the entity behavior of the task, the access status of multiple entity behaviors to the virtual environment under the task is analyzed to divide them into three types of execution branches, namely, different entity behaviors in executing a single task, the same entity behavior in executing multiple tasks, and different entity behaviors in executing multiple tasks; Use theorem proving tools to construct proof theorems to verify the entity behavior consistency of each type of execution branch, including: Construct proof Theorem 1 to verify the consistency of different entity behaviors in executing a single task: determine multiple different entity behaviors, determine that multiple different entity behaviors are located in the same task t, and determine that the entity labels in the task body of task t are in order; when there is only task t in the execution task list, the execution of the concurrent behavior function will not obtain multiple different entity behaviors at the same time, which shows that the different entity behaviors in executing a single task are consistent; Construct proof Theorem 2 to verify the consistency of the same entity behavior when executing multiple tasks: Determine that the entity labels of the task bodies in two or more different tasks are in order, determine that the activation and access bits of the virtual environment are in the initial state, determine that the same entity behavior and each task contain part of the execution behavior, determine that the operation object of the entity behavior is the virtual environment and the execution of the entity behavior will not change the access bit of the virtual environment; when there are two or more different tasks in the execution task list, the behavior list obtained is the same entity behavior, and when one task accesses the virtual environment, other tasks will wait for the execution operation of the virtual environment and will not modify the environment attributes, which shows that the same entity behavior when executing multiple tasks is consistent; Construct proof Theorem 3 to verify the consistency of different entity behaviors in executing multiple tasks: determine that the entity labels of the task bodies in two or more different tasks are in order, determine that the activation and access bits of the virtual environment are in the initial state, determine two or more entity behaviors and each task contains partial execution behaviors, determine that the operation object of the entity behavior is the virtual environment and the execution of the entity behavior will not change the access bit of the virtual environment; when there are two or more different tasks in the execution task list, the obtained behavior list is two or more entity behaviors, when one task accesses the virtual environment, other tasks will wait for the execution operation on the virtual environment and will not modify the environment attributes, which indicates that the different entity behaviors in executing multiple tasks are consistent.
2. A verification method for ensuring the consistency of entity behavior in a distributed virtual environment according to claim 1, characterized in that: The steps of modeling entities in the distributed virtual environment, classifying the entities into static entities and dynamic entities, adding viewing angle features to the dynamic entities based on the static entities, and determining the authority of entity behavior according to the viewing angle features include: Define characteristics and behavior rules for static entities and dynamic entities respectively: Static entities are defined as static appearance parts that constitute the virtual environment, cannot be actively moved, and can be accessed and modified by dynamic entities; A dynamic entity is defined as a static entity with a viewing angle feature added thereto. The entity can move actively and has the authority to determine the entity behavior according to the viewing angle feature. The entity behavior has multiple execution behaviors, and the entity behavior is used to modify the entity attributes and return the modification results.
3. A verification method for ensuring the consistency of entity behavior in a distributed virtual environment according to claim 2, characterized in that: The implementation process of the multi-task concurrent execution includes: Implement multi-task concurrent execution by designing and modifying task list functions and multi-task concurrent functions; The task list modification function is used to dequeue the completed tasks and mark the task that has been successfully executed at a certain moment as the next behavior of this task, so as to obtain the task list at a certain moment and the real-time status of each task; The multi-task concurrent function is used to retrieve and execute each marked behavior in the task list, interact with the virtual environment and modify the state through entity behavior to execute the tasks in the task list that are in the execution state.
4. A verification method for ensuring the consistency of entity behavior in a distributed virtual environment according to claim 3, characterized in that: The single-task execution and multi-task concurrent execution processes both include the steps of task selection, task activation entity and entity behavior, including: Through task selection, the user entity is designed to select the task to be performed in the task list; Activate the entity through the task to enter the ready state according to the selected task and activate the user entity and the task body required to execute the task, the task body includes multiple different entities; Through entity behavior, the entity part of the task body is executed, and multiple different entities that are activated collaborate to complete the target task through corresponding execution behaviors.
5. A verification method for ensuring the consistency of entity behavior in a distributed virtual environment according to claim 4, characterized in that: The task-based entity behavior analyzes the access status of multiple entity behaviors to the virtual environment based on the task to divide the execution branches into three types, namely, executing different entity behaviors in a single task, executing the same entity behavior in multiple tasks, and executing different entity behaviors in multiple tasks. The steps include: When two or more different entities need to be activated to access and modify the same virtual environment simultaneously during the execution of a task, the different entity behaviors of the single task are executed; When two or more different tasks need to activate the same entity to access and modify the same virtual environment at the same time during the execution of two or more different tasks, the same entity behavior of multiple tasks is executed; When two or more different tasks are executed simultaneously and two or more different entities need to be activated to access and modify the same virtual environment at the same time, different entity behaviors of multiple tasks are executed.
6. A verification system for ensuring the consistency of entity behavior in a distributed virtual environment, characterized in that: The verification system comprises: An entity modeling module is used to model entities in a distributed virtual environment, classify entities into static entities and dynamic entities, and add viewing angle features to the dynamic entities based on the static entities, and determine the authority of entity behavior according to the viewing angle features; A task modeling module is used to model tasks in a distributed virtual environment, design single-task execution and multi-task concurrent execution, wherein the multi-task concurrent execution is designed as entity collaboration behavior between multiple single tasks, and both the single-task execution and multi-task concurrent execution processes include task selection, task activation entity and entity behavior; The execution classification module is used for task-based entity behaviors. It analyzes the access status of multiple entity behaviors to the virtual environment based on the task, and divides them into three types of execution branches, namely, different entity behaviors in executing a single task, the same entity behaviors in executing multiple tasks, and different entity behaviors in executing multiple tasks. The behavior verification module is used to use theorem proving tools to build proof theorems to verify the entity behavior consistency of each type of execution branch, including: Construct proof Theorem 1 to verify the consistency of different entity behaviors in executing a single task: determine multiple different entity behaviors, determine that multiple different entity behaviors are located in the same task t, and determine that the entity labels in the task body of task t are in order; when there is only task t in the execution task list, the execution of the concurrent behavior function will not obtain multiple different entity behaviors at the same time, which shows that the different entity behaviors in executing a single task are consistent; Construct proof Theorem 2 to verify the consistency of the same entity behavior when executing multiple tasks: Determine that the entity labels of the task bodies in two or more different tasks are in order, determine that the activation and access bits of the virtual environment are in the initial state, determine that the same entity behavior and each task contain part of the execution behavior, determine that the operation object of the entity behavior is the virtual environment and the execution of the entity behavior will not change the access bit of the virtual environment; when there are two or more different tasks in the execution task list, the behavior list obtained is the same entity behavior, and when one task accesses the virtual environment, other tasks will wait for the execution operation of the virtual environment and will not modify the environment attributes, which shows that the same entity behavior when executing multiple tasks is consistent; Construct proof Theorem 3 to verify the consistency of different entity behaviors in executing multiple tasks: determine that the entity labels of the task bodies in two or more different tasks are in order, determine that the activation and access bits of the virtual environment are in the initial state, determine two or more entity behaviors and each task contains partial execution behaviors, determine that the operation object of the entity behavior is the virtual environment and the execution of the entity behavior will not change the access bit of the virtual environment; when there are two or more different tasks in the execution task list, the obtained behavior list is two or more entity behaviors, when one task accesses the virtual environment, other tasks will wait for the execution operation on the virtual environment and will not modify the environment attributes, which indicates that the different entity behaviors in executing multiple tasks are consistent.
7. A computer device, characterized in that: The computer device includes a memory, a processor, and a processing program stored in the memory and executable on the processor. When the processing program is executed by the processor, a verification method for ensuring the consistency of entity behavior in a distributed virtual environment is implemented as described in any one of claims 1 to 5.
8. A storage medium, characterized in that: The storage medium stores a processing program, and when the processing program is executed by the processor, the verification method for ensuring the consistency of entity behavior in a distributed virtual environment as claimed in any one of claims 1 to 5 is implemented.
