Interpolating Strong Induction

The principle of strong induction, also known as k-induction is one of the first techniques for unbounded SAT-based Model Checking (SMC). While elegant and simple to apply, properties as such are rarely k-inductive and when they can be strengthened, there is no effective strategy to guess the depth of induction. It has been mostly displaced by techniques that compute inductive strengthenings based on interpolation and property directed reachability (Pdr). In this paper, we present kAvy, an SMC algorithm that effectively uses k-induction to guide interpolation and Pdr-style inductive generalization. Unlike pure k-induction, kAvy uses Pdr-style generalization to compute and strengthen an inductive trace. Unlike pure Pdr, kAvy uses relative k-induction to construct an inductive invariant. The depth of induction is adjusted dynamically by minimizing a proof of unsatisfiability. We have implemented kAvy within the Avy Model Checker and evaluated it on HWMCC instances. Our results show that kAvy is more effective than both Avy and Pdr, and that using k-induction leads to faster running time and solving more instances. Further, on a class of benchmarks, called shift, kAvy is orders of magnitude faster than Avy, Pdr and k-induction.


Introduction
The principle of strong induction, also known as k-induction, is a generalization of (simple) induction that extends the base-and inductive-cases to k steps of a transition system [27].A safety property P is k-inductive in a transition system T iff (a) P is true in the first (k − 1) steps of T , and (b) if P is assumed to hold for (k − 1) consecutive steps, then P holds in k steps of T .Simple induction is equivalent to 1-induction.Unlike induction, strong induction is complete for safety properties: a property P is safe in a transition system T iff there exists a natural number k such that P is k-inductive in T (assuming the usual restriction to simple paths).This makes k-induction a powerful method for unbounded SATbased Model Checking (SMC).
Unlike other SMC techniques, strong induction reduces model checking to pure SAT that does not require any additional features such as solving with assumptions [12], interpolation [24], resolution proofs [17], Maximal Unsatisfiable Subsets (MUS) [2], etc.It easily integrates with existing SAT-solvers and immediately benefits from any improvements in heuristics [23,22], pre-and inprocessing [18], and parallel solving [1].The simplicity of applying k-induction made it the go-to technique for SMT-based infinite-state model checking [9,11,19].In that context, it is particularly effective in combination with invariant synthesis [20,14].Moreover, for some theories, strong induction is strictly stronger than 1-induction [19]: there are properties that are k-inductive, but have no 1-inductive strengthening.Notwithstanding all of its advantages, strong induction has been mostly displaced by more recent SMC techniques such as Interpolation [25], Property Directed Reachability [7,13,15,3], and their combinations [29].In SMC k-induction is equivalent to induction: any k-inductive property P can be strengthened to an inductive property Q [16,6].Even though in the worst case Q is exponentially larger than P [6], this is rarely observed in practice [26].Furthermore, the SAT queries get very hard as k increases and usually succeed only for rather small values of k.A recent work [16] shows that strong induction can be integrated in Pdr.However, [16] argues that k-induction is hard to control in the context of Pdr since choosing a proper value of k is difficult.A wrong choice leads to a form of state enumeration.In [16], k is fixed to 5, and regular induction is used as soon as 5-induction fails.
In this paper, we present kAvy, an SMC algorithm that effectively uses k-induction to guide interpolation and Pdr-style inductive generalization.As many state-of-the-art SMC algorithms, kAvy iteratively constructs candidate inductive invariants for a given safety property P .However, the construction of these candidates is driven by k-induction.Whenever P is known to hold up to a bound N , kAvy searches for the smallest k ≤ N + 1, such that either P or some of its strengthening is k-inductive.Once it finds the right k and strengthening, it computes a 1-inductive strengthening.
It is convenient to think of modern SMC algorithms (e.g., Pdr and Avy), and k-induction, as two ends of a spectrum.On the one end, modern SMC algorithms fix k to 1 and search for a 1-inductive strengthening of P .While on the opposite end, k-induction fixes the strengthening of P to be P itself and searches for a k such that P is k-inductive.kAvy dynamically explores this spectrum, exploiting the interplay between finding the right k and finding the right strengthening.As an example, consider a system in Fig. 1 that counts upto 64 and resets.The property, p : c < 66, is 2-inductive.IC3, Pdr and Avy iteratively guess a 1-inductive strengthening of p.In the worst case, they require at least 64 iterations.On the other hand, kAvy determines that p is 2-inductive after 2 iterations, computes a 1-inductive invariant (c = 65) ∧ (c < 66), and terminates.kAvy builds upon the foundations of Avy [29].Avy first uses Bounded Model Checking [4] (BMC) to prove that the property P holds up to bound N .Then, it uses a sequence interpolant [28] and Pdr-style inductive-generalization [7] to construct 1-inductive strengthening candidate for P .We emphasize that using k-induction to construct 1-inductive candidates allows kAvy to efficiently utilize many principles from Pdr and Avy.While maintaining k-inductive candidates might seem attractive (since they may be smaller), they are also much harder to generalize effectively [7].
We implemented kAvy in the Avy Model Checker, and evaluated it on the benchmarks from the Hardware Model Checking Competition (HWMCC).Our experiments show that kAvy significantly improves the performance of Avy and solves more examples than either of Pdr and Avy.For a specific family of examples from [21], kAvy exhibits nearly constant time performance, compared to an exponential growth of Avy, Pdr, and k-induction (see Fig. 2b in Section 5).This further emphasizes the effectiveness of efficiently integrating strong induction into modern SMC.
The rest of the paper is structured as follows.After describing the most relevant related work, we present the necessary background in Section 2 and give an overview of SAT-based model checking algorithms in Section 3. kAvy is presented in Section 4, followed by presentation of results in Section 5. Finally, we conclude the paper in Section 6.
Related work.kAvy builds on top of the ideas of IC3 [7] and Pdr [13].The use of interpolation for generating an inductive trace is inspired by Avy [29].While conceptually, our algorithm is similar to Avy, its proof of correctness is non-trivial and is significantly different from that of Avy.We are not aware of any other work that combines interpolation with strong induction.
There are two prior attempts enhancing Pdr-style algorithms with k-induction.Pd-Kind [19] is an SMT-based Model Checking algorithm for infinite-state systems inspired by IC3/Pdr.It infers k-inductive invariants driven by the property whereas kAvy infers 1-inductive invariants driven by k-induction.Pd-Kind uses recursive blocking with interpolation and model-based projection to block bad states, and k-induction to propagate (push) lemmas to next level.While the algorithm is very interesting it is hard to adapt it to SAT-based setting (i.e.SMC), and impossible to compare on HWMCC instances directly.
The closest related work is KIC3 [16].It modifies the counter example queue management strategy in IC3 to utilize k-induction during blocking.The main limitation is that the value for k must be chosen statically (k = 5 is reported for the evaluation).kAvy also utilizes k-induction during blocking but computes the value for k dynamically.Unfortunately, the implementation is not available publicly and we could not compare with it directly.

Background
In this section, we present notations and background that is required for the description of our algorithm.Safety Verification.A symbolic transition system T is a tuple (v, Init, Tr , Bad ), where v is a set of Boolean state variables.A state of the system is a complete valuation to all variables in v (i.e., the set of states is {0, 1} |v| ).We write v = {v | v ∈ v}) for the set of primed variables, used to represent the next state.Init and Bad are formulas over v denoting the set of initial states and bad states, respectively, and Tr is a formula over v ∪ v , denoting the transition relation.
With abuse of notation, we use formulas and the sets of states (or transitions) that they represent interchangeably.In addition, we sometimes use a state s to denote the formula (cube) that characterizes it.For a formula ϕ over v, we use ϕ(v ), or ϕ in short, to denote the formula in which every occurrence of v ∈ v is replaced by v ∈ v .For simplicity of presentation, we assume that the property P = ¬Bad is true in the initial state, that is Init ⇒ P .
Given a formula ϕ(v), an M -to-N -unrolling of T , where ϕ holds in all intermediate states is defined by the formula: We write Tr [ϕ] N when M = 0 and Tr N M when ϕ = .A transition system T is UNSAFE iff there exists a state s ∈ Bad s.t.s is reachable, and is SAFE otherwise.Equivalently, T is UNSAFE iff there exists a number N such that the following unrolling formula is satisfiable: T is SAFE if no such N exists.Whenever T is UNSAFE and s N ∈ Bad is a reachable state, the path from s 0 ∈ Init to s N is called a counterexample.
An inductive invariant is a formula Inv that satisfies: A transition system T is SAFE iff there exists an inductive invariant Inv s.t.Inv(v) ⇒ P (v).In this case we say that Inv is a safe inductive invariant.
The safety verification problem is to decide whether a transition system T is SAFE or UNSAFE, i.e., whether there exists a safe inductive invariant or a counterexample.
Strong Induction.Strong induction (or k-induction) is a generalization of the notion of an inductive invariant that is similar to how "simple" induction is generalized in mathematics.A formula Inv is k-invariant in a transition system T if it is true in the first k steps of T .That is, the following formula is valid: -invariant and is inductive after k steps of T , i.e., the following formula is valid: Compared to simple induction, k-induction strengthens the hypothesis in the induction step: Inv is assumed to hold between steps 0 to k − 1 and is established in step k.Whenever Inv ⇒ P , we say that Inv is a safe k-inductive invariant.An inductive invariant is a 1-inductive invariant.
Theorem 1.Given a transition system T .There exists a safe inductive invariant w.r.t.T iff there exists a safe k-inductive invariant w.r.t.T .
Theorem 1 states that k-induction principle is as complete as 1-induction.One direction is trivial (since we can take k = 1).The other can be strengthened further: for every k-inductive invariant Inv k there exists a 1-inductive strengthening Inv 1 such that Inv 1 ⇒ Inv k .Theoretically Inv 1 might be exponentially bigger than Inv k [6].In practice, both invariants tend to be of similar size.
We say that a formula Craig Interpolation [10].We use an extension of Craig Interpolants to sequences, which is common in Model Checking.and (d) I i is over variables that are shared between the corresponding prefix and suffix of A.

SAT-based Model Checking
In this section, we give a brief overview of SAT-based Model Checking algorithms: IC3/Pdr [7,13], and Avy [29].While these algorithms are well-known, we give a uniform presentation and establish notation necessary for the rest of the paper.We fix a symbolic transition system T = (v, Init, Tr , Bad ).
The main data-structure of these algorithms is a sequence of candidate invariants, called an inductive trace.An inductive trace, or simply a trace, is a sequence of formulas F = [F 0 , . . ., F N ] that satisfy the following two properties: An element F i of a trace is called a frame.The index of a frame is called a level.F is clausal when all its elements are in CNF.For convenience, we view a frame as a set of clauses, and assume that a trace is padded with until the required length.The In a monotone trace, a frame F i overapproximates the set of states reachable in up to i steps of the We define an unrolling formula of a k-suffix of a trace F = [F 0 , . . ., F N ] as : We write Tr [F ] to denote an unrolling of a 0-suffix of F (i.e F itself).Intuitively, An extension trace is not unique, but there is a largest extension level.We denote the set of all extension levels of F by W(F ).The existence of an extension level i implies that an unrolling of the i-suffix does not contain any Bad states: Example 1.For Fig. 1, F = [c = 0, c < 66] is a safe trace of size 1.The formula (c < 66) ∧ Tr ∧ ¬(c < 66) is satisfiable.Therefore, there does not exists an extension trace at level 1.Since (c = 0) ∧ Tr ∧ (c < 66) ∧ T r ∧ (c ≥ 66) is unsatisfiable, the trace is extendable at level 0. For example, a valid extension trace at level 0 is Both Pdr and Avy iteratively extend a safe trace either until the extension is closed or a counterexample is found.However, they differ in how exactly the trace is extended.In the rest of this section, we present Avy and Pdr through the lens of extension level.The goal of this presentation is to make the paper selfcontained.We omit many important optimization details, and refer the reader to the original papers [13,7,29].
Pdr maintains a monotone, clausal trace F with Init as the first frame (F 0 ).The trace F is extended by recursively computing and blocking (if possible) states that can reach Bad (called bad states).A bad state is blocked at the largest level possible.Alg. 1 shows PdrBlock, the backward search procedure that identifies and blocks bad states.PdrBlock maintains a queue of states and the levels at which they have to be blocked.The smallest level at which blocking occurs is tracked in order to show the construction of the extension trace.For each state s in the queue, it is checked whether s can be blocked by the previous frame F d−1 (line 5).If not, a predecessor state t of s that satistisfies F d−1 is computed and added to the queue (line 7).If a predecessor state is found at level 0, the trace is not extendable and an empty trace is returned.If the state s is blocked at level d, PdrIndGen, is called to generate a clause that blocks s and possibly others.The clause is then added to all the frames at levels less than or equal to d. PdrIndGen is a crucial optimization to Pdr.However, we do not explain it for the sake of simplicity.The procedure terminates whenever there are no more states to be blocked (or a counterexample was found at line 4).By construction, the output trace G is an extension trace of F at the extension level w.Once Pdr extends its trace, PdrPush is called to check if the clauses it learnt are also true at higher levels.Pdr terminates when the trace is closed.
Avy, shown in Alg. 2, is an alternative to Pdr that combines interpolation and recursive blocking.Avy starts with a trace F , with F 0 = Init, that is extended in every iteration of the main loop.A counterexample is returned whenever F is not extendable (line 3).Otherwise, a sequence interpolant is extracted from the unsatisfiability of Tr [F max(W) ] ∧ Bad (v N +1 ).A longer trace 12 return G Algorithm 2: Avy.
Input: A transition system T = (Init, Tr , Bad ) Observe that G is an extension trace of F .While G is safe, it is neither monotone nor clausal.A helper routine AvyMkTrace is used to convert G to a proper Pdr trace on line 8 (see [29] for the details on AvyMkTrace).Avy converges when the trace is closed.

Interpolating k-Induction
In this section, we present kAvy, an SMC algorithm that uses the principle of strong induction to extend an inductive trace.The section is structured as follows.First, we introduce a concept of extending a trace using relative kinduction.Second, we present kAvy and describe the details of how k-induction is used to compute an extended trace.Third, we describe two techniques for computing maximal parameters to apply strong induction.Unless stated otherwise, we assume that all traces are monotone.
A safe trace F , with |F | = N , is strongly extendable with respect to (i, k), where 1 ≤ k ≤ i + 1 ≤ N + 1, iff there exists a safe inductive trace G stronger than F such that |G| > N and Tr [F i ] k ⇒ G i+1 .We refer to the pair (i, k) as a strong extension level (SEL), and to the trace G as an (i, k)-extension trace, or simply a strong extension trace (SET) when (i, k) is not important.Note that for k = 1, G is just an extension trace.
Example 2. For Fig. 1, the trace We write K(F ) for the set of all SELs of F .We define an order on SELs by : ( Note that the existence of a SEL (i, k) means that an unrolling of the i-suffix with F i repeated k times does not contain any bad states.We use Tr F i k to Algorithm 3: kAvy algorithm.
denote this characteristic formula for SEL (i, k) : Proposition 2. Let F be a safe trace, where The level i in the maximal SEL (i, k) of a given trace F is greater or equal to the maximal extension level of F : Hence, extensions based on maximal SEL are constructed from frames at higher level compared to extensions based on maximal extension level.
Example 3.For Fig. 1, the trace [c = 0, c < 66] has a maximum extension level of 0. Since (c < 66) is 2-inductive, the trace is strongly extendable at level 1 (as was seen in Example 2).kAvy Algorithm kAvy is shown in Fig. 3.It starts with an inductive trace F = [Init] and iteratively extends F using SELs.A counterexample is returned if the trace cannot be extended (line 4).Otherwise, kAvy computes the largest extension level (line 5) (described in Section 4.2).Then, it constructs a strong extension trace using kAvyExtend (line 6) (described in Section 4.1).Finally, PdrPush is called to check whether the trace is closed.Note that F is a monotone, clausal, safe inductive trace throughout the algorithm.

Extending a Trace with Strong Induction
In this section, we describe the procedure kAvyExtend (shown in Alg. 4) that given a trace F of size |F | = N and an (i, k) SEL of F constructs an (i, k)extension trace G of size |G| = N + 1.The procedure itself is fairly simple, but its proof of correctness is complex.first present the theoretical results that connect sequence interpolants with strong extension traces, then the procedure, and then details of its correctness.Through the section, we fix a trace F and its SEL (i, k).
Sequence interpolation for SEL.Let (i, k) be an SEL of F .By Proposition 2, Ψ = Tr F i k ∧ Bad (v N +1 ) is unsatisfiable.Let A = {A i−k+1 , . . ., A N +1 } be a partitioning of Ψ defined as follows: . ., I N +1 ] be a sequence interpolant corresponding to A. Then, I satisfies the following properties: Note that in (♥), both i and k are fixed -they are the (i, k)-extension level.Furthermore, in the top row F i is fixed as well.
The conjunction of the first k interpolants in I is k-inductive relative to the frame F i : Proof.Since F i and F i+1 are consecutive frames of a trace, . By induction over the difference between (i + 1) and (i − k + 2), we show that ), which concludes the proof.
We use Lemma 2 to define a strong extension trace G: be an inductive trace defined as follows: Then, G is an (i, k)-extension trace of F (not necessarily monotone).
4: kAvyExtend.The invariants marked † hold only when the PdrBlock does no inductive generalization.
Since F is safe and I N +1 ⇒ ¬Bad , then G is safe and stronger than F .Lemma 3 defines an obvious procedure to construct an (i, k)-extension trace G for F .However, such G is neither monotone nor clausal.In the rest of this section, we describe the procedure kAvyExtend that starts with a sequence interpolant (as in Lemma 3), but uses PdrBlock to systematically construct a safe monotone clausal extension of F .
The procedure kAvyExtend is shown in 4. For simplicity of the presentation, we assume that PdrBlock does not use inductive generalization.The invariants marked by † rely on this assumption.We stress that the assumption is for presentation only.The correctness of kAvyExtend is independent of it.
kAvyExtend starts with a sequence interpolant according to the partitioning A. The extension trace G is initialized to F and G N +1 is initialized to (line 2).The rest proceeds in three phases: Phase 1 (lines 3-5) computes the prefix G i−k+2 , . . ., G i+1 using the first k − 1 elements of I; Phase 2 (line 8) computes G i+1 using I i+1 ; Phase 3 (lines 9-12) computes the suffix G i+2 using the last (N − i) elements of I.During this phase, PdrPush (line 12) pushes clauses forward so that they can be used in the next iteration.The correctness of the phases follows from the invariants shown in Alg. 4. We present each phase in turn.
Recall that PdrBlock takes a trace F (that is safe up to the last frame) and a transition system, and returns a safe strengthening of F , while ensuring that the result is monotone and clausal.This guarantee is maintained by Alg 4, by requiring that any clause added to any frame G i of G is implicitly added to all frames below G i .
Phase 1.By Lemma 2, the first k elements of the sequence interpolant computed at line 1 over-approximate states reachable in i + 1 steps of Tr .Phase 1 uses this to strengthen G i+1 using the first k elements of I.Note that in that phase, new clauses are always added to frame G i+1 , and all frames before it!Correctness of Phase 1 (line 5) follows from the loop invariant Inv 2 .It holds on loop entry since G i ∧Tr ⇒ I i−k+2 (since G i = F i and (♥)) and G i ∧Tr ⇒ G i+1 (since G is initially a trace).Let G i and G * i be the i th frame before and after execution of iteration j of the loop, respectively.PdrBlock blocks ¬P j at iteration j of the loop.Assume that Inv 2 holds at the beginning of the loop.Then, Finally, since G is a trace, Inv 2 holds at the end of the iteration.
Inv 2 ensures that the trace given to PdrBlock at line 5 can be made safe relative to P j .From the post-condition of PdrBlock, it follows that at iteration j, G i+1 is strengthened to G * i+1 such that G * i+1 ⇒ P j and G remains a monotone clausal trace.At the end of Phase 1, [G 0 , . . ., G i+1 ] is a clausal monotone trace.
Interestingly, the calls to PdrBlock in this phase do not satisfy an expected pre-condition: the frame G i in [Init, G i , G i+1 ] might not be safe for property P j .However, we can see that Init ⇒ P j and from Inv 2 , it is clear that P j is inductive relative to G i .This is a sufficient precondition for PdrBlock.
Phase 2. This phase strengthens G i+1 using the interpolant I i+1 .After Phase 2, G i+1 is k-inductive relative to F i .Phase 3. Unlike Phase 1, G j+1 is computed at the j th iteration.Because of this, the property P j in this phase is slightly different than that of Phase 1. Correctness follows from invariant Inv 6 that ensures that at iteration j, G j+1 be made safe relative to P j .From the post-condition of PdrBlock, it follows that G j+1 is strengthened to G * j+1 such that G * j+1 ⇒ P j and G is a monotone clausal trace.The invariant implies that at the end of the loop G N +1 ⇒ G N ∨ I N +1 , making G safe.Thus, at the end of the loop G is a safe monotone clausal trace that is stronger than F .What remains is to show is that G i+1 is k-inductive relative to F i .
Let ϕ be the formula from Lemma 2. Assuming that PdrBlock did no inductive generalization, Phase 1 maintains Inv † 3 , which states that at iteration j, PdrBlock strengthens frames {G m }, j < m ≤ (i + 1).Inv † 3 holds on loop entry, since initially G = F .Let G m , G * m ( j < m ≤ (i + 1) ) be frame m at the beginning and at the end of the loop iteration, respectively.In the loop, PdrBlock adds clauses that block ¬P j .Thus, ).Thus, Inv † 3 holds at the end of the loop.In particular, after line 8, Theorem 2. Given a safe trace F of size N and an SEL (i, k) for F , kAvyExtend returns a clausal monotone extension trace G of size N +1.Furthermore, if PdrBlock does no inductive generalization then G is an (i, k)-extension trace.
Of course, assuming that PdrBlock does no inductive generalization is not realistic.kAvyExtend remains correct without the assumption: it returns a trace G that is a monotone clausal extension of F .However, G might be stronger than any (i, k)-extension of F .The invariants marked with † are then relaxed to their unmarked versions.Overall, inductive generalization improves kAvyExtend since it is not restricted to only a k-inductive strengthening.
Importantly, the output of kAvyExtend is a regular inductive trace.Thus, kAvyExtend is a procedure to strengthen a (relatively) k-inductive certificate to a (relatively) 1-inductive certificate.Hence, after kAvyExtend, any strategy for further generalization or trace extension from IC3, Pdr, or Avy is applicable.

Searching for the maximal SEL
In this section, we describe two algorithms for computing the maximal SEL.Both algorithms can be used to implement line 5 of Alg. 3.They perform a guided search for group minimal unsatisfiable subsets.They terminate when having fewer clauses would not increase the SEL further.The first, called topdown, starts from the largest unrolling of the Tr and then reduces the length of the unrolling.The second, called bottom-up, finds the largest (regular) extension level first, and then grows it using strong induction.

Evaluation
We implemented kAvy on top of the Avy Model Checker3 .For line 5 of Alg. 3 we used Alg 5. We evaluated kAvy's performance against a version of Avy [29] from the Hardware Model Checking Competition 2017 [5], and the Pdr engine of ABC [13].We have used the benchmarks from HWMCC'14, '15, and '17.
Benchmarks that are not solved by any of the solvers are excluded from the presentation.The experiments were conducted on a cluster running Intel E5-2683 V4 CPUs at 2.1 GHz with 8GB RAM limit and 30 minutes time limit.The results are summarized in Table 1.The HWMCC has a wide variety of benchmarks.We aggregate the results based on the competition, and also benchmark origin (based on the name).Some named categories (e.g., intel ) include benchmarks that have not been included in any competition.The first column in Table 1 indicates the category.Total is the number of all available benchmarks, ignoring duplicates.That is, if a benchmark appeared in multiple categories, it is counted only once.Numbers in brackets indicate the number of instances that are solved uniquely by the solver.For example, kAvy solves 14 instances in oc8051 that are not solved by any other solver.The VBS column indicates the Virtual Best Solver -the result of running all the three solvers in parallel and stopping as soon as one solver terminates successfully.
Overall, kAvy solves more safe instances than both Avy and Pdr, while taking less time than Avy (we report time for solved instances, ignoring timeouts).The VBS column shows that kAvy is a promising new strategy, significantly improving overall performance.In the rest of this section, we analyze the results in more detail, provide detailed run-time comparison between the tools, and isolate the effect of the new k-inductive strategy.
To compare the running time, we present scatter plots comparing kAvy and Avy (Fig. 3a), and kAvy and Pdr (Fig. 3b).In both figures, kAvy is at the bottom.Points above the diagonal are better for kAvy.Compared to Avy, whenever an instance is solved by both solvers, kAvy is often faster, sometimes by orders of magnitude.Compared to Pdr, kAvy and Pdr perform well on very different instances.This is similar to the observation made by the authors of the original paper that presented Avy [29].Another indicator of performance is the depth of convergence.This is summarized in Fig. 3d and Fig. 3e.kAvy often converges much sooner than Avy.The comparison with Pdr is less clear which is consistent with the difference in performance between the two.To get the whole picture, Fig. 2a presents a cactus plot that compares the running times of the algorithms on all these benchmarks.To isolate the effects of k-induction, we compare kAvy to a version of kAvy with k-induction disabled, which we call vanilla.Conceptually, vanilla is similar to Avy since it extends the trace using a 1-inductive extension trace, but its implementation is based on kAvy.The results for the running time and the depth of convergence are shown in Fig. 3c and Fig. 3f, respectively.The results are very clear -using strong extension traces significantly improves performance and has non-negligible affect on depth of convergence.
Finally, we discovered one family of benchmarks, called shift, on which kAvy performs orders of magnitude better than all other techniques.The benchmarks come from encoding bit-vector decision problem into circuits [21,31].The shift family corresponds to deciding satisfiability of (x + y) = (x << 1) for two bit-vecors x and y.The family is parameterized by bit-width.The property is k-inductive, where k is the bit-width of x.The results of running Avy, Pdr, k-induction4 , and kAvy are shown in Fig. 2b.Except for kAvy, all techniques exhibit exponential behavior in the bit-width, while kAvy remains constant.Deeper analysis indicates that kAvy finds a small inductive invariant while

Conclusion
In this paper, we present kAvy-an SMC algorithm that effectively uses kinductive reasoning to guide interpolation and inductive generalization.kAvy searches both for a good inductive strengthening and for the most effective induction depth k.We have implemented kAvy on top of Avy Model Checker.The experimental results on HWMCC instances show that our approach is effective.The search for the maximal SEL is an overhead in kAvy.There could be benchmarks in which this overhead outweighs its benefits.However, we have not come across such benchmarks so far.In such cases, kAvy can choose to settle for a sub-optimal SEL as mentioned in section 4.2.Deciding when and how much to settle for remains a challenge.
execution of the Tr that is consistent with the k-suffix F k .If a transition system T admits a safe trace F of size |F | = N , then T does not admit counterexamples of length less than N .A safe trace F , with |F | = N is extendable with respect to level 0 ≤ i ≤ N iff there exists a safe trace G stronger than F such that |G| > N and F i ∧ Tr ⇒ G i+1 .G and the corresponding level i are called an extension trace and an extension level of F , respectively.SAT-based model checking algorithms work by iteratively extending a given safe trace F of size N to a safe trace of size N + 1.
steps in the execution of the circuit.At the same time, neither inductive generalization nor k-induction alone are able to consistently find the same invariant quickly.

Table 1 .
Summary of instances solved each tool.Timeouts were ignored when computing the time column.