{'fraction_non_alphanumeric': 0.037636080870917576, 'fraction_numerical': 0.00880248833592535, 'mean_word_length': 4.4613555291319855, 'pattern_counts': {'":': 0, '<': 2, '<?xml version=': 0, '>': 0, 'https://': 1, 'lorem ipsum': 0, 'www.': 0, 'xml': 0}, 'pii_count': 0, 'substrings_counts': 0, 'word_list_counts': {'cursed_substrings.json': 7, 'profanity_word_list.json': 0, 'sexual_word_list.json': 0, 'zh_pornsignals.json': 0}}
Nonuniform abstractions, refinement and controller synthesis with novel BDD encodings

This paper presents a control synthesis algorithm for dynamical systems to satisfy specifications given in a fragment of linear temporal logic. It is based on an abstraction-refinement scheme with nonuniform partitions of the state space. A novel encoding of the resulting transition system is proposed that uses binary decision diagrams for efficiency. We discuss several factors affecting scalability and present some benchmark results demonstrating the effectiveness of the new encodings. These ideas are also being implemented on a publicly available prototype tool, ARCS, that we briefly introduce in the paper.


Introduction
Automatic synthesis of embedded control software that meets its specifications by construction provides a rigorous means for the design of cyber-physical control systems. Abstraction-based techniques, where one creates a finite transition system (FTS) corresponding to the continuous or hybrid system to be controlled, and solves a discrete control synthesis problem, has attracted considerable attention in the past decade [2,19].
Various software tools have been developed for correct-by-construction control synthesis. These tools differ by the class of systems (e.g., discrete-time vs. continuous-time; linear, piecewise affine or nonlinear) or specifications that they can handle (e.g., simple safety or reachability [12,16,17]; expressive fragments of linear temporal logic [10,20]), the abstraction techniques that are used (e.g., uniform grid-based [12,17], multi-scale [13], or partition-based [10]), the way they represent the FTSs internally (symbolic or explicit) and the synthesis techniques implemented.
The key challenge in control synthesis is scalability. Factors affecting scalability include the number of discrete states in the FTS, efficiency of computation of transitions between the discrete states based on continuous dynamics, the representation of the FTS, the complexity of the specification, and the complexity of the resulting controller. For instance, structural properties of dynamics such as linearity or monotonicity [8] are shown to make the computation of transitions easy. Sparsity of the dynamics has recently been exploited together with binary decision diagrams (BDDs), a compact (i.e., memory-efficient) representation of FTSs, to obtain abstractions efficiently [11]. However, it is in general unclear how optimizing different factors individually would affect the efficiency of solving the end-to-end synthesis problem. This paper builds on the abstraction-refinement based incremental synthesis approach by [14] that handles a slightly more general class of specifications than most of the earlier tools listed above. In particular, the class includes safety, recurrence and persistence components, while allowing augmented finite transition systems as the discrete model, thereby handling fairness-like assumptions. To mitigate the state-explosion problem, a nonuniform partition of the continuous state space is used. The main contribution of the present paper is a novel BDD encoding of the states that takes into account the topology of the partition and that makes it convenient to add new states in the refinement process while preserving structure. The effectiveness of the new encoding is demonstrated with examples. A prototype tool, ARCS, that implements some of these ideas is also introduced.

Overview
In this section we formally state the control synthesis problem and give an overview of the solution methodology.
The first ingredient of the synthesis problem is a dynamical system model where x ∈ X is the state, u ∈ U is the control input, and d ∈ D is the disturbance. The notation x + either stands for the value of x in the next time step in the discrete-time setting or the derivative in the continuous-time setting. The second ingredient is the specification, which in this paper is restricted to the following fragment of linear temporal logic: where A, B, and G i 's are propositions that indicate the membership of the state in a certain subset of the state space X . The specification ϕ roughly mandates that the state trajectory of (1) should never leave the states indicated by A (safety); that it should eventually reach the states indicated by B and remain there indefinitely (persistence); and that it should visit the states indicated by each G i infinitely often (recurrence). In comparison to other fragments of linear temporal logic, formula (2) slightly generalizes the guarantee part of a Generalized Reactivity (1) specification [3] and is similar to the guarantee part of a Generalized Rabin (1) formula [9]. For a more complete treatment of semantics of LTL, we refer the reader to [1]. Given these ingredients, the control synthesis problem can be stated as follows.
Problem 1 Given a system of the form (1) and a specification of the form (2), find a control policy µ, possibly dependent on the state history, and a set of initial conditions X 0 ⊂ X called the winning set, such that all closed-loop trajectories starting in X 0 satisfy ϕ.
Ideally, we want to solve for the largest winning set X 0 but since this is in general hard, we opt for trying to incrementally expand it until it is large enough, or a certificate for its maximality is obtained.
Our solution methodology consists of the following steps: 1. Construction of an abstraction in the form of a (potentially augmented) FTS: This step  requires partitioning the state space into cells based on propositions, finding transitions among  cells, and, in case of an augmented FTS, finding transient cells for progress groups. 1 2. Representing the abstraction using BDDs: This step requires deciding on an encoding of the states and representing transitions and progress groups as a BDD as they are generated in step (1).
3. Solving the discrete synthesis problem on the abstraction via fixed-point algorithms that generate a winning set.
4. Refining the abstraction: If the winning set is not satisfactory, additional cells are added to the partition using the information from the fixed points in step (3). The BDD representation of the abstraction is updated accordingly with new states, transitions, and possibly progress groups.
5. Extracting a controller from the resulting fixed point.
For the first step, we follow the optimization-based procedures in [14]. Our tool ARCS currently supports polynomial f for the dynamics, a finite set U for the inputs, and rectangular sets for X and D. It can however be extended to any setting where computing or over-approximating reachable sets (required for encoding transitions in the FTS) and certifying transience properties (required for progress groups in an augmented FTS) are possible. This paper is primarily concerned with steps (2) through (5) above; in the rest of the paper we introduce our novel ideas and demonstrate resulting computational gains.

Representing the Abstract System
As mentioned in earlier sections the continuous system (1) is abstracted to an FTS. Formally, an FTS is a tuple T = (Q, U, → T , L), where Q is a finite set of states, U is a finite set of inputs, → T ⊂ Q × U × Q is a transition relation, and L is a labeling function mapping each state in Q to a subset of propositions appearing in the formula (2). In order to find a control policy µ T for the FTS T , we need to represent it with a data structure suitable for both storage (memory efficiency) and processing (time efficiency). In what follows, we discuss different representations available in ARCS, their advantages and disadvantages, with a particular focus on a novel BDD encoding.

List Representation
The perhaps most obvious way to represent an FTS is by encoding states and actions as integers, and transitions as an array L = (q 0 , u 0 , q 0 ), (q 1 , u 1 , q 1 ), . . . , (q |T | , u |T | , q |T | ) . (3) 1 Augmented finite transition systems (AFTSs) are FTSs extended with progress groups that capture a type of fairness property. In particular, progress groups identify state-action sets such that the system is guaranteed to eventually leave the corresponding state set when the actions from the set are persistently selected. This is useful in abstractions to encode sets of transient states that do not contain any invariant sets. Our results are valid for AFTSs but for simplicity of exposition we focus on FTSs in the rest of the paper. For details of AFTSs, the reader is referred to [14].
Evidently, this choice requires O(|T |) memory and standard array operations such as access, insertion, search, and deletion can be done in at most O(|T |) time, where |T | is the number of transitions in the system.

Remark 1 Eq.
(3) can be viewed as a representation of a sparse matrix in coordinate (COO) format, that has non-zero entries q k at positions (q k , u k ). There are several other methods for sparse matrix representations that have different benefits. For instance, the compressed sparse row (CSR) format allows for efficient matrix-vector product computation.
This representation is very simple and thus easy to implement, and scales linearly in both space and time. Although this might seem like an acceptable complexity, the size of a grid-based abstraction T scales at least exponentially with the dimension of the concrete system. To illustrate the potential for improvement consider an n-dimensional linear systemẋ = Ax: it requires n 2 numbers (the entries of A) to represent in its canonical ODE form, whereas the size of a finite abstraction based on a list scales exponentially with n. This results from the fact that the semantics of an ODE encodes more side information than the semantics of a transition system, thus allowing the former to be more succinct. The idea of this paper is to explore whether information such as geometrical relationships embedded in an ODE can be stored as part of the encoding of T by working with more sophisticated representations.

Binary Decision Diagrams
In this section, we present an alternative representation of transition systems based on Binary Decision Diagrams (BDDs). We briefly overview how certain operations on transition systems can be performed with BDDs. A key design choice for this type of representations is how to encode the state and action sets as binary variables. As the main contribution of the paper, we present a novel choice for the encodings that attempts to capture underlying geometrical relationships.
A BDD is a data structure for representing boolean functions taking binary variables, z 1 , . . . , z n , defined with an order of evaluation z 1 < · · · < z n . To represent a finite set C with a BDD, one needs an encoding E : C → {0, 1} n , an injective map from elements of C to truth assignments of the variables {z i }, following the order of evaluation. The boolean function B C is then said to represent the set C if such an encoding E is defined on all possible elements c and i.e. the BDD forms the characteristic function of the set [7]. For a given encoding such a function can easily be obtained for singletons: if the encoding of q k is the binary array E(q k ) = (b k,1 , b k,2 , . . . , b k,n ), the boolean function for that element can be constructed as where z i denotes negation of the variable z i . Then a boolean function for the whole set C can be formed as To construct BDDs for the elements of a transition mapping → T , an encoding has to be chosen to represent elements (q k , u k , q k ) ∈ Q × U × Q. To construct singleton BDDs according to (6), one needs to separate the logical variables for the different parts of the elements, while also separating those used for the initial and final transition states q k and q k . Therefore 2n + m variables are defined: z q,1 , . . . , z q,n to represent the set initial states Q, z u,1 , . . . , z u,m for the action set, and z q ,1 , . . . , z q ,n for the final state set Q . Having defined encodings E Q and E U for the set of states Q and set of actions U, an encoding for the transition can be chosen as With such an encoding, the BDD for one transition t = (q k , u k , q k ) can be constructed as in (6): The BDD representing the entire set → T is then constructed on disjunctive normal form from the singleton BDDs as Working with BDDs as representations of sets, one is limited to the logical operations of boolean functions, among which {∧, ∨, ¬, ∃, ∀} are useful. However, using BDDs is analogous to working with the sets themselves, as the basic set operations {∪, ∩, \} have as counterparts logical operations on the corresponding BDDs. It follows from (5) that for sets C and D represented by BDDs B C and B D : In less trivial set definitions, the description might make use of existential and universal quantifiers, ∃ and ∀. As logical operators, these are defined as acting on a boolean function with one of its variables according to But as set notation, they are used to signify conditions which have to hold for at least one, or all, elements of a certain set. The BDD equivalent of quantification over elements of a set is to use logical quantification over all variables used in describing the corresponding set BDD. We therefore define the quantifiers ∃ C , ∀ C as being where the variables z = (z 1 , . . . , z n ) are used to describe the elements in a set C. By expansion of (15) and (16) using (13) and (14) it can be seen that these operators act on a BDD B( z, z ), where the variables z are quantified, by creating new BDDs (∃ C B)( z ) and (∀ C B)( z ). These new boolean functions have the following properties: (∃ C B)( z ) = 1 if and only if there exists at least one assignment for z such that B( z, z ) = 1, and, respectively, (∀ C B)( z ) = 1 if and only if for all assignments to z, B( z, z ) = 1. As assignments are merely the representations of set elements in our definitions, the operators (13)- (14) can be used to construct BDDs that represent sets defined through quantification. For the operations above, the complexity as functions of the size of BDDs involved is as follows: • Conjunction/disjunction of two BDDs B 1 and B 2 requires O(|B 1 ||B 2 |) time, producing a BDD with the same bound in size [6].
• Negation and assignment of a number of variables in a BDD B requires O(|B|) time. Negation does not change the BDD size, but the size after variable assignment is bounded by the original BDD size |B| [7].
• Following the previous remarks regarding (13) and (14), quantification of a single variable on a BDD B, can be achieved in O(|B| 2 ) and results in a size bounded by O(|B| 2 ).
Each operation only takes time, and produces a BDD of size, that is polynomial in the input sizes, but successive applications of these operations are required in BDD manipulation. For instance, the quantifications (15) and (16) have a worst-case complexity that is exponential in the input size. However, these worst-case complexities are seldom encountered in practice.
The BDD data structure is based on a reduced binary tree whose size, i.e. number of nodes, varies not only with the number of elements it represents but also with the encodings and the evaluation order defined for the variables. Choices of evaluation order and encodings are therefore vital when using BDDs and deserves careful consideration, as time and memory used by the logical operations are dependent on the size of the BDD structures involved [6].
As for the choice of variable ordering, an optimal choice can result in a BDD of size linear in the number of binary variables, and a bad choice can give a size exponential in the number of variables [6]. Finding the optimal variable ordering is a computationally hard problem [5] and cannot be solved exactly for any large number of variables in reasonable time, although several heuristics exist (e.g. [4], [15]).
The choice of element encoding E involves two aspects: The number of variables used in the encoding, and how each element is mapped. We investigate two kinds of encodings for the states in the abstracted system. One memory-efficient encoding that minimizes the number of variables used, and one encoding that attempts to capture the structure of the partition after iterated refinement.
State Encodings: The first type of encoding, which we refer to as the log encoding, assumes a numbering of the states from 1 to some number |Q| and uses these to define the mapping in the form where Bin(q) is the binary representation of the number q. When the state space Q is expanded at refinement, a state with number k is split into two new states. One of these is numbered by k and the other by |Q| + 1, after which they are encoded according to (17). The number of variables is also incremented if |Q| = 2 n before refinement, i.e. all encodings for n variables are used by the present states. With this encoding, the absolute minimum of log 2 (|Q|) variables are used to Eq 1 = 00 Eq 3 = 10 Eq 4 = 11 Eq 1 = 000 Eq 2 = 010 Eq 2 = 010 Initial partition q4 refined q1 refined Figure 1: Example of change in split encoding after refinement of initial partition using k = 2 variables.
Refinement of q 4 also reaches new largest refinement depth. Bits appended during expansion, but not later assigned, are shown in red.
encode the states. As it simply uses the least amount of variables, it is the encoding to prefer when nothing obvious can be stated about the structure of the problem. This is the standard encoding used in some tools [10,11].
The novel encoding we propose in this paper-denoted the split encoding-is based on the splitting procedure during refinement. As the partition grows increasingly non-uniform with time, with a possibly small area becoming increasingly fine in contrast to others, we believe that an encoding that reflects this structure can lead to computational gains.
Starting with a coarse initial abstraction and an encoding E for the states using k variables, new states created from the splitting procedure have their encoding chosen based on that of its predecessor and refinement depth. The refinement depth is a measure of how many refinements have been performed on the domain the state contains. Every cell resulting from splitting a cell with depth d has a depth of d + 1, and cells in the initial partition are defined to have depth zero. When a state q with depth d is split into two others, q , q , the new states keep the encoding of their predecessor, with a modified bit at position k + d + 1. This bit is set to 0 for q and to 1 for q . In the event that the partition reaches a new largest splitting depth, a new variable first has to be created to describe the new states, effectively expanding all encodings by one bit. The default value of the appended bit is chosen as 0. An example of both cases is shown in Fig. 1. If the states of the initial partition are given unique initial encodings before refinement, this procedure also results in a unique assignment of state encodings.
To summarize, having a partition with an encoding E and largest refinement depth D; the state q with a refinement depth d and encoding E(q) = (b q,1 , . . . , b q,k , . . . , b q,k+D ), is split into two states labeled q and q . The encodings of the new states are chosen as But if d = D, then all encodings are first expanded by a 0 bit, i.e.
before applying (18) and (19) with the newly expanded encodings. 2 With this choice of encoding, neighboring cells have similar encodings and our hypothesis is that such similarity admits a compact BDD representation by capturing the geometry of the underlying vector fields. Smaller BDDs typically result in computational gains in the synthesis step, an effect we see in simulations. However, the number of binary variables is generally larger than with the log encoding so the theoretical worst-case complexity is higher.

Solving Synthesis Problems
The general way of solving a finite LTL synthesis problem involves translating the LTL specification to a Rabin automaton and computing fixed points on the product of the transition system and the Rabin automaton. Certain LTL fragments do however admit winning sets defined as fixed points on the transition system, which avoids the potentially expensive construction of the product system. This is the case for the GR(1) fragment, as well as the fragment (2) considered in this paper. In the following, we present the fixed-point mappings associated with (2) and how they can be evaluated symbolically when sets are represented as BDDs.
The fundamental component of the fixed-point mappings is the backwards controlled reachability operator Pre 1 , 2 defined as follows: Here, 1 and 2 is either ∃ or ∀ and reflect the controllability assumptions: Pre ∃,∀ corresponds to u being controllable and nondeterminism uncontrollable, whereas Pre ∀,∃ corresponds to uncontrollable u but controllable nondeterminism.
Computing Pre with list representation: For synthesis algorithms the fundamental operator is the Pre ∃,∀ (X) operator, which can be computed as follows: 1. Find the set C = Pre ∃,∃ (X) of all q such that there exists (q, u, q ) ∈→ T for q ∈ X.
2. For each q ∈ C, for each action u, find the set C q,u = {q : ∃(q, u, q ) ∈→ T }.
3. Now for all q, q ∈ Pre ∃,∀ (X) if and only if q ∈ C and for some u, C q,u = ∅ and C q,u ⊂ X.
The procedure can be slightly modified to account for other combinations of quantifiers (i.e. ∀, ∀). The first step can be done via one traversal of L, and the second via |C||U| traversals. Thus the complexity for computing Pre is upper bounded by O (| Pre ∃,∃ (X)||U||T |). However, since the same sets C q,u are typically computed many times when evaluating a fixed point, step 2 can be discounted across multiple Pre operations by storing the sets C q,u , which improves the time complexity of a single Pre computation towards O(|T |) at the expense of a larger memory footprint.
Computing Pre with BDD representation: When the set of final states X is represented as a BDD B X using an encoding E, the set Pre 1 , 2 (X) can be represented as the binary mapping 2 Appending the encodings with 0 to have all states represented with the same number of bits is just for coding convenience. One can alternatively change the co-domain of the function E to ∪ n i=k {0, 1} i . which can be computed symbolically from B X via quantifier elimination. 3 The runtime of this operation ultimately depends on the sizes of intermediate results, but considering the complexity and worst-case size result of each operation involved, an upper bound can be obtained as O((|B X ||B T |) 2 nu+nq ), when using n u action variables and n q end state variables. The complexity can also be expressed solely in the number of variables used, if one assumes the maximum size of each intermediate BDD. Then the theoretically largest possible runtime is that of the 2 nq−1 conjunctions when expanding 2Q , acting on BDDs having assigned all but n q + n u variables, thus having complexity O(2 3nq+2nu ). Equipped with the Pre operator, we give fixed-point characterizations for the winning set of (2). We borrow notation from µ-calculus for succinct expression of fixed points. Let κ : 2 Q → 2 Q be a mapping that is monotone with respect to set inclusion, i.e., V ⊂ W =⇒ κ(V ) ⊂ κ(W ). Then the greatest fixed point of κ, written νV κ(V ), is the value after convergence of the set sequence Correspondingly, the smallest fixed point of κ, written µV κ(V ), is the value after convergence of Due to monotonicity and finiteness of Q, both these sequences converge in a finite number of steps. With this notation, the winning set of (2) is as follows:

Specification-Guided Abstraction Refinement
In the event that the winning set Win ∃,∀ (ϕ) computed via (25) is empty, or otherwise not satisfactory (e.g., it does not cover an expected initial condition), the abstraction can be refined in an attempt to extract more information about the underlying concrete system. Instead of doing this blindly, we select refinement regions guided by the internals of the fixed point computation (25). Loosely speaking, for a greatest fixed point (23) we perform refinement in the set Pre ∃,∃ (V ∞ ) \ V ∞ just outside the fixed point V ∞ , with the hope that the greatest fixed point will be enlarged in the refined system. For a smallest fixed point, refinement is instead done in V 1 \ V ∞ , where V k is the k'th iteration of (24). These ideas are illustrated in Fig. 2. For multi-level fixed points such as (25) we select the refinement regions as the union of the refinement regions corresponding to lower-level fixed points. For more details see [14].

Controller Extraction
In addition to computing the winning set, in practice also a controller that enforces the specification inside the winning set is required. Fundamentally, such a controller can be extracted by saving the set of u's satisfying the quantification in low-level calls to Pre in (21), and storing these u's in a memory hierarchy whose structure depends on the type of fixed point. For instance, invariance or reachability controllers can be memoryless (i.e. state feedback), but a recurrence controller must maintain an internal memory state that switches between different reachability objectives. Thus certain specifications trivialize controller extraction and as a result this issue is not discussed in detail for tools that handle only invariance specifications. However, control extraction adds to the overall complexity when specifications of more general form such as (2) are considered, or when AFTSs are used.

Results and Comparisons
In this section, we present results comparing different representations of transition systems. Our toolbox ARCS, available at https://github.com/pettni/abstr-refinement, implements the examples in this section. ARCS has a MATLAB front-end for handling continuous dynamics, computation of transitions, and list representations, and a C back-end for BDD operations using the CUDD library [18]. As benchmarks we consider hydronic radiant systems for buildings, in which chilled water is run through concrete slabs to regulate the temperature of the rooms to which they are connected. The systems are controlled by turning on/off flow to any one slab, thus changing the temperature of zone i according to the heating dynamics where the sum is taken over all temperature zones in the system, including other rooms, slabs, supply water sources, and the outside (the last two are assumed to have constant temperature). Thermal capacitances c i , thermal resistances R ij = R ji and nominal heat gains k i are determined by sets of parameters that together define room types. In this article we use parameters for the outside and water temperature and two room types as defined in [14], slightly extending the framework to take into account adjacency with multiple rooms of different types, and multiple slabs in different configurations. A setup with n r rooms and n s slabs results in a dynamical system with n r + n s continuous states (room and slab temperatures), and 2 ns discrete control inputs (water flow through each slab turned on or off).
We construct a collection of benchmark systems and perform three types of run time tests: 1. Synthesis on systems of varying size and topology, 2. Synthesis on the same system but at different levels of refinement, 3. An end-to-end synthesis-refinement procedure on one system.
For these tests a persistence specification ϕ = ♦ B is considered, with B being the proposition corresponding to all rooms and slabs having temperatures in [22,25] • C and [21, 27] • C respectively, in a total domain of ([20, 28] • C) nr+ns . In the first test, different configurations of adjacent rooms and connecting slabs, as shown in Fig. 3, are used. After refining the abstraction of each system 2000 times, resulting in roughly 2000 states in each abstraction, a final synthesis is performed and timed. The final synthesis is done using the BDD representation with the suggested log and split encoding, both as is and after reordering of the BDD variables using the simulated annealing algorithm implemented in CUDD. Fig. 4 shows the resulting run times for each system and representation scenario. It is worth noting that for all systems except 3, which is special in the sense that one room lacks a controller, the order from slowest to fastest run times is consistently measured as log, reordered log, split and reordered split encodings.
In the second test, System 2 in Fig. 3 is used in measuring the synthesis time at different levels of refinement. An abstraction is obtained after a number of synthesis-refinement iterations between 500 and 4000, and the run time of synthesis on that abstraction is measured. In Fig. 5     time of synthesis is plotted against the number of transitions present in the abstraction. Just as in the first test, the split encoding is seen to have lower run time than the log encoding for both the ordered and unordered case. It is also interesting to note how for this test, the slope of the reordered split encoding graph in this loglog-plot is close to linear and less than that of the list encoding toward the larger number of transitions. As a final test, the synthesis-refinement procedure is ran on System 2 for one hour using the list representation, log and split encoding, and cumulative time together with runtime of each synthesis-refinement iteration is measured. In Fig. 6, the cumulative time is plotted against the total number of iterations achieved, and in Fig. 7, the runtime of the iterations are shown as averages over intervals of 50 iterations. As seen in Fig. 6, the split encoding manages a few hundred more iterations in total than the log encoding, especially during the time the abstraction is more refined and transition relations are more complex. And in Fig. 7, the average iteration time for log encoding grows at a faster rate than for the split encoding, when the partition is increasingly refined. As a side note, overall timing for each of the methods can be improved by warm-starting synthesis at each refinement step (see [14]) but this is not currently implemented in ARCS, and will not affect the comparative results significantly. Finally, we also note that in terms of memory requirements, the number of nodes allocated by CUDD to represent the BDDs for split encoding is approximately twice as much as that for the log encoding, with 2% to 10% extra memory usage   at iteration steps 2000 and 3000, respectively. This extra memory usage is not surprising given that the number of binary variables in split encoding is more than the minimal number achieved by the log encoding. On the other hand, the split encoding achieves a better compression in terms of memory used per number of binary variables as shown in Fig. 8. Moreover, this redundancy in representation seems to improve computation times significantly. Finally, we point out how non-uniformly the partition of the state space evolves through the abstraction-refinement process. Figure 9 shows an initial partition of the domain for System 1 and the partition after 200 refinement steps for the same system. It is hard to capture the structure in the refined partition when starting with a log encoding of the initial state and appending one state to the end of the list of states at every refinement step, where the list is eventually encoded via (17). On the other hand, the split encoding is designed to capture the topological relations in the partition naturally.

Conclusions
In this paper, we presented an abstraction-refinement based controller synthesis framework and, specifically, discussed several ways of representing the transition systems resulting from abstractions. We proposed a novel BDD-based encoding, namely split encoding, of the states of the transition system that takes into account the geometry of the underlying continuous states and how they evolve with refinement. A comparative study of various representations shows the effectiveness of the new encoding. The presented ideas are implemented in a toolbox, ARCS, which is made publicly available.