Partial Quantifier Elimination And Property Generation
Abstract
We study partial quantifier elimination (PQE) for propositional CNF formulas with existential quantifiers. PQE is a generalization of quantifier elimination where one can limit the set of clauses taken out of the scope of quantifiers to a small subset of clauses. The appeal of PQE is that many verification problems (e.g., equivalence checking and model checking) can be solved in terms of PQE and the latter can be dramatically simpler than full quantifier elimination. We show that PQE can be used for property generation that can be viewed as a generalization of testing. The objective here is to produce an unwanted property of a design implementation thus exposing a bug. We introduce two PQE solvers called - and -. - is a very simple SAT-based algorithm. - is more sophisticated and robust than -. We use these PQE solvers to find an unwanted property (namely, an unwanted invariant) of a buggy FIFO buffer. We also apply them to invariant generation for sequential circuits from a HWMCC benchmark set. Finally, we use these solvers to generate properties of a combinational circuit that mimic symbolic simulation.
1 Introduction
In this paper, we consider the following problem. Let be a propositional formula in conjunctive normal form (CNF)111Every formula is a propositional CNF formula unless otherwise stated. Given a CNF formula represented as the conjunction of clauses , we will also consider as the set of clauses . where are sets of variables. Let be a subset of clauses of . Given a formula , find a quantifier-free formula such that . In contrast to full quantifier elimination (QE), only the clauses of are taken out of the scope of quantifiers here. So, we call this problem partial QE (PQE)ย [1]. (In this paper, we consider PQE only for formulas with existential quantifiers.) We will refer to as a solution to PQE. Like SAT, PQE is a way to cope with the complexity of QE. But in contrast to SAT that is a special case of QE (where all variables are quantified), PQE generalizes QE. The latter is just a special case of PQE where and the entire formula is unquantified. Interpolationย [2, 3] is a special case of PQE as wellย [4] (see also Appendixย 0.A).
The appeal of PQE is threefold. First, it can be much more efficient than QE if is a small subset of . Second, many verification problems like SAT, equivalence checking, model checking can be solved in terms of PQEย [1, 5, 6, 7]. So, PQE can be used to design new efficient methods for solving known problems. Third, one can apply PQE to solving new problems like property generation considered in this paper. In practice, to perform PQE, it suffices to have an algorithm that takes a single clause out of the scope of quantifiers. Namely, given a formula and a clause , this algorithm finds a formula such that . To take out clauses, one can apply this algorithm times. Since , solving the PQE above reduces to finding that makes redundant in . So, the PQE algorithms we present here employ redundancy based reasoning. Namely, we describe two PQE algorithms called - and - where โEGโ stands for โEnumerate and Generalizeโ. - is a very simple SAT-based algorithm that can sometimes solve very large problems. - is a modification of - that makes the algorithm more powerful and robust.
Inย [6], we showed the viability of an equivalence checker based on PQE. In particular, we presented instances for which this equivalence checker outperformed ABCย [8], a high quality tool. In this paper, we describe and check experimentally one more important application of PQE called property generation. Our motivation here is as follows. Suppose a design implementation Imp meets the set of specification properties . Typically, this set is incomplete. So, Imp can still be buggy even if every holds. Let be desired properties adding which makes the specification complete. If Imp meets the properties but is still buggy, a missed property above fails. That is, Imp has the unwanted property . So, one can detect bugs by generating unspecified properties of Imp and checking if there is an unwanted one.
Currently, identification of unwanted properties is mostly done by massive testing. (As we show later, the input/output behavior specified by a single test can be cast as a simple property of Imp.) Another technique employed in practice is guessing a list of unwanted properties that may hold and formally checking if this is the case. The problem with these techniques is that they can miss an unwanted property. In this paper, we describe property generation by PQE. The benefit of PQE is that it can produce much more complex properties than those corresponding to single tests. So, using PQE one can detect bugs that testing overlooks or cannot find in principle. Importantly, PQE generates properties covering different parts of Imp. This makes the search for unwanted properties more systematic and facilitates discovering bugs that can be missed if one simply guesses unwanted properties that may hold.
In this paper, we experimentally study generation of invariants of a sequential circuit . An invariant of is unwanted if a state that is supposed to be reachable in falsifies this invariant and hence is unreachable. Note that finding a formal proof that has no unwanted invariants is impractical. (It is hard to efficiently prove a large set of states reachable because different states are reached by different execution traces.) So developing practical methods for finding unwanted invariants if very important. We also study generation of properties mimicking symbolic simulation for a combinational circuit obtained by unrolling a sequential circuit. An unwanted property here exposes a wrong execution trace.
The main body of this paper is structured as follows. (Some additional information can be found in appendices.) In Sectionย 2, we give basic definitions. Sectionย 3 presents property generation for a combinational circuit. In Sectionย 4, we describe invariant generation for a sequential circuit. Sectionsย 5 andย 6 present - and - respectively. In Sectionย 7, invariant generation is used to find a bug in a FIFO buffer. Experiments with invariant generation for HWMCC benchmarks are described in Sectionย 8. Sectionย 9 presents an experiment with property generation for combinational circuits. In Sectionย 10 we give some background. Finally, in Sectionย 11, we make conclusions and discuss directions for future research.
2 Basic Definitions
In this section, when we say โformulaโ without mentioning quantifiers, we mean โa quantifier-free formulaโ.
Definition 1
We assume that formulas have only Boolean variables. A literal of a variable is either or its negation. A clause is a disjunction of literals. A formula is in conjunctive normal form (CNF) if where are clauses. We will also view as the set of clauses . We assume that every formula is in CNF.
Definition 2
Let be a formula. Then denotes the set of variables of and denotes .
Definition 3
Let be a set of variables. An assignment to is a mapping where . We will denote the set of variables assigned in ย ย as . We will refer to as a full assignment to if . We will denote as the fact that a) and b) every variable of has the same value in and .
Definition 4
A literal, a clause, and a formula are said to be satisfied (respectively falsified) by an assignment if they evaluate to 1 (respectively 0) under .
Definition 5
Let be a clause. Let be a formula that may have quantifiers, and be an assignment to . If is satisfied by , then . Otherwise, is the clause obtained from by removing all literals falsified by . Denote by the formula obtained from by removing the clauses satisfied by and replacing every clause unsatisfied by with .
Definition 6
Given a formula , a clause of is called a quantified clause if . If , the clause depends only on free, i.e., unquantified variables ofโ and is called a free clause.
Definition 7
Let be formulas that may have existential quantifiers. We say that are equivalent, written , if for all full assignments to .
Definition 8
Let be a formula and and . The clauses of are said to be redundant in if . Note that if implies , the clauses of are redundant in .
Definition 9
Given a formula and where , the Partial Quantifier Elimination (PQE) problem is to find such that. (So, PQE takes out of the scope of quantifiers.) The formula is called a solution to PQE. The case of PQE where is called Quantifier Elimination (QE).
Example 1
Consider the formula where , , , . Let denote and denote . Consider the PQE problem of taking out of , i.e., finding such that . As we show later, . That is, is a solution to the PQE problem above.
Remark 1
Let be a clause of a solution to the PQE problem of Definitionย 9. If implies , then is a solution to this PQE problem too.
Proposition 1
Let be a solution to the PQE problem of Definitionย 9. That is, . Then (i.e., implies ).
The proofs of propositions are given in Appendixย 0.B.
Definition 10
Let clauses , have opposite literals of exactly one variable . Then , are called resolvable onย . The clause having all literals of but those of is called the resolvent of ,. The clause is said to be obtained by resolution on .
Definition 11
Let be a clause of a formula and . The clause is said to be blockedย [9] in with respect to the variable if no clause of is resolvable with on .
Proposition 2
Let a clause be blocked in a formula with respect to a variable . Then is redundant in , i.e., .
3 Property Generation By PQE
Many known problems can be formulated in terms of PQE, thus facilitating the design of new efficient algorithms. In Appendixย 0.C, we recall some results on solving SAT, equivalence checking and model checking by PQE presented in ย [1, 5, 6, 7]. In this section, we describe application of PQE to property generation for a combinational circuit. The objective of property generation is to expose a bug via producing an unwanted property.
Let be a combinational circuit where specify the sets of the internal, input, and output variables of respectively. Let denote a formula specifying . As usual, this formula is obtained by Tseitinโs transformationsย [10]. Namely, equals where are the gates of and specifies the functionality of gate .
Example 2
Let be a 2-input AND gate defined as where denotes the output value and denote the input values of . Then is specified by the formula . Every clause of is falsified by an inconsistent assignment (where the output value of is not implied by its input values). For instance, is falsified by the inconsistent assignment . So, every assignment satisfying corresponds to a consistent assignment to and vice versa. Similarly, every assignment satisfying the formula above is a consistent assignment to the gates of and vice versa.
3.1 High-level view of property generation by PQE
One generates properties by PQE until an unwanted property exposing a bug is produced. (Like in testing one runs tests until a bug-exposing test is encountered.) The benefit of property generation by PQE is fourfold. First, by property generation one can identify bugs that are hard or simply impossible to find by testing. Second, using PQE makes property generation efficient. Third, by taking out different clauses one can generate properties covering different parts of the design. This increases the probability of discovering a bug. Fourth, every property generated by PQE specifies a large set of high-quality tests.
In this paper (Sectionsย 7,ย 9), we consider cases where identifying an unwanted property is easy. However, in general, such identification is not trivial. A detailed discussion of this topic is beyond the scope of this paper. (Nevertheless, in Appendixย 0.D, we give the main idea of the procedure for deciding if a property is unwanted.)
3.2 Property generation as generalization of testing
The behavior of corresponding to a single test can be cast as a property. Let be an output variable of and be a test, i.e., a full assignment to the input variables of . Let denote the longest clause falsified by , i.e., . Let be the literal satisfied by the value of produced by under input . Then the clause is satisfied by every assignment satisfying , i.e., is a property of . We will refer to it as a single-test property (since it describes the behavior of for a single test). If the input is supposed to produce the opposite value of (i.e., the one falsifying ), then exposes a bug in . In this case, the single-test property above is an unwanted property of exposing the same bug as the test .
A single-test property can be viewed as a weakest property of as opposed to the strongest property specified by . The latter is the truth table of that can be computed explicitly by performing QE on . One can use PQE to generate properties of that, in terms of strength, range from the weakest ones to the strongest property inclusively. (By combining clause splitting with PQE one can generate single-test properties, see the next subsection.) Consider the PQE problem of taking a clause out of . Let be a solution to this problem, i.e., . Since is implied by , it can be viewed as a property of . If is an unwanted property, has a bug. (Here we consider the case where a property of is obtained by taking a clause out of formula where only the internal variables of are quantified. Later we consider cases where some external variables of are quantified too.)
We will assume that the property generated by PQE has no redundant clauses (see Remarkย 1). That is, if , then . Then one can view as a property that holds due to the presence of the clause in .
3.3 Computing properties efficiently
If a property is obtained by taking only one clause out of , its computation is much easier than performing QE on . If computing still remains too time-consuming, one can use the two methods below that achieve better performance at the expense of generating weaker properties. The first method applies when a PQE solver forms a solution incrementally, clause by clause (like the algorithms described in Sectionsย 5 andย 6). Then one can simply stop computing as soon as the number of clauses in exceeds a threshold. Such a formula is still implied by and hence specifies a property of .
The second method employs clause splitting. Here we consider clause splitting on input variables , i.e., those of (but one can split a clause on any subset of variables from ). Let denote the formula where a clause is replaced with clauses: ,โฆ, , , where is a literal of . The idea is to obtain a property by taking the clause out of rather than out of . The former PQE problem is simpler than the latter since it produces a weaker property . One can show that if , then a) the complexity of PQE reduces to linear; b) taking out actually produces a single-test property. The latter specifies the input/output behavior of for the test falsifying the literals . (See Appendixย 0.E for more details.)
3.4 Using design coverage for generation of unwanted properties
Arguably, testing is so effective in practice because one verifies a particular design. Namely, one probes different parts of this design using some coverage metric rather than sampling the truth table (which would mean verifying every possible design). The same idea works for property generation by PQE for the following two reasons. First, by taking out a clause, PQE generates a property inherent to the specific circuit . (If one replaces with an equivalent but structurally different circuit, PQE will generate different properties.) Second, by taking out different clauses of one generates properties corresponding to different parts of thus โcoveringโ the design. This increases the chance to take out a clause corresponding to the buggy part of and generate an unwanted property.
3.5 High-quality tests specified by a property generated by PQE
In this subsection, we show that a property generated by PQE, in general, specifies a large set of high-quality tests. Let be obtained by taking out of . Let be a clause of . As mentioned above, we assume that . Then there is an assignment (,,) satisfying formula where ,, are assignments to respectively. (Note that by definition, (,) falsifies .) Let be the execution trace of under the input . So, satisfies . Note that the output assignments and must be different because has to satisfy . (Otherwise, satisfies and so and hence .) So, one can view as a test โdetectingโ disappearance of the clause from . Note that different assignments satisfying correspond to different tests . So, the clause of , in general, specifies a very large number of tests. One can show that these tests are similar to those detecting stuck-at faults and so have very high quality (see Appendixย 0.F for more details).
4 Invariant Generation By PQE
In this section, we extend property generation for combinational circuits to sequential ones. Namely, we generate invariants. Note that generation of desired auxiliary invariants is routinely used in practice to facilitate verification of a predefined property. The problem we consider here is different in that our goal is to produce an unwanted invariant. We picked generation of invariants (over that of weaker properties just claiming that a state cannot be reached in transitions or less) because identification of an unwanted invariant is, arguably, easier. This simplifies bug detection by property generation.
4.1 Bugs making states unreachable
Let be a sequential circuit and denote the state variables of . Let specify the initial state (i.e., ). Let denote the transition relation of where are the present and next state variables and specifies the (combinational) input variables. We will say that a state of is reachable if there is an execution trace leading to . That is, there is a sequence of states where , and there exist for which . Let have to satisfy a set of invariants . That is, holds iff for every reachable state of . We will denote the aggregate invariant as . We will call a bad state of if . If holds, no bad state is reachable. We will call a good state of if .
Typically, the set of invariants is incomplete in the sense that it does not specify all states that must be unreachable. So, a good state can well be unreachable. We will call a good state operative (or op-state for short) if it is supposed to be used by and so should be reachable. We introduce the term an operative state just to factor out โuselessโ good states. We will say that has an op-state reachability bug if an op-state is unreachable in . In Sectionย 7, we consider such a bug in a FIFO buffer. The fact that holds says nothing about reachability of op-states. Consider, for instance, a trivial circuit that simply stays in the initial state and . Then holds for but the latter has op-state reachability bugs (assuming that the correct circuit must reach states other than ).
Let be the predicate satisfied only by a state . In terms of CTL, identifying an op-state reachability bug means finding for which the property must hold but it does not. The reason for assuming to be unknown is that the set of op-states is typically too large to explicitly specify every property to hold. This makes finding op-state reachability bugs very hard. The problem is exacerbated by the fact that reachability of different states is established by different traces. So, in general, one cannot efficiently prove many properties (for different states) at once.
4.2 Proving op-state unreachability by invariant generation
In practice, there are two methods to check reachability of operative states for large circuits. The first method is testing. Of course, testing cannot prove a state unreachable, however, the examination of execution traces may point to a potential problem. (For instance, after examining execution traces of the circuit above one realizes that many operative states look unreachable.) The other method is to check unwanted invariants, i.e., those that are supposed to fail. If an unwanted invariant holds for a circuit, the latter has an op-state reachability bug. For instance, one can check if a state variable of a circuit never changes its initial value. To break this unwanted invariant, one needs to find an operative state where the initial value of is flipped. (For the circuit above this unwanted invariant holds for every state variable.) The potential unwanted invariants are formed manually, i.e., simply guessed.
The two methods above can easily overlook an op-state reachability bug. Testing cannot prove that an op-state is unreachable. To correctly guess an unwanted invariant that holds, one essentially has to know the underlying bug. Below, we describe a method for invariant generation by PQE that is based on property generation for combinational circuits. The appeal of this method is twofold. First, PQE generates invariants โinherentโ to the implementation at hand, which drastically reduces the set of invariants to explore. Second, PQE is able to generate invariants related to different parts of the circuit (including the buggy one). This increases the probability of generating an unwanted invariant. We substantiate this intuition in Sectionย 7.
Let formula specify the combinational circuit obtained by unfolding a sequential circuit for time frames and adding the initial state constraint . That is, where denote the state and input variables of -th time frame respectively. Let be a solution to the PQE problem of taking a clause out of where . That is, . Note that in contrast to Sectionย 3, here some external variables of the combinational circuit (namely, the input variables ) are quantified too. So, depends only on state variables of the last time frame. can be viewed as a local invariant asserting that no state falsifying can be reached in transitions.
One can use to find global invariants (holding for every time frame) as follows. Even if is only a local invariant, a clause of can be a global invariant. The experiments of Sectionย 8 show that, in general, this is true for many clauses of . (To find out if is a global invariant, one can simply run a model checker to see if the property holds.) Note that by taking out different clauses of one can produce global single-clause invariants relating to different parts of . From now on, when we say โan invariantโ without a qualifier we mean a global invariant.
5 Introducing -
In this section, we describe a simple SAT-based algorithm for performing PQE called -. Here โEGโ stands for โEnumerate and Generalizeโ. - accepts a formula and a clause . It outputs a formula such that where is the initial formula . (This point needs clarification because - changes by adding clauses.)
5.1 An example
Before describing the pseudocode of -, we explain how it solves the PQE problem of Exampleย 1. That is, we consider taking clause out of where , , , , and and .
- iteratively generates a full assignment to and checks if is redundant in (i.e., if is redundant in in subspace ). Note that if implies , then is trivially redundant in . To avoid such subspaces, - generates by searching for an assignment (,) satisfying the formula . (Here and are full assignments to and respectively.) If such (,) exists, it satisfies and falsifies thus proving that does not imply .
Assume that - found an assignment satisfying . So = . Then - checks if is satisfiable. = and so it is unsatisfiable. This means that is not redundant in . (Indeed, is satisfiable. So, removing makes satisfiable in subspace .) - makes redundant in by adding to a clause falsified by . The clause equals and is obtained by identifying the assignments to individual variables of that made unsatisfiable. (In our case, this is the assignment .) Note that derivation of clause generalizes the proof of unsatisfiability of in subspace so that this proof holds for subspace too.
Now - looks for a new assignment satisfying . Let the assignment be found. So, = . Since satisfies , the formula is satisfiable. So, is already redundant in . To avoid re-visiting the subspace , - generates the plugging clause falsified by .
- fails to generate a new assignment because the formula is unsatisfiable. Indeed, every full assignment we have examined so far falsifies either the clause added to or the plugging clause . The only assignment - has not explored yet is . Since and = , the formula is unsatisfiable in subspace . In other words, is implied by and hence is redundant. Thus, is redundant in for every assignment to where is the initial formula . That is, and so the clause is a solution to our PQE problem.
5.2 Description of -
{ | |||
1 | ; | ||
2 | while (true) { | ||
3 | |||
4 | |||
5 | if () | ||
6 | return() | ||
7 | |||
8 | if () { | ||
9 | |||
10 | continue } | ||
11 | |||
12 | }} |
The pseudo-code of - is shown in Fig.ย 1. - starts with storing the initial formula and initializing formula that accumulates the plugging clauses generated by - (line 1). As we mentioned in the previous subsection, plugging clauses are used to avoid re-visiting the subspaces where the formula is proved satisfiable.
All the work is carried out in a while loop. First, - checks if there is a new subspace where does not imply . This is done by searching for an assignment (,) satisfying (lines 3-4). If such an assignment does not exist, the clause is redundant in . (Indeed, let be a full assignment to . The formula is unsatisfiable in subspace for one of the two reasons. First, falsifies . Then is redundant because is satisfiable. Second, is unsatisfiable. In this case, implies .) Then - returns the set of clauses added to the initial formula as a solution to the PQE problem (lines 5-6).
If the satisfying assignment (,) above exists, - checks if the formula is satisfiable (line 7). If not, then the clause is not redundant in (because is satisfiable). So, - makes redundant by generating a clause falsified by and adding it to (line 9). Note that adding also prevents - from re-visiting the subspace again. The clause is built by finding an unsatisfiable subset of and collecting the literals of removed from clauses of this subset when obtaining from .
If is satisfiable, - generates an assignment to such that satisfies (line 7). The satisfiability of means that every clause of including is redundant in . At this point, - uses the longest clause falsified by as a plugging clause (line 11). The clause is added to to avoid re-visiting subspace . Sometimes it is possible to remove variables from to produce a shorter assignment such that still satisfies . Then one can use a shorter plugging clause involving only the variables assigned in .
5.3 Discussion
- is similar to the QE algorithm presented at CAV-2002ย [11]. We will refer to it as -. Given a formula , - enumerates full assignments to . In subspace , if is unsatisfiable, - adds to a clause falsified by . Otherwise, - generates a plugging clause . (Inย [11], is called โa blocking clauseโ. This term can be confused with the term โblocked clauseโ applied to a completely different kind of a clause. So, we use the term โa plugging clauseโ instead.) To apply the idea of - to PQE, we reformulated it in terms of redundancy based reasoning.
The main flaw of - inherited from - is the necessity to use plugging clauses produced from a satisfying assignment. Consider the PQE problem of taking a clause out of . If is proved unsatisfiable in subspace , typically, only a small subset of clauses of is involved in the proof. Then the clause generated by - is short and thus proves redundant in many subspaces different from . On the contrary, to prove satisfiable in subspace , every clause of must be satisfied. So, the plugging clause built off a satisfying assignment includes almost every variable of . Despite this flaw of -, we present it for two reasons. First, it is a very simple SAT-based algorithm that can be easily implemented. Second, - has a powerful advantage over - since it solves PQE rather than QE. Namely, - does not need to examine the subspaces where is implied by . Surprisingly, for many formulas this allows - to completely avoid examining subspaces where is satisfiable. In this case, - is very efficient and can solve very large problems. Note that when - performs complete QE on , it cannot avoid subspaces where is satisfiable unless itself is unsatisfiable (which is very rare in practical applications).
6 Introducing -
In this section, we describe -, an improved version of -.
6.1 Main idea
The pseudocode of - is shown in Figย 2. It is different from that of - only in line 11 marked with an asterisk. The motivation for this change is as follows. Line 11 describes proving redundancy of for the case where is not implied by and is satisfiable. Then - simply uses a satisfying assignment as a proof of redundancy of in subspace . This proof is unnecessarily strong because it proves that every clause of (including ) is redundant in in subspace . Such a strong proof is hard to generalize to other subspaces.
{ | ||
1 | ; | |
2 | while (true) { | |
11โ | ||
12 | }} |
The idea of - is to generate a proof for a much weaker proposition namely a proof of redundancy of (and only ). Intuitively, such a proof should be easier to generalize. So, - calls a procedure PrvClsRed generating such a proof. - is a generic algorithm in the sense that any suitable procedure can be employed as PrvClsRed. In our current implementation, the procedure -ย [1] is used as PrvClsRed. - generates a proof stating that is redundant in in subspace . Then the plugging clause falsified by is generated. Importantly, can be much shorter than . Appendixย 0.G gives a brief description of -.
Example 3
Consider the example solved in Subsectionย 5.1. That is, we consider taking clause out of where , , , , and and . Consider the step where - proves redundancy of in subspace . - shows that satisfies , thus proving every clause of (including ) redundant in in subspace . Then - generates the plugging clause falsified by .
In contrast to -, - calls PrvClsRed to produce a proof of redundancy for the clause alone. Note that has no clauses resolvable with on in subspace . (The clause containing is satisfied by .) This means that is blocked in subspace and hence redundant there (see Propositionย 2). Since , - produces a more general proof of redundancy than -. To avoid re-examining the subspace , - generates a shorter plugging clause .
6.2 Discussion
Consider the PQE problem of taking a clause out of . There are two features of PQE that make it easier than QE. The first feature mentioned earlier is that one can ignore the subspaces where implies . The second feature is that when is satisfiable, one only needs to prove redundancy of the clause alone. Among the three algorithms we run in experiments, namely, -, -, and - only the latter exploits both features. (In addition to using - inside - we also run it as a stand-alone PQE solver.) - does not use the first featureย [1] and - does not exploit the second one. As we show in Sectionsย 7 andย 8, this affects the performance of - and -.
7 Experiment With FIFO Buffers
In this and the next two sections we describe some experiments with-, - and - (their sources are available atย [12],ย [13] and ย [14] respectively). We used Minisat2.0ย [15] as an internal SAT-solver. The experiments were run on a computer with Intel Core i5-8265U CPU of 1.6โGHz.
ย ย ย ย ย ย ย ย ย ย ย ย ย | ||
if () | ||
* | if () | |
begin | ||
; | ||
; | ||
end | ||
ย ย ย ย ย ย ย ย ย ย ย ย ย |
In this section, we give an example of bug detection by invariant generation for a FIFO buffer. Our objective here is threefold. First, we want to give an example of a bug that can be overlooked by testing and guessing the unwanted properties to check (see Subsectionย 7.3). Second, we want to substantiate the intuition of Subsectionย 3.4 that property generation by PQE (in our case, invariant generation by PQE) has the same reasons to be effective as testing. In particular, by taking out different clauses one generates invariants relating to different parts of the design. So, taking out a clause of the buggy part is likely to produce an unwanted invariant. Third, we want to give an example of an invariant that can be easily identified as unwanted222Let be an invariant for a circuit depending only on a subset of the state variables . Identifying as an unwanted invariant is much easier if is meaningful from the high-level view of the design. Suppose, for instance, that assignments to specify values of a high-level variable . Then is unwanted if it claims unreachability of a value of that is supposed to be reachable. Another simple example is that assignments to specify values of high-level variables and that are supposed to be independent. Then is unwanted if it claims that some combinations of values of and are unreachable. (This may mean, for instance, that an assignment operator setting the value of erroneously involves the variable .) .
7.1 Buffer description
Consider a FIFO buffer that we will refer to as . Let be the number of elements of and denote the data buffer of . Let each have bits and be an integer where . A fragment of the Verilog code describing is shown in Figย 3. This fragment has a buggy line marked with an asterisk. In the correct version without the marked line, a new element is added to if the write flag is on and has less than elements. Since can have any combination of numbers, all states are supposed to be reachable. However, due to the bug, the number cannot appear in . (Here is some constant . We assume that the buffer elements are initialized to 0.) So, has an op-state reachability bug since it cannot reach operative states where an element of equals .
7.2 Bug detection by invariant generation
Let be a circuit implementing . Let be the set of state variables of and be the subset corresponding to the data buffer . We used -, - and - to generate invariants of as described in Sectionย 4. Note that an invariant depending only on is an unwanted one. If holds for , some states of are unreachable. Then has an op-state reachability bug since every state of is supposed to be reachable. To generate invariants, we used the formula introduced in Subsectionย 4.2. Here and describe the initial state and the transition relation of respectively and and denote state variables and combinational input variables of -th time frame respectively. First, we used a PQE solver to generate a local invariant obtained by taking a clause out of where . So, . (Since , no state falsifying can be reached in transitions.) In the experiment, we took out only clauses of containing an unquantified variable, i.e., a state variable of the -th time frame. The time limit for solving the PQE problem of taking out a clause was set to 10 sec.
buff. | lat- | time | total pqe probs | finished pqe probs | unwant. invar | runtime (s.) | ||||||||
---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
size | ches | fra- | ds- | eg- | eg- | ds- | eg- | eg- | ds- | eg- | eg- | ds- | eg- | eg- |
ย ย | mes | pqe | pqe | pqe+ | pqe | pqe | pqe+ | pqe | pqe | pqe+ | pqe | pqe | pqe+ | |
ย ย 8 | ย 300 | ย 5 | 1,236 | 311 | ย 8 | ย 2% | 36% | 35% | no | yes | yes | 12,141 | 2,138 | 52 |
ย ย 8 | ย 300 | ย 10 | ย 560 | 737 | ย 39 | ย 2% | 1% | 3% | yes | yes | yes | 5,551 | 7,681 | 380 |
ย ย 16 | ย 560 | ย 5 | 2,288 | 2,288 | ย 16 | ย 1% | 65% | 71% | no | no | yes | 22,612 | 9,506 | 50 |
ย ย 16 | ย 560 | ย 10 | 653 | 2,288 | ย 24 | ย 1% | 36% | 38% | yes | no | yes | 6,541 | 16,554 | 153 |
For each clause of every local invariant generated by PQE, we checked if was a global invariant. Namely, we used a public version of IC3ย [16, 17] to verify if the property held (by showing that no reachable state of falsified ). If so, and depended only on variables of , had an unwanted invariant. Then we stopped invariant generation. The results of the experiment for buffers with 32-bit elements are given in Tableย 1. When picking a clause to take out, i.e., a clause with a state variable of -th time frame, one could make a good choice by pure luck. To address this issue, we picked clauses to take out randomly and performed 10 different runs of invariant generation and then computed the average value. So, the columns four to twelve of Tableย 1 actually give the average value of 10 runs.
Let us use the first line of Tableย 1 to explain its structure. The first two columns show the number of elements in implemented by and the number of latches in (8 and 300). The third column gives the number of time frames (i.e., 5). The next three columns show the total number of PQE problems solved by a PQE solver before an unwanted invariant was generated, e.g., 8 problems for -. On the other hand, - failed to find an unwanted invariant and had to solve all 1,236 PQE problems of taking out a clause of with an unquantified variable. The following three columns show the share of PQE problems finished in the time limit of 10 sec. For instance, - finished 36% of 311 problems. The next three columns show if an unwanted invariant was generated by a PQE solver. (- and - found one whereas - did not.) The last three columns give the total run time. Tableย 1 shows that only - managed to generate an unwanted invariant for all four instances of . This invariant asserted that cannot reach a state where an element of equals .
7.3 Detection of the bug by conventional methods
The bug above (or its modified version) can be overlooked by conventional methods. Consider, for instance, testing. It is hard to detect this bug by random tests because it is exposed only if one tries to add Val to . The same applies to testing using the line coverage metricย [18]. On the other hand, a test set with 100% branch coverageย [18] will find this bug. (To invoke the else branch of the if statement marked with โ*โ in Fig.ย 3, one must set to .) However, such a test set is not hard to beat. Consider a slightly modified bug. Namely, assume that the buggy line isย ย ifโ(() and in the else branch of this if statement, the element is pushed to . So, instead of just ignoring the element , the modified bug replaces it with in . Similarly to the bug of Subsectionย 7.1, does not appear in . So, the modified bug can also be detected by generating an unwanted invariant. On the other hand, it can be overlooked by tests with 100% branch coverage because either branch of the modified if statement can be activated without assigning to .
Now consider the โmanualโ generation of unwanted properties. It is virtually impossible to guess an unwanted invariant of exposing the bug of Subsectionย 7.1 unless one knows exactly what this bug is. However, one can detect this bug by checking a property asserting that the element must appear in the buffer if is ready to accept it, i.e., holds. Note that this is a non-invariant property involving states of different time frames. The more time frames are used in such a property, the more guesswork is required to pick it. Consider, for instance, the following bug. Suppose does not reject the element . So, the non-invariant property above holds. However, if , then changes the previous accepted element if that element was too. So, cannot have two consecutive elements . Our method will detect this bug via generating an unwanted invariant falsified by states with consecutive elements . One can also identify this bug by checking a property involving two consecutive elements of . But picking it requires a lot of guesswork and so the modified bug can be easily overlooked.
8 Experiments With HWMCC Benchmarks
In this section, we describe three experiments with 98 multi-property benchmarks of the HWMCC-13 setย [19]. (We use this set because it has a multi-property track, see the explanation below.) The number of latches in those benchmarks range from 111 to 8,000. More details about the choice of benchmarks and the experiments can be found in Appendixย 0.H. Each benchmark consists of a sequential circuit and invariants to prove. Like in Sectionย 4, we call the aggregate invariant. In experiments 2 and 3 we used PQE to generate new invariants of . Since every invariant implied by is a desired one, the necessary condition for to be unwanted is . The conjunction of many invariants produces a stronger invariant , which makes it harder to generate not implied by . (This is the reason for using multi-property benchmarks in our experiments.) The circuits of the HWMCC-13 set are anonymous, so, we could not know if an unreachable state is supposed to be reachable. For that reason, we just generated invariants not implied by without deciding if some of them were unwanted.
Similarly to the experiment of Sectionย 7, we used the formula to generate invariants. The number of time frames was in the range of . As in the experiment of Sectionย 7, we took out only clauses containing a state variable of the -th time frame. In all experiments, the time limit for solving a PQE problem was set to 10 sec.
8.1 Experiment 1
In the first experiment, we generated a local invariant by taking out a clause of where . The formula asserts that no state falsifying can be reached in transitions. Our goal was to show that PQE can find for large formulas that have hundreds of thousands of clauses. We used - to partition the PQE problems we tried into two groups. The first group consisted of 3,736 problems for which we ran - with the time limit of 10 sec. and it never encountered a subspace where was satisfiable. Here is a full assignment to . Recall that only the variables are unquantified in . So, in every subspace , formula was either unsatisfiable or . (The fact that so many problems meet the condition of the first group came as a big surprise.) The second group consisted of 3,094 problems where - encountered subspaces where was satisfiable.
For the first group, - finished only 30% of the problems within 10 sec. whereas - and - finished 88% and 89% respectively. The poor performance of - is due to not checking if in the current subspace. For the second group, -, - and - finished 15%, 2% and 27% of the problems respectively within 10 sec. - finished far fewer problems because it used a satisfying assignment as a proof of redundancy of (see Subsectionย 6.2).
To contrast PQE and QE, we employed a high-quality tool ย [20, 21] to perform QE on the 98 formulas (one formula per benchmark). That is, instead of taking a clause out of by PQE, we applied to perform full QE on this formula. (Performing QE on produces a formula specifying all states unreachable in transitions.) finished only 25% of the 98 QE problems with the time limit of 600 sec. On the other hand, - finished 60% of the 6,830 problems of both groups (generated off ) within 10 sec. So, PQE can be much easier than QE if only a small part of the formula gets unquantified.
8.2 Experiment 2
The second experiment was an extension of the first one. Its goal was to show that PQE can generate invariants for realistic designs. For each clause of a local invariant generated by PQE we used IC3 to verify if was a global invariant. If so, we checked if held. To make the experiment less time consuming, in addition to the time limit of 10 sec. per PQE problem we imposed a few more constraints. The PQE problem of taking a clause out of terminated as soon as accumulated 5 clauses or more. Besides, processing a benchmark aborted when the summary number of clauses of all formulas generated for this benchmark reached 100 or the total run time of all PQE problems generated off exceeded 2,000 sec.
pqe | #bench | results | ||
---|---|---|---|---|
solver | marks | local | glob. | not imp. |
invar. | invar. | by | ||
ds-pqe | ย 98 | 5,556 | 2,678 | 2,309 |
eg-pqe | ย 98 | 9,498 | 4,839 | 4,009 |
eg-pqe+ | ย 98 | 9,303 | 4,773 | 3,940 |
Tableย 2 shows the results of the experiment. The third column gives the number of local single-clause invariants (i.e., the total number of clauses in all over all benchmarks). The fourth column shows how many local single-clause invariants turned out to be global. (Since global invariants were extracted from and the summary size of all could not exceed 100, the number of global invariants per benchmark could not exceed 100.) The last column gives the number of global invariants not implied by . So, these invariants are candidates for checking if they are unwanted. Tableย 2 shows that - and - performed much better than -.
8.3 Experiment 3
To prove an invariant true, IC3 conjoins it with clauses to make inductive. If IC3 succeeds, every is an invariant. Moreover, may be an unwanted invariant. The goal of the third experiment was to demonstrate that PQE and IC3, in general, produce different invariant clauses. The intuition here is twofold. First, IC3 generates clauses to prove a predefined invariant rather than find an unwanted one. Second, the closer to being inductive, the fewer new invariant clauses are generated by IC3. Consider the circuit that simply stays in the initial state (Sectionย 4). Any invariant satisfied by is already inductive for . So, IC3 will not generate a single new invariant clause. On the other hand, if the correct circuit is supposed to leave the initial state, has unwanted invariants that our method will find.
In this experiment, we used IC3 to generate , an inductive version of . The experiment showed that in 88% cases, an invariant clause generated by - and not implied by was not implied by either. (See Appendixย 0.H.3 for more detail.)
9 Properties Mimicking Symbolic Simulation
Let be a combinational circuit where are internal, input and output variables. In this section, we describe generation of properties of that mimic symbolic simulationย [22]. Every such a property specifies a cube of tests that produce the same values for a given subset of variables of . We chose generation of such properties because deciding if is an unwanted property is, in general, simple. The procedure for generation of these properties is slightly different from the one presented in Sectionย 3.
Let be a formula specifying . Let be a clause. Let be a solution to the PQE problem of taking a clause out of . That is, . Let be a clause of . Then has the property that for every full assignment to falsifying , it produces an output falsifying (see Propositionย 3 of Appendixย 0.B). Suppose, for instance, and . Then for every where , the circuit produces an output where . Note that is implied by rather than . So, it is a property of under constraint rather than alone. The property is unwanted if there is an input falsifying that should not produce an output falsifying .
To generate combinational circuits, we unfolded sequential circuits of the set of 98 benchmarks used in Sectionย 8 for invariant generation. Let be a sequential circuit. (We reuse the notation of Sectionย 4). Let denote the combinational circuit obtained by unfolding for time frames. Here are state and input variables of -th time frame respectively. Let denote the formula describing the unfolding of for time frames. Note that specifies the circuit above under the input constraint . Let be a clause. Let be a solution to the PQE problem of taking a clause out of formula . Here . That is, . Let be a clause of . Then for every assignment (,,โฆ,) falsifying , the circuit outputs falsifying . (Here is the initial state of and is a state of the last time frame.)
In the experiment, we used -,- and - to solve 1,586 PQE problems described above. In Tableย 3, we give a sample of results by -. (More details about this experiment can be found in Appendixย 0.I.) Below, we use the first line of Tableย 3 to explain its structure. The first column gives the benchmark name (6s326). The next column shows that 6s326 has 3,342 latches. The third column gives the number of time frames used to produce a combinational circuit (here ). The next column shows that the clause introduced above consisted of 15 literals of variables from . (Here and below we still use the index assuming that .) The literals of were generated randomly. When picking the length of we just tried to simulate the situation where one wants to set a particular subset of output variables of to specified values. The next two columns give the size of the subcircuit of that feeds the output variables present in . When computing a property we took a clause out of formula where specifies instead of formula where specifies . (The logic of not feeding a variable of is irrelevant for computing .) The first column of the pair gives the number of gates in (i.e., 348,479). The second column provides the number of input variables feeding (i.e., 1,774). Here we count only variables of and ignore those of since the latter are already assigned values specifying the initial state of .
circuits
name | lat- | time | size | subc. | results | ||||
---|---|---|---|---|---|---|---|---|---|
ches | fra- | of | gates | inp. | min | max | time | 3-val. | |
mes | vars | (s.) | sim. | ||||||
6s326 | 3,342 | ย 20 | ย 15 | 348,479 | 1,774 | 27 | 28 | 2.9 | ย no |
6s40m | 5,608 | ย 20 | ย 15 | 406,474 | 3,450 | 27 | 29 | 1.1 | ย no |
6s250 | 6,185 | ย 20 | ย 15 | 556,562 | 2,456 | 50 | 54 | 0.8 | ย no |
6s395 | 463 | ย 30 | ย 15 | 36,088 | 569 | 24 | 26 | 0.7 | ย yes |
6s339 | 1,594 | ย 30 | ย 15 | 179,543 | 3,978 | 70 | 71 | 3.1 | ย no |
6s292 | 3,190 | ย 30 | ย 15 | 154,014 | 978 | 86 | 89 | 1.1 | ย no |
6s143 | 260 | ย 40 | ย 15 | 551,019 | 16,689 | 526 | 530 | 2.5 | ย yes |
6s372 | 1,124 | ย 40 | ย 15 | 295,626 | 2,766 | 513 | 518 | 1.7 | ย no |
6s335 | 1,658 | ย 40 | ย 15 | 207,787 | 2,863 | 120 | 124 | 6.7 | ย no |
6s391 | 2,686 | ย 40 | ย 15 | 240,825 | 7,579 | 340 | 341 | 8.9 | ย no |
The next four columns show the results of taking a clause out of. For each PQE problem the time limit was set to 10 sec. Besides, - terminated as soon as 5 clauses of property were generated. The first three columns out of four describe the minimum and maximum sizes of clauses in and the run time of -. So, it took for - 2.9 sec. to produce a formula containing clauses of sizes from 27 to 28 variables. A clause of with 27 variables, for instance, specifies tests falsifying that produce the same output of (falsifying the clause ). Here is the number of input variables of not present in . The last column shows that at least one clause of specifies a property that cannot be produced by 3-valued simulation (a version of symbolic simulationย [22]). To prove this, one just needs to set the input variables of present in to the values falsifying and run 3-valued simulation. (The remaining input variables of are assigned a donโt-care value.) If after 3-valued simulation some output variable of is assigned a donโt-care value, the property specified by cannot be produced by 3-valued simulation.
Running -, - and - on the 1,586 PQE problems mentioned above showed that a) - performed poorly producing properties only for 28% of problems; b) - and - showed much better results by generating properties for 62% and 66% of problems respectively. When - and - succeeded in producing properties, the latter could not be obtained by 3-valued simulation in 74% and 78% of cases respectively.
10 Some Background
In this section, we discuss some research relevant to PQE and property generation. Information on BDD based QE can be found inย [23, 24]. SAT based QE is described in [11, 25, 26, 27, 28, 29, 30, 31, 20]. Our first PQE solver called - was introduced inย [1]. It was based on redundancy based reasoning presented inย [32] in terms of variables and inย [33] in terms of clauses. The main flaw of - is as follows. Consider taking a clause out of . Suppose - proved redundant in a subspace where is satisfiable and some quantified variables are assigned. The problem is that - cannot simply assume that is redundant every time it re-enters this subspaceย [34]. The root of the problem is that redundancy is a structural rather than semantic property. That is, redundancy of a clause in a formula (quantified or not) does not imply such redundancy in every formula logically equivalent to . Since our current implementation of - uses - as a subroutine, it has the same learning problem. We showed inย [35] that this problem can be addressed by the machinery of certificate clauses. So, the performance of PQE can be drastically improved via enhanced learning in subspaces where is satisfiable.
We are unaware of research on property generation for combinational circuits. As for invariants, the existing procedures typically generate some auxiliary desired invariants to prove a predefined property (whereas our goal is to generate invariants that are unwanted). For instance, they generate loop invariantsย [36] or invariants relating internal points of circuits checked for equivalence ย [37]. Another example of auxiliary invariants are clauses generated by IC3 to make an invariant inductiveย [16]. As we showed in Subsectionย 8.3, the invariants produced by PQE are, in general, different from those built by IC3.
11 Conclusions And Directions For Future Research
We consider Partial Quantifier Elimination (PQE) on propositional CNF formulas with existential quantifiers. In contrast to complete quantifier elimination, PQE allows to unquantify a part of the formula. We show that PQE can be used to generate properties of combinational and sequential circuits. The goal of property generation is to check if there is an unwanted property identifying a bug. We used PQE to generate an unwanted invariant for a FIFO buffer exposing a non-trivial bug. We also applied PQE to invariant generation for HWMCC benchmarks. Finally, we used PQE to generate properties of combinational circuits mimicking symbolic simulation. Our experiments show that PQE can efficiently generate properties for realistic designs.
There are at least three directions for future research. The first direction is to improve the performance of PQE solving. As we mentioned in Sectionย 10, the most promising idea here is to enhance the power of learning in subspaces where the formula is satisfiable. The second direction is to use the improved PQE solvers to design new, more efficient algorithms for well-known problems like SAT, model checking and equivalence checking. The third direction is to look for new problems that can be solved by PQE.
References
- [1] E.ย Goldberg and P.ย Manolios, โPartial quantifier elimination,โ in Proc. of HVC-14.ย ย ย Springer-Verlag, 2014, pp. 148โ164.
- [2] W.ย Craig, โThree uses of the herbrand-gentzen theorem in relating model theory and proof theory,โ The Journal of Symbolic Logic, vol.ย 22, no.ย 3, pp. 269โ285, 1957.
- [3] K.ย McMillan, โInterpolation and sat-based model checking,โ in CAV-03.ย ย ย Springer, 2003, pp. 1โ13.
- [4] E.ย Goldberg, โProperty checking by logic relaxation,โ Tech. Rep. arXiv:1601.02742 [cs.LO], 2016.
- [5] E.ย Goldberg and P.ย Manolios, โSoftware for quantifier elimination in propositional logic,โ in ICMS-2014,Seoul, South Korea, August 5-9, 2014, pp. 291โ294.
- [6] E.ย Goldberg, โEquivalence checking by logic relaxation,โ in FMCAD-16, 2016, pp. 49โ56.
- [7] โโ, โProperty checking without inductive invariant generation,โ Tech. Rep. arXiv:1602.05829 [cs.LO], 2016.
- [8] B.ย L. Synthesis and V.ย Group, โABC: A system for sequential synthesis and verification,โ 2017, http://www.eecs.berkeley.edu/alanmi/abc.
- [9] O.ย Kullmann, โNew methods for 3-sat decision and worst-case analysis,โ Theor. Comput. Sci., vol. 223, no. 1-2, pp. 1โ72, 1999.
- [10] G.ย Tseitin, โOn the complexity of derivation in the propositional calculus,โ Zapiski nauchnykh seminarov LOMI, vol.ย 8, pp. 234โ259, 1968, english translation of this volume: Consultants Bureau, N.Y., 1970, pp. 115โ125.
- [11] K.ย McMillan, โApplying sat methods in unbounded symbolic model checking,โ in Proc. of CAV-02.ย ย ย Springer-Verlag, 2002, pp. 250โ264.
- [12] The source of -, http://eigold.tripod.com/software/ds-pqe.tar.gz.
- [13] The source of -, http://eigold.tripod.com/software/eg-pqe.1.0.tar.gz.
- [14] The source of -, http://eigold.tripod.com/software/eg-pqe-pl.1.0.tar.gz.
- [15] N.ย Eรฉn and N.ย Sรถrensson, โAn extensible sat-solver,โ in SAT, Santa Margherita Ligure, Italy, 2003, pp. 502โ518.
- [16] A.ย R. Bradley, โSat-based model checking without unrolling,โ in VMCAI, 2011, pp. 70โ87.
- [17] An implementation of IC3 by A. Bradley, https://github.com/arbrad/IC3ref.
- [18] M.ย Aniche, Effective Software Testing: A developerโs guide.ย ย ย Manning publications, 2022.
- [19] HardWare Model Checking Competition 2013 (HWMCC-13), http://fmv.jku.at/hwmcc13/.
- [20] M.ย Rabe, โIncremental determinization for quantifier elimination and functional synthesis,โ in CAV, 2019.
- [21] CADET, https://github.com/MarkusRabe/cadet.
- [22] R.ย Bryant, โSymbolic simulationโtechniques and applications,โ in DAC-90, 1990, pp. 517โ521.
- [23] โโ, โGraph-based algorithms for Boolean function manipulation,โ IEEE Transactions on Computers, vol. C-35, no.ย 8, pp. 677โ691, August 1986.
- [24] P.ย Chauhan, E.ย Clarke, S.ย Jha, J.ย Kukula, H.ย Veith, and D.ย Wang, โUsing combinatorial optimization methods for quantification scheduling,โ ser. CHARME-01, 2001, pp. 293โ309.
- [25] H.ย Jin and F.Somenzi, โPrime clauses for fast enumeration of satisfying assignments to boolean circuits,โ ser. DAC-05, 2005, pp. 750โ753.
- [26] M.ย Ganai, A.Gupta, and P.Ashar, โEfficient sat-based unbounded symbolic model checking using circuit cofactoring,โ ser. ICCAD-04, 2004, pp. 510โ517.
- [27] J.ย Jiang, โQuantifier elimination via functional composition,โ in Proceedings of the 21st International Conference on Computer Aided Verification, ser. CAV-09, 2009, pp. 383โ397.
- [28] J.ย Brauer, A.ย King, and J.ย Kriener, โExistential quantification as incremental sat,โ ser. CAV-11, 2011, pp. 191โ207.
- [29] W.ย Klieber, M.ย Janota, J.Marques-Silva, and E.ย Clarke, โSolving qbf with free variables,โ in CP, 2013, pp. 415โ431.
- [30] N.ย Bjorner, M.ย Janota, and W.ย Klieber, โOn conflicts and strategies in qbf,โ in LPAR, 2015.
- [31] N.ย Bjorner and M.ย Janota, โPlaying with quantified satisfaction,โ in LPAR, 2015.
- [32] E.ย Goldberg and P.ย Manolios, โQuantifier elimination by dependency sequents,โ in FMCAD-12, 2012, pp. 34โ44.
- [33] โโ, โQuantifier elimination via clause redundancy,โ in FMCAD-13, 2013, pp. 85โ92.
- [34] E.ย Goldberg, โQuantifier elimination with structural learning,โ Tech. Rep. arXiv: 1810.00160 [cs.LO], 2018.
- [35] โโ, โPartial quantifier elimination by certificate clauses,โ Tech. Rep. arXiv:2003.09667 [cs.LO], 2020.
- [36] I.ย Dillig, T.ย Dillig, B.ย Li, and K.ย McMillan, โInductive invariant generation via abductive inference,โ vol.ย 48, 10 2013, pp. 443โ456.
- [37] J.Baumgartner, H.ย Mony, M.ย Case, J.ย Sawada, and K.ย Yorav, โScalable conditional equivalence checking: An automated invariant-generation based approach,โ in 2009 Formal Methods in Computer-Aided Design, 2009, pp. 120โ127.
- [38] A.ย Biere, A.ย Cimatti, E.ย Clarke, M.ย Fujita, and Y.ย Zhu, โSymbolic model checking using sat procedures instead of bdds,โ in DAC, 1999, pp. 317โ320.
Appendix
Appendix 0.A PQE And Interpolation
In this appendix, we recall the observation ofย [4] that interpolation is a special case of PQE. Let be an unsatisfiable formula. Let be a formula such that and . Then is called an interpolantย [2]. Now, let us show that interpolation can be described in terms of PQE. Consider the formula where and are the formulas above and . Let be obtained by taking out of the scope of quantifiers i.e. . Since is unsatisfiable, is unsatisfiable too. So, . If , then is an interpolant.
The general case of PQE that takes out of is different from the instance above in three aspects. First, one does not assume that is unsatisfiable. Second, one does not assume that . In other words, in general, PQE does not remove any variables from the original formula. Third, a solution is implied by rather than by alone. Summarizing, one can say that interpolation is a special case of PQE.
Appendix 0.B Proofs Of Propositions
Proposition 1
Let be a solution to the PQE problem of Definitionย 9. That is . Then (i.e. implies ).
Proof
By conjoining both sides of the equality with one concludes that and hence . Then and thus .
Proposition 2
Let a clause be blocked in a formula with respect to a variable . Then is redundant in i.e. .
Proof
It was shown inย [9] that adding a clause blocked in to the formula does not change the value of this formula. This entails that removing a clause blocked in does not change the value of either. So, is redundant in . Let be a full assignment to . Then the clause is either satisfied by or is blocked in with respect to . (The latter follows from the definition of a blocked clause.) In either case is redundant in . Since is redundant in in every subspace , is redundant in .
Proposition 3
Let be a combinational circuit where are the internal, input and output variables. Let be a formula specifying . Let be a clause. Let be a formula obtained by taking a clause out of . That is . Let be a clause of . Then for every full assignment to falsifying , the circuit outputs an assignment falsifying the clause .
Proof
From Propositionย 1 it follows that and hence . This entails that . Let be a full assignment to i.e. an input to . Let (,,) be the execution trace produced by under the input . Here , are full assignments to and respectively. Suppose, satisfies (and so falsifies ). Then (,,) satisfies . Since (,,) is an execution trace, it satisfies and so falsifies . This entails that (,,) (and specifically ) satisfies and hence falsifies .
Appendix 0.C Examples Of Problems That Reduce To PQE
SAT-solving by PQEย [1]. Consider the SAT problem of checking if formula is true. One can view traditional SAT-solving as proving all clauses redundant in e.g. by finding a satisfying assignment or by deriving an empty clause and adding it to . The reduction to PQE below facilitates developing an incremental SAT-algorithm that needs to prove redundancy only for a fraction of clauses.
Let be a full assignment to and denote the clauses of falsified by . Checking the satisfiability of reduces to taking out of the scope of quantifiers i.e. to finding such that . Since all variables of are quantified in , the formula is a Boolean constant 0 or 1. If , then is unsatisfiable. If , then is satisfiable because is satisfied by .
Equivalence checking by PQEย [6]. Let and be single-output combinational circuits to check for equivalence. Here are the sets of internal and input variables and is the output variable of . (Definition of for is the same.) The reduction to PQE below facilitates the design of a complete algorithm able to exploit the similarity of and . This is important because the current equivalence checkers exploiting such similarity are incomplete. If and are not โsimilar enoughโ, e.g. they have no functionally equivalent internal points, the equivalence checker invokes a complete (but inefficient) procedure ignoring similarities between and .
Let specify a formula such that = 1 iff where are full assignments to and respectively. Let formulas and specify and respectively. (As usual, we assume that a formula specifying a circuit is obtained by Tseitin transformationsย [10], see Sectionย 3.) Let be a formula obtained by taking eq out of where . That is . If , then and are equivalent. Otherwise, and are inequivalent, unless they are identical constants i.e. or . It is formally proved inย [6] that the more similar are (where similarity is defined in the most general sense), the easier taking out of becomes.
Model checking by PQEย [7]. One can use PQE to find the reachability diameter of a sequential circuit without computing the set of all reachable states. So, one can prove an invariant by PQE without generating a stronger invariant that is inductive. Let denote the transition relation of a sequential circuit where are the present and next state variables and specifies the (combinational) input variables. Let specify the initial states of . For the sake of simplicity, we assume that can stutter i.e. for every state there exists a full assignment to such that , (Then the sets of states reachable in transitions and at most transitions are identical. If has no stuttering, it can be easily introduced by adding a variable to .)
Let denote the reachability diameter for initial states and transition relation . That is every state of the circuit can be reached in at most transitions. Given a number , one can use PQE to decide if . This is done by checking if is redundant in . Here and specify the initial states of in terms of variables of and respectively, and . If is redundant, then .
The idea above can be used, for instance, to prove an invariant true in an IC3-like manner (i.e. by constraining ) but without generating an inductive invariant. To prove true, it suffices to constrain to a formula such thata) , b) and c) no state falsifying can be reached from a state satisfying in transitions. The conditions b) and c) can be verified by PQE and bounded model checkingย [38] respectively. In the special case where meets the three conditions above for , it is an inductive invariant.
Appendix 0.D Deciding If A Property Is Unwanted
In this appendix, we give the main idea of a procedure for deciding if a property is unwanted. We reuse the notation of Sectionย 3. That is, we consider property generation for a combinational circuit specified by formula . Here denote the sets of the internal, input, and output variables of respectively. For the sake of simplicity, we consider generation of a property depending only on output variables of . Such a property can be obtained by taking a clause out of formula (where only variables of are not quantified). So, .
Note that every clause of is a property too. is an unwanted property if and only if one of its clauses is an unwanted property. Let be a single-clause unwanted property (and so has a bug). This property says that never outputs an assignment falsifying . To prove unwanted one needs to find a test for which a correct version of would produce an output falsifying . Here โbeโ stands for โbug-exposingโ. (If is a desired property, such cannot be produced. So, the failure to find is an argument in favor of being a desired property.)
A test can be found as follows. Since implies , the formula is unsatisfiable (and so cannot produce an output falsifying ). Let be a formula obtained by removing some clauses from for which the formula is satisfiable. Then means that the circuit specified by can produce an output falsifying . The intuition here is that if is unwanted property, the clauses removed from to obtain relate to the buggy part of . (Note that the circuit specified by is non-deterministic. The reason is that can be satisfied by assignments (,,) and (,,) with the same input and different outputs and ).
Assume that all clauses making up the buggy part of has been removed from when obtaining . Then there is an assignment (,,) satisfying . That is a correct version of would produce the assignment falsifying under the input . So, to obtain one needs to build the formula above and examine the input part of assignments satisfying .
The formula can be obtained as follows. Recall that by our assumption (see Subsectionย 3.2 and Remarkย 1). So the formula where is satisfiable. However, one may not extract a test from assignments satisfying because may not be the only clause making up the buggy part of . A good heuristic for forming is to remove from every clause such that . (The latter means that one could obtain the property by taking out the clause from ). However, the topic of obtaining formula and producing a test needs further research.
Appendix 0.E Combining PQE With Clause Splitting
In this appendix, we consider combining PQE with clause splitting mentioned in Subsectionย 3.3. We show that the corresponding PQE problem of taking out a clause produced by splitting is solved by - in linear time. We also show that if this clause is not redundant, the solution produced by - is a single-test property.
Here we reuse the notation of Sectionย 3 but, for the sake of simplicity, consider a single-output combinational circuit. Let be such a circuit where and specify the internal and input variables respectively and is the output variable of . Let be a formula specifying the circuit and be a clause of . Consider the case of splitting on all variables of . That is where ,โฆ,โ,โ and is a literal of and . Let denote the formula obtained from by replacing the clause with . Denote by the input assignment falsifying the literals where โsplโ stands for โsplittingโ.
Consider applying - to solve the PQE problem of taking the clause out of . - starts with looking for an assignment satisfying (to find a subspace where does not imply ). Consider the following three cases. The first case is that the formula above is unsatisfiable. Then is trivially redundant in and hence in and - terminates.
The second case is that there is an assignment () satisfying where is a full assignment to and is the output value taken by under the input . (Note that any full assignment to that is different from falsifies . So, any assignment satisfying has to contain .) Then formula is satisfiable in subspace and - adds the plugging clause that is the longest clause falsified by . If is unsatisfiable, then is redundant in and - terminates.
The third case occurs when there is an assignment () satisfying where is the negation of the output value taken by under input . In this case, formula is unsatisfiable in subspace . Since, is satisfiable in this subspace, is not redundant in . To make redundant in subspace , - has to add the clause that is the longest clause falsified by . The clause is a solution to the PQE problem at hand i.e. .
The clause above is implied by (and hence ) and so, is a property of . This property specifies the input/output behavior of under the input . Namely, to satisfy when the variables of are assigned as in , one has to set the variable to . The latter is the output produced by under the input . So, the property specifies the behavior of under a single test. In all three cases above, the SAT problem considered by - is solved just by initial BCP. (The reason is that the formula at hand contains the unit clauses produced by negating or those specifying the subspace .) So, - solves the PQE problem above in linear time.
Appendix 0.F Tests Specified By A Property Generated By PQE
In this appendix, we show the relation between tests specified by a property obtained via PQE (see Subsectionย 3.5) and those detecting stuck-at faults. Here, we reuse the notation of Sectionย 3. Let be a combinational circuit where are the internal, input and output variables respectively. Let be a formula specifying . Let be an AND gate of whose functionality is . That is are the input variables of and is its output variable. The functionality of is specified by the formula where , , (see Exampleย 2). The clauses are present in formula . Consider taking out of . This clause makes produce the output value 1 when its input values are 1. (If and are set to 1, the clause can be satisfied only by setting to 1.)
Let be the property obtained by taking out . That is. Let be a clause of . As we mentioned earlier, we assume that does not have redundant clauses i.e. those implied by . Then the formula is satisfiable. Let (,,) be an assignment satisfying this formula. Note that this assignment falsifies . (Indeed, assume the contrary. Then (,,) satisfies because it already satisfies . Since this assignment falsifies , we have to conclude that and hence . So we have a contradiction.)
The fact that (,,) falsifies and satisfies means that one can view this assignment as an execution trace of a faulty version of . Namely, the output of gate is stuck at 0 in . (The clause is falsified when i.e. if the gate outputs 0 when its input variables are assigned 1.) Let be the execution trace of under the input . As we showed in Subsectionย 3.5, is different from . So the input exposes a stuck-at fault by making and produce different outputs.
Appendix 0.G Brief Description Of -
In this appendix, we give a high-level view of - and explain how it works in - in more detail. A full description of - can be found inย [1]. - is based on the machinery of D-sequentsย [33] (โDSโ in the name - stands for โD-sequentโ). Given a formula and an assignment to , a D-sequent is a record stating that clause is redundant in in subspace . In -, - is called in subspaces where is satisfiable. (Here is a full assignment to .) - terminates upon deriving a D-sequent where . Such derivation means that is proved redundant in in subspace . Then the plugging clause falsified by is generated where .
- derives the D-sequent above by branching on variables of . A variable is assigned a value either by a decision or during Boolean Constraint Propagation (BCP). A branch of the search tree goes on until an atomic D-sequent is derived for . This occurs when proving in the current subspace becomes trivial. When backtracking, - merges D-sequents derived in different branches using a resolution like operation called join. For instance, the join operation applied to D-sequents where and where produces the D-sequent where =.
- has three situations where an atomic D-sequent is generated. First, when is blocked in the current subspace and hence is redundant there. Then an atomic D-sequent is generated where consists of assignments that made blocked in the current subspace. For instance, in Exampleย 3, - would generate an atomic D-sequent . Second, an atomic D-sequent is generated when is satisfied by an assignment where and . (This can be a decision assignment or an assignment derived from a clause during BCP.) Then an atomic D-sequent is built. Third, an atomic D-sequent is generated when a conflict occurs and a conflict clause falsified in the current subspace is derived. Adding to makes redundant in the current subspace. So, an atomic D-sequent is generated where is the shortest assignment falsifying .
Appendix 0.H Experiments With HWMCC-13 Benchmarks
In Sectionย 8, we described experiments with multi-property benchmarks of the HWMCC-13 setย [19]. In this appendix, we provide some additional information. Each benchmark consists of a sequential circuit and invariants that are supposed to hold for . We will refer to the invariant equal to as the aggregate invariant. We applied PQE to the generation of invariants of that may be unwanted. Since every invariant implied by must hold, the necessary condition for to be unwanted is .
Similarly to the experiment of Sectionย 7, we used the formula to generate invariants. The number of time frames was in the range of . Specifically, we set to the largest value in this range where did not exceed 500,000 clauses. We discarded the benchmarks with . We also dropped the smallest benchmarks. So, in the experiments, we used 98 out of the 178 benchmarks of the set.
We describe three experiments. In every experiment, we generated properties by taking out a clause of where . Propertyย is a local invariant claiming that no state falsifying can be reached in transitions. As in the experiment of Sectionย 7, we took out only clauses containing an unquantified variable (i.e a variable of ). In all experiments, the time limit for solving a PQE problem was set to 10 sec.
0.H.1 Experiment 1
The objective of the first experiment was to demonstrate that - could compute for realistic designs. We also showed in this experiment that PQE could be much easier than QE (see Sectionย 8) and that - outperforms - and -. In this experiment, for each benchmark out of 98 mentioned above we generated PQE problems of taking a clause out of . Some of them were trivially solved by preprocessing. The latter eliminated the blocked clauses of that were easy to identify and ran BCP launched due to the unit clauses specifying the initial state. In all experiments, we discarded problems solved by preprocessing i.e. we considered only non-trivial PQE problems.
pqe | total | finished | |
---|---|---|---|
solver | probl. | num. | perc. |
ds-pqe | 3,736 | 1,132 | ย 30% |
eg-pqe | 3,736 | 3,296 | ย 88% |
eg-pqe+ | 3,736 | 3,329 | ย 89% |
Let be a clause taken out of . We used - to partition the PQE problems we tried into two groups. The first group consisted of problems for which we ran - with the time limit of 10 sec. and it never encountered a subspace where was satisfiable. Here is a full assignment to . (Recall that the variables of are the only unquantified variables of .) So, in every subspace tried by -, formula was either unsatisfiable or . The second group consisted of problems where - encountered subspaces where was satisfiable. For either group we generated up to 40 problems per benchmark. For some benchmarks, the total number of non-trivial problems generated for the first or second group was under 40. Many PQE problems of either group had hundreds of thousands of variables.
pqe | total | finished | |
---|---|---|---|
solver | probl. | num. | perc. |
ds-pqe | 3,094 | 464 | 15% |
eg-pqe | 3,094 | 74 | 2% |
eg-pqe+ | 3,094 | 830 | 27% |
The results for the first group are shown in Tableย 4. The first column gives the name of a PQE solver. The second column shows the number of PQE problems in the first group. The last two columns give the number and percentage of problems finished in the time limit of 10 sec. Tableย 4 shows that - and - performed quite well finishing a very high percentage of problems. The results of - are much poorer because it does not check if in the current subspace i.e. if is trivially redundant.
The results for the second group are shown in Tableย 5 that has the same structure as Tableย 4. In particular, the second column gives the number of PQE problems in the second group. Tableย 5 shows that - and - finished 2% and 27% of the problems respectively. So, - significantly outperformed -. The reason is that - uses a satisfying assignment as a proof of redundancy of the clause in subspace .
0.H.2 Experiment 2
The second experiment was an extension of the first one. Its goal was to show that PQE can generate invariants for realistic designs. For each clause of a local invariant generated by PQE we used IC3 to verify if was a global invariant. If so, we checked if held. To make the experiment less time consuming, in addition to the time limit of 10 sec. per PQE problem, we imposed the following constraints. First, we stopped a PQE-solver even before the time limit if it generated more than 5 free clauses. Second, the time limit for IC3 was set to 30 sec. Third, instead of constraining the number of PQE problems per benchmark (i.e. the number of single clauses taken out of ) like in the first experiment, we imposed the following two constraints. First, we stopped processing a benchmark as soon as the total of 100 free clauses was generated (for all the PQE problems generated for this benchmark). Second, we stopped processing a benchmark even earlier if the summary run time for all PQE problems generated for this benchmark exceeded 2,000 sec.
the experiment with -
name | lat- | in- | time | clau- | single-clause properties | ||||
ches | var. | fra- | ses | gen. | invariant? | not | |||
of | mes | taken | props | un- | no | yes | impl. | ||
out | dec. | by | |||||||
6s306 | 7,986 | ย 25 | ย ย 2 | ย 182 | ย 100 | ย 0 | ย 94 | ย 6 | ย 6 |
6s176 | 1,566 | ย 952 | ย ย 3 | ย 31 | ย 100 | ย 23 | ย 11 | ย 66 | ย 11 |
6s428 | 3,790 | ย 340 | ย ย 4 | ย 28 | ย 100 | ย 9 | ย 5 | ย 86 | ย 83 |
6s292 | 3,190 | ย 247 | ย ย 5 | ย 24 | ย 100 | ย 41 | ย 0 | ย 59 | ย 59 |
6s156 | 513 | ย 32 | ย ย 6 | ย 113 | ย 100 | ย 0 | ย 0 | ย 100 | ย 100 |
6s275 | 3,196 | ย 673 | ย ย 7 | ย 20 | ย 100 | ย 0 | ย 50 | ย 50 | ย 50 |
6s325 | 1,756 | ย 301 | ย ย 8 | ย 22 | ย 100 | ย 0 | ย 1 | ย 99 | ย 97 |
6s391 | 2,686 | ย 387 | ย ย 9 | ย 35 | ย 100 | ย 1 | ย 29 | ย 70 | ย 70 |
6s282 | 1,933 | ย 20 | ย 10 | ย 111 | ย 100 | ย 0 | ย 64 | ย 36 | ย 35 |
A sample of 9 benchmarks out of the 98 we used in the experiment with - is shown in Tableย 6. Let us explain the structure of this table by the benchmark 6s306 (the first line of the table). The name of this benchmark is shown in the first column. The second column gives the number of latches (7,986). The number of invariants that should hold for 6s306 is provided in the third column (25). So, the aggregate invariant of 6s306 is the conjunction of those 25 invariants. The fourth column shows that the number of time frames for 6s306 was set to 2 (since ). The value 182 shown in the fifth column is the total number of single clauses taken out of i.e. the number of PQE problems (where for 6s306).
Every free clause generated by - when taking a clause out of was stored as a local single-clause invariant. The sixth column shows that taking clauses out of the scope of quantifiers was terminated when 100 free clauses (specifying 100 local single-clause invariants) were generated. Each of these 100 local invariants held in -th time frame. The following three columns show how many of those 100 local invariants were true globally. IC3 finished every problem out of 100 in the time limit of 30 sec. So, the number of undecided invariants was 0. The number of invariants IC3 proved false or true globally was 94 and 6 respectively. The last column gives the number of global invariants not implied by i.e. invariants that may be unwanted. For 6s306, this number is 6.
0.H.3 Experiment 3
To prove an invariant true, IC3 conjoins it with clauses to make inductive. If IC3 succeeds, every is an invariant. Moreover, may be an unwanted invariant. Arguably, the cause of efficiency of IC3 is that is often close to an inductive invariant. So, IC3 needs to generate a relatively small number of clauses to make the constrained version of inductive. However, this nice feature of IC3 drastically limits the set of invariant clauses it generates. In this subsection, we substantiate this claim by an experiment. In this experiment, we picked the HWMCC-13 benchmarks for which one could prove all predefined invariants within a time limit. Namely, for every benchmark we formed the aggregate invariant = and ran IC3 to prove true.
We selected the benchmarks that IC3 solved in less than 1,000 sec. (In addition to dropping the benchmarks not solved in 1,000 sec., we discarded those where failed because some invariants were false). Let denote the inductive version of produced by IC3 when proving true. That is, is conjoined with the invariant clauses produced by IC3.
IC3
name | lat- | inva- | glob. single cls. invars | ||
ches | riants | glob. | not | not | |
of | inva- | impl. | impl. | ||
riants | by | by | |||
6s135 | 2,307 | ย 340 | ย 53 | ย 53 | ย 27 |
6s325 | 1,756 | ย 301 | ย 99 | ย 99 | ย 96 |
ex1 | 130 | ย 33 | ย 25 | ย 16 | ย 16 |
ex2 | 212 | ย 32 | ย 64 | ย 64 | ย 47 |
6s106 | 135 | ย 17 | ย 100 | ย 96 | ย 96 |
6s256 | 3,141 | ย 5 | ย 6 | ย 6 | ย 6 |
ex3 | 61 | ย 3 | ย 4 | ย 4 | ย 4 |
ex4 | 63 | ย 3 | ย 1 | ย 1 | ย 1 |
6s209 | 5,759 | ย 2 | ย 95 | ย 95 | ย 89 |
6s113 | 994 | ย 1 | ย 19 | ย 16 | ย 16 |
6s143 | 260 | ย 1 | ย 97 | ย 86 | ย 77 |
6s170 | 3,141 | ย 1 | ย 13 | ย 13 | ย 13 |
6s252 | 170 | ย 1 | ย 55 | ย 41 | ย 34 |
Total | 590 | 522 |
For each of the selected benchmarks we generated invariants by - exactly as in Experiment 2. That is, we stopped generation of local single clause invariants when their number exceeded 100. Then we ran IC3 to identify local invariants that were global as well. After that we checked which of the global invariants generated by - were not implied by . The difference from Experiment 2 was that we also checked which global invariants generated by - were not implied by .
The results of the experiment are shown in Tableย 7. The first three columns of this table are the same as in Tableย 6. They give the name of a benchmark, the number of latches and the number of invariants ,, to prove. (The actual names of examples ex1,..,ex4 in the HWMCC-13 set are pdtvsarmultip, bobtuintmulti, nusmvdme1d3multi, nusmvdme2d3multi respectively.) The next column of Tableย 7 shows the number of local invariants generated by - that turn out to be global. The last two columns give the number of global invariants that were not implied by and respectively. The last row of the table shows that in 522 cases out of 590 the invariants not implied by were not implied by either. So, in 88% of cases, the invariant clauses generated by - were different from those generated by IC3 to form .
Appendix 0.I Experiment With Combinational Circuits
In this appendix, we give more information about the experiment with property generation for combinational circuits described in Sectionย 9. We formed PQE problems as follows. For each benchmark we picked the number of time frames to unroll. The value of ranged from 10 to 40. (For larger circuits we picked a smaller value of .) Then we unrolled for time frames to form a combinational circuit and randomly generated a clause of 15 literals. So, depended on output variables of . After that, we constructed the subcircuit of as described in Sectionย 9. That is, was obtained by removing the logic of that did not feed any output variable present in .
Let formula specify the subcircuit . (Here we reuse the notation of Sectionย 9.) For every benchmark, we generated PQE problems of taking different clauses out of . That is each PQE problem was to find such that . Each clause to take out was chosen among the clauses of that contained a variable of (i.e. an output variable of ). In this way, we formed a set of 3,254 PQE problems. 1,668 of these problems were solved by simple formula preprocessing i.e. turned out to be trivial. So, in the experiment we used the remaining 1,586 non-trivial PQE problems.
pqe | num. | properties were generated | |||
solver | of pqe | num- | stronger than | ||
prob- | ber | ย ย % | 3-val. sim. | ||
lems | num. | ย ย % | |||
ds-pqe | 1,586 | 983 | ย ย 62 | ย 728 | ย ย 74 |
eg-pqe | 1,586 | 450 | ย ย 28 | ย 361 | ย ย 80 |
eg-pqe+ | 1,586 | 1,046 | ย ย 66 | ย 817 | ย ย 78 |
The time limit for solving a PQE problem was set to 10 sec. Besides, solving a PQE problem terminated as soon as the size of reached 5 clauses. The results of the experiment are summarized in Tableย 8. The second column gives the total number of PQE problems. The next two columns show the number and percentage of problems where was non-empty i.e. had at least one clause. (Recall, that each clause of represents a property.) The last two columns give the number and percentage of cases where a clause of represented a property that was stronger than ones produced by 3-valued simulation, a version of symbolic simulationย [22]. Consider, for instance, the last line of the table corresponding to -. For 817 out of 1,046 PQE problems where was not empty, at least one clause of constituted a property that could not be produced by 3-valued simulation. Tableย 8 shows that - had the weakest results generating properties only for 28% of problems whereas - and - performed much better producing properties for 62% and 66% problems respectively.