Approximate Bisimulation and Optimization of Software Programs Based on Symbolic-Numeric Computation

Abstract

To achieve behavior and structure optimization for a type of software program whose data exchange processes are represented by nonlinear polynomial systems, this paper establishes a novel formal description called a nonlinear polynomial transition system to represent the behavior and structure of the software program. Then, the notion of bisimulation for software programs is proposed based on the equivalence relation of corresponding nonlinear polynomial systems in their nonlinear polynomial transition systems. However, the exact equivalence is too strict in application. To enhance the flexibility of the relation among the different software systems, the notion of approximate bisimulation within a controllable error range and the calculation algorithm of approximate bisimulation based on symbolic-numeric computation are given. In this calculation, an approximate relation is represented as a MAX function that is resolved with the full filled method. At the same time, the actual error is calculable. An example on a multithreading program indicates that the approximate bisimulation relation is feasible and effective in behavior and structure optimization.

1. Introduction

With the development of computer software technology and the increase in user requirements for the function of software programs, the structure and behavior of software programs have been growing more and more complex. This change will make the design and property verification processes increasingly difficult. However, if we can achieve a method that can optimize the behavior and structure, then this accomplishment will most likely make a significant difference.

In the process of achieving this method, establishing a formal description is a prerequisite of researching the behavior and structure of the software program. The previous formal descriptions of the software programs are discrete concurrent systems, which are composed of abstract behaviors, discrete states, and transitions between states [1–5]. These descriptions are good at calculating and reasoning against programs that are based on ergodic states. Nevertheless, they cannot successfully express the data exchange processes of the software program. The representations of data exchange processes are diverse for example, they can be described by a polynomial algebraic system, a semialgebraic system, a differential algebraic system, and a differential semialgebraic system [6–9]. Among these systems, research on a particular type of software program whose data exchange processes can be described by polynomial algebraic systems can form a basis for researching other types of programs. Thus, we will study this type of software program first. For a polynomial algebraic system, its representation can also be divided into several different types, for example, a homogeneous linear polynomial system, a nonhomogeneous linear polynomial system, or a nonlinear polynomial system, among others. The software programs that have different behavior and structure correspond to different types of polynomial systems and optimization methods. We have already studied the descriptions of one type of software program, whose data exchange processes can be described by linear polynomial systems, and one type of high-level datapath system, whose data exchange processes can be expressed by nonlinear polynomial systems, and these are referred to as a linear polynomial transition system and a polynomial transition system, respectively [10, 11]. These descriptions are a basis for proposing an appropriate description of the type of software programs that are researched in this paper, whose data exchange processes can be expressed by nonlinear polynomial systems.

In addition to the above prerequisite, to define and determine the behavior equivalence relation for programs is another precondition to obtain behavior and structure optimization. With equivalence, the equivalent nondeterministic branches are removed, and the complex branch is replaced with a simpler branch. Two software programs are behavior equivalent representations that have the same function. To evaluate equivalence, bisimulation is the best behavior equivalence relation that we can utilize today [12, 13]. If two or more software programs are bisimular, then the solutions of the polynomial systems of their corresponding branches in their transition systems are the same. Based on the nature of bisimulation, researchers have already used it to optimize the design and verification of complex systems, such as hybrid systems and dynamical systems [14, 15]. We have also chosen it to process software programs that are represented by linear polynomial transition systems. For the type of software program researched in this paper, this type of equivalence theory will be established.

Exact equivalence can achieve behavior and structure optimization, but this type of equivalence is too strict to be a good solution for programs in which there are errors in the applications. Take a square with side length 1, for example; the length of its diagonal line is √2. Because √2 is an irrational number, strictly speaking, we can only make the length of the diagonal line approximately be equal to√2. Therefore, there exists an error. For this type of application, exact equivalence is not practical. To strengthen the flexibility of the equivalence relation for different systems, an approximate equivalence within a controllable error range is a good solution. Thus far, approximate bisimulation has been established and applied to optimize the task of property verification for hybrid systems and dynamical systems [16–18]. For software programs that are represented by linear polynomial transition systems, the corresponding approximate relation has been given. Unfortunately, this calculation of an approximate equivalence relation cannot be applied to process the types of software programs that are researched in this paper.

For the calculation of approximate equivalence, symbolic-numeric computation can provide us with technical support [19, 20]. The fact that two software programs are approximate means that the solutions of the polynomial systems of the corresponding branches in their transition systems are approximately the same. It also means that the solutions of one system can make another system approximately be equal to zero. This relationship can be expressed as a constrained global optimization, which is called the MAX function in this paper. In the existing literature, there are many different methods that can be used to solve this constrained global optimization. Among these methods, the full filled method proposed by Ge [21–23] is one of the most widely used. Based on this author’s studies, researchers perform some related research and made some improvements [24, 25]. We will use the full filled method in the literature [26] because it has fewer unknown parameters. With this method, the value of the exact error caused by an approximation can be computed.

In the next section, we provide a new formal description, called a nonlinear polynomial transition system, which is used to describe the behavior and structure of the type of software program whose data exchange processes are represented by nonlinear polynomial systems. In Section 3, we give the notion and algorithm of bisimulation after analyzing the condition of equivalence for these software programs. Based on this relation, the notion and the calculation of the algorithm for approximate bisimulation are described in detail in Section 4. The approximate relation is expressed as a constrained global optimization called the MAX function, which is solved by the full filled method. In Section 5, an example of a multithreading program shows that our approach obtains three useful results, which are listed as follows. The last section presents our conclusions.(i)The data exchange processes of software programs are described.(ii)The equivalence and approximate relations are determined for software programs based on symbolic-numeric computation. (iii)The behavior and structure optimization for the software program are achieved.

2. Nonlinear Polynomial Transition System

The definition of a nonlinear polynomial transition system is introduced in this section. This definition is used to describe a type of software program whose data exchange processes can be represented by nonlinear polynomial systems.

This nonlinear polynomial transition system is composed of states and transitions, which provide us with a supportive framework to research the behavior and the structure of software programs. A transition that is expressed by a nonlinear polynomial system shows a part of the data exchange process. A function is a transition. The statements between two functions can also be considered to be transitions.

First, we must establish a transform rule between a part of the data exchange process and a nonlinear polynomial system, which is established as follows.

Algorithm 1. The transform rule between a part of the data exchange process of a software program and a nonlinear polynomial system.
Input: A part of the data exchange process within a software program.
Output: A nonlinear polynomial system.
Step 1. If there are many assignment statements that assign values to the same variable and that variable does not appear on the right side of the assignment statements, then remove the assignment statements except for the last one.
Step 2. Change the symbols of the variables on the left side of the assignment statements by adding intermediate variables after Step 1.
Step 3. If a variable on the right side of the assignment statements is the same as a variable on the left side of the assignment statements before Step 2, then change the symbol of the variable on the right side of the assignment statements with the symbol of the variable on the left side of the last assignment statement after Step 2.
Step 4. Add the assignment statements into NLPS after being processed by Steps 1, 2, and 3.
Step 5. For the conditional statements, if there are variables that were assigned before them, then first change the symbol of these variables with their symbols on the left side of their last assignment statements after Step 2, respectively; then, add these conditional statements into NLPS. Otherwise, add the conditional statements into NLPS directly.

In NLPS, the variables are temporary variables if they can be eliminated. The remainders are global variables, which play an important role in judging the equivalence relations of the software programs. Based on this transform rule, the notion of a nonlinear polynomial transition system for software programs can be given as follows.

Definition 2. A nonlinear polynomial transition system is a tuple ⟨𝑉,𝑆,𝑇,𝑄₀,𝑣₁⟩ that includes(i)a set 𝑉 of variables, including temporary variables and global variables; (ii)a set 𝑆 of states, which are the values of the variables in 𝑉; (iii) a set 𝑇 of transitions; each of the transitions is a tuple ⟨𝑠₁,𝑠₂,NLPS,𝑣₀⟩:(a)𝑠₁ and 𝑠₂ are the pre- and postglobal states of a transition;(b)the transition relation NLPS is a nonlinear polynomial system; (c)𝑣₀ represents the global variables of this transition;(iv)𝑄₀ is the initial state of this software program; (v)a set 𝑣₁ of global variables; the form of 𝑣₁ can be defined as follows: 𝑣₁=𝑣_in,𝑣_out={{{{},…,{}}_layer∶1,…,{{},…,{}}_layer∶𝑛},{{{},…,{}}_layer∶1,…,{{},…,{}}_layer∶𝑛}}, (1)where 𝑣_in is a set of global input variables and 𝑣_out is a set of global output variables. The layer number of the nonlinear polynomial transition system is 𝑛. If we consider every nonlinear polynomial transition system to be a tree, then the layer number is considered to be the depth of the tree. Every bracket represents the set of global input or output variables of one branch in this layer.
Corresponding to the form of 𝑣₁, we can give a definition of a set of global states 𝑠: 𝑠=𝑠₁,𝑠₂={{{{},…,{}}_layer∶1,…,{{},…,{}}_layer∶𝑛},{{{},…,{}}_layer∶1,…,{{},…,{}}_layer∶𝑛}}, (2) where 𝑠₁ is a set of global input states and 𝑠₂ is a set of global output states.
To describe the transform process between a software program and a nonlinear polynomial transition system clearly, an example is given in Figure 1. The value of 𝑄₀ is given in advance.
With this transform process, we discover that the behavior and structure of a software program are successfully expressed by a nonlinear polynomial transition system, which can also be represented by a transition graph. Compared with the description of a software program language, the forms of a transition system and transition graph are more direct. Moreover, based on the transform process, the behavior equivalence relation between two data exchange processes of software programs can be described by Definition 3.

Figure 1 

Transform process.

Definition 3. The data exchange processes ⟨𝑠₁₁,𝑠₁₂,NLPS₁,𝑣₀₁⟩ and ⟨𝑠₂₁,𝑠₂₂,NLPS₂,𝑣₀₂⟩ of a software program are equivalent; if NLPS₁ and NLPS₂ have solutions in 𝐐, 𝑣₀₁ and 𝑣₀₂ are the same, then there is(i)∀𝑥−−−−−→₁^NLPS1𝑥₂, ∃𝑦₁=𝑥₁, 𝑦−−−−−→₁^NLPS2𝑦₂, and 𝑥₂=𝑦₂,(ii)∀𝑦−−−−−→₁^NLPS2𝑦₂, ∃𝑥₁=𝑦₁, 𝑥−−−−−→₁^NLPS1𝑥₂, and 𝑦₂=𝑥₂,where 𝑥₁×𝑥₂∈𝑠₁₁×𝑠₁₂, 𝑦₁×𝑦₂∈𝑠₂₁×𝑠₂₂, the variables that correspond to 𝑥₁and 𝑦₁are the same, and the variables that correspond to 𝑥₂ and 𝑦₂ are the same. 𝐐 is a rational number field.
Within this definition, stating that the solutions of two nonlinear polynomial systems are the same implies that their corresponding data exchange processes in a software program are behavior equivalent.
After determining the relation for two data exchange processes, how to establish the definition of behavior equivalence for the whole software program must also be researched because there could be many layers and many branches in the same layer in a software program.

3. Bisimulation for Nonlinear Polynomial Transition Systems

In process algebra, equivalence verification is one of the most important parts and bisimulation is the finest equivalence semantic that can provide the most exact equivalence relation for systems. With equivalence determination, the extra transitions, called nondeterminism, can be removed and a complex branch can be replaced with a simple branch.

3.1. The Definition of Bisimulation

Let there be two nonlinear polynomial transition systems: 𝐴∶𝑉₁,𝑆₁,𝑇₁,𝑄₀₁,𝑣₁₁,𝐵∶𝑉₂,𝑆₂,𝑇₂,𝑄₀₂,𝑣₁₂. (3) The global state sets of them are 𝑠_𝐴=𝑠_1𝐴,𝑠_2𝐴={{{{},…,{}}_layer∶1,…,{{},…,{}}_layer∶𝑎},{{{},…,{}}_layer∶1,…,{{},…,{}}_layer∶𝑎,𝑠}}_𝐵=𝑠_1𝐵,𝑠_2𝐵={{{{},…,{}}_layer∶1,…,{{},…,{}}_layer∶𝑏},{{{},…,{}}_layer∶1,…,{{},…,{}}_layer∶𝑏}}, (4) where the symbol 𝑠_{𝑖𝑗𝑚𝑛} represents the 𝑛th branch of the 𝑚th layer in 𝑠_𝑖𝑗.

The sets of nonlinear polynomial systems of 𝐴 and 𝐵 can also be given as follows: NLPS₁={{{},…,{}}_layer∶1,…,{{},…,{}}_layer∶𝑎},NLPS₂={{{},…,{}}_layer∶1,…,{{},…,{}}_layer∶𝑏}, (5) where the symbol NPLS_𝑖𝑚𝑛 represents the 𝑛th branch of the 𝑚th layer in NLPS_𝑖.

Definition 4. A binary relation 𝐑⊆𝑠_𝐴×𝑠_𝐵 is called bisimulation; if 𝑣₁₁and 𝑣₁₂ are exactly the same, NLPS_{1𝐴𝑙𝑚} and NLPS_{2𝐵𝑙𝑔} have solutions in 𝐐, and 𝑎=𝑏, then, for all (𝑥₁×𝑦₁)∈𝐑, there are(i)∀𝑥−−−−−−−−→₁^{NLPS1𝐴𝑙𝑚}𝑥₂, ∃𝑦₁=𝑥₁, 𝑦−−−−−−−→₁^{NLPS2𝐵𝑙𝑔}𝑦₂, 𝑥₂𝐑𝑦₂, and 𝑥₂=𝑦₂,(ii)∀𝑦−−−−−−−→₁^{NLPS2𝐵𝑙𝑔}𝑦₂, ∃𝑥₁=𝑦₁, 𝑥−−−−−−−−→₁^{NLPS1𝐴𝑙𝑚}𝑥₂, 𝑥₂𝐑𝑦₂, and 𝑥₂=𝑦₂.
Then, 𝐴 and 𝐵 are bisimular, with the notation 𝐴=_𝐵𝐸𝐵.
Where 𝑥₁∈𝑠_{1𝐴𝑙𝑚}, 𝑥₂∈𝑠_{2𝐴𝑙𝑚}, 𝑦₁∈𝑠_{1𝐵𝑙𝑔}, 𝑦₂∈𝑠_{2𝐵𝑙𝑔}, the variables that correspond to 𝑥₁ and 𝑦₁ are the same, and the variables that correspond to 𝑥₂ and 𝑦₂ are the same.
With this definition, we can determine whether there is a bisimulation relation or not between two software programs. If two software programs are bisimular, then their transition systems are bisimular. This fact also means that if there exists a transition for one, there exists the same transition for another and vice versa. This statement represents that the solutions are the same for the polynomial systems of the corresponding branches in the nonlinear polynomial transition system for the software program as well. Therefore, the bisimulation relation between software programs has the following nature.

Theorem 5. The bisimulation relation for nonlinear polynomial transition systems exists.(i)Reflexivity: 𝐴=_𝐵𝐸𝐴, if there is a nonlinear polynomial transition system 𝐴.(ii)Symmetry: 𝐵=_𝐵𝐸𝐴, if 𝐴=_𝐵𝐸𝐵.(iii)Transitivity: 𝐴=_𝐵𝐸𝐶, if 𝐴=_𝐵𝐸𝐵 and 𝐵=_𝐵𝐸𝐶.

Proof. (i) For reflexivity: the behavior and structure of 𝐴 are the same as itself; thus, 𝐴=_𝐵𝐸𝐴.
(ii) For symmetry: if 𝐴=_𝐵𝐸𝐵, then the corresponding branches of 𝐴 and 𝐵 are equivalent, which implies that the corresponding branches of 𝐵 and 𝐴 are equivalent; thus, 𝐵=_𝐵𝐸𝐴.
(iii) For transitivity: if 𝐴=_𝐵𝐸𝐵, then the corresponding branches of 𝐴 and 𝐵 are equivalent.
If 𝐵=_𝐵𝐸𝐶, then the corresponding branches of 𝐵 and 𝐶 are equivalent. Therefore, the corresponding branches of 𝐴 and 𝐶 are equivalent, which can be expressed with the notation 𝐴=_𝐵𝐸𝐶.
Thus, the bisimulation relation between the software programs is an equivalence relation.

3.2. The Calculation of Bisimulation

After obtaining the definition of behavior equivalence for a software program, we must establish a method for determining whether the solutions of two nonlinear polynomial systems are the same or not. For the type of software programs studied in this paper, Ritt-Wu’s method [27] can be used to determine this solution relation.

Theorem 6. If 𝐶_𝐴 and 𝐶_𝐵 are the same, then the solutions of 𝐴 and 𝐵 are the same, which means that 𝐴 and 𝐵 are equivalent.

Proof. Because 𝐶_𝐴 and 𝐶_𝐵 are the same, then the initials 𝐼_𝐴𝑖 and 𝐼_𝐵𝑖 are the same, which correspond to 𝐶_𝐴 and 𝐶_𝐵, respectively. At the same time, 𝑠_𝐴=^𝑒_𝑖=1Zero𝐶_𝐴𝑖/𝐼_𝐴𝑖,𝑠_𝐵=^𝑒_𝑖=1Zero𝐶_𝐵𝑖/𝐼_𝐵𝑖. (6)
The irreducible characteristic set of a polynomial system is unique; thus, there is 𝑠_𝐴=^𝑒_𝑖=1Zero𝐶_𝐴𝑖/𝐼_𝐴𝑖=𝑠_𝐵=^𝑒_𝑖=1Zero𝐶_𝐵𝑖/𝐼_𝐵𝑖. (7)
Then, 𝐴 and 𝐵 are equivalent where 𝐴 and 𝐵 are nonlinear polynomial systems. 𝐶_𝐴=[𝐶_𝐴1,…,𝐶_𝐴𝑒] and 𝐶_𝐵=[𝐶_𝐵1,…,𝐶_𝐵𝑒] are the irreducible characteristic sets of 𝐴 and 𝐵, respectively. Here, 𝑠_𝐴 and 𝑠_𝐵 are the solutions of 𝐴 and 𝐵, respectively.
Therefore, a unique condition that is used to determine the solution relation of the nonlinear polynomial systems is obtained.
This determination in the equivalence relation is based on symbolic computation. From analysis, we discover that numerical computation can also be used in this process, because if the solutions of the two polynomial systems are the same, then the solutions of one system can make another system be equal to zero. In other words, if we change one system into a special formula, the solutions of another system can approximately make the maximum value of this formula be equal to zero. This process can be considered to be a constrained global optimization. Because there are approximate processes while we are addressing this constrained global optimization problem, we will therefore implement this process in the next section.

4. Approximate Bisimulation for Nonlinear Polynomial Transition Systems

Exact equivalence requires that the solutions of two polynomial systems must be identical, which appears to be too restrictive and not practical for some software programs. An appropriate approximation within a controllable error range can be a good solution for addressing this issue. By approximation, different software programs might be changed into approximately the same program. Then, the simpler programs can be used to approximately replace the complex programs. Therefore, behavior and structure approximate optimization can be achieved.

4.1. The Definition of Approximate Bisimulation

Suppose that there are two nonlinear polynomial transition systems. The descriptions of the variables of these two systems are the same as the descriptions in Section 3.1.

Definition 7. The data exchange processes ⟨𝑠₁₁,𝑠₁₂,NLPS₁,𝑣₀₁⟩ and ⟨𝑠₂₁,𝑠₂₂,NLPS₂,𝑣₀₂⟩ of a software program are approximate; if NLPS₁ and NLPS₂ have solutions in 𝐐, 𝑣₀₁ and 𝑣₀₂ are the same, and 𝜀≤𝛿, then there is(i)∀𝑥−−−−−→₁^NLPS1𝑥₂, ∃𝑦−−−−−→₁^NLPS2𝑦₂ and ∃𝑥−−−−−→₁^NLPS2_𝜀𝑥₂, then, 𝑦₁=_𝜀𝑥₁∪𝑦₁, 𝑦₂=_𝜀𝑥₂∪𝑦₂.(ii)∀𝑦−−−−−→₁^NLPS2𝑦₂, ∃𝑥−−−−−→₁^NLPS1𝑥₂ and ∃𝑦−−−−−→₁^NLPS1_𝜀𝑦₂, then, 𝑥₁=_𝜀𝑥₁∪𝑦₁, 𝑥₂=_𝜀𝑥₂∪𝑦₂,where 𝑥₁×𝑥₂∈𝑠₁₁×𝑠₁₂, 𝑦₁×𝑦₂∈𝑠₂₁×𝑠₂₂, the variables that correspond to 𝑥₁ and 𝑦₁ are the same, and the variables that correspond to 𝑥₂ and 𝑦₂ are the same. Here, 𝑚=_𝜀𝑚∪𝑛 (8) represents that we place 𝑛 into 𝑚 to form a new 𝑚 with an error 𝜀. Then, 𝑚−−−−→^NLPS_𝜀𝑛 (9) represents that 𝑚 and 𝑛 are the approximate solutions of NLPS with an error 𝜀. Here, 𝜀 is the exact error and 𝛿 is the precision.
This definition shows that two data exchange processes are approximate if the solutions of their corresponding nonlinear polynomial systems are approximate. Based on this definition, the approximate relation for the entire software program can be given as follows.

Definition 8. A binary relation 𝐑_𝜀⊆𝑠_𝐴×𝑠_𝐵 is called an approximate bisimulation; if 𝑣₁₁ and 𝑣₁₂ are the same, NLPS_{1𝐴𝑙𝑚} and NLPS_{2𝐵𝑙𝑔} have solutions in 𝐐, 𝑎=𝑏, and 𝜀≤𝛿, then, for all (𝑥₁×𝑦₁)∈𝐑_𝜀, there are(i)∀𝑥−−−−−−−−→₁^{NLPS1𝐴𝑙𝑚}𝑥₂, ∃𝑦−−−−−−−→₁^{NLP𝑆2𝐵𝑙𝑔}𝑦₂, and ∃𝑥−−−−−−−→₁^{NLPS2𝐵𝑙𝑔}_{𝜀𝑙(𝑚𝑔)}𝑥₂; then, 𝑦₁=_{𝜀𝑙(𝑚𝑔)}𝑥₁∪𝑦₁, 𝑦₂=_{𝜀𝑙(𝑚𝑔)}𝑥₂∪𝑦₂, and 𝑥₂𝐑_𝜀𝑦₂.(ii)∀𝑦−−−−−−−→₁^{NLPS2𝐵𝑙𝑔}𝑦₂, ∃𝑥−−−−−−−−→₁^{NLPS1𝐴𝑙𝑚}𝑥₂, and ∃𝑦−−−−−−−−→₁^{NLPS1𝐴𝑙𝑚}_{𝜀𝑙(𝑚𝑔)}𝑦₂; then, 𝑥₁=_{𝜀𝑙(𝑚𝑔)}𝑥₁∪𝑦₁, 𝑥₂=_{𝜀𝑙(𝑚𝑔)}𝑥₂∪𝑦₂, and 𝑥₂𝐑_𝜀𝑦₂.
Then, 𝐴 and 𝐵 are approximately bisimular, with the notation 𝐴=_𝐴𝐵𝐵.
Where 𝑥₁∈𝑠_{1𝐴𝑙𝑚}, 𝑥₂∈𝑠_{2𝐴𝑙𝑚}, 𝑦₁∈𝑠_{1𝐵𝑙𝑔}, 𝑦₂∈𝑠_{2𝐵𝑙𝑔}, the variables that correspond to 𝑥₁ and 𝑦₁ are the sam, and the variables that correspond to 𝑥₂ and 𝑦₂ are the same.
Here, 𝜀_{𝑙(𝑚𝑔)} represents the error between NPLS_{1𝐴𝑙𝑚} and NPLS_{2𝐵𝑙𝑔}.
For two different nonlinear polynomial systems, the error between them can be calculated by the function norm. For the nonlinear polynomial transition system researched in this paper, there are always many branches and layers; thus, a measurement rule for the exact error must be given.

Step 1. For different branches in the same layer, compute the errors of every two of them first. Then, choose the largest one as the error in that layer.

Step 2. For the whole nonlinear polynomial transition system, compute the error of every layer with Step 1; then, the total error of the system is found by taking the sum.

With the previous definition, software programs that are approximately bisimular are those for which the solutions of the polynomial systems of the corresponding branches in their nonlinear polynomial transition systems are approximately the same. In other words, if we change a nonlinear polynomial system into a special formula, the solutions of another system can make the maximum value of this formula approximately be equal to zero. This process can be considered to be a constrained global optimization and its description is given as follows.

Given two nonlinear polynomial systems, as follows: 𝑝₁=0,𝑝₂𝑓=0;₁=0,𝑓₂=0,𝑓₃=0. (10)

Then, change them into two constrained global optimizations, called MAX functions, as follows max𝑝²₁+𝑝²₂s.t.𝑓₁𝑓=0₂𝑓=0₃=0;max𝑓²₁+𝑓²₂+𝑓²₃s.t.𝑝₁𝑝=0₂=0, (11) which can also be expressed as follows: max𝑝²₁+𝑝²₂s.t.𝑓₁𝑓=0₂𝑓=0₃=0;max𝑓²₁+𝑓²₂+𝑓²₃s.t.𝑝₁𝑝=0₂=0. (12)

The results of these two constrained global optimizations fall into three categories.(i)If the two maximum values are equal to zero, then the two nonlinear polynomial systems are equivalent. Thus, the determination of bisimulation between two nonlinear polynomial transition systems in Section 3.2 can be solved based on numerical computation.(ii)If the two maximum values are not more than the precision, then two nonlinear polynomial systems are approximate. Therefore, the determination of approximate bisimulation between two nonlinear polynomial transition systems is achieved.(iii)If one of the two maximum values is more than the precision, then two nonlinear polynomial systems are not approximate.

The maximum value can be achieved by the full filled method. In this process, the maximum number of iterations and the step length of variables must be given in advance.

4.2. The Calculation of Approximate Bisimulation

For a software program, we hope to optimize its behavior and structure through approximately optimizing its formal description; this approach is called a nonlinear polynomial transition system with approximate bisimulation.

When the variables of the corresponding branches in polynomial transition system are the same, the framework of approximate bisimulation of a software program contains four parts: (i)change the software program into a nonlinear polynomial transition system;(ii)group the corresponding branches of the transition system;(iii) determine the relations of corresponding branches by symbolic-numeric computation;(iv) achieve the behavior and structure optimization by reducing the equivalent or approximate branches for the given program.

The detailed computation algorithm of approximate bisimulation is shown as follows, which is described in Figure 2.

Figure 2 

Approximate bisimulation for the nondeterministic branches of a software program.

Algorithm 9. The calculation algorithm of approximate bisimulation for the nondeterministic branches of a software program based on symbolic-numeric computation.
Input: A software program expressed by a nonlinear polynomial transition system.
Output: An optimized software program for the given software program.
Step 1. Change the software program into a nonlinear polynomial transition system. Let 𝛿 be the precision. Group the corresponding branches with bisimulation relations. Suppose that the number of groups is 𝑚. We are given a counter 𝑖 that starts with 𝑖=1.
Step 2. Process the 𝑖th group. Let the precision 𝛿_𝑖 in this group belong to the following: 0,𝛿−^𝑖−1_𝑒=1𝛿_𝑒. (13)
Step 3. Choose Ritt-Wu’s method and the MAX function to determine the relation of each of the two branches in this group.
Step 3.1. If irreducible characteristic sets are the same and the errors are equal to zero, then these branches are equivalent. Choose the simplest branch to replace them and go to Step 5. Otherwise, go to Step 3.2.
Step 3.2. If the errors are not more than 𝛿_𝑖, then these branches are approximate. Then, choose an appropriate branch to replace them and go to Step 5. Otherwise, go to Step 3.3.
Step 3.3. Let the number of branches be 𝑎, and label them from 1 to 𝑎 Initiate a counter 𝑏 at 𝑏=1 and go to Step 4.
Step 4. Determine the relation between the 𝑏th branch and the other branches from the (𝑏+1)th to the 𝑎th branch. Let the symbol of the nonlinear polynomial system that corresponds to the 𝑗th branch be 𝐽_𝑗. Let 𝜀_𝑏+1=𝐽_𝑏−𝐽_𝑏+1,𝜀_𝑏+2=𝐽_𝑏−𝐽_𝑏+2,…,𝜀_𝑎=𝐽_𝑏−𝐽_𝑎. (14) Select 𝐽_𝑗 except for 𝐽_𝑏 to form a set 𝐴 when the errors are larger than 𝛿_𝑖. The remainder except for 𝐽_𝑏 forms a set 𝐵; go to Step 4.1.
Step 4.1. Let 𝑈=𝐴. Choose an appropriate element from 𝐵 and 𝐽_𝑏 to replace them. Let the symbol of this element be 𝐽_𝑤.
Step 4.2. The merger of 𝑈 and 𝐽_𝑤 forms a new group, which is to be considered as the new 𝑖th group. Let the number of branches of this new group be 𝑎, with 𝑏=2. If 𝑎>2, then go to Step 4; otherwise, go to Step 5.
Step 5. Increment 𝑖 with 𝑖++; if 𝑖≤𝑚, then go to Step 2; otherwise, end. A new polynomial transition system is achieved, which also means that a new optimized software program is got.

This algorithm gives a method to optimize the behavior and structure of a software program with approximate bisimulation.

If there are several different software programs, then we must know how to implement the determination of an approximate bisimulation for them.

The framework of approximate bisimulation of different software programs contains five parts:(i)optimize software programs by Algorithm 9  respectively;(ii)consider the optimized programs to be the nondeterministic branches of a new program;(iii) group the corresponding branches of the new program;(iv)determine the relations of corresponding branches by symbolic-numeric computation;(v)get the behavior and structure optimizations for the given programs by equivalence.

The detailed algorithm is also given as follows and is described by Figure 3.

Figure 3 

Approximate bisimulation for software programs.

Algorithm 10. The calculation algorithm of approximate bisimulation for software programs based on symbolic-numeric computation.
Input: Different software programs that are represented by nonlinear polynomial transition systems.
Output: Optimized software programs for the given software programs.
Step 1. Get the approximately optimized software programs for the given software programs by Algorithm 9. Then, consider these approximately optimized programs as the nondeterministic branches of a new software program.
Step 2. Group the corresponding branches of this new program. Let the number of groups be 𝑚 and use a counter 𝑖 that starts with 𝑖=1.
Step 3. If there are equivalent branches in the 𝑖th group as determined by Ritt-Wu’s method or the MAX function, then go to Step 4. Otherwise, go to Step 6.
Step 4. Choose the simplest one of them to replace them.
Step 5. Increment 𝑖 with 𝑖++; if 𝑖≤𝑚, then go to Step 3. Otherwise, go to Step 6.
Step 6. End. Achieve the last optimized software programs of the given programs.

5. Example Verification and Results

In this section, a multithreading program is used to demonstrate the efficiency of approximate bisimulation in the behavior and structure optimization of software programs.

5.1. Example Verification

The multithreading program is represented in Algorithm 1.

#include “main.h” WINMULTITHREAD Branch2Thread5(LPVOID pParam) {PThreadArg tharg = (PThreadArg)pParam;   double y1 = tharg->il, y2 = tharg->i2;   double z1 = MINIMUMVALUE, z2 = MINIMUMVALUE;   do {   do {   if (((y1*y1 - (0.01*y2 + 1)*z1) > -APPZERO &&   (y1*y1 - (0.01*y2 + 1)*z1) < APPZERO) &&   ((2*y1*y2 - z2 - 0.01) > -APPZERO &&   (2*y1*y2 - z2 - 0.01) < APPZERO)) {   printf(“one solution of HLPS9 is z1 = %f, z2 = %f∖n”, z1, z2);   }   z2 += GRANULARITY;   }while (z2 <= MAXIMUMVALUE);   z1 += GRANULARITY;   z2 = MINIMUMVALUE;   } while (z1 <= MAXIMUMVALUE); return 0; } WINMULTITHREAD Branch2Thread4(LPVOID pParam) {PThreadArg tharg = (PThreadArg)pParam;   double y1 = tharg->i1, y2 = tharg->i2;   double z1 = MINIMUMVALUE, z2 = MINIMUMVALUE;   do {   do {   if (((y1*y1 - z1) > -APPZERO &&   (y1*y1 - z1) < APPZERO) &&   ((2*y1*y2 - z2) > -APPZERO &&   (2*y1*y2 - z2) < APPZERO)) {   printf(“one solution of NLPS8 is z1 = %f, z2 = %f∖n”, z1, z2);   }   z2 += GRANULARITY;   }while (z2 <= MAXIMUMVALUE);   z1 += GRANULARITY;   z2 = MINIMUMVALUE;   } while (z1 <= MAXIMUMVALUE); return 0; } WINMULTITHREAD Branch1Thread3(LPVOID pParam) {PThreadArg tharg = (PThreadArg)pParam;   double y1 = tharg->i1, y2 = tharg->i2;   double z1 = MINIMUMVALUE, z2 = MINIMUMVALUE;   do {   do {   if (((-(y1*y2 + 1)*(y1*y2 + 1) + 3*z1) > -APPZERO &&   (-(y1*y2 + 1)*(y1*y2 + 1) + 3*z1) < APPZERO) &&   ((-z1 + z2*(y1*y2 + 1)) > -APPZERO &&   (-z1 + z2*(y1*y2 + 1)) < APPZERO)) {   printf(“one solution of NLPS6 is z1 = %f, z2 = %f∖n”, z1, z2);   }   z2 += GRANULARITY;   }while (z2 <= MAXIMUMVALUE);   z1 += GRANULARITY;   z2 = MINIMUMVALUE;   } while (z1 <= MAXIMUMVALUE); return 0; } WINMULTITHREAD Branch1Thread4(LPVOID pParam) {PThreadArg tharg = (PThreadArg)pParam;   double y1 = tharg->i1, y2 = tharg->i2;   double z1 = MINIMUMVALUE, z2 = MINIMUMVALUE;   do {   do {   if (((-z1 + (y1*y2 + 1)*z2) > -APPZERO &&   (-z1 + (y1*y2 + 1)*z2) < APPZERO) &&   ((-(y1*y2 + 1)*(y1*y2 + 1) + 2*z1 + z2*(y1*y2 + 1)) >   -APPZERO &&   (-(y1*y2 + 1)*(y1*y2 + 1) + 2*z1 + z2*(y1*y2 + 1)) <   APPZERO)) {   printf(“one solution of NLPS7 is z1 = %f, z2 = %f∖n”, z1, z2);   }   z2 += GRANULARITY;   }while (z2 <= MAXIMUMVALUE);   z1 += GRANULARITY;   z2 = MINIMUMVALUE;   } while (z1 <= MAXIMUMVALUE); return 0; } WINMULTITHREAD Branch1Thread2(LPVOID pParam) {HANDLE hThread13 = NULL;   PThreadArg tharg = (PThreadArg)pParam;   ThreadArg tharg12 = {0};   double x1 = tharg->i1, x2 = tharg->i2;   double y1 = MINIMUMVALUE, y2 = MINIMUMVALUE;   do {   do {   if (((3*x1 - y1*y1 + y2*y1) > -APPZERO &&   (3*x1 - y1*y1 + y2*y1) < APPZERO) &&   ((x2 - y2*y1) > -APPZERO &&   (x2 - y2*y1) < APPZERO)) {   printf(“one solution of NLPS3 is y1 = %f, y2 = %f∖n”, y1, y2);   tharg12.i1 = y1;   tharg12.i2 = y2;   hThread13 = CreateThread(NULL, 0, Branch1Thread3,                 (LPVOID)&tharg12, 0, NULL);   WaitForSingleObject(hThread13, INFINITE);   CloseHandle(hThread13);   }   y2 += GRANULARITY;   }while (y2 <= MAXIMUMVALUE);   y1 += GRANULARITY;   y2 = MINIMUMVALUE;   } while (y1 <= MAXIMUMVALUE); return 0; } WINMULTITHREAD Branch2Thread3(LPVOID pParam) {HANDLE hThread25 = NULL;   PThreadArg tharg = (PThreadArg)pParam;   ThreadArg tharg23 = {0};   double x1 = tharg->i1, x2 = tharg->i2;   double y1 = MINIMUMVALUE, y2 = MINIMUMVALUE;   do {   do {   if (((3*x1 - y1*y1 + x2) > -APPZERO &&   (3*x1 - y1*y1 + x2) < APPZERO) &&   ((x2 - y2*y1) > -APPZERO &&   (x2 - y2*y1) < APPZERO)) {   printf(“one solution of NLPS5 is y1 = %f, y2 = %f∖n”, y1, y2);   tharg23.i1 = y1;   tharg23.i2 = y2;   hThread25 = CreateThread(NULL, 0, Branch2Thread5,                  (LPVOID)&tharg23, 0, NULL);   WaitForSingleObject(hThread25, INFINITE);   CloseHandle(hThread25);   }   y2 += GRANULARITY;   }while (y2 <= MAXIMUMVALUE);   y1 += GRANULARITY;   y2 = MINIMUMVALUE;   } while (y1 <= MAXIMUMVALUE); return 0; } WINMULTITHREAD Branch2Thread2(LPVOID pParam) {HANDLE hThread24 = NULL;   PThreadArg tharg = (PThreadArg)pParam;   ThreadArg tharg22 = {0};   double x1 = tharg->i1, x2 = tharg->i2;   double y1 = MINIMUMVALUE, y2 = MINIMUMVALUE;   do {   do {   if (((3*x1 - 0.99*y1*y1 + y2*y1 - 0.01*y2*x1) >   -APPZERO &&   (3*x1 - 0.99*y1*y1 + y2*y1 - 0.01*y2*x1) <   APPZERO) &&   ((x2 - y2*y1 + 0.01*y2*x1) > -APPZERO &&   (x2 - y2*y1 + 0.01*y2*x1) < APPZERO)) {   printf(“one solution of NLPS4 is y1 = %f, y2 = %f∖n”, y1, y2);   tharg22.i1 = x1;   tharg22.i2 = x2;   hThread24 = CreateThread(NULL, 0, Branch2Thread4,                  (LPVOID)&tharg22, 0, NULL);   WaitForSingleObject(hThread24, INFINITE);   CloseHandle(hThread24);   }   y2 += GRANULARITY;   }while (y2 <= MAXIMUMVALUE);   y1 += GRANULARITY;   y2 = MINIMUMVALUE;   } while (y1 <= MAXIMUMVALUE); return 0; } WINMULTITHREAD Branch2Thread1(LPVOID pParam) {HANDLE hThread22 = NULL, hThread23 = NULL;   PThreadArg tharg = (PThreadArg)pParam;   ThreadArg tharg21 = {0};   double m1 = tharg->i1, m2 = tharg->i2;   double x1 = MINIMUMVALUE, x2 = MINIMUMVALUE;   do {   do {   if (((m2*m2 - x1) > -APPZERO &&   (m2*m2 - x1) < APPZERO) &&   ((2*m1*m2 + x2) > -APPZERO &&   (2*m1*m2 + x2) < APPZERO)) {   printf(“one solution of NLPS2 is x1 = %f, x2 = %f∖n”, x1, x2);   tharg21.i1 = x1;   tharg21.i2 = x2;   hThread22 = CreateThread(NULL, 0, Branch2Thread2,                  (LPVOID)&tharg21, 0, NULL);   hThread23 = CreateThread(NULL, 0, Branch2Thread3,                 (LPVOID)&tharg21, 0, NULL);   WaitForSingleObject(hThread22, INFINITE);   WaitForSingleObject(hThread23, INFINITE);   CloseHandle(hThread22);   CloseHandle(hThread23);   }   x2 += GRANULARITY;   }while (x2 <= MAXIMUMVALUE); x1 += GRANULARITY;   x2 = MINIMUMVALUE;   } while (x1 <= MAXIMUMVALUE); return 0; } WINMULTITHREAD Branch1Thread1(LPVOID pParam) {HANDLE hThread12 = NULL;   PThreadArg tharg = (PThreadArg)pParam;   ThreadArg tharg11 = {0};   double m1 = tharg->i1, m2 = tharg->i2;   double x1 = MINIMUMVALUE, x2 = MINIMUMVALUE;   do {   do {   if (((2*m1*m2 + m2*m2 - x1 + x2) > -APPZERO &&   (2*m1*m2 + m2*m2 - x1 + x2) < APPZERO) &&   ((2*m1*m2 - m2*m2 + x1 + x2) > -APPZERO &&   (2*m1*m2 - m2*m2 + x1 + x2) < APPZERO)) {   printf(“one solution of NLPS1 is x1 = %f, x2 = %f∖n”, x1, x2);   tharg11.i1 = x1;   tharg11.i2 = x2;   hThread12 = CreateThread(NULL, 0, Branch1Thread2,                 (LPVOID)&tharg11, 0, NULL);   WaitForSingleObject(hThread12, INFINITE);   CloseHandle(hThread12);   }   x2 += GRANULARITY;   }while (x2 <= MAXIMUMVALUE);   x1 += GRANULARITY;   x2 = MINIMUMVALUE;   } while (x1 <= MAXIMUMVALUE); return 0; } int main() {HANDLE hThread1 = NULL, hThread2 = NULL;   LARGE_INTEGER litc, litStart, litEnd;   ThreadArg iTharg = {0};   printf(“Please enter the value of input m1 = ”);   scanf(“%lf”, &iTharg.i1);   printf(“Please enter the value of input m2 = ”);   scanf(“%lf”, &iTharg.i2);   QueryPerformanceFrequency(&litc);   QueryPerformanceCounter(&litStart);   hThread1 = CreateThread(NULL, 0, Branch1Thread1,             (LPVOID)&iTharg, 0, NULL);   hThread2 = CreateThread(NULL, 0, Branch2Thread1,              (LPVOID)&iTharg, 0, NULL);   WaitForSingleObject(hThread1, INFINITE);   WaitForSingleObject(hThread2, INFINITE);   QueryPerformanceCounter(&litEnd);   printf(“Execution time is %fs∖n”, (double)       (litEnd.QuadPart - litStart.QuadPart)/litc.QuadPart);   return 0; }

Algorithm 1 

Multithreading program.

Let 𝛿=0.1. The maximum number of iterations is 𝑁𝐿=10 and the step length of variables is 𝑑=0.5 in the full filled method. The recommended values of the variables are in the range from −1 to 1.

Step 1. With the substitution rules and transform rules, change the multithreading program into a nonlinear polynomial transition system, as shown in Figure 4.

Figure 4 

Transition graph.

Step 2. Because the variables of the corresponding branches are the same, there is a need to determine whether there is an equivalence or approximate relation or not of the corresponding polynomial systems in the multithreading program, which is accomplished as follows: NLPS₁,NLPS₂;NLPS₃,NLPS₄,NLPS₅;NLPS₆,NLPS₇,NLPS₈,NLPS₉. (15)
Step 2.1. For {NLPS₁,NLPS₂}: Ritt-Wu’s method is applied to verify the relations. Then, we achieve the irreducible characteristic sets as follows: 𝐶₁=𝑚²₂−𝑥₁,2𝑚₁𝑚₂+𝑥₂;𝐶₂=𝑚²₂−𝑥₁,2𝑚₁𝑚₂+𝑥₂. (16)
The irreducible characteristic sets are equivalent. Moreover, the behavior of NLPS₂ is simpler; thus, the branch that corresponds to NLPS₂ can be used to replace and merge the two branches that correspond to NLPS₂ and NLPS₁.
Step 2.2. For {NLPS₃,NLPS₄,NLPS₅}.
First, Ritt-Wu’s method is applied to determine the relation for {NLPS₃,NLPS₅}. Then, we can obtain the irreducible characteristic sets: 𝐶₃=𝐶₃₁,𝐶₃₂=𝑦²₁+3𝑥₁+𝑥₂,−2𝑦₁𝑦₂+𝑥₂,𝑥₁,𝑥₂,𝑦₁;𝐶₅=𝐶₅₁,𝐶₅₂=𝑦²₁+3𝑥₁+𝑥₂,−2𝑦₁𝑦₂+𝑥₂,𝑥₁,𝑥₂,𝑦₁. (17)
Therefore, they are equivalent. The behavior of NLPS₅ is simpler; thus, the branch that corresponds to NLPS₅ is used to replace and merge the two branches that correspond to NLPS₅ and NLPS₃.
For NLPS₄ and NLPS₅, the MAX function is chosen to determine the relation for them.
Step 2.2.1. With the full filled method, calculate min−3𝑥₁−0.99𝑦²₁+𝑦₂𝑦₁−0.01𝑦₂𝑥₁²−𝑥₂−𝑦₂𝑦₁+0.01𝑦₂𝑥₁²s.t.3𝑥₁−𝑦²₁+𝑥₂𝑥=0;₂−𝑦₂𝑦₁=0. (18)
The results are showed in Table 1.
In this process, the solutions of the objective function are the same when 𝐾=3 and 𝐾=5. The solutions will be duplicated from 𝐾=5; thus, the trend in the objective function will become smooth. Then, the result of max3𝑥₁−0.99𝑦²₁+𝑦₂𝑦₁−0.01𝑦₂𝑥₁²+𝑥₂−𝑦₂𝑦₁+0.01𝑦₂𝑥₁^21/2 (19) is 0.0096.
Step 2.2.2. With the full filled method, calculate min−𝑥₁−𝑦²₁+𝑥₂²−𝑥₂−𝑦₂𝑦₁²s.t.3𝑥₁−0.99𝑦²₁+𝑦₂𝑦₁−0.01𝑦₂𝑥₁𝑥=0;₂−𝑦₂𝑦₁+0.01𝑦₂𝑥₁=0. (20)
The results are showed in Table 2.
In this process, the solutions will be duplicated from 𝐾=1. Thus, the trend in the objective function becomes smooth. The result of max𝑥₁−𝑦₁²+𝑥₂²+𝑥₂−𝑦₂𝑦₁² (21) is 0.01.
The above two maxima are less than the precision; therefore, NLPS₄ and NLPS₅ are approximate. The branch that corresponds to NLPS₅ can replace and merge the branches that correspond to NLPS₃, NLPS₄, and NLPS₅.
Step 2.3. For {NLPS₆,NLPS₇,NLPS₈,NLPS₉}.
First, the Ritt-Wu’s method is applied to verify the relation for NLPS₆ and NLPS₇. Then, we obtain the irreducible characteristic sets as follows: 𝐶₆=𝐶₆₁,𝐶₆₂=𝑦²₁𝑦²₂+2𝑦₁𝑦₂+1−3𝑧₁,𝑦₁𝑦₂−3𝑧₂,𝑦+1₁𝑦₂+1,𝑧₁;𝐶₇=𝐶₇₁,𝐶₇₂=𝑦²₁𝑦²₂+2𝑦₁𝑦₂+1−3𝑧₁,𝑦₁𝑦₂−3𝑧₂,𝑦+1₁𝑦₂+1,𝑧₁. (22)
Therefore, NLPS₆ and NLPS₇ are equivalent. Because NLPS₆ is simpler, the branch that corresponds to NLPS₆ is used to replace and merge the two branches that correspond to NLPS₇ and NLPS₆.
For NLPS₈ and NLPS₉, the MAX function is used to determine the relation for them.
Step 2.3.1. With the full filled method, calculate min−𝑦²₁−𝑧₁²−2𝑦₁𝑦₂−𝑧₂²s.t.𝑦²₁−0.01𝑦₁+1𝑧₁=0;2𝑦₁𝑦₂−𝑧₂−0.01=0. (23)
The results are showed in Table 3.
The results will be duplicated from 𝐾=2. At this point, the trend in the objective function becomes smooth. Thus, the result of max𝑦²₁−𝑧₁²+2𝑦₁𝑦₂−𝑧₂² (24) is 0.011.
Step 2.3.2. With the full filled method, calculate min−𝑦²₁−0.01𝑦₁+1𝑧₁²−2𝑦₁𝑦₂−𝑧₂−0.01²s.t.𝑦²₁−𝑧₁=0;2𝑦₁𝑦₂−𝑧₂=0. (25)
The results are showed in Table 4.
There are duplicate minimums when 𝐾=1 and 𝐾=2. Thus, the trend in the objective function becomes smooth. Then, the result of max𝑦²₁−0.01𝑦₁+1𝑧₁²+2𝑦₁𝑦₂−𝑧₂−0.01² (26) is 0.011.
The precision of this layer is 0.7−0.01≈0.69. The achieved two maxima are less than this precision; thus, NLPS₈ and NLPS₉ are approximate. The branch that corresponds to NLPS₈ is used to replace and merge the two branches that correspond to NLPS₈ and NLPS₉.
Step 2.3.3. For NLPS₈ and NLPS₆, calculate min−−𝑦₁𝑦₂+1²+3𝑧₁²−𝑧₂𝑦₁𝑦₂+1−𝑧₁²s.t.𝑦²₁−𝑧₁=0;2𝑦₁𝑦₂−𝑧₂=0. (27)
The results are showed in Table 5.
Therefore, the first maximum of −𝑦₁𝑦₂+1²+3𝑧₁²+𝑧₂𝑦₁𝑦₂+1−𝑧₁² (28) is 1.95, which is more than the precision in this layer; thus, NLPS₈ and NLPS₆ are not approximate.
Step 2.4. By analysis, the transition graph in Figure 4 is turned into a new transition graph, which is shown in Figure 5, and the optimized multithreading program for the given multithreading program in Algorithm 1 also can be expressed in Algorithm 2.

Table 1 

Results.

Table 2 

Results.

Table 3 

Results.

Table 4 

Results.

Table 5 

Results.

#include “main.h” WINMULTITHREAD Branch1Thread3(LPVOID pParam) {PThreadArg tharg = (PThreadArg)pParam;   double y1 = tharg->i1, y2 = tharg->i2;   double z1 = MINIMUMVALUE, z2 = MINIMUMVALUE;   do {   do {   if (((-(y1*y2 + 1)*(y1*y2 + 1) + 3*z1) > -APPZERO &&   (-(y1*y2 + 1)*(y1*y2 + 1) + 3*z1) < APPZERO) &&   ((-z1 + z2*(y1*y2 + 1)) > -APPZERO &&   (-z1 + z2*(y1*y2 + 1)) < APPZERO)) {   printf(“one solution of NLPS13 is z1 = %f, z2 = %f∖n”, z1, z2);   }   z2 += GRANULARITY;   }while (z2 <= MAXIMUMVALUE);   z1 += GRANULARITY;   z2 = MINIMUMVALUE;   } while (z1 <= MAXIMUMVALUE);   return 0; } WINMULTITHREAD Branch1Thread4(LPVOID pParam) {PThreadArg tharg = (PThreadArg)pParam;   double y1 = tharg->i1, y2 = tharg->i2;   double z1 = MINIMUMVALUE, z2 = MINIMUMVALUE;   do {   do {   if (((y1*y1 - z1) > -APPZERO &&   (y1*y1 - z1) < APPZERO) &&   ((2*y1*y2 - z2) > -APPZERO &&   (2*y1*y2 - z2) < APPZERO)) {   printf(“one solution of NLPS14 is z1 = %f, z2 = %f∖n”, z1, z2);   }   z2 += GRANULARITY;   }while (z2 <= MAXIMUMVALUE);   z1 += GRANULARITY;   z2 = MINIMUMVALUE;   } while (z1 <= MAXIMUMVALUE);   return 0; } WINMULTITHREAD Branch1Thread2(LPVOID pParam) {HANDLE hThread13 = NULL, hThread14 = NULL;   PThreadArg tharg = (PThreadArg)pParam;   ThreadArg tharg12 = {0};   double x1 = tharg->i1, x2 = tharg->i2;   double y1 = MINIMUMVALUE, y2 = MINIMUMVALUE;   do {   do {   if (((3*x1 - y1*y1 + x2) > -APPZERO &&   (3*x1 - y1*y1 + x2) < APPZERO) &&   ((x2 - y2*y1) > -APPZERO &&   (x2 - y2*y1) < APPZERO)) {   printf(“one solution of NLPS12 is y1 = %f, y2 = %f∖n”, y1, y2);   tharg12.i1 = y1;   tharg12.i2 = y2;   hThread13 = CreateThread(NULL, 0, Branch1Thread3,          (LPVOID)&tharg12, 0, NULL);   hThread14 = CreateThread(NULL, 0, Branch1Thread4,     (LPVOID)&tharg12, 0, NULL);   WaitForSingleObject(hThread13, INFINITE);   WaitForSingleObject(hThread14, INFINITE);   CloseHandle(hThread13);   CloseHandle(hThread14);   }   y2 += GRANULARITY;   }while (y2 <= MAXIMUMVALUE);   y1 += GRANULARITY;   y2 = MINIMUMVALUE;   } while (y1 <= MAXIMUMVALUE);   return 0; } WINMULTITHREAD Branch1Thread1(LPVOID pParam) {HANDLE hThread12 = NULL;   PThreadArg tharg = (PThreadArg)pParam;   ThreadArg tharg11 = {0};   double m1 = tharg->i1, m2 = tharg->i2;   double x1 = MINIMUMVALUE, x2 = MINIMUMVALUE;   do {   do {   if (((m2*m2 - x1) > -APPZERO &&   (m2*m2 - x1) < APPZERO) &&   ((2*m1*m2 + x2) > -APPZERO &&   (2*m1*m2 + x2) < APPZERO)) {   printf(“one solution of NLPS11 is x1 = %f, x2 = %f∖n”, x1, x2);   tharg11.i1 = x1;   tharg11.i2 = x2;   hThread12 = CreateThread(NULL, 0, Branch1Thread2,          (LPVOID)&tharg11, 0, NULL);   WaitForSingleObject(hThread12, INFINITE);   CloseHandle(hThread12);   }   x2 += GRANULARITY;   }while (x2 <= MAXIMUMVALUE);   x1 += GRANULARITY;   x2 = MINIMUMVALUE;   } while (x1 <= MAXIMUMVALUE);   return 0; } int main() {LARGE_INTEGER litc, litStart, litEnd;   HANDLE hThread1 = NULL;   ThreadArg iTharg = {0};   printf(“Please enter the value of input m1 = ”);   scanf(“%lf”, &iTharg.i1);   printf(“Please enter the value of input m2 = ”);   scanf(“%lf”, &iTharg.i2);   QueryPerformanceFrequency(&litc);   QueryPerformanceCounter(&litStart);   hThread1 = CreateThread(NULL, 0, Branch1Thread1,         (LPVOID)&iTharg, 0, NULL);   WaitForSingleObject(hThread1, INFINITE);   QueryPerformanceCounter(&litEnd);   printf(“Execution time is %fs∖n”, (double)   (litEnd.QuadPart - litStart.QuadPart)/litc.QuadPart);   return 0; }

Algorithm 2 

Approximate multithreading program.

Figure 5 

Approximate transition graph.

5.2. Results

By the example verification in this section, many advantages of our method are achieved.(i)Achieve a formal description: software programs are represented by nonlinear polynomial transition systems and transition graphs that contain states and transitions, such as in Figures 4 and 5. With these descriptions, all of the data exchange processes, the behavior, and the structure of the software program are described more directly.(ii)With Ritt-Wu’s method and MAX function, the equivalence and approximate relations are determined for the software program based on symbolic-numeric computation. (a)With Ritt-Wu’s method and MAX function, the equivalence and approximate relations are expressed by the “standard forms” and “constrained global optimizations” without calculating the exact values of the states of the software programs. The traditional method must know the exact values of the inputs and outputs to determine the relations for the different software programs. Unfortunately, the exact values of the variables of a software program always exist in a range so that the traditional method will cost too much computing time. Thus, our method is more flexible and effective. (b)Based on these relations, the behavior and structure optimization of software programs are achieved and are compared, whereby Figure 4 is compared with Figure 5 and Algorithm 1 is compared with Algorithm 2. For example, the number of branches in Algorithm 1 is 9 and the number of branches in Algorithm 2 is 4. (c)Because the states and branches of the software programs are reduced with these relations, the number of feasible paths for the software program is decreased; therefore, the “state explosion” problem can be alleviated in the property verification and the occupancy factor of having a deadlock becomes small. (iii)The value of the behavior and the structure optimization of the software program is divided into two parts, as follows.(a)Behavior optimization: for example, for {NLPS₁,NLPS₂} in Figure 4, NLPS₁ is replaced by NLPS₂ in Figure 5. If we allow the inputs of the software programs that correspond to NLPS₁ and NLPS₂ to be equal to 0.0, and let the step length of variable in this process be equal to 0.00005, then the computing costs are 6.789 s and 4.878 s when calculating the same outputs, respectively. Therefore, the simpler the behavior is, the smaller the computing cost. The solutions of the variables and the computing costs of the software programs are given in Table 6.(b)Structure optimization: for example, the set {NLPS₁,NLPS₂,NLPS₃,NLPS₄,NLPS₅} in the given nonlinear polynomial transition system is reduced to two branches {NLPS₁₁,NLPS₁₂} in the approximate system. If we let the initial inputs of NLPS₁ and NLPS₁₁ be equal to 0.01 in the programs that correspond to {NLPS₁,NLPS₂,NLPS₃,NLPS₄,NLPS₅} and {NLPS₁₁,NLPS₁₂} and let the step length of variable in this process be equal to 0.00005, then the computing costs are 12.041 s and 9.678 s when calculating the approximate outputs of the software programs, respectively. Thus, the fewer the number of branches that are present, the lower the computing cost. The solutions of the variables and the computing costs of the software programs are given in Table 6.(iv)The approximate bisimulation in this paper can also be used to process the type of software programs whose data exchange processes are expressed by linear polynomial systems [11]. (a)In the calculation algorithms for approximate bisimulation for linear polynomial transition systems, the entire process is a linear computation that is based on the properties of the matrix in paper [11]. However, the whole process in determining the approximate bisimulation relation of the software programs is a nonlinear computation in this paper because the MAX function is applied to compute the value of the errors caused by the approximation. Therefore, the computing process in [11] requires less time and is more effective than the calculation proposed in this paper for linear polynomial systems. (b)Unfortunately, the method in [11] cannot be applied to process the nonlinear polynomial system researched in this paper because the property of the matrix cannot describe the solutions’ relations of the nonlinear polynomial systems.

Table 6 

Results.

6. Conclusions

In this paper, we propose a nonlinear polynomial transition system to describe the type of software program whose data exchange processes are expressed by nonlinear polynomial systems. Then, a novel calculation of an approximate bisimulation is provided to achieve the behavior and the structure optimization for the software programs, based on symbolic-numeric computation. The advantages of our approach are verified and listed in Section 5.

Except for those advantages that are achieved by our approach in this paper, on the one hand, how to improve the efficiency of symbolic-numeric computation is a substantial challenge. This goal will be researched in our future work. On the other hand, the numbers of the states and branches of the software program are reduced due to the behavior and the structure optimization. How to apply these circumstances to optimize the property verification of the software program based on the state, such as safety verification, is also a major direction for our research in the future.

Acknowledgments

This work was supported by the Natural Science Foundation of Guangxi under Grant nos. 2011GXNSFA018154 and 2012GXNSFGA060003, the Science and Technology Foundation of Guangxi under Grant no. 10169-1, and Guangxi Scientific Research Project no. 201012MS274.