Latticed k-Induction with an Application to Probabilistic Programs

Bounded model checking (BMC) [12, 17] is a successful method for analyzing models of hardware and software systems. For checking a finite-state transition system (TS) against a safety property (“bad states are unreachable”), BMC unrolls the transition relation until it either finds a counterexample and hence refutes the property, or reaches a pre-computed completeness threshold on the unrolling depth and accepts the property as verified. For infinite-state systems, however, such completeness thresholds need not exist (cf. [64]), rendering BMC a refutation-only technique. To verify infinite-state systems, BMC is typically combined with the search for an inductive invariant, i.e., a superset of the reachable states which is closed under the transition relation. Proving a—not necessarily inductive—safety property then amounts to synthesizing a sufficiently strong, often complicated, inductive invariant that excludes the bad states. A plethora of techniques target computing or approximating inductive invariants, including IC3 [14], induction [13, 20], interpolation [50, 51], and predicate abstraction [27, 36]. However, invariant synthesis may burden full automation, as it either relies on user-supplied annotations or confines push-button technologies to semi-decision or approximate procedures.

k-induction [65] generalizes the principle of simple induction (aka 1-induction) by considering k consecutive transition steps instead of only a single one. It is more powerful: an invariant can be k-inductive for some \(k >1\) but not 1-inductive. Following the seminal work of Sheeran et al. [65] which combines k-induction with SAT solving to check safety properties, k-induction has found a broad spectrum of applications in the realm of hardware [29, 37, 45, 65] and software verification [10, 21‐23, 55, 63]. Its success is due to (1) being a foundational yet potent reasoning technique, and (2) integrating well with SAT/SMT solvers, as also pointed out in [45]: “the simplicity of applying k-induction made it the go-to technique for SMT-based infinite-state model checking”. This paper explores whether k-induction can have a similar impact on the fully automatic verification of infinite-state probabilistic programs. That is, we aim to verify that the expected value of a specified quantity—think: “quantitative postcondition”—after the execution of a probabilistic program is bounded by a specified threshold.

(A) Quantitative reachability. In a TS, a state reachable within k steps remains reachable on increasing k. In contrast, reachability probabilities in Markov chains—a common operational model for probabilistic programs [28]—may increase on increasing k. Hence, proving that the probability of reaching a bad state remains below a given threshold is more intricate than reasoning about qualitative reachability.

(B) Counterexamples are subsystems. In a TS, an acyclic path from an initial to a bad state suffices as a witness for refuting safety, i.e., non-reachability. SAT encodings of k-induction rely on this by expressing the absence of witnesses up to a certain path-length. In the probabilistic setting, however, witnesses are no longer single paths [30]. Rather, a witness for the probability of reaching a bad state to exceed a threshold is a subsystem [15], i.e., a set of possibly cyclic paths.

(C) Symbolic encodings. To enable fully automated verification, we need a suitable encoding such that our lifting integrates well into SMT solvers. Verifying probabilistic programs involves reasoning about execution trees, where each (weighted) branch corresponds to a probabilistic choice. A suitable encoding needs to capture such trees which requires more involved theories than encoding paths in classical k-induction.

We address challenges (A) and (B) by developing latticed k-induction, which is a proof technique in the rather general setting of fixed point theory over complete lattices. Latticed k-induction generalizes classical k-induction in three aspects: (1) it works with any monotonic map on a complete lattice instead of being confined to the transition relation of a transition system, (2) it generalizes the Park induction principle for bounding fixed points of such monotonic maps, and (3) it extends from natural numbers k to (possibly transfinite) ordinals \(\kappa \), hence its short name: \(\kappa \)-induction.

It is this lattice-theoretic understanding that enables us to lift both k-induction and BMC to reasoning about quantitative properties of probabilistic programs. To enable automated reasoning, we address challenge (C) by an incremental SMT encoding based on the theory of quantifier-free mixed integer and real arithmetic with uninterpreted functions (\(\textsf {QF\_UFLIRA} \)). We show how to effectively compute all needed operations for \(\kappa \)-induction using the SMT encoding and, in particular, how to decide quantitative entailments.

A prototypical implementation of our method demonstrates that \(\kappa \)-induction for (linear) probabilistic programs manages to automatically verify non-trivial specifications for programs taken from the literature which—using existing techniques—cannot be verified without synthesizing a stronger inductive invariant.

Due to space restrictions, most proofs and details about individual benchmarks have been omitted; they are found in an extended version of this paper [8].

Related Work. Besides the aforementioned related work on k-induction, we briefly discuss other automated analysis techniques for probabilistic systems and other approaches for bounding fixed points. Symbolic engines exist for exact inference [26] and sensitivity analysis [33]. Other automated approaches focus on bounding expected costs [56], termination analysis [2, 16], and static analysis [3, 67]. BMC has been applied in a rather rudimentary form to the on-the-fly verification of finite unfoldings of probabilistic programs [35], and the enumerative generation of counterexamples in finite Markov chains [68]. (Semi-)automated invariant-synthesis techniques can be found in [6, 24, 41]. A recent variant of IC3 for probabilistic programs called PrIC3 [7] is restricted to finite-state systems. When applied to finite-state Markov chains, our \(\kappa \)-induction operator is related to other operators that have been employed for determining reachabilitiy probabilities through value iteration [4, 31, 61]. In particular, when iterated on the candidate upper bound, the \(\kappa \)-induction operator coincides with the (upper value iteration) operator in interval iteration [4]; the latter operator can be used together with the up-to techniques (cf. [53, 58, 59]) to prove our \(\kappa \)-induction rule sound (in contrast, we give an elementary proof). However, the \(\kappa \)-induction operator avoids comparing current and previous iterations. It is thus easier to implement and more amenable to SMT solvers. Finally, the proof rules for bounding fixed points recently developed in [5] are restricted to finite-state systems.

We start by recapping some fundamentals on fixed points of monotonic operators on complete lattices before we state our target verification problem.

Fundamentals. For the next three sections, we fix a complete lattice \((E,\, \sqsubseteq )\), i.e. a carrier set E together with a partial order \(\sqsubseteq \), such that every subset \(S \subseteq E\) has a greatest lower bound \(\sqcap S\) (also called the meet of S) and a least upper bound \(\bigsqcup S\) (also called the join of S). For just two elements \(\{g, h\} \subseteq E\), we denote their meet by \(g\sqcap h\) and their join by \(g\sqcup h\). Every complete lattice has a least and a greatest element, which we denote by \(\bot \) and \(\top \), respectively.

In addition to \((E,\, \sqsubseteq )\), we also fix a monotonic operator \(\varPhi :E\rightarrow E\). By the Knaster-Tarski theorem [43, 47, 66], every monotonic operator \(\varPhi \) admits a complete lattice of (potentially infinitely many) fixed points. The least fixed point \({\textsf {{lfp}}}~\varPhi \) and the greatest fixed point \({\textsf {{gfp}}}~\varPhi \) are moreover constructible by (possibly transfinite) fixed point iteration from \(\bot \) and \(\top \), respectively: Cousot & Cousot [18] showed that there exist ordinals \(\alpha \) and \(\beta \), such that¹

where denotes the upper \(\delta \)-fold iteration and \(\varPhi ^{\left\lfloor \delta \right\rfloor }\left( g\right) \) denotes the lower \(\delta \)-fold iteration of \(\varPhi \) on \(g\), respectively. Formally, is given by² Intuitively, if \(\delta \) is the successor of \(\gamma \), then we simply do another iteration of \(\varPhi \). If \(\delta \) is a limit ordinal, then can also be thought of as a limit, namely of iterating \(\varPhi \) on \(g\). However, simply iterating \(\varPhi \) on \(g\) need not always converge, especially if the iteration does not yield an ascending chain. To remedy this, we take as limit the join over the whole (possibly transfinite) iteration sequence, i.e., the least upper bound over all elements that occur along the iteration. The lower \(\delta \)-fold iteration \(\varPhi ^{\left\lfloor \delta \right\rfloor }\left( g\right) \) is defined analogously to , except that we take a meet instead of a join whenever \(\delta \) is a limit ordinal.

An important special case for fixed point iteration (see (\(\dagger \))) is when the operator \(\varPhi \) is Scott-continuous (or simply continuous), i.e., if . In this case, \(\alpha \) in (\(\dagger \)) coincides with the first infinite limit ordinal \(\omega \) (which can be identified with the set \(\mathbb {N} \) of natural numbers). This fact is also known as the Kleene fixed point theorem [1].

Problem Statement. Fixed points are ubiquitous in computer science. Prime examples of properties that can be conveniently characterized as least fixed points include both the set of reachable states in a transition system and the function mapping each state in a Markov chain to the probability of reaching some goal state (cf. [60]). However, least and greatest fixed points are often difficult or even impossible [39] to compute; it is thus desirable to bound them.

For example, it may be sufficient to prove that a system modeled as a Markov chain reaches a bad state from its initial state with probability at most \(10^{{-}6}\), instead of computing precise reachability probabilities for each state. Moreover, if said probability is not bounded by \(10^{{-}6}\), we would like to witness that as well.

In general lattice-theoretic terms, our problem statement reads as follows:

For proving, we will present latticed k-induction; for refuting, we will present latticed bounded model checking. Running both in parallel may (and under certain conditions: will) lead to a decision of the above problem.

In this section, we generalize the well-established k-induction verification technique [23, 29, 37, 45, 55, 65] to latticed k-induction (for short: \(\kappa \)-induction; reads: “kappa induction”). With \(\kappa \)-induction, our aim is to prove that \({\textsf {{lfp}}}~\varPhi \sqsubseteq f\). To this end, we attempt “ordinary” induction, also known as Park induction:

Intuitively, this principle says: if pushing our candidate upper bound \(f\) through \(\varPhi \) takes us down in the partial order \(\sqsubseteq \), we have verified that \(f\) is indeed an upper bound on \({\textsf {{lfp}}}~\varPhi \). The true power of Park induction is that applying \(\varPhi \) once tells us something about iterating \(\varPhi \) possibly transfinitely often (see (\(\dagger \)) in Sect. 2).

Park induction, unfortunately, does not work in the reverse direction: If we are unlucky, \(f\sqsupset {\textsf {{lfp}}}~\varPhi \) is an upper bound on \({\textsf {{lfp}}}~\varPhi \), but nevertheless \(\varPhi \left( f \right) \not \sqsubseteq f\). In this case, we say that \(f\) is not inductive. But how can we verify that \(f\) is indeed an upper bound in such a non-inductive scenario? We search below \(f\) for a different, but inductive, upper bound on \({\textsf {{lfp}}}~\varPhi \), that is, weIn order to perform a guided search for such an \(h\), we introduce the \(\kappa \)-induction operator—a modified version of \(\varPhi \) that is parameterized by our candidate \(f\):

What does \(\varPsi _{f}\) do? As illustrated in Fig. 1, if \(\varPhi \left( f \right) \not \sqsubseteq f\) (i.e. \(f\) is non-inductive) then “at least some part of \(\varPhi \left( f \right) \) is greater than \(f\)”. If the whole of \(\varPhi \left( f \right) \) is greater than \(f\), then \(f\sqsubset \varPhi \left( f \right) \); if only some part of \(\varPhi \left( f \right) \) is greater and some is smaller than \(f\), then \(f\) and \(\varPhi \left( f \right) \) are incomparable. The \(\kappa \)-induction operator \(\varPsi _{f}\) now rectifies \(\varPhi \left( f \right) \) being (partly) greater than \(f\) by pulling \(\varPhi \left( f \right) \) down via the meet with f (i.e., via ), so that the result is in no part greater than f. Applying \(\varPsi _{f}\) to \(f\) hence always yields something below or equal to f.

Together with the observation that \(\varPsi _{f}\) is monotonic, iterating \(\varPsi _{f}\) on \(f\) necessarily descends from \(f\) downwards in the direction of \({\textsf {{lfp}}}~\varPhi \) (and never below):

The descending sequence \(f\sqsupseteq \varPsi _{f}(f) \sqsupseteq \varPsi _{f}^{\left\lfloor 2 \right\rfloor }(f) \sqsupseteq {\ldots }\) constitutes our guided search for an inductive upper bound on \({\textsf {{lfp}}}~\varPhi \). For each ordinal \(\kappa \) (hence the short name: \(\kappa \)-induction), \({\varPsi _{f}^{\left\lfloor \kappa \right\rfloor }(f)}\) is a potential candidate for Park induction:

For efficiency reasons, e.g., when offloading the above inequality check to an SMT solver, we will not check the inequality (\(\ddagger \)) directly but a property equivalent to (\(\ddagger \)), namely whether \(\varPhi (\varPsi _{f}^{\left\lfloor \kappa \right\rfloor }(f))\) is below \(f\) instead of \(\varPsi _{f}^{\left\lfloor \kappa \right\rfloor }(f)\):

If \(\varPhi \bigl ( \varPsi _{f}^{\left\lfloor \kappa \right\rfloor } (f) \bigr ) \sqsubseteq f\), then Lemma 2 tells us that \(\varPsi _{f}^{\left\lfloor \kappa \right\rfloor } (f)\) is Park inductive and thereby an upper bound on \({\textsf {{lfp}}}~\varPhi \). Since iterating \(\varPsi _{f}\) on f yields a descending iteration sequence (see Lemma 1(b)), \(\varPsi _{f}^{\left\lfloor k \right\rfloor } (f)\) is below f and therefore f is also an upper bound on \({\textsf {{lfp}}}~\varPhi \). Put in more traditional terms, we have shown that \(\varPsi _{f}^{\left\lfloor \kappa \right\rfloor }(f)\) is an inductive invariant stronger than \(f\). Formulated as a proof rule, we obtain the following induction principle:

An illustration of \(\kappa \)-induction is shown in (the right frame of) Fig. 1. For every ordinal \(\kappa \), if \(\varPhi (\varPsi _{f}^{\left\lfloor \kappa \right\rfloor }(f))\sqsubseteq f\), then we call \(f\) \((\kappa {+}1)\)-inductive (for \(\varPhi \)). In particular, \(\kappa \)-induction generalizes Park induction, in the sense that 1-induction is Park induction and, \((\kappa > 1)\)-induction is a more general principle of induction.

Algorithm 1 depicts a (semi-)algorithm that performs latticed k-induction (for \(k < \omega \)) in order to prove \({\textsf {{lfp}}}~\varPhi \sqsubseteq f\) by iteratively increasing k. For implementing this algorithm, we require, of course, that both \(\varPhi \) and \(\varPsi _{f}\) are computable and that \(\sqsubseteq \) is decidable. Notice that the loop (lines 2–3) never terminates if \(f\sqsubset \varPhi \left( f \right) \)—a condition that can easily be checked before entering the loop. Even with this optimization, however, Algorithm 1 is a proper semi-algorithm: even if \({\textsf {{lfp}}}~\varPhi \sqsubseteq f\), then \(f\) is still not guaranteed to be k-inductive for some \(k < \omega \). And even if an algorithm could somehow perform transfinitely many iterations, then \(f\) is still not guaranteed to be \(\kappa \)-inductive for some ordinal \(\kappa \):

Despite its incompleteness, we now provide a sufficient criterion which ensures that every upper bound on \({\textsf {{lfp}}}~\varPhi \) is \(\kappa \)-inductive for some ordinal \(\kappa \).

The proof of the above theorem immediately yields that, if the unique fixed point can be reached through finite fixed point iterations starting at \(\top \), then \(f\) is k-inductive for some natural number k; Algorithm 1 thus eventually terminates.

We show that our purely lattice-theoretic \(\kappa \)-induction from Sect. 3 generalizes classical k-induction for hardware- and software verification. To this end, we first recap how k-induction is typically formalized in the literature [10, 23, 29, 37]: Let \(\text {TS} = (S,\, I, T)\) be a transition system, where \(S \) is a (countable) set of states, \(I \subseteq S \) is a non-empty set of initial states, and \(T \subseteq S \times S \) is a transition relation. As in the seminal work on k-induction [65], we require that \(T \) is a total relation, i.e., every state has at least one successor. This requirement is sometimes overlooked in the literature, which renders the classical SAT-based formulation of k-induction ((1a) and (1b) below) unsound in general.

Our goal is to verify that a given invariant property \(P \subseteq S \) covers all states reachable in \(\text {TS} \) from some initial state. Suppose that \(I \), \(T \) and \(P \) are characterized by logical formulae \(I (s)\), \(T (s,s')\) and \(P (s)\) (over the free variables s and \(s'\)), respectively. Then, achieving the above goal with classical k-induction amounts to proving the validity of Here, the base case (1a) asserts that \(P \) holds for all states reachable within k transition steps from some initial state; the induction step (1b) formalizes that \(P \) is closed under taking up to k transition steps, i.e., if we start in \(P \) and stay in \(P \) for up to k steps, then we also end up in \(P \) after taking the \((k{+}1)\)-st step. If both (1a) and (1b) are valid, then classical k-induction tells us that the property \(P \) holds for all reachable states of \(\text {TS} \). How is the above principle reflected in latticed k-induction (cf. Sect. 3)? For that, we choose the complete lattice \((2^S,\, \subseteq )\), where \(2^S\) denotes the powerset of \(S \); the least element is \(\bot = \emptyset \) and the meet operation is standard intersection \(\cap \).

Moreover, we define a monotonic operator \(\varPhi \) whose least fixed point precisely characterizes the set of reachable states of the transition system \(\text {TS} \):That is, \(\varPhi \) maps any given set of states \(F \subseteq S \) to the union of the initial states I and of those states \({\textsf {Succs}} (F)\) that are reachable from F using a single transition.³

Using the \(\kappa \)-induction operator constructed from \(\varPhi \) and \(P \) according to Definition 1, the principle of \(\kappa \)-induction (cf. Theorem 2) then tells us thatFor our above choices, the premise of \(\kappa \)-induction equals the classical formalization of k-induction—formulae (1a) and (1b)—because the set of initial states \(I \) is “baked into” the operator \(\varPhi \). More concretely, for the base case (1a), we haveIn other words, formula (1a) captures those states that are reachable from \(I \) via at most k transitions. If we assume that (1a) is valid, then \(P \) contains all initial states and formula (1b) coincides with the premise of \(\kappa \)-induction:It follows that, when considering transition systems, our (latticed) \(\kappa \)-induction is equivalent to the classical notion of k-induction for \(\kappa < \omega \):

We complement \(\kappa \)-induction with a latticed analog of bounded model checking [11, 12] for refuting that \({\textsf {{lfp}}}~\varPhi \sqsubseteq f\). In lattice-theoretic terms, bounded model checking amounts to a fixed point iteration of \(\varPhi \) on \(\bot \) while continually checking whether the iteration exceeds our candidate upper bound \(f\). If so, then we have indeed refuted \({\textsf {{lfp}}}~\varPhi \sqsubseteq f\):

Furthermore, if we were actually able to perform transfinite iterations of \(\varPhi \) on \(\bot \), then latticed bounded model checking is also complete: If \(f\) is in fact not an upper bound on \({\textsf {{lfp}}}~\varPhi \), this will be witnessed at some ordinal:

More practically relevant, if \(\varPhi \) is continuous (which is the case for Bellman operators characterizing reachability probabilities in Markov chains), then a simple finite fixed point iteration, see Algorithm 2, is sound and complete for refutation:

In the remainder of this article, we employ latticed k-induction and BMC to verify imperative programs with access to discrete probabilistic choices—branching on the outcomes of coin flips. In this section, we briefly recap the necessary background on formal reasoning about probabilistic programs (cf. [44, 49] for details).

We now instantiate latticed \(\kappa \)-induction and BMC (as developed in Sects. 2 to 5) to enable verification of loops written in \({\textsf {{pGCL}}} \); we discuss practical aspects later in Sects. 7.1 to 7.3 and Sect. 8. For the next two sections, we fix a loopFor simplicity, we assume that the loop body \(C\) is loop-free (every probabilistic program can be rewritten as a single while loop with loop-free body [62]).

Given an expectation \(g\in \mathbb {E}\) and a candidate upper bound \(f\in \mathbb {E}\) on the expected value of \(g\) after executing \(C_{\text {loop}}\) (i.e. \(\textsf {{wp}}\llbracket C_{\text {loop}}\rrbracket \left( g\right) \)), we will apply latticed verification techniques to check whether \(f\) indeed upper-bounds \(\textsf {{wp}}\llbracket C_{\text {loop}}\rrbracket \left( g\right) \).

To this end, we denote by \(\varPhi \) the characteristic functional of \(C_{\text {loop}}\) and \(g\), i.e.,whose least fixed point defines \(\textsf {{wp}}\llbracket C_{\text {loop}}\rrbracket \left( g\right) \) (cf. Table 1). We remark that \(\varPhi \) is a monotonic—and in fact even continuous—operator over the complete lattice \((\mathbb {E}, \, \preceq )\) (cf. Sect. 6.2). In this lattice, the meet is a pointwise minimum, i.e.,By Definition 1, \(\varPhi \) and \(g\) then induce the (continuous) \(\kappa \)-induction operatorWith this setup, we obtain the following proof rule for reasoning about probabilistic loops as an immediate consequence of Theorem 2:

Analogously, refuting that \(f\) upper-bounds the expected value of \(g\) after execution of \(C_{\text {loop}}\) via bounded model checking is an instance of Corollary 2:

In principle, we can semi-decide whether \(\textsf {{wp}}\llbracket C_{\text {loop}}\rrbracket \left( g\right) \not \preceq f\) holds or whether \(f\) is k-inductive for some k: it suffices to run Algorithms 1 and 2 in parallel. However, for these two algorithms to actually be semi-decision procedures, we cannot admit arbitrary expectations. Rather, we restrict ourselves to a suitable subset \(\mathsf {Exp} \) of expectations in \(\mathbb {E}\) satisfying all of the following requirements:

We have implemented a prototype called \(\textsc {kipro2}\)—k-Induction for PRObabilistic PROgrams—in Python 3.7 using the SMT solver Z3 [54] and the solver-API PySMT [25]. Our tool, its source code, and our experiments are available online.⁸ \(\textsc {kipro2}\) performs in parallel latticed k-induction and BMC to fully automatically verify upper bounds on expected values of \({\textsf {{pGCL}}} \) programs as described in Sect. 7. In addition to reasoning about expected values, \(\textsc {kipro2}\) supports verifying bounds on expected runtimes of \({\textsf {{pGCL}}} \) programs, which are characterized as least fixed points à la [40]. Rather than fixing a specific runtime model, we took inspiration from [56] and added a statement \({\texttt {tick}} \left( n \right) \) that does not affect the program state but consumes \(n \in \mathbb {N} \) time units.

To discharge quantitative entailments and compute the meet, we use the constructions in Theorems 7 and 8, respectively. As an additional optimization, we do not iteratively apply the k-induction operator \(\varPsi _{f}\) directly but use an incremental encoding. We briefly sketch our encoding for k-induction (Algorithm 2); the encoding for BMC is similar. In both cases, we employ uninterpreted functions on top of mixed integer and real arithmetic, i.e., \(\textsf {QF\_UFLIRA} \).

Recall Example 2, the geometric loop \(C_{\text {geo}}\), where we used k-induction to prove \(\textsf {{wp}}\llbracket C_{\text {geo}}\rrbracket \left( c\right) \preceq c + 1\). For every \(k \in \mathbb {N} \), \(\varPhi (\varPsi _{c+1}^{\left\lfloor k \right\rfloor }(c+1))\) is given byTo obtain an incremental encoding, we introduce an uninterpreted function \(P_k:\mathbb {N} \times \mathbb {N} \rightarrow \mathbb {R}_{\ge 0}\) and a formula \(\rho _{k}(c,x)\) specifying that \(P_k(c,x)\) characterizes \(\varPhi (\varPsi _{c+1}^{\left\lfloor k \right\rfloor }(c+1))\), i.e., for all \(\sigma \in \varSigma \) and \(r \in \mathbb {R}_{\ge 0}\) with \(\varPhi (\varPsi _{c+1}^{\left\lfloor k \right\rfloor }(c+1))(\sigma ) < \infty \),⁹ If \(\varPhi (\varPsi _{c+1}^{\left\lfloor k \right\rfloor }(c+1))(\sigma ) = \infty \), our construction of \(\rho _{k}(x,c)\) ensures that the above conjunction is satisfiable for arbitrarily large r. Analogously, we introduce an uninterpreted function \(Q_k:\mathbb {N} \times \mathbb {N} \rightarrow \mathbb {R}_{\ge 0}\) that characterizes \(\varPsi _{c+1}^{\left\lfloor k \right\rfloor }(c+1)\).

In particular, may use all uninterpreted functions introduced for smaller or equal values of k—not just the function \(P_k(c,x)\) it needs to characterize. This enables an incremental encoding, i.e., \(\rho _{k}(c,x)\) can be computed on top of \(\rho _{k-1}(c,x)\) by reusing \(P_{k-1}(c,x)\), \(Q_k(c,x)\), and the construction in Theorem 8.

Moreover, we can reuse \(\rho _{k}(c,x)\) to avoid computing the (expensive) GNF for deciding certain quantitative entailments (cf. Theorem 7): For example, to check whether \(\varPhi (\varPsi _{c+1}^{\left\lfloor k \right\rfloor }(c+1)) \not \preceq h'\) holds, we only need to transform the right-hand side into GNF (cf. Sect. 7.2), i.e., if \(\mathsf {GNF} \left( h'\right) = \sum _{j=1}^{m} \left[ {\psi _j} \right] \cdot \tilde{a}_j\), then

We evaluate \(\textsc {kipro2}\) on two sets of benchmarks. The first set, shown in Table 2, consists of four (infinite-state) probabilistic systems compiled from the literature; each benchmark is evaluated on multiple variants of candidate upper bounds:

Our second set of benchmarks, shown in Table 3, confirms the correctness of (1-inductive) bounds on the expected runtime of \({\textsf {{pGCL}}} \) programs synthesized by the runtime analyzers Absynth [56] and (later) KoAT [52]; this gives a baseline for evaluating the performance of our implementation. Moreover, it demonstrates the flexibility of our approach as we effortlessly apply the expected runtime calculus [40] instead of the weakest preexpectation calculus for verification.

Setup. We ran Algorithms 1 and 2 in parallel using an AMD Ryzen 5 3600X processor with a shared memory limit of 8GB and a 15-minute timeout. For every benchmark finishing within the time limit, \(\textsc {kipro2}\) either finds the smallest k required to prove the candidate bound by k-induction or the smallest unrolling depth k to refute it. If \(\textsc {kipro2}\) refutes, the SMT solver provides a concrete initial state witnessing that violation. In Tables 2 and 3, column #formulae gives the maximal number of conjuncts on the solver stack; formulae_t, sat_t, and total_t give the amount of time spent on (1) computing formulae, (2) satisfiability checking, and (3) everything (including preprocessing), respectively. The input consists of a program, a candidate upper bound, and a postexpectation; in Table 3, the latter is fixed to “postruntime” 0 and thus omitted.

Evaluation of Benchmark Set 1. Table 2 empirically underlines that probabilistic program verification can benefit from k-induction to the same extent as classical software verification: \(\textsc {kipro2}\) fully automatically verifies relevant properties of infinite-state randomized algorithms and stochastic processes from the literature that require k to be strictly larger than 1. That is, proving these properties using (1-)inductive invariants requires either non-trivial invariant synthesis or additional user annotations. This indicates that k-induction mitigates the need for complicated specifications in probabilistic program verification (cf. [40]).

We observe that k-induction tends to succeed if some variable is bounded in the candidate upper bound under consideration (cf. brp, rabin, ). However, k-induction can also succeed without any bounds (cf. geo). The time and formulae required for checking k-inductivity increases rapidly for larger k; this is particularly striking for rabin and . When refuting candidate bounds with BMC, we obtain a similar picture. Both the time and formulae required for refutation increase if the candidate bound increases (cf. brp, geo, rabin).

For both k-induction and BMC, we observe a direct correlation between the complexity of the loop, i.e., the number of possible traces through the loop from some fixed initial state after some bounded number of iterations, and the required time and space (number of formulae). Whereas for geo and brp—which exhibit a rather simple structure—these checks tend to be fast, this is not the case for rabin and , which have more complex loop bodies. For such complex loops, k-induction and BMC quickly become infeasible as k increases.

Evaluation of Benchmark Set 2. From Table 3, we observe that—in almost every case—verification is instantaneous and requires very few formulae. The programs we verify are equivalent to the programs provided in [56] up to interpreting minus as monus and using \(\mathbb {N} \)-typed (instead of \(\mathbb {Z} \)) variables. A manual inspection reveals that this matters for and rdwalk, which is the reason why the runtime bound for is 3-inductive rather than 1-inductive.

There are two timeouts (2drwalk, ) due to the GNF construction from Lemma 3, which exhibits a runtime exponential in the number of possible execution branches through the loop body. We conjecture that further preprocessing (by pruning infeasible branches upfront) can mitigate this, rendering 2drwalk and tractable as well. We consider a thorough investigation of suitable preprocessing strategies for GNF construction, which is outside the scope of this paper, a worthwhile direction for future research.

We presented \(\kappa \)-induction, a generalization of classical k-induction to arbitrary complete lattices, and—together with a complementary bounded model checking approach—obtained a fully automated technique for verifying infinite-state probabilistic programs. Experiments showed that this technique can prove non-trivial properties in an automated manner that using existing techniques cannot be proven—at least not without synthesizing a stronger inductive invariant. If a given candidate bound is k-inductive for some k, then our prototypical tool will find that k for linear programs and linear expectations. In theory, our tool is also applicable to non-linear programs at the expense of an undecidability quantitative entailment problem. It is left for future work to consider (positive) real-valued program variables for non-linear expectations.