Muller automaton determination method based on tree structure

Abstract

The invention provides a Muller automaton determination method based on a tree structure. The Muller automaton determination method comprises the following steps: constructing an initial state tree as an initial state of a deterministic automaton; reading alphabets from a predefined alphabet and endowing the alphabets to the initial state tree to change the structure of the alphabets so as to regenerate a state tree, taking the alphabets as a new state of the deterministic automaton so as to expand a state set, and recording migration information of the state tree in a conversion process; extracting a state tree from the state set, reading the state tree into letters in an alphabet to regenerate the state tree so as to update the state set; the process is repeated until no new state tree is generated, and a final state set and a migration set are obtained; and allocating the migration in the migration set to a set pair corresponding to the corresponding node in the final state set, thereby defining a receiving condition of the deterministic automaton. And the state transition system and the receiving condition form a final deterministic automaton. The state complexity can be reduced, the calculation efficiency is improved, the implementation process is simplified, and the engineering feasibility is improved.

Description

Technical Field

[0001] The present invention belongs to the technical field of verification based on automata, and in particular relates to a Muller automaton deterministic method based on a tree structure. Background Art

[0002] Software systems are crucial enablers of social development, and their quality is particularly critical in safety-critical sectors such as aerospace, national defense, and transportation. Software defects have caused numerous catastrophic accidents, making it crucial to ensure the trustworthiness of software systems.

[0003] Formal methods are an important and effective approach to ensuring software trustworthiness. They aim to describe and verify software systems using rigorous mathematical analysis. ω automata (finite state automata that accept infinite words) play a crucial role in the description and verification of non-terminating systems and ω-regular temporal specifications. Determining ω automata is a fundamental challenge. Automata-based verification methods treat issues related to systems and their specifications as language-related problems, simplifying them to problems such as determining the nullity of the automaton. Determining ω automata helps solve the complementation problem, an essential operation in processes such as specification verification. For Büchi automata, although complementation methods that do not require determinism outperform deterministic complementation methods in theoretical complexity, experimental results show that deterministic complementation methods are more effective in practice. Subsequently proposed optimal complementation methods still involve converting the Büchi automaton to be complemented into a deterministic automaton. Furthermore, in logic-based verification methods, the determinism and complexity of the logic are fundamental issues. Determinism directly affects the development of the logic in the field of software trustworthiness verification, while the complexity of the decision process directly affects verification efficiency. The original intention of establishing ω automata is to solve some basic judgment problems in logic. The deterministic nature of ω automata is such as SnS, CTL * ,△-PDL, u Safra's work, which is based on logical decision-making processes such as ω automata, reduces the complexity of certain logical decision-making processes by creatively optimizing deterministic algorithms. Therefore, exploring better deterministic algorithms for ω automata to reduce complexity can effectively improve the efficiency of trusted verification of software systems, which is of great practical significance and theoretical value.

[0004] The ω automaton is also composed of the state set Q , initial state set Q 0, alphabet Σ, transfer function δ: Q ×Σ→2 Q (The current state reads a letter and can reach another state through the transition function. The process of reading a letter from one state to another state is called a transition. △ represents the set of all transitions, that is, △={( q ,σ, q ′)∈Q ×Σ× Q | q ′∈δ( q ,σ)}) and the receiving condition λ, the unique receiving condition gives it the ability to receive infinite words. The receiving condition λ is a set, and its elements are either states / transitions, or state / transition sets, or state / transition set pairs, collectively referred to as indices. Depending on the different λ, the ω automaton can be specifically divided into Büchi, Streett, Rabin, parity, Muller automata, etc. If the initial state set is a single element, and any letter read from any state can reach at most one state, the ω automaton is deterministic; otherwise it is non-deterministic. Research on the determinization of ω automata has been going on for decades. Among them, the complexity problems of the determinization of Büchi, Streett, Rabin, and parity automata have all been solved, that is, their determinization algorithms have all reached the optimal or asymptotic optimal state, while the complexity problem of the determinization of Muller automata remains to be solved.

[0005] For those with n status and k The current deterministic method is to convert the nondeterministic Muller automaton (NMA) with index into an equivalent O ( n 2 k ) state nondeterministic Büchi automaton (NBA), and then the NBA is determinized to obtain the state complexity of The deterministic Rabin automaton (DRA) of NMA is still limited to ,There is a huge gap between the upper and lower bounds, and the deterministic algorithm of NMA still has a lot of room for improvement. Summary of the Invention

[0006] In order to solve the above problems existing in the prior art, the present invention provides a method for determining the Muller automaton based on a tree structure. The technical problem to be solved by the present invention is achieved through the following technical solutions: A tree-structured Muller automaton deterministic method includes: S100, constructing an initial state tree as the initial state of the deterministic automaton; S200, reading letters from a predefined alphabet and assigning them to the initial state tree, thereby changing the structure of the initial state tree and regenerating the state tree; during the current cyclic conversion process, reading new letters from the alphabet and assigning them to the state tree in the state set to change its structure and regenerate the state tree, and recording migration information of the state tree during the current cyclic conversion process; S300, putting the state tree regenerated in the current loop conversion process into the current state set to form a new state set, repeating the process of S200 until no new state tree is generated to obtain the final state set and transition set of the deterministic automaton; S400 , allocating transitions in the transition set to set pairs corresponding to corresponding nodes in the final state set, thereby defining a receiving condition of a deterministic automaton to obtain a deterministic receiver.

[0007] Beneficial effects: 1. The present invention directly determines the automaton, reducing intermediate steps: The determinization of existing Muller automata usually requires first converting them into other intermediate forms (Büchi automata), and then achieving determinism through the deterministic data structure of the Büchi automaton. The new data structure one-index MullerSafra tree proposed in this invention directly supports the deterministic conversion of Muller automata without relying on the transition of intermediate automaton types. It compresses the multi-step process (non-deterministic Muller automaton → non-deterministic Büchi automaton → deterministic Rabin automaton) into a single step operation, significantly simplifying the process and reducing the complexity of algorithm design and implementation.

[0008] 2. The present invention optimizes the state complexity and improves the computational efficiency: the state complexity of the existing Muller automaton deterministic method using Büchi automaton as the intermediate transition is The method provided by the present invention avoids the additional state complexity caused by the conversion to Büchi automaton, and optimizes the state complexity of the deterministic Muller automaton to In addition, the independence of the tree structure supports parallel processing (reading different letters in the same tree structure can be distributed computing), which is suitable for GPU or distributed system acceleration and significantly improves computing efficiency.

[0009] 3. The present invention simplifies the implementation process and improves engineering feasibility: The present invention compresses the multi-step process of determinizing the Muller automaton (non-deterministic Muller automaton → non-deterministic Büchi automaton → deterministic Rabin automaton) into a single-step operation. The explicitly structured tree design makes the algorithm logic more intuitive and easy to implement and optimize. This significantly simplifies the algorithm design process and implementation complexity, lowers the technical threshold for engineering implementation, and facilitates debugging and correctness verification.

[0010] 4. This invention expands potential applications: It provides more efficient underlying support for the application of infinite word automata in reactive system verification, software and hardware model testing, and other fields, and is particularly suitable for scenarios that are sensitive to state complexity.

[0011] The present invention will be further described in detail below with reference to the accompanying drawings and embodiments. BRIEF DESCRIPTION OF THE DRAWINGS

[0012] Figure 1 This is a flowchart of a tree-structured Muller automaton deterministic method provided by the present invention; Figure 2 Schematic diagram of a one-index Muller-Safra tree provided by the present invention; Figure 3 Schematic diagram of the initial one-index Muller-Safra tree provided by the present invention; Figure 4 It is a schematic diagram of a related fragment of a one-index NMA provided by the present invention; Figure 5 is a schematic diagram of a state tree obtained by updating state tags provided by the present invention; Figure 6 This is a schematic diagram of a state tree obtained by generating brother nodes provided by the present invention; Figure 7 It is a schematic diagram of a state tree for horizontally merging sibling nodes provided by the present invention; Figure 8 It is a schematic diagram of the state tree of the invention providing vertical merging of sibling nodes; Figure 9 is a schematic diagram of a state tree of a renamed node provided by the present invention; Figure 10 It is a schematic diagram of the state tree for generating child nodes provided by the invention. DETAILED DESCRIPTION

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

[0014] The present invention provides a complete one-index NMA determinization method based on a one-index Muller-Safra tree. First, the initial state of the deterministic automaton, i.e., the initial one-index Muller-Safra tree, is constructed. Then, starting from the initial tree, letters of the alphabet are sequentially read in. With each letter read in, the tree structure undergoes a transformation, resulting in a new one-index Muller-Safra tree, which is a new state. During this process, certain node information in the tree needs to be recorded. This cycle continues until no new trees are generated. All one-index Muller-Safra trees constitute a state set, and the transformation relationship between trees is a migration. Finally, the acceptance condition of the automaton is defined based on the node information in the migration. This process results in the desired deterministic automaton. The process includes three modules: initial state construction of the deterministic automaton, migration system construction, and acceptance condition construction. Given a one-index NMAM1=(Σ, Q, Q0, δ, {λ′}), where |Q|=n and λ′={q1, q2, …, qk′}∈Q, the details of the present invention are described below.

[0015] like Figure 1 As shown, the present invention provides a tree-structured Muller automaton deterministic method, comprising: S100, constructing an initial state tree as the initial state of the deterministic automaton; The following definitions of the two receiving conditions involved in this invention, Muller and Rabin, are given. When the index of the receiving condition is related to the state, the receiving condition is called state-based; when the index of the receiving condition is related to the transition, the receiving condition is called transition-based. For the state-based receiving 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) represents the i-th letter in α. Let inf(ρ) represent the set of states that appear infinitely in ρ. For the transition-based receiving 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)∈△. Inf(ρ) represents the set of states / transitions that appear infinitely in ρ. It should be noted that the reception condition of the deterministic object NMA of the present invention is based on states, while the reception condition of the deterministic DRA is based on transitions, which are described below.

[0016] Muller acceptance condition is: λ={λ1, λ2,…,λ k}, where λi ∈ Q (1≤ i ≤ k ), a run ρ is admissible if and only if there exists 1≤ i ≤ k , so that inf(ρ)=λ i , that is, the set of states that appear infinitely in the run ρ is exactly equal to an element in λ.

[0017] The Rabin acceptance condition is: λ={< A 1, R 1>,< A 2, R 2>,…,< A k , R k >}, where A i , R i ∈△(1≤ i ≤ k ), a run ρ is admissible if and only if there exists 1≤ i ≤ k , so that inf(ρ)∩ A i ≠ , and inf(ρ)∩ R i = .

[0018] The present invention takes the NMA with only one index (abbreviated as one-index NMA) as the starting point, that is, the receiving condition λ={λ′} of the NMA, and provides a one-index Muller-Safra tree, a data structure that can be directly applied to its determinism, and a one-index NMA determinism algorithm based on the one-index Muller-Safra tree.

[0019] For a one-index NMAM1=(Σ, Q , Q 0, δ, λ), where λ={λ′}, λ′={ q 1, q 2,…, q k′}∈ Q , a one-index MullerSafra tree of M1 is a seven-tuple<V,τr,p,l,j,stor,Mj> , where V is the set of all nodes, τr is the root node, and p is the parent node function. l : V →2Q is a state labeling function that labels all nodes with a subset of the 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 0, and the child nodes of the root node are labeled k′+1; each leaf node is labeled with an integer from 1 to k′, and among all leaf nodes, the sibling nodes are labeled with different integers; all other nodes are labeled 0; each non-root node labeled k′+1 or 0 has at least one child node that is a leaf node; stor represents the 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 a node naming rule that assigns a unique name to each node based on the key-value label. Starting from the root node, the naming is recursively performed layer by layer. The name of each node is the concatenation of the key-value labels of all its ancestor nodes. 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: 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 the left sibling of τ, and j(τ′) = j(τ)}|. That is, among the left siblings of node τ, the number of nodes with the same key-value label as its node is denoted as i. The dots (.) in Mj(p(τ)).j(τ) and Mj(p(τ).j(τ)i+1 indicate a connection.

[0020] refer to Figure 2 As shown, given a one-index NMA with 6 states {a, b, c, d, e, f} and |λ′|=4, Figure 2 It shows a one-index Muller-Safra tree containing 10 nodes. The state set in the node is its state label. The key-value label and name of the node are represented by blue and red fonts respectively.

[0021] Constructing the initial state means constructing the initial one-index Muller-Safra tree M. M is a single-branch labeled tree containing only three nodes: τr, τ1, and τ2. τr is the root node of M, τ1 is a child node of τr, and τ2 is a child node of τ1. The state labels of these three nodes are all Q0, i.e., 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′.

[0022] consider Figure 2 Corresponding one-index NMA, if the initial state set Q0 = {a, c}, then the corresponding initial one-index MullerSafra tree is as follows Figure 3 As shown. For the node named 0.51, its responsibility is to detect whether each run in its state label has passed through all states in λ′, and the specific detection process is performed by its child nodes. The detection of states in λ′ is performed in reverse order. Therefore, at this time, the node named 0.51.4 is used to detect whether there are some runs that have passed 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 named 0.51 is also used to detect whether there are runs that have passed through Q\λ′. If such runs exist, these runs are migrated to a newly generated sibling node.

[0023] The present invention proposes an innovative tree data structure, namely the one-index MullerSafra tree. This data structure accurately records the state reached by the Muller automaton when reading letters and whether the reception conditions are met by setting state labels, key-value labels and unique names for the nodes in the tree. It is the first tree representation method that can efficiently handle the determinism of the Muller automaton, and significantly reduces the computational complexity compared to traditional methods that require intermediate conversions.

[0024] S200, reading letters from a predefined alphabet and assigning them to the initial state tree, thereby changing the structure of the initial state tree and regenerating the state tree; during the current cyclic conversion process, reading new letters from the alphabet and assigning them to the state tree in the state set to change its structure and regenerate the state tree, and recording migration information of the state tree during the current cyclic conversion process; Starting from the initial one-index MullerSafra tree, the letters in the alphabet Σ are read in sequence. The reading of each letter is a transformation of the tree structure, and this cycle is repeated until no new trees are generated. After the cyclic transformation process, each one-index MullerSafra tree exists as a state of the deterministic automaton. All different one-index MullerSafra trees generated constitute the state set of the deterministic automaton, and the elements of the migration set correspond to the transformations between trees, thus obtaining the migration system of the deterministic automaton. In this process, the most important thing is the transformation algorithm of the one-index MullerSafra tree, that is, when a one-index MullerSafra tree M When reading a letter σ, how to get the successor one-index MullerSafra tree M ′. The conversion algorithm consists of six steps, and an example is used to illustrate each step. Figure 2 The one-index MullerSafra tree in M1 , its corresponding one-indexNMA all migrations of letter σ are as follows Figure 4 As shown, the reception condition of the one-index NMA has only one index λ′={a, c, e, f}.

[0025] The node tags of the present invention include a state tag, a key-value tag and a name; the state tag and the key-value tag constrain the node; and the node name is determined by the key-value tag.

[0026] S300, putting the state tree regenerated in the current loop conversion process into the current state set to form a new state set, repeating the process of S200 until no new state tree is generated to obtain the final state set and transition set of the deterministic automaton; Given a one-index Muller-Safra tree and a letter, the present invention uses a conversion algorithm to output another one-index Muller-Safra tree. The algorithm includes six steps: updating the status label, generating sibling nodes, horizontally merging sibling nodes, vertically merging sibling nodes, updating the node name, and generating child nodes. The present invention's parallel tree construction method can parallelize the processing of different letters within a one-index Muller-Safra tree, simultaneously generating different one-index Muller-Safra trees.

[0027] S400 , allocating transitions in the transition set to set pairs corresponding to corresponding nodes in the final state set, thereby defining a receiving condition of a deterministic automaton to obtain a deterministic receiver.

[0028] In a specific embodiment of the present invention, S200 includes: S210, reading a letter from a predefined alphabet, and assigning it to the initial state tree so that it changes its own structure and state according to the letter, thereby regenerating the state tree M; S220, traversing the nodes in the state tree M during the current loop conversion process, and using a 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′; The present invention updates the state label as follows: for any node τ in M, its state label is updated to ⋃q∈l(τ)δ(q,σ), and the resulting state tree is called M1. For example, Figure 5 Shows the state tree M1 obtained by updating the state label of M, Figure 2 compared to, Figure 5 The status labels of all nodes in are updated.

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

[0030] Based on the aforementioned tree structure and transformation algorithm, this paper proposes a comprehensive method for determinizing single-index Müller automata. This method comprises three key steps: mapping the automaton's initial state set into a standardized initial tree; generating the deterministic automaton's state set and transition relationships through alphabet-driven iterative transformations; and assigning indices based on the transition labels. This method, for the first time, achieves direct determinization of single-index Müller automata.

[0031] To handle more general Müller automata, this paper further proposes a general determinization scheme. This scheme first splits the original automaton into multiple single-index automata based on the number of indices in the received condition. Then, the aforementioned determinization method is applied to each single-index automaton. Finally, the results are combined using a union operation. This three-stage "split-determinize-union" approach overcomes the traditional method's reliance on intermediate automata.

[0032] In terms of optimization technology, this paper proposes a parallelized tree construction method. By simultaneously processing different letters in a one-index Muller-Safra tree, multiple transformation results can be efficiently generated. This parallelization strategy significantly accelerates the construction of the automaton state space and improves computational efficiency.

[0033] In a specific embodiment of the present invention, the process of generating a sibling node in S220 includes: S221a, traverse the nodes τ1, τ2, ..., τm in the state tree M1 in hierarchical order; S222a, for each traversed node τi, if the node exists j(τi)=k′+1 and l(τi)∩Q\λ′≠ , then the node p(τi) generates a new youngest child node τ′, whose 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 subtraction in a set, that is, one set is subtracted from another set; 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, merge the sibling nodes with the same key value label in the range of 1~k′ in the leaf node to obtain the state tree M2.

[0034] It should be noted that the names of the newly generated nodes are not defined yet. Then, the sibling nodes with the same key value labels in the range of 1~k′ are merged in the leaves. For each newly generated node τ, if 1≤j(τ)≤k′ and there is a named sibling node τ′ with the same key value label, all states in l(τ) are added to l(τ′) and the node τ is deleted. Further, starting from the root node, the sibling nodes are rearranged layer by layer according to the structural order, that is, the sibling nodes are arranged in order from large to small according to their key value labels, and the nodes with the same key value keep their relative positions unchanged. After S223a, the subsequent tree is called M2. Figure 6 The tree M2 obtained by the example is shown, in which the unnamed nodes are newly generated. In addition, it can be seen that each leaf node with a key-value label in 1~k′ does not have a sibling node with the same key-value label, and all nodes have followed the structural order.

[0035] For the data structure of the one-index Muller Safra tree, the present invention develops a six-step conversion algorithm that can achieve the conversion of the tree when a given input letter is provided. The algorithm first updates the status labels of all nodes, then generates necessary new sibling nodes, resolves sibling node conflicts through horizontal merging, filters special nodes through vertical merging, and finally updates the node naming and generates child nodes. This process strictly ensures that the converted tree still satisfies the constraint conditions of the one-index Muller Safra tree. This conversion algorithm constitutes the core of the conversion from a non-deterministic automaton to a deterministic automaton.

[0036] In a specific embodiment of the present invention, the process of horizontally merging sibling nodes in S220 includes: S221b, traverse each node τ in the status tree M2 in hierarchical order. For each state q in l(τ), if q also appears in the status 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 status labels of node τ and all its descendant nodes; S222b, after checking all states in l(τ), if the status 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 τ is called a rejecting node to obtain the status tree M3.

[0037] Next, define the rejection flag sigrej of the transition from M through σ to M′ to record all rejecting nodes. For convenience, the nodes in sigrej are represented by their names, that is, sigrej = {Mj(τ) | τ is a rejecting node that appears in the transition from M through σ to M′}. For example, the obtained M3 is as Figure 7 shown. In this step, there are a total of five deleted nodes, but only one rejecting node, named 0.52, so sigrej = {0.52}. In M3, the status labels between sibling nodes are all non-overlapping, and there is no node with an empty status label, but there may be a node whose key value labels of all its child nodes are 0.

[0038] In a specific embodiment of the present invention, the process of vertically merging non-leaf nodes in S220 includes: S221c, traverse each non-leaf node τ in the status 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 accepting node to obtain the status tree M4.

[0039] Similar to the rejection flag, also define the acceptance flag sig of the transition from M through σ to M′ acc to record all accepting nodes, that is, sigacc ={M j (τ)|τ is the receiving node that appears in the migration from M to M′ through σ. 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 , so sig acc ={0.5 1 .0 1 In M4, there is no node whose key-value labels of all its child nodes are 0, but the names of some nodes may not follow the naming rules.

[0040] In a specific embodiment of the present invention, the process of renaming the node in S220 includes: Traverse each named node in the state tree M4 in hierarchical order and rename it by applying 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 it is named is added to the rejected flag to obtain the state tree M5.

[0041] The tree after step S5 is called M 5. Figure 9 Showing the tree obtained from the example 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 , you need to add the name before the change to sig rej In, at this time sig rej ={0.5 2 , 0.5 3}.

[0042] In a specific embodiment of the present invention, the process of generating a child node 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 τ′, whose state label l(τ′)=l(τ) and key-value label j(τ′)=k′; use the node naming rule to assign names to the unnamed nodes in the state tree M5 to obtain the regenerated state tree M′.

[0043] The state tree M′ is the successor one-index MullerSafra tree M′ obtained after M reads the letter σ. For the example, the obtained M′ is as follows Figure 10It should be noted that, given a one-index MullerSafra tree M and a letter σ, in addition to obtaining a successor one-index MullerSafra tree M′, we also obtain the receiving flag sig of the transition from M to M′ through σ. acc and rejection flag sig rej .

[0044] Based on the six-step tree structure conversion algorithm described above, starting from the initial one-index Muller-Safra tree, each letter of the alphabet is read in sequence. The resulting new one-index Muller-Safra tree is then read in sequence with each letter of the alphabet, and this cycle continues until no new one-index Muller-Safra trees are generated. All the different one-index Muller-Safra trees generated constitute the state set of the DRA. The conversion between trees is the migration of the DRA, thus forming the DRA migration system.

[0045] In a specific embodiment of the present invention, S300 includes: S310, convert the state tree regenerated during the current cycle conversion process M ' is put into the current state set to form a new state set; S320, repeating the process of S200 to put all the regenerated state trees M' into the current state set until the current state set no longer generates new state trees to obtain the final state set and transition set of the deterministic automaton.

[0046] In a specific embodiment of the present invention, S400 includes: S410, setting a set pair for each node in the final state set, denoted as a first set Am and a second set Rm; S420, using the acceptance flag and the rejection flag in the transition information to determine the corresponding node, and assigning the transition corresponding to the transition information in the transition set to the set pair of the node, thereby defining the acceptance condition of the deterministic automaton to obtain a deterministic receiver.

[0047] The DRA acceptance condition is a set of set pairs. The number of set pairs depends on the number of possible node names in the one-index MullerSafra tree. Each possible node name corresponds to a set pair. The node name is used as the subscript of the set in the set pair to represent the correspondence. That is, if the node name m may appear in a one-index MullerSafra tree, then there is a corresponding set pair in the DRA acceptance condition. m , R m ​>. In the process of constructing the migration system, each migration has a corresponding receiving flag sig acc and rejection flag sig rej The receiving condition construction module allocates each migration according to the corresponding acceptance / rejection flag of the migration: if the acceptance flag sig of a migration is acc contains the name m, then the migration is assigned to the first set A in the set pair corresponding to name m. m ; If a migration rejection flag sig rej contains the name m, then assign the migration to the second set R in the set pair corresponding to name m. m .

[0048] For example, the receiving flag sig of the migration record (M, σ, M′) acc ={0.5 1 .0 1}、Rejection flag sig rej ={0.5 2 , 0.5 3}, then the migration will be assigned to 0.5 1 .0 1 The first set in the corresponding set pair, and 0.5 2 and 0.5 3 The second set in the corresponding set pair, namely (M, σ, M′)∈A 0.5 1 .0 1 ,(M,σ,M′)∈R 0.5 2 And (M, σ, M′)∈R 0.5 3 .

[0049] The migration system combined with the reception condition constitutes a DRA equivalent to one-index NMAM1. Based on this, for a general NMAM with k indices in the reception condition = (Σ, Q, Q0, δ, {λ1, λ2, ..., λ k}), where |Q|=n, which can be viewed as k one-index NMAM11, M12, ..., M1 k Each one-indexNMA has the same migration system as NMAM, but the receiving condition contains only one index, namely M1 i =(Σ, Q, Q0, δ, {λ i}), where 1≤i≤k. Further, each one-index NMAM1 i All of them can be determined as DRAR through the one-index Muller-Safra tree i=(Σ,Q i ,q0 i , δ i , i , R i > [P(i)] ),in, i , R i > [P(i)] ={ <A1 i , R1 i >, <A2 i , R2 i >, …, P(i) i , R P(i) i >}. Finally, for k DRAR i Find the union and get the final DRAR=(Σ,Q R ,q R0 , δ R ,λ R ),in, Q R ∈Q 1 ×Q 2 ×⋯×Q k ; q R0 ={q0 1 ,q0 2 ,…,q0 k}; 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 ,σ)}; λ 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.

[0050] This DRAM is a deterministic automaton obtained by determinizing NMAM, and the state complexity of R is 2 O(nklogn) Compared with the existing deterministic method of NMA, the method provided by the present invention has lower state complexity.

[0051] According to the number of indices in the Muller automaton acceptance condition, the Muller automaton is split into multiple single-index Muller automata, and the single-index Muller automata are determinized into deterministic automata through the one-index MullerSafra tree. Finally, the multiple deterministic automata obtained are complemented.

[0052] Furthermore, to demonstrate the practical effects of the two existing and presently proposed NMA determinization methods, the present invention designed and implemented a determinization tool, NM2DR, for NMAs. This tool is developed in Java on a Windows platform and supports both NMA determinization methods. Based on this, a series of NMAs were randomly generated as a test set. This test set contained 100 randomly generated NMAs, 10 each with states of 5, 6, …, and 14. The experimental results are shown in Table 1, where "NMA" represents the test cases with different states in the test set. For NMAs with the same number of states, the average value of their number of states, number of transitions, and number of indices was taken as experimental data. Similarly, the average value of the corresponding DRA was also taken. NMA-NBA-DRA represents the DRA obtained by the determinization method using NBA as an intermediate transformation, while NMA-DRA represents the DRA obtained by the present invention's determinization method. The experimental results in Table 1 demonstrate that the DRA obtained by determinizing the NMA using the present invention's method indeed has a lower number of states, meeting expectations. As for the equivalence of the automata before and after determinization of the test case, we use the existing tool Spot to verify it. The parameter equivalent_to of this tool has the function of verifying the equivalence of any two automata. The last column in Table 1 shows the verification results, where "T" indicates that the automata before and after determinization are equivalent.

[0053] Table 1 Experimental results of NMA transformation into DRA

[0054] It is worth noting that the terms "first" and "second" in this disclosure are used for descriptive purposes only and should not be understood to indicate or imply relative importance or implicitly specify the number of the technical features indicated. Therefore, features defined as "first" or "second" may explicitly or implicitly include one or more of such features. In the description of this disclosure, "plurality" means two or more, unless otherwise specifically defined.

[0055] The above is a further detailed description of the present invention in conjunction with specific preferred embodiments, and the specific implementation of the present invention should not be considered to be limited to these descriptions. For those skilled in the art of the present invention, without departing from the concept of the present invention, several simple deductions or substitutions can be made, which should be considered to fall within the scope of protection of the present invention.

Claims

1. A tree-structured Muller automaton deterministic method, characterized in that: Comprising: S100, constructing an initial state tree as the initial state of a deterministic automaton; S200, reading out 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 a state tree; During the current loop transformation process, reading out a new letter from the alphabet and assigning it to the state tree in the state set to change its structure and thereby regenerate a state tree, and recording the transition information of the state tree during the current loop transformation process; S300, putting the state tree 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 tree is 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.

2. The tree-structured Muller automaton deterministic method according to claim 1, characterized in that: The initial state tree uses a seven-tuple<V,τr,p,l,j,stor,Mj> Represents, where V is the set of all nodes, τr is the root node, p is the parent node function, l : V → 2Q is a state labeling function that labels all nodes with a subset of the 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 0, and the child nodes of the root node are labeled k′+1; each leaf node is labeled with an integer from 1 to k′, and among all leaf nodes, the sibling nodes are labeled with different integers; all other nodes are labeled 0; each non-root node labeled k′+1 or 0 has at least one is the child node of the leaf node; stor represents the parameter used to define the structural order between sibling nodes. For any two sibling nodes τ and τ′, τ′ is located 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. Among the left sibling nodes of node τ, the number of nodes with the same key-value label as its left sibling is represented as i.

3. The tree-structured Muller automaton deterministic method according to claim 2, characterized in that: S200 includes: S210, reading out a letter from a predefined alphabet and assigning it to the initial state tree so that it changes its own structure and state according to the letter 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 label, 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'.

4. The tree-structured Muller automaton deterministic method according to claim 3, 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 traversed node τi, if the node exists j(τi)=k′+1 and l(τi)∩Q\λ′≠ , then the node p(τi) generates a new youngest child node τ′, whose 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; 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.

5. The tree-structured Muller automaton deterministic method according to claim 4, 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, and 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.

6. The tree-structured Muller automaton deterministic method according to claim 5, 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.

7. The tree-structured Muller automaton deterministic method according to claim 6, characterized in that: The process of renaming a node in S220 includes: Traverse each named node in the state tree M4 in hierarchical order and rename it by applying 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 it is named is added to the rejected flag to obtain the state tree M5.

8. The tree-structured Muller automaton deterministic method according to claim 7, characterized in that: The process of generating a child node 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 τ′, whose state label l(τ′)=l(τ) and key-value label j(τ′)=k′; use the node naming rule to assign names to the unnamed nodes in the state tree M5 to obtain the regenerated state tree M′.

9. The tree-structured Muller automaton deterministic method according to claim 8, characterized in that: S300 includes: S310, putting the state tree M′ regenerated in the current loop conversion process into the current state set to form a new state set; S320, repeating the process of S200 to put all the regenerated state trees M' into the current state set until the current state set no longer generates new state trees to obtain the final state set and transition set of the deterministic automaton.

10. The tree-structured Muller automaton deterministic method according to claim 1, characterized in that: S400 includes: S410, setting a set pair for each node in the final state set, denoted as a first set Am and a second set Rm; S420, using the acceptance flag and the rejection flag in the transition information to determine the corresponding node, and assigning the transition corresponding to the transition information in the transition set to the set pair of the node, thereby defining the acceptance condition of the deterministic automaton to obtain a deterministic receiver.

Images