Shepherding Hordes of Markov Chains

This paper considers large families of Markov chains (MCs) that are defined over a set of parameters with finite discrete domains. Such families occur in software product lines, planning under partial observability, and sketching of probabilistic programs. Simple questions, like `does at least one family member satisfy a property?', are NP-hard. We tackle two problems: distinguish family members that satisfy a given quantitative property from those that do not, and determine a family member that satisfies the property optimally, i.e., with the highest probability or reward. We show that combining two well-known techniques, MDP model checking and abstraction refinement, mitigates the computational complexity. Experiments on a broad set of benchmarks show that in many situations, our approach is able to handle families of millions of MCs, providing superior scalability compared to existing solutions.


Introduction
Randomisation is key to research fields such as dependability (uncertain system components), distributed computing (symmetry breaking), planning (unpredictable environments), and probabilistic programming. Families of alternative designs differing in the structure and system parameters are ubiquitous. Software dependability has to cope with configuration options, in distributed computing the available memory per process is highly relevant, in planning the observability of the environment is pivotal, and program synthesis is all about selecting correct program variants. The automated analysis of such families has to face a formidable challenge -in addition to the state-space explosion affecting each family member, the family size typically grows exponentially in the number of features, options, or observations. This affects the analysis of (quantitative) software product lines [17,27,42,44,45], strategy synthesis in planning under partial observability [11,13,28,35,40], and probabilistic program synthesis [9,12,26,39].
This paper considers families of Markov chains (MCs) to describe configurable probabilistic systems. We consider finite MC families with finite-state family members. Family members may have different transition probabilities and distinct topologies -thus different reachable state spaces. The latter aspect goes beyond the class of parametric MCs as considered in parameter synthesis [10,21,23,30] and model repair [6,15,41].
For an MC family D and quantitative specification ϕ, with ϕ a reachability probability or expected reward objective, we consider the following synthesis problems: (a) does some member in D satisfy a threshold on ϕ? (aka: feasibility synthesis), (b) which members of D satisfy this threshold on ϕ and which ones do not? (aka: threshold synthesis), and (c) which family member(s) satisfy ϕ optimally, e.g., with highest probability? (aka: optimal synthesis).
The simplest synthesis problem, feasibility, is NP-complete and can naively be solved by analysing all individual family members -the so-called one-byone approach. This approach has been used in [17] (and for qualitative systems in e.g. [18]), but is infeasible for large systems. An alternative is to model the family D by a single Markov decision process (MDP) -the so-called all-in-one MDP [17]. The initial MDP state non-deterministically chooses a family member of D, and then evolves in the MC of that member. This approach has been implemented in tools such as ProFeat [17], and for purely qualitative systems in [19]. The MDP representation avoids the individual analysis of all family members, but its size is proportional to the family size. This approach therefore does not scale to large families. A symbolic BDD-based approach is only a partial solution as family members may induce different reachable state-sets.
This paper introduces an abstraction-refinement scheme over the MDP representation 4 . The abstraction forgets in which family member the MDP operates. The resulting quotient MDP has a single representative for every reachable state in a family member. It typically provides a very compact representation of the family D and its analysis using off-the-shelf MDP model-checking algorithms yields a speed-up compared to the all-in-one approach. Verifying the quotient MDP yields under-and over-approximations of the min and max probability (or reward), respectively. These bounds are safe as all consistent schedulers, i.e., those that pick actions according to a single family member, are contained in all schedulers considered on the quotient MDP. (CEGAR-based MDP model checking for partial information schedulers, a slightly different notion than restricting schedulers to consistent ones, has been considered in [29]. In contrast to our setting, [29] considers history-dependent schedulers and in this general setting no guarantee can be given that bounds on suprema converge [28]).
Model-checking results of the quotient MDP do provide useful insights. This is evident if the resulting scheduler is consistent. If the verification reveals that the min probability exceeds r for a specification ϕ with a ≤ r threshold, then -even for inconsistent schedulers -it holds that all family members violate ϕ. If the model checking is inconclusive, i.e., the abstraction is too coarse, we iteratively refine the quotient MDP by splitting the family into sub-families. We do so in an efficient manner that avoids rebuilding the sub-families. Refinement employs a light-weight analysis of the model-checking results.
We implemented our abstraction-refinement approach using the Storm model checker [24]. Experiments with case studies from software product lines, plan-ning, and distributed computing yield possible speed-ups of up to 3 orders of magnitude over the one-by-one and all-in-one approaches (both symbolic and explicit). Some benchmarks include families of millions of MCs where family members are thousands of states. The experiments reveal that -as opposed to parameter synthesis [10,23,30] -the threshold has a major influence on the synthesis times.
To summarise, this work presents: a) MDP-based abstraction-refinement for various synthesis problems over large families of MCs, b) a refinement strategy that mitigates the overhead of analysing sub-families, and c) experiments showing substantial speed-ups for many benchmarks. Extra material can be found in [1].

Preliminaries
We present the basic foundations for this paper, for details, we refer to [4,5].
Probabilistic models. A probability distribution over a finite or countably infinite set X is a function µ : where S is a finite set of states, s 0 ∈ S is an initial state, and P : S → Distr(S) is a transition probability matrix.
MCs have unique distributions over successor states at each state. Adding nondeterministic choices over distributions leads to Markov decision processes.
Definition 2 (MDP) A Markov decision process (MDP) is a tuple M = (S, s 0 , Act, P) where S, s 0 as in Def. 1, Act is a finite set of actions, and P : S ×Act Distr(S) is a partial transition probability function.
The available actions in s ∈ S are Act(s) = {a ∈ Act | P(s, a) = ⊥}. An MDP with |Act (s)| = 1 for all s ∈ S is an MC. For MCs (and MDPs), a statereward function is rew : S → R ≥0 . The reward rew(s) is earned upon leaving s.
A path of an MDP M is an (in)finite sequence π = s 0 a0 − → s 1 a1 − → · · · , where s i ∈ S, a i ∈ Act(s i ), and P(s i , a i )(s i+1 ) = 0 for all i ∈ N. For finite π, last(π) denotes the last state of π. The set of (in)finite paths of M is Paths M fin (Paths M ). The notions of paths carry over to MCs (actions are omitted). Schedulers resolve all choices of actions in an MDP and yield MCs.
For an MDP M , a specification ϕ holds (M |= ϕ) if and only if it holds for the induced MCs of all schedulers. The maximum probability Prob max (M, φ) to satisfy a path formula φ for an MDP M is given by a maximising scheduler σ max ∈ Σ M , that is, there is no scheduler σ ′ ∈ Σ M such that Prob(M σ max , φ) < Prob(M σ ′ , φ). Analogously, we define the minimising probability Prob min (M, φ), and the maximising (minimising) expected reward ExpRew max (M, φ) (ExpRew min (M, φ)).
The probability (expected reward) to satisfy path formula φ from state s ∈ S in MC D is Prob(D, φ)(s) (ExpRew(D, φ)(s)). The notation is analogous for maximising and minimising probability and expected reward measures in MDPs. Note that the expected reward ExpRew(D, φ) to satisfy path formula φ is only defined if Prob(D, φ) = 1. Accordingly, the expected reward for MDP M under scheduler σ ∈ Σ M requires Prob(M σ , φ) = 1.

Families of MCs
We present our approaches on the basis of an explicit representation of a family of MCs using a parametric transition probability function. While arbitrary probabilistic programs allow for more modelling freedom and complex parameter structures, the explicit representation alleviates the presentation and allows to reason about practically interesting synthesis problems. In our implementation, we use a more flexible high-level modelling language, cf. Sect 5.

Definition 5 (Family of MCs)
A family of MCs is defined as a tuple D = (S, s 0 , K, P) where S is a finite set of states, s 0 ∈ S is an initial state, K is a finite set of discrete parameters such that the domain of each parameter k ∈ K is T k ⊆ S, and P : S → Distr (K) is a family of transition probability matrices.
The transition probability function of MCs maps states to distributions over successor states. For families of MCs, this function maps states to distributions over parameters. Instantiating each of these parameters with a value from its domain yields a "concrete" MC, called a realisation. Definition 6 (Realisation) A realisation of a family D = (S, s 0 , K, P) is a function r : K → S where ∀k ∈ K : r(k) ∈ T k . A realisation r yields a MC D r = (S, s 0 , P(r)), where P(r) is the transition probability matrix in which each k ∈ K in P is replaced by r(k). Let R D denote the set of all realisations for D.
As a family D of MCs is defined over finite parameter domains, the number of family members (i.e. realisations from R D ) of D is finite, viz. |D| := |R D | = k∈K |T k |, but exponential in |K|. Subsets of R D induce so-called subfamilies of D. While all these MCs share the same state space, their reachable states may differ, as demonstrated by the following example. We state two synthesis problems for families of MCs. The first is to identify the set of MCs satisfying and violating a given specification, respectively. The second is to find a MC that maximises/minimises a given objective. We call these two problems threshold synthesis and max/min synthesis.
Problem 1 (Threshold synthesis) Let D be a family of MCs and ϕ a probabilistic reachability or expected reward specification. The threshold synthesis problem is to partition R D into T and F such that ∀r ∈ T : D r ϕ and ∀r ∈ F : D r ϕ.
As a special case of the threshold synthesis problem, the feasibility synthesis problem is to find just one realisation r ∈ R D such that D r ϕ.
Problem 2 (Max synthesis) Let D a family of MCs and φ = ♦G for G ⊆ S The max synthesis problem is to find a realisation r * ∈ R D such that Prob(D r * , φ) = max r∈R D {Prob(D r , φ)}. The problem is defined analogously for an expected reward measure or minimising realisations.
Example 2 (Synthesis problems). Recall the family of MCs D from Example 1. For the specification ϕ = P ≥0.1 (♦{1}), the solution to the threshold synthesis problem is T = {r 2 , r 3 } and F = {r 1 , r 4 }, as the goal state 1 is not reachable for D r1 and D r4 . For φ = ♦{1}, the solution to the max synthesis problem on D is r 2 or r 3 , as D r2 and D r3 have probability one to reach state 1.
Approach 1 (One-by-one [17]) A straightforward solution to both synthesis problems is to enumerate all realisations r ∈ R D , model check the MCs D r , and either compare all results with the given threshold or determine the maximum.
We already saw that the number of realisations is exponential in |K|.

Theorem 1
The feasibility synthesis problem is NP-complete.
The theorem even holds for almost-sure reachability properties. The proof is a straightforward adaption of results for augmented interval Markov chains [16,Theorem 3], partial information games [14], or partially observable MDPs [13].

Guided Abstraction-Refinement Scheme
In the previous section, we introduced the notion of a family of MCs, two synthesis problems and the one-by-one approach. Yet, for a sufficiently high number of realisations such a straightforward analysis is not feasible. We propose a novel approach allowing us to more efficiently analyse families of MCs.

All-in-one MDP
We first consider a single MDP that subsumes all individual MCs of a family D, and is equipped with an appropriate action and state labelling to identify the underlying realisations from R D .
Definition 7 (All-in-one MDP [17,27,42]) The all-in-one MDP of a family D = (S, s 0 , K, P) of MCs is given as and P D is defined as follows: Example 3 (All-in-one MDP). Fig. 2 shows the all-in-one MDP M D for the family D of MCs from Example 1. Again, states that are not reachable from the initial state s D 0 are marked grey. For the sake of readability, we only include the transitions and states that correspond to realisations r 1 and r 2 . From the (fresh) initial state s D 0 of the MDP, the choice of an action a r corresponds to choosing the realisation r and entering the concrete MC D r . This property of the all-in-one MDP is formalised as follows.
Corollary 1 For the all-in-one MDP M D of family D of MCs: Consequently, the feasibility synthesis problem for ϕ has the solution r ∈ R D iff there exists a memoryless deterministic scheduler σ r such that M D σ r ϕ.
Approach 2 (All-in-one [17]) Model checking the all-in-one MDP determines max or min probability (or expected reward) for all states, and thereby for all realisations, and thus provides a solution to both synthesis problems.
As also the all-in-one MDP may be too large for realistic problems, we merely use it as formal starting point for our abstraction-refinement loop.

Abstraction
First, we define a predicate abstraction that at each state of the MDP forgets in which realisation we are, i.e., abstracts the second component of a state (s, r).
. At each state of the quotient MDP, the actions correspond to any realisation. It includes states that are unreachable in every realisation.
Remark 1 (Action space). According to Def. 8, for every state [s] ∼ there are |D| actions. Many of these actions lead to the same distributions over successor states. In particular, two different realisations r and r ′ lead to the same distribution in s if r(k) = r ′ (k) for all k ∈ K where P(s)(k) = 0. To avoid this spurious blow-up of actions, we a-priori merge all actions yielding the same distribution. The quotient MDP under forgetting involves that the available actions allow to switch realisations and thereby create induced MCs different from any MC in D.
We formalise the notion of a consistent realisation with respect to parameters.
Definition 9 (Consistent realisation) For a family D of MCs and k ∈ K, k-realisation-consistency is an equivalence relation ≈ k ⊆ R D ×R D satisfying: Definition 10 (Consistent scheduler) For quotient MDP M D ∼ after forgetting and k ∈ K, a scheduler σ ∈ Σ M D ∼ is k-consistent if for all π, π ′ ∈ Paths M D ∼ fin : A scheduler is K-consistent (short: consistent) if it is k-consistent for all k ∈ K.
Proof (Idea). For σ r ∈ Σ M D , we construct σ r * ∈ Σ M D ∼ such that σ r * ([s] ∼ ) = a r for all s. Clearly σ r * is consistent and M D σ r = M D ∼ σ r * is obtained via a map between (s, r) and For all other states, we define σ r ((s, r ′ )) = a r ′ independently of σ r * . Then M D σ r = M D ∼ σ r * is obtained as above.
The following theorem is a direct corollary: we need to consider exactly the consistent schedulers.  However, optimising over exponentially many consistent schedulers solves the NP-complete feasibility synthesis problem, rendering such an iterative approach unlikely to be efficient. Another natural approach is to employ solving techniques for NP-complete problems, like satisfiability modulo linear real arithmetic.

Approach 4 (SMT) A dedicated SMT-encoding (in Sect. A) of the induced MCs of consistent schedulers from M D
∼ that solves the feasibility problem.

Refinement Loop
Although iterating over consistent schedulers (Approach 3) is not feasible, model checking of M D ∼ still provides useful information for the analysis of the family D. Recall the feasibility synthesis problem for ϕ = P ≤λ (φ). If Prob max (M D ∼ , φ) ≤ λ, then all realisations of D satisfy ϕ. On the other hand, Prob min (M D ∼ , φ) > λ implies that there is no realisation satisfying ϕ. If λ lies between the min and max probability, and the scheduler inducing the min probability is not consistent, we cannot conclude anything yet, i.e., the abstraction is too coarse. A natural countermeasure is to refine the abstraction represented by M D ∼ , in particular, split the set of realisations leading to two synthesis sub-problems.
Definition 11 (Splitting) Let D be a family of MCs, and R ⊆ R D a set of realisations. For k ∈ K and predicate A k over S, splitting partitions R into Splitting the set of realisations, and considering the subfamilies separately, rather than splitting states in the quotient MDP, is crucial for the performance of the synthesis process as we avoid rebuilding the quotient MDP in each iteration. Instead, we only restrict the actions of the MDP to the particular subfamily.

Algorithm 1 Threshold synthesis
Input: A family D of MCs with the set R D of realisations, and specification P ≤λ (φ) Output: A partition of R D into subsets T and F according to Problem 1.
if min > λ then F ← F ∪ R 10: if min ≤ λ ≤ max then 11: U ← U ∪ split(R, selPredicate(max, σmax, min, σmin)) ⊲ See Sect. 4.4 12: return T , F The splitting operation is the core of the proposed abstraction-refinement. Due to space constraints, we do not consider feasibility separately.
Algorithm 1 illustrates the threshold synthesis process. Recall that the goal is to decompose the set R D into realisations satisfying and violating a given specification, respectively. The algorithm uses a set U to store subfamilies of R D that have not been yet classified as satisfying or violating. It starts building the quotient MDP with merged actions. That is, we never construct the all-in-one MDP, and we merge actions as discussed in Rem. 1. For every R ∈ U , the algorithm restricts the set of realisations to obtain the corresponding subfamily. For the restricted quotient MDP, the algorithm runs standard MDP model checking to compute the max and min probability and corresponding schedulers, respectively. Then, the algorithm either classifies R as satisfying/violating, or splits it based on a suitable predicate, and updates U accordingly. We describe the splitting strategy in the next subsection. The algorithm terminates if U is empty, i.e., all subfamilies have been classified. As only a finite number of subfamilies of realisations has to be evaluated, termination is guaranteed.
The refinement loop for max synthesis is very similar, cf. Alg. 2. Recall that now the goal is to find the realisation r * that maximises the satisfaction probability max * of a path formula. The difference between the algorithms lies in the interpretation of the results of the underlying MDP model checking. If the max probability for R is below max * , R can be discarded. Otherwise, we check whether the corresponding scheduler σ max is consistent. If consistent, the algorithm updates r * and max * , and discards R. If the scheduler is not consistent but min > max * holds, we can still update max * and improve the pruning process, as it means that some realisation (we do not know which) in R induces a higher probability than max * . Regardless whether max * has been updated, the algorithm has to split R based on some predicate, and analyse its subfamilies as they may include the maximising realisation.

Algorithm 2 Max synthesis
Input: A family D of MCs with the set R D of realisations, and a path formula φ Output: A realisation r * ∈ R D according to Problem 2.

Splitting strategies
If verifying the quotient MDP M D ∼ [R] cannot classify the (sub-)realisation R as satisfying or violating, we split R, while we guide the splitting strategy by using the obtained verification results. The splitting operation chooses a suitable parameter k ∈ K and predicate A k that partition the realisations R into R ⊤ and R ⊥ (see Def. 11). A good splitting strategy globally reduces the number of model-checking calls required to classify all r ∈ R.
The two key aspects to locally determine a good k are: 1) the variance, that is, how the splitting may narrow the difference between max = Prob max (M D ∼ [X ], φ) and min = Prob min (M D ∼ [X ], φ) for both X = R ⊤ or X = R ⊥ , and 2) the consistency, that is, how the splitting may reduce the inconsistency of the schedulers σ max and σ min . These aspects cannot be evaluated precisely without applying all the split operations and solving the new MDPs M D ∼ [R ⊥ ] and M D ∼ [R ⊤ ]. Therefore, we propose an efficient strategy that selects k and A k based on a lightweighted analysis of the model-checking results for M D ∼ [R]. The strategy applies two scores variance(k) and consistency(k) that estimate the influence of k on the two key aspects. For any k, the scores are accumulated over all important states s (reachable via σ max or σ min , respectively) where P(s)(k) = 0. A state s is important for R and some δ ∈ R ≥0 if where Prob min (.)(s) and Prob max (.)(s) is the min and max probability in the MDP with initial state s. To reduce the overhead of computing the scores, we simplify the scheduler representation. In particular, for σ max and every k ∈ K, we extract a map C k max : T k → N , where C k max (t) is the number of important states for which σ max (s) = a r with r(k) = t. The mapping C k min represents σ min .
We define variance(k) = t∈T k |C k max (t) − C k min (t)|, leading to high scores if the two schedulers vary a lot. Further, we define consistency(k) = size C k max · max C k max +size C k min ·max C k min , where size (C) = |{t ∈ T k | C(t) > 0}|−1 and max (C) = max t∈T k {C(t)}, leading to high scores if the parameter has clear favourites for σ max and σ min , but values from its full range are chosen.
As indicated, we consider different strategies for the two synthesis problems. For threshold synthesis, we favour the impact on the variance as we principally do not need consistent schedulers. For the max synthesis, we favour the impact on the consistency, as we need a consistent scheduler inducing the max probability.
Predicate A k is based on reducing the variance: The strategy selects T ′ ⊂ T k with |T ′ | = 1 2 ⌈|T k |⌉, containing those t for which C k max (t) − C k min (t) is the largest. The goal is to get a set of realisations that induce a large probability (the ones including T ′ for parameter k) and the complement inducing a small probability.
Approach 5 (MDP-based abstraction refinement) The methods underlying Algorithms 1 and 2, together with the splitting strategies, provide solutions to the synthesis problems and are referred to as MDP abstraction methods.

Experiments
We implemented the proposed synthesis methods as a Python prototype using Storm [24]. In particular, we use the Storm Python API for model-adaption, -building, and -checking as well as for scheduler extraction. For SMT solving, we use Z3 [38] via pySMT [25]. The tool-chain takes a PRISM [37] or JANI [8] model with open integer constants, together with a set of expressions with possible values for these constants. The model may include the parallel composition of several modules/automata. The open constants may occur in guards 7 , probability definitions, and updates of the commands/edges. Via adequate annotations, we identify the parameter values that yield a particular action. The annotations are key to interpret the schedulers, and to restrict the quotient without rebuilding.
All experiments were executed on a Macbook MF839LL/A with 8GB RAM memory limit and a 12h time out. All algorithms can significantly benefit from coarse-grained parallelisation, which we therefore do not consider here.

Research questions and benchmarks
The goal of the experimental evaluation is to answer the research question: How does the proposed MDP-based abstraction methods (Approaches 3-5) cope with the inherent complexity (i.e. the NP-hardness) of the synthesis problems (cf. Problems 1 and 2)? To answer this question, we compare their performance with Approaches 1 and 2 [17], representing state-of-the-art solutions and the base-line algorithms. The experiments show that the performance of the MDP abstraction significantly varies for different case studies. Thus, we consider benchmarks from various application domains to identify the key characteristics of the synthesis problems affecting the performance of our approach.
Benchmarks description. We consider the following case studies: Maze is a planning problem typically considered as POMDP, e.g. in [40]. The family describes all MCs induced by small-memory [13,34] observation-based deterministic strategies (with a fixed upper bound on the memory). We are interested in the expected time to the goal. In [34], parameter synthesis was used to find randomised strategies, using [21]. Pole considers balancing a pole in a noisy and unknown environment (motivated by [2,11]). At deploy time, the controller has a prior over a finite set of environment behaviours, and should optimise the expected behavior without depending on the actual (hidden) environment. The family describes schedulers that do not depend on the hidden information. We are interested in the expected time until failure. Herman is an asynchronous encoding of the distributed Herman protocol for self-stabilising rings [32,36]. The protocol is extended with a bit of memory for each station in the ring, and the choice to flip various unfair coins. Nodes in the ring are anonymous, they all behave equivalently (but may change their local memory based on local events). The family describes variations of memory-updates and coin-selection, but preserves anonymity. We are interested in the expected time until stabilisation. DPM considers a partial information scheduler for a disk power manager motivated by [7,26]. We are interested in the expected energy consumption. BSN (Body sensor network, [42]) describes a network of connected sensors that identify health-critical situations. We are interested in the reliability. The family contains various configurations of the used sensors. BSN is the largest software product line benchmark used in [17]. We drop some implications between features (parameters for us) as this is not yet supported by our modelling language. We thereby extended the family. Table 1 shows the relevant statistics for each benchmark: the benchmark name, the (approximate) range of the min and max probability/reward for the given family, the number of non-singleton parameters |K|, and the number of family members |D|. Then, for the family members the average number of states and transitions of the MCs, and the states, actions (= s∈S |Act (s)|), and transitions of the quotient MDP. Finally, it lists in seconds the run time of the base-line algorithms and the consistent scheduler enumeration 8 . The base-line algorithms employ the one-by-one and the all-in-one technique, using either a BDD or a sparse matrix representation. We report the best results. MOs indicate breaking the memory limit. Only the all-in-one approach required significant memory. As expected, the SMT-based implementation provides an inferior performance and thus we do not report its results.

Results and discussion
To simplify the presentation, we focus primarily on the threshold synthesis problem as it allows a compact presentation of the key aspects. Below, we provide some remarks about the performance for the max and feasibility synthesis.
Results. Table 2 shows results for threshold synthesis. The first two columns indicate the benchmark and the various thresholds. For each threshold λ, the table lists the number of family members below (above) λ, each with the number of subfamilies that together contain these instances, and the number of singleton subfamilies that were considered. The last table part gives the number of iterations of the loop in Alg. 1, and timing information (total, build/restrict times, model checking times, scheduler analysis times). The last column gives the speed-up over the best base-line (based on the estimates).
Key observations. The speed-ups drastically vary, which shows that the MDP abstraction often achieves a superior performance but may also lead to a performance degradation in some cases. We identify four key factors.
Iterations. As typical for CEGAR approaches, the key characteristic of the benchmark that affects the performance is the number N of iterations in the refinement loop. The abstract action introduces an overhead per iteration caused by performing two MDP verification calls and by the scheduler analysis. The run time for BSN, with a small |D| is actually significantly affected by the initialisation of various data structures; thus only a small speedup is achieved.
Abstraction size. The size of the quotient, compared to the average size of the family members, is relevant too. The quotient includes at least all reachable states of all family members, and may be significantly larger if an inconsistent scheduler reaches states which are unreachable under any consistent scheduler.
The existence of such states is a common artefact from encoding families in high-level languages. Table 1, however, indicates that we obtain a very compact representation for Maze and Pole.
Thresholds. The most important aspect is the threshold λ. If λ is closer to the optima, the abstraction requires a smaller number of iterations, which directly improves the performance. We emphasise that in various domains, thresholds that ask for close-to-optimal solutions are indeed of highest relevance as they typically represent the system designs developers are most interested in [43]. Why do thresholds affect the number of iterations? Consider a family with T k = {0, 1} for each k. Geometrically, the set R D can be visualised as |K|-dimensional cube. The cube-vertices reflect family members. Assume for simplicity that one of these vertices is optimal with respect to the specification. Especially in benchmarks where parameters are equally important, the induced probability of a vertex roughly corresponds to the Manhattan distance to the optimal vertex. Thus, vertices above the threshold induce a diagonal hyperplane, which our splitting method approximates with orthogonal splits. Splitting diagonally is not possible, as it would induce optimising over observation-based schedulers. Consequently, we need more and more splits the more the diagonal goes through the middle of the cube. Even when splitting optimally, there is a combinatorial blow-up in the required splits when the threshold is further from the optimal values. Another effect is that thresholds far from optima are more affected by the over-approximation of the MDP model-checking results and thus yield more inconclusive answers.
Refinement strategy. So far, we reasoned about optimal splits. Due to the computational overhead, our strategy cannot ensure optimal splits. Instead, the strategy depends mostly on information encoded in the computed MDP strategies. In models where the optimal parameter value heavily depends on the state, the obtained schedulers are highly inconsistent and carry only limited information for splitting. Consequently, in such benchmarks we split sub-optimally. The sub-optimality has a major impact on the performance for Herman as all obtained strategies are highly inconsistent -they take a different coin for each node, which is good to speed up the stabilisation of the ring.
Summary. MDP abstraction is not a silver bullet. It has a lot of potential in threshold synthesis when the threshold is close to the optima. Consequently, feasibility synthesis with unsatisfiable specifications is handled perfectly well by MDP abstraction, while this is the worst-case for enumeration-based approaches. Likewise, max synthesis can be understood as threshold synthesis with a shifting threshold max * : If the max * is quickly set close to max, MDP abstraction yields superior performance. Roughly, we can quickly approximate max * when some of the parameter values are clearly beneficial for the specification.