A tree structure-based method for determining muller automaton

Abstract

The application provides a Muller automaton determination method based on a tree structure, which comprises the following steps: constructing an initial state tree as an initial state of a deterministic automaton; reading a letter from a predefined alphabet and assigning the letter to the initial state tree to change the structure of the initial state tree, thereby regenerating a state tree, which is a new state of the deterministic automaton, to expand a state set, and recording migration information of the state tree during the transition; extracting the state tree from the state set, reading the letter from the alphabet, regenerating the state tree, and updating the state set; repeating the process until no new state tree is generated to obtain a final state set and a migration set; distributing the migration in the migration set to a corresponding set pair of a node pair in the final state set, thereby defining a receiving condition of the deterministic automaton; and constructing a final deterministic automaton by combining a state migration system and the receiving condition. The application can reduce the state complexity, improve the calculation efficiency, simplify the implementation process, and improve the engineering feasibility.

Description

TECHNICAL FIELD

[0001] The application belongs to the technical field of verification based on automata, and particularly relates to a Muller automaton determination method based on a tree structure. BACKGROUND

[0002] Software system is an important enabling component of social development, and its quality is particularly crucial in safety-related fields such as aerospace, national defense and transportation. Software defects have caused many catastrophic accidents, so it is crucial to ensure the credibility of software systems.

[0003] Formal methods are one of the important and effective ways to ensure software credibility, aiming to use strict mathematical analysis to describe and verify software systems. For the description and verification of non-terminating systems and omega regular timed specifications, omega automata (finite state automata that accept infinite words) play an important role, and their determination is one of the basic problems. The verification method based on automata regards the problem of the system and its specification as a language problem, and simplifies it to the problem of determining the emptiness of automata. The determination of omega automata helps to solve the complement problem, which is an essential operation in the process of specification verification. For Büchi automata, although the complement method without determination is superior to the complement method based on determination in terms of theoretical complexity, experimental results show that the complement method based on determination has better results in practice. The optimal complement method proposed later still converts the Büchi automaton to be complemented into a deterministic automaton. In addition, in the verification method based on logic, the determinacy and complexity of logic are the fundamental problems. The determinacy directly affects the development of the logic in the field of software credibility verification, and the complexity of the determination process directly affects the verification efficiency. The original intention of omega automata is to solve some basic decision problems in logic. The determination of omega automata is the basis for the determination process of logics such as SnS, CTL * , △-PDL, u and other logics. Safra reduced the complexity of some logic determination processes by creatively optimizing the determination algorithm. Therefore, exploring a better ω automata determination algorithm to reduce complexity can effectively improve the efficiency of software system credibility verification, which has great practical significance and theoretical value.

[0004] An ω automaton is also a state set Q , an initial state set Q 0, an alphabet Σ, and a transition function δ: Q ×Σ→2 Q (reading a letter in the current state through the transition function can reach another state, and the process of reading a letter in a state to reach another state is called a transition, and △ represents the set of all transitions, i.e. △={( q ,σ, q ′)∈Q x Sigma x Q | q epsilon delta q , sigma) and receiving condition lambda constitute a five-tuple, and unique receiving condition gives its receiving infinite word ability. Receiving condition lambda is a set, and its elements are state / transition, or state / transition set, or state / transition set pair, collectively referred to as index, and according to lambda, the omega automaton can be specifically divided into Büchi, Streett, Rabin, parity, Muller automaton, etc. If the initial state set is a single element, and at most one state is reached by reading any letter from any state, then the omega automaton is deterministic; otherwise, it is non-deterministic. The research on the determinization of omega automaton has lasted for decades, and the complexity problem of Büchi, Streett, Rabin, parity automaton determinization has been solved, that is, their determinization algorithms have reached optimal or asymptotically optimal, and the complexity problem of Muller automaton determinization still needs to be solved.

[0005] For a non-deterministic Muller automaton (Nondeterministic Muller Automaton, referred to as NMA) with n states and k indexes, the current determinization method is to convert it into a non-deterministic Büchi automaton (Nondeterministic Büchi Automaton, referred to as NBA) with O ( n 2 k ) states, and then the NBA is determined to obtain a deterministic Rabin automaton (Deterministic Rabin Automaton, referred to as DRA) with a state complexity of . The lower bound of the state complexity of the current NMA determinization is still , and there is a huge gap between the upper and lower bounds, and the NMA determinization algorithm still has a lot of room for improvement. SUMMARY

[0006] In order to solve the above problems existing in the prior art, the present application provides a Muller automaton determinization method based on tree structure. The technical problems to be solved by the present application are solved by the following technical solutions:

[0007] A Muller automaton determinization method based on tree structure comprises:

[0008] S100, constructing an initial state tree as the initial state of a deterministic automaton;

[0009] S200, reading a letter from the predefined alphabet and assigning it to the initial state tree, thereby changing the structure of the initial state tree to regenerate the state tree; in the current cycle conversion process, a new letter is read from the alphabet and assigned to the state tree in the state set to change its structure to regenerate the state tree, and the migration information of the state tree in the current cycle conversion process is recorded;

[0010] S300, putting the regenerated state tree in the current cycle conversion process into the current state set to form a new state set, and repeating the process of S200 until no new state tree is generated to obtain the final state set and the migration set of the deterministic automaton;

[0011] S400, distributing the migration in the migration set to the corresponding set pair of the node pair in the final state set, thereby defining the receiving condition of the deterministic automaton to obtain the deterministic receiver.

[0012] Advantages:

[0013] 1. The present application directly determines the automaton, reduces the intermediate steps: the determination of the existing Muller automaton usually needs to be converted into other intermediate forms (Buchi automaton) first, and then the determination of the data structure of the Buchi automaton is realized. The new data structure one-index Muller Safra tree proposed in the present application directly supports the deterministic conversion of Muller automaton, without relying on the transition of intermediate automaton type, and compresses the multi-step process (non-deterministic Muller automaton → non-deterministic Buchi automaton → deterministic Rabin automaton”) into a single-step operation, which significantly simplifies the process and reduces the complexity of algorithm design and implementation.

[0014] 2. The present application optimizes the state complexity and improves the calculation efficiency: the state complexity of the existing Muller automaton determination method with Buchi automaton as the intermediate transition is , the method provided by the present application avoids the additional state complexity brought by the conversion into Buchi automaton, and optimizes the state complexity of the Muller automaton determination to . In addition, the independence of the tree structure supports parallel processing (different letters read into the same tree structure can be distributed for operation), which is suitable for GPU or distributed system acceleration, and significantly improves the calculation efficiency.

[0015] 3. The present application simplifies the implementation process and improves the engineering feasibility: the present application compresses the multi-step process of Muller automata determination (non-deterministic Muller automata→ non-deterministic Büchi automata→ deterministic Rabin automata”) into a single-step operation, and the explicit structured tree design makes the algorithm logic more intuitive, easy to code and optimize, significantly simplifies the algorithm design process and implementation complexity, reduces the technical threshold of engineering landing, and facilitates debugging and verification of correctness.

[0016] 4. The present application expands the potential applications: it provides more efficient underlying support for the application of infinite word automata in reactive system verification, hardware and software model checking and other fields, especially suitable for scenarios sensitive to state complexity.

[0017] The present application will be further described in detail below in combination with the drawings and examples. BRIEF DESCRIPTION OF DRAWINGS

[0018] Figure 1 is a flowchart of a tree structure-based Muller automata determination method provided by the present application;

[0019] Figure 2 is a schematic diagram of a one-index Muller Safra tree provided by the present application;

[0020] Figure 3 is a schematic diagram of an initial one-index Muller Safra tree provided by the present application;

[0021] Figure 4 is a schematic diagram of a related fragment of a one-index NMA provided by the present application;

[0022] Figure 5 is a schematic diagram of a state tree obtained by updating state labels provided by the present application;

[0023] Figure 6 is a schematic diagram of a state tree obtained by generating sibling nodes provided by the present application;

[0024] Figure 7 is a schematic diagram of a state tree of horizontal merging sibling nodes provided by the present application;

[0025] Figure 8 is a schematic diagram of a state tree of vertical merging sibling nodes provided by the present application;

[0026] Figure 9 is a schematic diagram of a state tree of renaming nodes provided by the present application;

[0027] Figure 10 is a schematic diagram of a state tree of generating child nodes provided by the present application. DETAILED DESCRIPTION

[0028] The application will be described in further detail below with reference to specific embodiments, but the embodiments of the application are not limited thereto.

[0029] The application provides a complete one-index Muller Safra tree-based one-index NMA determinization method. First, an initial state of a deterministic automaton is constructed, i.e., an initial one-index Muller Safra tree. Then, starting from the initial tree, letters in an alphabet are read in turn. After each letter is read, the tree structure is converted, and a new one-index Muller Safra tree obtained is a new state. During this process, some node information in the tree needs to be recorded. The process is repeated until no new tree is generated. All one-index Muller Safra trees constitute a state set, and the conversion relationship between the trees is a transition. Finally, a receiving condition of the automaton is defined according to the node information in the transition. Thus, the required deterministic automaton can be obtained. The process includes three modules: initial state construction of the deterministic automaton, transition system construction, and receiving condition construction. Given a one-index NMA M1=(Σ, Q, Q0, δ, {λ'}) where |Q|=n and λ'={q1, q2,..., qk'}∈Q, details of the scheme of the application are described below.

[0030] As shown in Figure 1 The application provides a Muller automaton determinization method based on a tree structure, which includes the following steps.

[0031] S100, an initial state tree is constructed as an initial state of a deterministic automaton;

[0032] Two kinds of accepting conditions Muller and Rabin involved in the present application are defined as follows: when the index of an accepting condition is related to a state, the accepting condition is called state-based; when the index of an accepting condition is related to a transition, the accepting condition is called transition-based. For a state-based accepting condition, a run ρ of the ω automaton on an infinite word α is an infinite sequence of states ρ: N→Q, such that ρ(0)∈Q0, and for all i∈N, ρ(i+1)∈δ(ρ(i), α(i)), where α(i) denotes the i-th letter of α. Let inf(ρ) denote the set of states that occur infinitely often in ρ. For a transition-based accepting condition, a run ρ of the ω automaton on an infinite word α is an infinite sequence of transitions ρ: N→△, such that ρ(0)=(q0, α(0), q1)∈△, where q0∈Q0, and for all i∈N, ρ(i)=(qi, α(i), qi+1)∈△. Let inf(ρ) denote the set of states / transitions that occur infinitely often in ρ. It should be noted that the accepting condition of the determinized object NMA of the present application is state-based, while the accepting condition of the determinized DRA is transition-based, which will be introduced as follows.

[0033] The Muller accepting condition is λ={λ1, λ2, …, λ k}, where λ i ∈ Q (1≤ i ≤ k ), and a run ρ is acceptable if and only if there exists 1≤ i ≤ k such that inf(ρ)=λ i , i.e., the set of states that occur infinitely often in the run ρ is exactly equal to an element in λ.

[0034] The Rabin accepting condition is λ={< A 1, R 1>,< A 2, R 2>,…,< A k , R k}, where A i , R i ∈△(1≤ i ≤ k ), and a run ρ is acceptable if and only if there exists 1≤ i ≤ k such that inf(ρ)∩ A i ≠ , and inf(ρ)∩ Ri = .

[0035] The present application takes one-index NMA (one-index NMA for short) as a starting point, i.e. the receiving condition λ of NMA is {λ'}, and provides a data structure one-index Muller Safra tree which can be directly applied to determination of the one-index NMA, and a one-index NMA determination algorithm based on the one-index Muller Safra tree.

[0036] For a one-index NMA M1=(Σ, Q , Q 0, δ, λ), wherein λ={λ'}, λ'={λ1, λ2, …, λn}, and λ1<λ2<…<λn. q 1, q 2, …, q k′}∈ Q A one-index Muller Safra tree of M1 is a seven-tuple <V, τr, p, l, j, stor, Mj>, wherein V is a set of all nodes, τr is a root node, p is a parent node function, l : V → 2Qis a state label function that labels each node with a subset of a state set Q; the state label of each node is nonempty except for the root node; the state label of each nonleaf node is the union of the state labels of all its children; the state labels of any two sibling nodes are disjoint; j: V→{0, 1, …, k'+1} is a key value label function that labels each node with an integer from 0 to k'+1; the root node is labeled 0 and the children of the root node are labeled k'+1; each leaf node is labeled with an integer from 1 to k' and in all leaf nodes, sibling nodes are labeled with different integers; other nodes are labeled 0; each nonroot node labeled k'+1 or 0 has at least one child that is a leaf node; stor represents a parameter used to define the order of the structure between sibling nodes, for any two sibling nodes τ and τ', τ' is on the right of τ if and only if j(τ) > j(τ'), or j(τ) = j(τ') and τ is generated before τ'; Mj is a node naming rule that assigns a unique name to each node according to the key value label. The naming is performed recursively layer by layer from the root node, and the name of each node is the concatenation of the key value labels of all its ancestor nodes. In order to distinguish the names of sibling nodes with the same key value label, a superscript is added to the key value label as an identifier. The naming rule is as follows: for the root node τr, Mj(τr) = 0; for any other node τ, if j(τ)≠0 and j(τ)≠k'+1, then Mj(τ) = Mj(p(τ)).j(τ), otherwise, Mj(τ) = Mj(p(τ).j(τ) i+1 where i = |{τ' | τ' is a left sibling node of τ and j(τ') = j(τ)}|. That is, the number of nodes with the same key value label as τ among the left sibling nodes of τ is denoted as i. The "." in Mj(p(τ)).j(τ) and Mj(p(τ).j(τ) indicates concatenation.

[0037] Reference Figure 2 As shown in FIG. 1, given a one-index NMA with 6 states {a, b, c, d, e, f} and |λ'| = 4, Figure 2 shows one of its one-index Muller Safra trees, which contains 10 nodes. The state set in each node is its state label, and the key value label and name of each node are represented by blue and red fonts, respectively.

[0038] The initial state is constructed, that is, the initial one-index Muller Safra tree M is constructed. M is a single-branch labeled tree containing only three nodes τr, τ1 and τ2, wherein τr is the root node of M, τ1 is the child node of τr, and τ2 is the child node of τ1. The state labels of the three nodes are all Q0, that is, l(τr)=l(τ1)=l(τ2)=Q0. For the key value labels of the nodes, j(τr)=0, j(τ1)=k'+1, and j(τ2)=k'. Finally, the names of the three nodes are Mj(τr)=0, Mj(τ1)=0.(k'+1)1, and Mj(τ2)=0.(k'+1)1.k', respectively.

[0039] It is considered that Figure 2 For the corresponding one-index NMA, if the initial state set Q0={a, c}, the corresponding initial one-index Muller Safra tree is as shown in Figure 3 For the node with the name 0.51, it is responsible for detecting whether each run in its state label passes through all the states in λ'. The specific detection process is performed by its child nodes. The detection of the states in λ' is performed in reverse order, so that the node with the name 0.51.4 is used to detect whether there is a run passing through the last state in λ'. The index of the detected state in λ' is mapped by the key value label of the corresponding node. In addition, the node with the name 0.51 is also used to detect whether there is a run passing through Q\λ'. If there is such a run, the run is migrated to a newly generated sibling node.

[0040] The present application proposes an innovative tree data structure, that is, a one-index Muller Safra tree, which accurately records the states reached by a Muller automaton when reading in letters and whether the receiving condition is met by setting state labels, key value labels and unique names for the nodes in the tree. It is the first tree representation method capable of efficiently processing Muller automaton determination, which significantly reduces the computational complexity compared with the traditional method requiring intermediate conversion.

[0041] S200, reading a letter from a predefined alphabet and assigning it to the initial state tree, thereby changing the structure of the initial state tree to regenerate the state tree; in the current loop conversion process, a new letter is read from the alphabet and assigned to the state tree in the state set to change the structure of the state tree to regenerate the state tree, and the migration information of the state tree in the current loop conversion process is recorded;

[0042] From the initial one-index Muller Safra tree, read in the alphabet in alphabet Σ one by one, each read-in alphabet is a transformation of the tree structure, and the process is repeated until no new tree is generated. After the transformation process, each one-index Muller Safra tree exists as a state of a deterministic automaton, and all different one-index Muller Safra trees generated constitute the state set of the deterministic automaton, and the elements of the transition set correspond to the transformation between trees, thus obtaining the transition system of the deterministic automaton. In this process, the most important thing is the transformation algorithm of the one-index Muller Safra tree, that is, when a one-index Muller Safra tree M How to get the successor one-index Muller Safra tree when reading in an alphabet σ M The transformation algorithm contains six steps, and each step is illustrated by an example, and the one-index Muller Safra tree in Figure 2 is transformed into M1 , and all transitions of the corresponding one-index NMA with respect to the alphabet σ are as shown in Figure 4 , and the only index λ'={a, c, e, f} in the acceptance condition of the one-index NMA.

[0043] In the present application, the nodes are marked with state tags, key value tags and names; the state tags and the key value tags constrain the nodes; and the node names are determined by the key value tags.

[0044] S300, the state tree regenerated in the current cycle transformation process is put into the current state set to form a new state set, and the process of S200 is repeated until no new state tree is generated to obtain the final state set and the transition set of the deterministic automaton;

[0045] The present application gives a one-index Muller Safra tree and an alphabet, and the transformation algorithm outputs another one-index Muller Safra tree, which contains six steps: updating the state tag, generating the sibling node, horizontally merging the sibling nodes, vertically merging the sibling nodes, updating the node name, and generating the child node. The parallel construction method of the tree structure of the present application can process different one-index Muller Safra trees in parallel when reading in different alphabets, and different one-index Muller Safra trees are obtained at the same time.

[0046] S400, the transitions in the transition set are distributed to the corresponding set pairs of the nodes in the final state set, so as to define the acceptance condition of the deterministic automaton to obtain the deterministic receiver.

[0047] In one specific embodiment of the present application, S200 comprises:

[0048] S210, reading out a letter from a predefined alphabet and assigning it to the initial state tree to make it change its structure and state according to the letter and thus regenerate a state tree M;

[0049] S220, traversing the nodes in the state tree M in the current cycle of conversion, using the tree structure conversion algorithm to sequentially perform the processes of updating state labels, generating sibling nodes, horizontally merging sibling nodes, vertically merging non-leaf nodes, renaming nodes, and generating child nodes for leaf nodes to obtain a state tree M';

[0050] The present application updates the state label as follows: for any node τ in M, update its state label to ⋃q∈l(τ)δ(q,σ), and the resulting state tree is called M1. For the example, Figure 5 The state tree M1 obtained by updating the state label of M is shown, compared with Figure 2 Compared with Figure 5 In the above, the state labels of all nodes are updated.

[0051] S230, recording the migration information of the state tree M1 to the state tree M'.

[0052] Based on the above tree structure and conversion algorithm, the present application proposes a complete single-index Muller automaton determination method. The method includes three key steps: mapping the initial state set of the automaton into an initial tree that meets the specifications; generating the state set and transition relationship of the deterministic automaton through alphabet-driven iterative conversion; and assigning an index according to the label of the transition. This method first realizes the direct determination of single-index Muller automata.

[0053] To handle more general Muller automata, the present application further proposes a general determination scheme. The scheme first splits the original automaton into multiple single-index automata according to the number of indexes in the acceptance condition, then applies the aforementioned determination method to each single-index automaton, and finally merges the results through a union operation. This three-stage method of "split-determination-union" breaks through the dependence on intermediate automata of traditional methods.

[0054] In terms of optimization techniques, the present application proposes a parallel construction method of tree structure. By simultaneously processing different letters into one one-index Muller Safra tree in parallel, multiple conversion results can be efficiently generated. This parallelization strategy can significantly improve the construction speed of the automaton state space and improve the computing efficiency.

[0055] In one specific embodiment of the present application, the process of generating sibling nodes in S220 includes:

[0056] S221a, traversing nodes τ1, τ2, …, τm in state tree M1 in hierarchical order;

[0057] S222a, for each node τi traversed, if the node has j(τi)=k'+1 and l(τi)∩Q\λ'≠ , then node p(τi) generates a new youngest child node τ' with state label l(τ')=l(τi)∩Q\λ' and key value label j(τ')=j(τi), and deletes all states belonging to l(τi)∩Q\λ' from the state labels of node τi and all its descendant nodes; where the symbol \ represents set subtraction, i.e., one set minus another set;

[0058] S223a, for each node τi traversed, if the node has 1≤j(τi)≤k' and qj(τi)∈l(τi), then node p(τi) generates a new youngest child node τ' with state label l(τ')={qj(τi)} and key value label j(τ')=max(0,j(τi)-1), and deletes state qj(τi) from the state labels of node τi and all its descendant nodes;

[0059] S224a, merging sibling nodes with the same key value label and in the range of 1 to k' in leaf nodes to obtain state tree M2.

[0060] It should be noted that the names of newly generated nodes are not defined at this time. Then, sibling nodes with the same key value label and in the range of 1 to k' are merged in leaf nodes. For each newly generated node τ, if 1≤j(τ)≤k' and there is a named sibling node τ' with the same key value label, then all states in l(τ) are added to l(τ'), and node τ is deleted. Further, starting from the root node, sibling nodes are rearranged according to the structural order layer by layer, i.e., sibling nodes are arranged in the order of their key value labels from large to small, where nodes with the same key value label maintain their relative positions. After S223a, the tree is called M2. Figure 6 An example obtained tree M2 is shown, where no named node is newly generated, and it can be seen that each key value label in the leaf nodes in the range of 1 to k' has no sibling node with the same key value label, and all nodes have followed the structural order.

[0061] A six-step conversion algorithm is developed for the data structure of one-index Muller Safra tree, which can realize the conversion of the tree when the input alphabet is given. The algorithm firstly updates the state labels of all nodes, then generates the necessary new sibling nodes, solves the sibling node conflict by horizontal merging, filters the special nodes by vertical merging, and finally updates the node naming and generates the child nodes. This process strictly maintains that the converted tree still satisfies the constraints of one-index Muller Safra tree. The conversion algorithm constitutes the core of the conversion from nondeterministic automaton to deterministic automaton.

[0062] In a specific embodiment of the present application, the process of horizontally merging sibling nodes in S220 includes:

[0063] S221b, traversing each node τ in the state tree M2 in hierarchical order, for each state q in l(τ), if q also appears in the state label of some sibling node τ' of τ, and satisfies j(τ') < j(τ), or j(τ') = j(τ) and τ' is on the left side of τ, then delete q from the state label of node τ and all its descendant nodes;

[0064] S222b, after checking all states in l(τ), if the state label of τ is empty at this time, then delete node τ; if the deleted node τ has been named and its key value label is equal to 0 or k'+1, then call τ a rejection node to obtain state tree M3.

[0065] Then define the rejection flag sigrej of the transition of M to M' by σ to record all rejection nodes. For convenience, the nodes in sigrej are represented by their names, that is, sigrej = {Mj(τ)|τ is a rejection node appearing in the transition of M to M' by σ}. For the example, the obtained M3 is shown as Figure 7 There are five deleted nodes in this step, but only one rejection node, named 0.52, so sigrej = {0.52}. In M3, the state labels of sibling nodes are mutually disjoint, there is no node with an empty state label, but there may be a node whose key value labels of all child nodes are 0.

[0066] In a specific embodiment of the present application, the process of vertically merging non-leaf nodes in S220 includes:

[0067] S221c, traversing each non-leaf node τ in the state tree M3 in hierarchical order, if the key value label of each child node of τ is 0, then delete all descendant nodes of τ, and call τ an acceptance node to obtain state tree M4.

[0068] Similar to the rejection flag, a receive flag sig is also defined for the transition M to M′ via σ. acc To record all receiving nodes, i.e., sig acc ={M j (τ)|τ is the receiving node that appears in the migration from M to M′ via σ}. For the example, the obtained M4 is as follows: Figure 8 As shown, there is only one receiving node, named 0.5. 1 .0 1 Therefore, sig acc ={0.5 1 .0 1 In M4, there is no node whose key-value labels are all 0, but some node names may not follow naming rules.

[0069] In one specific embodiment of the present invention, the process of renaming nodes in S220 includes:

[0070] Traverse each named node in the state tree M4 in hierarchical order and rename it according to the node naming rules; if the key value label of the renamed node is 0 or k′+1, it is called a rejected node, and the name of the node before the name is added to the rejection flag to obtain the state tree M5.

[0071] The tree after step S5 is called M 5. Figure 9 The example tree is shown. M 5. In this step, there is a rejection node. Figure 8 The Chinese name is 0.5 3 ,exist Figure 9 Change to 0.5 2 The original name needs to be added to the list. sig rej In the middle, at this time sig rej ={0.5 2 0.5 3}

[0072] In one specific embodiment of the present invention, the process of generating child nodes in S220 includes:

[0073] Traverse each leaf node τ in the state tree M5 in hierarchical order. If the key value label of τ is equal to 0 or k′+1, then τ generates a new child node τ′ with state label l(τ′)=l(τ) and key value label j(τ′=k′). Assign names to the unnamed nodes in the state tree M5 using the node naming rules to obtain the regenerated state tree M′.

[0074] The state tree M' is the successor one-index Muller Safra tree M' of M after reading the alphabet σ. For the example, the resulting M' is shown in Fig. 2. Figure 10 It is noted that, given a one-index Muller Safra tree M and an alphabet σ, in addition to the successor one-index Muller Safra tree M', the acceptance flag sig acc and the rejection flag sig rej are also obtained.

[0075] Based on the above six-step tree structure conversion algorithm, starting from the initial one-index Muller Safra tree, each alphabet in the alphabet table is read in turn, and the new one-index Muller Safra tree obtained is read in turn each alphabet in the alphabet table, and the cycle is repeated until no new one-index Muller Safra tree is generated. The generated all different one-index Muller Safra trees constitute the state set of the DRA, and the conversion between the trees is the transition of the DRA, and thus the transition system of the DRA is obtained.

[0076] In a specific embodiment of the present application, S300 comprises:

[0077] S310, the state tree M' regenerated in the current loop conversion process is put into the current state set to form a new state set; M S310, the state tree M' regenerated in the current loop conversion process is put into the current state set to form a new state set;

[0078] S320, the process of S200 is repeated to put all the regenerated state trees M' into the current state set, until the current state set no longer produces a new state tree to determine the final state set and the transition set of the deterministic automaton.

[0079] In a specific embodiment of the present application, S400 comprises:

[0080] S410, a set pair is set for each node in the final state set, respectively denoted as the first set Am and the second set Rm;

[0081] S420, the corresponding node is determined by using the acceptance flag and the rejection flag in the transition information, and the transition information corresponding transition in the transition set is distributed to the set pair of the node, thereby defining the acceptance condition of the deterministic automaton to obtain the deterministic acceptor.

[0082] The DRA receiving condition is a set composed of set pairs, the number of set pairs depends on the number of all possible node names appearing in one-index Muller Safra tree, each possible node name corresponds to a set pair, the corresponding relationship is represented by using node name as the subscript of the set in the set pair, that is, if node name m can appear in a one-index Muller Safra tree, there is a corresponding set pair in the receiving condition of DRA, that is, <A m , R m >. In the process of constructing the migration system, each migration has a corresponding receiving flag sig acc and a rejection flag sig rej . The receiving condition construction module allocates the migration according to the receiving / rejection flag corresponding to each migration: if the receiving flag sig acc of a migration contains the name m, the migration is allocated to the first set A m in the set pair corresponding to the name m; if the rejection flag sig rej of a migration contains the name m, the migration is allocated to the second set R m in the set pair corresponding to the name m.

[0083] For example, the receiving flag sig acc of the migration record (M, σ, M') is {0.5 1 , 0.5 1}, the rejection flag sig rej is {0.5 2 , 0.5 3}, then the migration will be allocated to the first set in the set pair corresponding to 0.5 1 , 0.5 1 , and the second set in the set pair corresponding to 0.5 2 and 0.5 3 respectively, that is, (M, σ, M') ∈ A 0.5 1 .0 1 , (M, σ, M') ∈ R 0.5 2 and (M, σ, M') ∈ R 0.5 3 .

[0084] The migration system combined with the receiving condition constitutes a DRA equivalent to one-index NMAM1. Based on this, for a general NMAM with k indexes in the receiving condition, (Σ, Q, Q0, δ, {λ1, λ2, …, λ k}) where |Q| = n, can be seen as the union of k one-index NMAMs M1, M2,..., M1 k , each one-index NMA having the same migration system as NMAM but only one index in the receiving condition, i.e. i = (Σ, Q, Q0, δ, {λ i}) where 1≤i≤k. Further, each one-index NMAM1 i can be determinized into a DRAR i = (Σ, Q i , q0 i , δ i , <A i , R i > [P(i)] ) where <A i , R i > [P(i)] = {<A1 i , R1 i >, <A2 i , R2 i >,..., <A P(i) i , R P(i) i}. Finally, taking the union of the k DRARs i = (Σ, Q R , q R0 , δ R , λ R ) where,

[0085] Q R ∈ Q 1 x Q 2 x... x Q k ;

[0086] q R0 = {q0 1 , q0 2 ,..., q0 k};

[0087] for each state {q1, q2,..., q k} ∈ Q R and each letter σ ∈ Σ, δ R ({q0 1 , q0 2 ,..., q0 k}, σ) = {δ 1 (q1, σ), δ 2 (q2, σ),..., δk (q k ,σ)};

[0088] λ R ={<A1,R1> ,<A2,R2> , ..., P(1)+P(2)+⋯+P(k) R P(1)+P(2)+⋯+P(k) >}, for each migration trans=({q1, q2, ..., q k},σ,{q1′,q2′,…,q k If (q) i , σ, q i ′)∈A j i (or R) j i ), where 1≤i≤k, 1≤j≤P(i), then trans∈A P(1)+P(2)+⋯+P(i-1)+j (or R) P(1)+P(2)+⋯+P(i-1)+j In particular, when i=1, P(1)+P(2)+⋯+P(i-1)=0.

[0089] This DRAM is the deterministic automaton obtained by NMAM determinization, and the state complexity of R is 2. O(nklogn) Compared to existing deterministic NMA methods, the method provided in this invention has lower state complexity.

[0090] The Muller automaton is split into multiple single-index Muller automata according to the number of indices in the Muller automaton's acceptance condition. The single-index Muller automata are then determinized into deterministic automata using a one-index MullerSafra tree. Finally, the multiple deterministic automata are complemented by a complement operation.

[0091] ​In addition, in order to show the actual effect of the two NMA determination methods provided by the present application, the present application designs and implements the NMA determination tool NM2DR about NMA, which is developed based on the Windows platform using Java language and supports the two NMA determination methods. On this basis, a series of NMA are randomly generated as a test set, which contains 100 randomly generated NMA, wherein the number of states of the NMA is 5, 6, …, 14, and there are 10 NMA for each number of states. The experimental results are shown in Table 1, wherein NMA represents the test cases of different states in the test set, and for the NMA with the same number of states, the average value of the number of states, the number of transitions and the number of indexes is taken as the experimental data. Similarly, the corresponding DRA also takes the average value. NMA-NBA-DRA represents the DRA obtained by the determination method with NBA as the intermediate conversion, and NMA-DRA represents the DRA obtained by the determination method of the present application. The experimental results in Table 1 show that the DRA obtained by determining the NMA by the method of the present application indeed has fewer number of states, which meets the expected result. As for the equivalence of the automata before and after the test case determination, the existing tool Spot is used for verification, and the parameter equivalent_to of the tool has the function of verifying the equivalence of any two automata. The last column of Table 1 shows the verification results, and “T” represents that the automata before and after the determination are equivalent.

[0092] Table 1 Experimental results of NMA determination to DRA

[0093]

[0094] It should be noted that the terms “first”, “second” in the present application are only used for description purposes, and cannot be understood as indicating or implying relative importance or implicitly indicating the number of indicated technical features. Therefore, the features limited by “first”, “second” can explicitly or implicitly include one or more of the features. In the description of the present application, the meaning of “a plurality of” is two or more, unless otherwise specifically limited.

[0095] The above is a further detailed description of the present application in combination with specific preferred embodiments, and the specific implementation of the present application cannot be limited to these descriptions. For ordinary skilled persons in the technical field to which the present application belongs, without departing from the concept of the present application, a number of simple deductions or replacements can also be made, which should be regarded as falling within the protection scope of the present application.

Claims

1. A deterministic method for Muller automata based on tree structure, characterized in that, Comprising: S100, constructing an initial state tree as the initial state of a deterministic automaton; S200, reading out letters from a predefined alphabet and assigning them to the initial state tree, thereby changing the structure of the initial state tree to regenerate a state tree; During the current loop transformation process, reading out new letters from the alphabet and assigning them to the state trees in the state set to change their structures and thereby regenerate state trees, and recording the transition information of the state trees during the current loop transformation process; S300, putting the state trees regenerated during the current loop transformation process into the current state set to form a new state set, repeating the process of S200 until no new state trees are generated to obtain the final state set and transition set of the deterministic automaton; S400, allocating the transitions in the transition set to the set pairs corresponding to the corresponding nodes in the final state set, thereby defining the acceptance condition of the deterministic automaton to obtain a deterministic receiver; S200 includes: S210, reading out letters from a predefined alphabet and assigning them to the initial state tree so that it changes its own structure and state according to the letters to regenerate a state tree M; S220, traversing the nodes in the state tree M during the current loop transformation process, and successively executing the processes of updating the state labels, generating sibling nodes, horizontally merging sibling nodes, vertically merging non-leaf nodes, renaming nodes, and generating child nodes for leaf nodes by using a tree structure transformation algorithm to obtain a state tree M'; S230, recording the transition information of the state tree M1 migrating to the state tree M'; where the state tree M1 is the state tree after the state labels of the nodes in the state tree M are updated.

2. The deterministic method for Muller automata based on tree structure according to claim 1, characterized in that, The initial state tree uses a seven-tuple.<V,τr,p,l,j,stor,Mj> This represents the expression, where V is the set of all nodes, τr is the root node, and p is the parent node function. l : V → 2Q `V` is a state labeling function that labels all nodes with a subset of a state set `Q`. Except for the root node, the state label of each node is non-empty. The state label of each non-leaf node is equal to the union of the state labels of all its child nodes. The state labels of any two sibling nodes are disjoint. `j: V→{0, 1, ..., k′+1}` is a key-value labeling function that labels each node with an integer from 0 to `k′+1`. The root node is labeled with 0, and the child nodes of the root node are labeled with `k′+1`. Each leaf node is labeled with an integer from 1 to `k′`, and sibling nodes in the leaf nodes have different integers. All other nodes are labeled with 0. Each non-root node labeled with `k′+1` or 0 has at least one key-value labeling function. `stor` represents the child nodes of the leaf nodes; `stor` is a parameter used to define the structural order between sibling nodes. For any two sibling nodes `τ` and `τ′`, `τ′` is to the right of `τ` if and only if `j(τ) > j(τ′)`, or `j(τ) = j(τ′)` and `τ` is generated before `τ′`; `Mj` is the node naming rule, which is: for the root node `τr`, `Mj(τr) = 0`; for any other node `τ`, if `j(τ) ≠ 0` and `j(τ) ≠ `k′+1`, then `Mj(τ) = Mj(p(τ)).j(τ)`, otherwise, `Mj(τ) = Mj(p(τ).j(τ)i+1`. The number of nodes with the same key value label as the left sibling node of `τ` is represented by `i`.

3. The deterministic method for Muller automata based on tree structure according to claim 2, characterized in that, The process of generating sibling nodes in S220 includes: S221a, traversing the nodes τ1, τ2,..., τm in the state tree M in hierarchical order; S222a, for each node τi traversed, if there exists j(τi) = k′ + 1 and l(τi) ∩(Q\λ′) ≠ Then, node p(τi) generates a new youngest child node τ′ with state label l(τ′)=l(τi)∩(Q\λ′) and key label j(τ′=j(τi). All states belonging to l(τi)∩(Q\λ′) are removed from the state labels of node τi and all its descendant nodes; where the symbol \ indicates the subtraction of sets; S223a, for each traversed node τi, if there exists 1 ≤ j(τi) ≤ k' and qj(τi) ∈ l(τi), then the node p(τi) generates a new youngest child node τ', whose state label l(τ') = {qj(τi)}, key value label j(τ') = max(0, j(τi) - 1), and deletes the state qj(τi) from the state labels of the node τi and all its descendant nodes; S224a, merging sibling nodes with the same key value label and within the range of 1 to k' in the leaf nodes to obtain a state tree M2.

4. The deterministic method for Muller automata based on tree structure according to claim 3, characterized in that, The process of horizontally merging sibling nodes in S220 includes: S221b, traversing each node τ in the state tree M2 in hierarchical order, for each state q in l(τ), if q also appears in the state label of a sibling node τ' of τ and satisfies j(τ') < j(τ), or j(τ') = j(τ) and τ' is on the left side of τ, then delete q from the state labels of the node τ and all its descendant nodes; S222b, after checking all states in l(τ), if the state label of τ is empty at this time, then delete the node τ; if the deleted node τ has been named and its key value label is equal to 0 or k' + 1, then τ is called a rejecting node to obtain a state tree M3.

5. The deterministic method for Muller automata based on tree structure according to claim 4, characterized in that, The process of vertically merging non-leaf nodes in S220 includes: S221c, traverse each non-leaf node τ in the state tree M3 in hierarchical order. If the key value label of each child node of τ is 0, delete all descendant nodes of τ and call τ the receiving node to obtain the state tree M4.

6. The deterministic method for Muller automata based on tree structure according to claim 5, characterized in that, The process of renaming nodes in S220 includes: Traverse each named node in the state tree M4 in hierarchical order and rename it according to the node naming rules; if the key value label of the renamed node is 0 or k′+1, it is called a rejected node, and the name of the node before the name is added to the rejection flag to obtain the state tree M5.

7. The deterministic method for Muller automata based on tree structure according to claim 6, characterized in that, The process of generating child nodes in S220 includes: Traverse each leaf node τ in the state tree M5 in hierarchical order. If the key value label of τ is equal to 0 or k′+1, then τ generates a new child node τ′ with state label l(τ′)=l(τ) and key value label j(τ′=k′). Assign names to the unnamed nodes in the state tree M5 using the node naming rules to obtain the regenerated state tree M′.

8. The deterministic method for Muller automata based on tree structure according to claim 7, characterized in that, The S300 includes: S310, put the newly generated state tree M′ during the current loop transition into the current state set to form a new state set; S320, repeat the process of S200 to put all the newly generated state trees M′ into the current state set, until the current state set no longer generates new state trees, thus obtaining the final state set and transition set of the deterministic automaton.

9. The deterministic method for Muller automata based on tree structure according to claim 1, characterized in that, The S400 includes: S410, Set a set pair for each node in the final state set, which are respectively represented as the first set Am and the second set Rm; S420, using the receive flag and rejection flag in the migration information to determine the corresponding node, and assigning the migrations corresponding to the migration information in the migration set to the set pair of that node, thereby defining the receiving conditions of the deterministic automaton to obtain a deterministic receiver.

Images