Efficient and Complete FD-solving for extended array constraints

1 Introduction

Context. Automated reasoning and deduction systems are increasingly used in the domain of software verification, typically for checking the adequacy between program behavior and a formal specification. Numerous theories and powerful tools have been developed to prove different kinds of properties of a program [De Moura and Bjørner, 2008; Barrett et al., 2011]. The most popular approach consists in rewriting verification problems as satisfiability problems, that can then be solved using SMT solvers. Another path in the quest of an efficient and expressive solving is the use of Constraint Programming over Finite Domains (FD) [Bardin and Gotlieb, 2012; Bardin and Herrmann, 2008; Charreteur et al., 2009; Marre and Blanc, 2005]. FD has been proved useful for reasoning about complex structures crucial to software verification, such as floating point numbers [Botella et al., 2006], modular arithmetic [Gotlieb et al., 2010] and bitvectors [Bardin et al., 2010]. Multi-theory and verificationoriented FD frameworks are also starting to emerge [Marre and Blanc, 2005].

Our Problem. One aspect that is still lacking in constraintbased approaches to verification is an efficient handling of data structures. In many cases, constraints on such structures can be modeled using the theory of arrays [Kroening and Strichman, 2016]. One difficulty is that, unlike other theories (e.g., bitvectors, modular arithmetic), arrays do not provide many opportunities for efficient application of local-consistency based filtering techniques that are at the core of FD approaches. Instead, solving array constraints often requires reasoning on the global structure of formulas. Previous works [Hentenryck and Carillon, 1988; Charreteur et al., 2009; Bardin and Gotlieb, 2012] on this theory enabled to build FD tools to handle the fixed-size case, i.e., when arrays are known to have a fixed, finite size. They allowed to tackle some verification focused problems, such as test case generation. However, in many applications relevant to verification, such as unit verification, there is typically much fewer information available about data structure sizes. These sizes are sometimes known to be smaller than a (potentially big) given bound (bounded case), or no information is available about the size (unbounded case). Overall, FDbased techniques extend poorly to the bounded case while the unbounded case is considered out of scope.

∗Work partially funded by ANR (grant 14-CE28-0020).

Challenge and Goals. We tackle the problem of finding efficient FD-based techniques for reasoning about fixedsize, bounded and unbounded arrays, as typically found in verification-oriented problems. We pay particular attention to the following points:

• Efficiency: The overhead when dealing with large arrays should be reasonable;
• Completeness: Our technique should handle complex constraints (array equality, unbounded size) in a complete way;
• Expressiveness: It should be compatible with expressing other constraints on elements and indices, for example arithmetic constraints.

Contribution. First, we introduce array reduction, a formula transformation that takes as input a quantifier-free formula containing (possibly unbounded) arrays, and outputs an equisatisfiable reduced formula using only fixed-sized arrays. Thus the reduced formula can be solved using finitedomain solvers implementing array constraints [Gotlieb,

• . CP+R: constraint programming, with our array reduction
• . size-dep: complexity depend on array size
• . N.O.: Nelson-Oppen solver combination [Nelson and Oppen, 1979] (expensive)

2009; Bardin and Gotlieb, 2012], with no modification to the propagators. Moreover, the sizes of the reduced arrays have no relation with the sizes of the arrays in the input formula, but only depend on the number of indices used in the input formula.

Second, we demonstrate that our encoding is efficient (Section 4.4), in the sense that the algorithm itself is cheap and that the obtained search space is significantly reduced w.r.t. alternative resolution methods for arrays - mainly because our approach builds deeply on the many symmetries of the theory of arrays.

Third, we implement this technique inside fdcc [Bardin and Gotlieb, 2012] and evaluate it (Section 5). We show that our technique allows one to solve previously unsupported formulas, typically over unbounded arrays. In addition, the resulting solver significantly outperforms FD reasoning in the case where all arrays have fixed sizes because of the powerful state space reduction opened during the transformation, and it also competes favorably with state-of-the art SMT solvers, especially when arrays have small sizes.

Overall, we achieve a promising trade-off between efficiency and expressiveness (see Table 1) with the native support of size/domains and handling of arithmetic on indices.

2 Motivation

Let us consider the following formula, where S is an integer constant, t is an array, and i, j are integers (indices):

The formula φ has in fact no solution since t[i] < t[j] implies that these two array accesses are different, while i = j implies that they are equal. Constraint-based approaches typically rely on encoding the two array accesses t[i] and t[j] with ELEMENT constraints. However, the local filtering-based reasoning of constraint solvers is insufficient to detect this conflict. Therefore an exhaustive labeling will be required to conclude unsatisfiability of φ, essentially making the solving time dependent on the size S of the array.

For addressing such limitations, we introduce in this work a formula transformation that accounts for the fact that many array related conflicts are size independent, while preserving the ability to reason about sizes for arithmetic purposes. It consists of three main steps: separation of array literals from arithmetic literals in φ (purification), rewriting of size constraints as additional arithmetic constraints, and introduction of proxy variables to reason separately on array indices as array theory objects and arithmetic objects. The transformation eventually produces a reduced form for φ, denoted φr . An example is given hereafter. The two proxy variables are ir and j r . The renaming of t in tr makes it clear that these two arrays are not identical. The consistency constraint is

Note that S only appears in φr to define domains for i and j. Our transformation captures the idea that, since φ has only two array accesses (in i and j), considering an array with S elements is not useful - intuitively, the vast majority of these elements will be unconstrained. In traditional FD approaches, arrays are typically modeled using a list of variables, corresponding to every array element. With our transformation, we can drastically reduce the search space.

3 Background

The Theory of Arrays [Kroening and Strichman, 2016] is concerned with indexed data structures equipped with access and update operators. The pure theory of arrays is built on three sorts Arr, indices Ind, and elements Elem, and two operators:

where select(t, i) is the value at index i in array t, while store(t, i, e) is an array identical to t, except in i, where the value e is now present. Formally, the theory is defined over the signature ΣA = {select, store,=, ̸=}, and has the following axioms :

Yet simple, this theory is hard to solve: the satisfiability problem for the conjunctive fragment is already NPcomplete [Downey and Sethi, 1978]. The extensional theory of arrays is a common extension of the latter theory where (dis)equalities between entire arrays can be expressed. It is defined by adding the axiom of extensionality :

Finally, we encode size constraints by adding an operator size : Arr →N∪ {∞}, satisfying the following axioms:

In order to avoid dealing with undefined values, we only consider in the following formulas with the well-defined access property. A formula has the well-defined access property if it is guaranteed that array accesses will always occur within the array bounds. An arbitrary formula can be made to have this property by adding the well-defined access condition 1 ≤ i ≤ size(t) for every term select(t, i) and store(t, i, ) it contains, in the vein of type correctness conditions from the PVS proof assistant [Owre et al., 1999].

Let φ be a formula in the theory of arrays. A model for φ, or φ-model, is a first order interpretation satisfying φ. φ is said to be satisfiable if it has a model, and is otherwise unsatisfiable.

CSPs. A valuation θ over a set of variables Var ≜ {v1, ..., vn}, each associated to a domain D1, ..., Dn is a mapping from variables to values, such that, for each i, θ(vi) ∈ Di. A constraint c over variables vars(c) is defined by a set of valuations over vars(c), these valuations being called solutions to c. A Constraint Satisfaction Problem (CSP) is a tuple (Vars , Dom, C), where Vars is a finite set of variables, Dom is a mapping from variables to finite domains, and C is a set of constraint, where each constraint is defined over a subset of Vars. A solution to a CSP (Vars, Dom, C) is a valuation θ over Vars, such that, for each v ∈ Vars, θ(v) ∈ Dom(v), and for every constraint c ∈ C, θ/vars(c) is a solution to c.

A CSP that has at least one solution is called satisfiable, otherwise it is called unsatisfiable. Deciding a CSP consists in determining if it is satisfiable or not.

Procedures for solving CSPs are called finite domain constraint solvers (FD in the rest of the paper). The key idea is local filtering: propagators remove from the variables' domains the values that cannot participate in any solution. Local filtering can lead to spectacular pruning of the search space, and has enabled FD solvers to tackle complex combinatorial problems, where brute force is not an option.

Encoding Array Problems as CSP. The usual approach to deal with array accesses in FD is by using the global constraint ELEMENT [Hentenryck and Carillon, 1988]. This constraint is well known, and numerous implementations are available [Carlsson et al., 1997; Tack et al., 2006; Nethercote et al., 2007]. For an index i, an element e, and an array A, modeled with n FD-variables representing every array element (thus only fixed size arrays can be encoded), ELEMENT(i,A, e) is true iff A[i] = e. Filtering algorithms for ELEMENT can usually ensure at least domain consistency over i and bound consistency over e and all the A[k] [Carlsson et al., 1997], at a cost quadratic in n. In [Charreteur et al., 2009], another global constraint is proposed to deal with array updates, also with a propagation cost quadratic in the array size. By combining these global constraints with a congruence closure algorithm, the fdcc solver has been implemented and evaluated on randomly generated formula [Bardin and Gotlieb, 2012]. However, labeling-based search and local reasoning are ill-conditioned for large or unbounded arrays. That is why the transformation proposed in this paper is a necessary complement to any FD reasoning over arrays.

4 Formula Transformation

In this section we detail the process of obtaining a reduced form for a formula containing extended array constraints. Our transformation takes as input a quantifier-free formula φ containing fixed-size, bounded and/or unbounded arrays with access and update constraints, array (dis)equalities as well as other arbitrary FD-constraints on elements and indices. φ may contain disjunctions, and is assumed to be provided in negational normal form. The transformation outputs an equisatisfiable formula φr containing only fixed-size arrays, amenable to efficient FD reasoning.

4.1 Key Insights

The transformation takes advantage of the following key insights into the theory of arrays. The first two insights are well-known in SMT (but not used in FD approaches), while the last two insights are at the core of our contribution.

1. Distinguished array cells. Each array cell that is not referred to by an index expression in the formula does not impact the status of a given interpretation (model or not); i.e. two interpretations differing only on unreferenced array cells are equivalent. Hence, we can restrict our reasoning to referred array cells only, whose number is always finite and independent from array size (for quantifier-free formulas). This is a first step toward handling unbounded arrays with finite reasoning.
2. Equality-based reasoning. In pure array theory, only the (dis-)equality of index expressions are important - not their exact values. This is the basic enumeration strategy for solving pure array formulas (without domains nor size), requiring to enumerate 2N 2 different cases - but being absolutely independent from the domain of indices (N is the number of index expressions).
3. Implicit equality encoding. (new) With pure arrays, we can use an alternative method: bound every array to size N (the number of index expressions), and choose for indices values between 1..N, in order to encode in an implicit way the dis-equalities of index expressions. The technique is correct and complete (this is proved in section 4.3), and shows two advantages over equality-based reasoning:
4. finite-encoding: the formula contains now only fixedsize arrays, and we can solve it through standard FD approaches - even if the original formula was on unbounded arrays;
5. efficiency: we can refine the technique in order to have a search space of (N/ln(N))N , which is considerably smaller than for explicit equality-based reasoning.
6. Proxying / array isolation. (new) In the case of extended array constraints, we need an additional step of proxying, or array isolation, in order to keep the FD-reduction on arrays while allowing arbitrary constraints over index expressions. The idea is to separate the array-based reasoning on index expressions from other non-array reasoning on those index expressions, by introducing a proxy-variable er ∈ 1..N for each index expression e, and ensuring overall formula consistency through a new dedicated (FD) constraint. Hence, arrays can be dealt with through the implicit encoding (the er )

while constraints over indexes are dealt with by the original problem variables.

4.2 Core Technique: Array Reduction

Our array reduction consists in four elementary steps, mostly involving rewriting or introducing new literals, and producing a series of equisatisfiable formulas.

Step 1: Preprocessing (Purification) The first step of the transformation is standard and consists in rewriting literals containing both array operators and arithmetic operators, such as select(t, i + 1) - x = y into conjunctions of literals that contain only one type of operator, introducing new variables where needed. For the previous literal, a purified form is select (t, j) = e∧j = i+1∧e-x = y. Note that = is to be understood as logical equality, and variables are assumed to be declared beforehand. Purification is a well known technique in SMT and is required in solver combination framework such as Nelson Oppen. It induces a linear growth of the input formula. We also flatten array constraints so as to make their arguments atomic. For example, e = select(store(t, i, e), j) is rewritten as t′ = store(t, i, e)∧e = select(t′ , j), introducing one array variable t′ . We call φpure the formula obtained after these operations. Finally, we rewrite array disequalities t ̸= t′ as select(t, j) ̸= select(t′ , j), introducing a fresh variable j for every such disequality.

Step 2: Size Constraint Elimination We now proceed to remove every size constraints from φarray, by encoding their semantics directly in the arithmetic part of the formula. Denote Arr the set of array atoms occurring in φarray, and for every array t ∈ Arr introduce a fresh variable st.

• replace every occurrence of size(t) with st
• replace every array equality t = t′ with t = t′ ∧st = st′
• replace every array equality t′ = store(t, i, e) with t′ = store(t, i, e) ∧ st = st′ ∧ i ∈ 1..st
• replace every constraint e = select(t, i) with e = select(t, i) ∧ i ∈ 1..st

We call φelim the formula obtained after eliminating size constraints from φpure.

Step 3: Index Reduction In φelim, we denote Ind ≜ {i1, ..., iNi } the set of index variables, that is the variables that appear as the second argument in a select or store constraint. For each one of these variables, say ik, we introduce a fresh variable irk , and call Indr ≜ {ir1 , ..., irNi } the reduced indices associated with Ind. The first step of index reduction consists in replacing every term of the form select(t, ik) in φelim with select(t, irk ), and similarly every term store(t, ik, e) with store(t, irk , e). We emphasize that only the occurrences of indices as the second argument of an array constraint are replaced with their reduced counterparts. In particular, arithmetic constraints on indices remain unchanged. The idea is to isolate the arithmetic reasoning on indices, which is concerned about precise values, from the array reasoning, which is merely concerned about (dis)equalities.

Partially replacing indices with reduced indices amounts to under-constraining the problem, and as such, index reduction is not sound, that is, it may introduce solutions that do not satisfy the original formula. In order to ensure that the reduced indices are consistent with the original ones, we add the following consistency constraints:

The number of consistency constraints is quadratic in Ni. Section 4.4 will show how to handle consistency efficiently in a FD solver using the new global constraint consistent ([ir1 , ..., irNi ], [i1, ..., iNi ]).

As an additional step, we rename every array t in φelim as tr (we refer to them as reduced arrays). This step is purely syntactic and optional, yet it helps avoiding confusion when we discuss the generation of φ-models from φr -models.

We call φi.r. the formula obtained as a result of index reduction on φelim.

Step 4: Size Fixing All arrays in φi.r. are unbounded, since size constraints were eliminated. Moreover, all array accesses occur on reduced indices, and the reduced indices appear nowhere except in array constraints and equality constraints (consistency constraints). For these reasons, it is possible to add the following fixed sizes for arrays and domains for reduced indices :

• add constraint size(tr ) = Ni for every reduced array
• add domain constraints irk ∈ 1.. maxl<k(irl ) + 1

The domain constraints presented here are sophisticated and allow for efficient solving of φr . Using the weaker domain 1..Ni (implied by the size constraints) for every reduced index also leads to a sound transformation. The stronger domains are obtained using the fact that the values of the reduced indices can be freely interchanged, as long as their arrangement with respect to equality is preserved. Technically speaking, the set of reduced indices admits all value symmetries. Using the stronger domain form amounts to statically breaking these symmetries.

4.3 Correctness

Array reduction enjoys the following theoretical properties :

Theorem 1 (Equisatisfiability). φ and φr are equisatisfiable.

Sketch of Proof We focus on the equisatisfiability of φelim and φr (equisatisfiability of φ and φpure is well-documented, and φpure and φelim are equisatisfiable by the definition of size constraints). We first consider the case where φelim is a conjunction of literals, and let I be a φelim-model. For every non-array variable in v ∈ vars(φelim), we define I r (v) ≜ I(v). Since φelim and φr have the same arithmetic literals, we only need to define I r for reduced arrays and indices, and check that it satisfies array literals, and consistency constraints. We define :

It is easy to check, by induction, that I r (irk)s are well defined, and that this definition satisfies the consistency constraints as well

as the domain constraints for reduced indices. Now let t be an array variable in φelim. I(t) is an integer sequence (tk)k>0 (all arrays in φelim are unbounded). We will define I r (tr ) as the finite sequence (trk)1≤k≤Ni such that :

trk ≜ tI(il) if ∃l, I r (irl ) = k ≜ 0 otherwise

It is again easy to check that I r (tr ) is well defined and satisfies the size constraint size(tr ) = Ni. It remains to show that I r satisfies array literals in φr . This step is easy, remarking that for every index i and array t in φ, tI(i) = trIr(ir) , and unreferenced array elements all have value 0 in reduced array models, hence high level properties like array equalities are preserved. As a consequence, if φelim is satisfiable, then so is φr . The proof that φelim is satisfiable when φr is has the same structure (it is actually simpler since a φr already provides values for non-reduced indices). When φelim is not a conjunction of literals, the same proof applied to a satisfied clause in its disjunctive normal form shows that the result still holds.

Theorem 2 (Model Extension). φr -models can be extended to φ-models, that is, models that agree on every variable common to φ and φr

Sketch of Proof Let I r be a φr -model. We obtain a φelimmodel Ielim as follows :

• Ielim(v) ≜ I r (v) for every non-reduced variable
• Ielim(t) ≜ (tk)k>0 for array variables, where :

tIr(ik) ≜ trIr(irk ) for each k ≜ 0 otherwise

The proof that Ielim is well defined, and actually a model for φelim is similar to the previous proof. Remarking that vars(φ) ⊂ vars(φelim), a φ-model I is defined as follows :

• I(v) ≜ Ielim(v), for every non array variable v ∈ vars(φ)
• I(t) ≜ t(1≤k≤Ielim(st)), for array variables

The proof that I is a φ-model is routine.

Theorem 3 (Finite Reasoning). φr can be solved using FD techniques, especially consistency constraints.

Proof Arithmetic literals come with finite domains. FD solving for arithmetic is well documented. Arrays and indices in φr all have fixed size and finite domains (introduced at transformation time), hence array accesses and updates can be modeled using existing FD techniques. Consistency constraints are finite in number, and all have the form ir = j r ⇔ i = j. This constraint can be encoded in most FD frameworks using reified constraints. Section 4.4 shows a more efficient handling.

4.4 Efficiency

We discuss how to efficiently maintain consistency while solving φr . For that goal we introduce the global consistent constraint. This constraint takes as input two lists of variables having the same length n. Two list of values [u1, ..., un]and [v1, ..., vn] satisfy the consistent constraint when they have the same arrangement with respect to equality, that is, when ui = uj, if, and only if, vi = vj, for every i and j in 1..n.

We now show how to propagate the consistent(L1,L2) constraint. The constraint internally maintains two lists I1 and I2 of integer values i such that L1[i] (respectively L2[i])

is assigned. The constraint is woken whenever a variable in L1 or L2 becomes assigned, and uses the following propagation algorithm :

Using a global consistency constraint is more efficient than using reified constraints in our applications. A search strategy that worked well in practice is to label reduced indices first, since their domains are generally smaller than other variables in φr and instantiating these variables leads to strong propagation, both in array and consistency constraints.

When using a consistency constraint, the overall size blowup of φr relative to φ is only linear.

Theorem 4 (Solution Space Reduction). Every φ-model can be obtained as an extension of a φr-model. Hence, the solution space for φr is a reduced version of that of φ, all solutions are preserved but irrelevant indices are abstracted.

Sketch of Proof The φr -model is constructed using the definitions in the proof of Theorem 1, with minor adaptations.

Theorem 5 (Search Space Reduction). Let Ind be the set of index expressions in φ and Indr the set of reduced index in φr . Two φr -models not agreeing on Indr extend to φmodels not agreeing on Ind, while the converse does not hold in general.

Sketch of Proof Let Indr ≜ {ir1, ..., irn}, and call I and I ′ two φr -models such that I(irk) and I ′ (irk) differ, for some k. Because of the domains of reduced indices, we know that, I(ir1) = I ′ (ir1) = 1, and I(ir2), as well as I ′ (ir2), is either 1 or 2. If they differ, then one of these models gives the same value to ir1 and ir2, while the other does not. With a similar argument we prove by induction that there will always be two indices irl and irm such that I(irl ) = I(irm) and I ′ (irl ) ̸= I ′ (irl ), exchanging the roles of I and I ′ if needed. The result then follows from the fact that I and I ′ satisfy the consistency constraints.

Search Space Comparison We consider a pure array formula φ with unbounded arrays. That is, φr has no arithmetic literal. In this case, deciding the formula only requires enumerating the valuations for Ind r the reduced indices in φr . This is because array elements appear only at most in (dis)equality constraints, so finding values for these elements from a non-conflicting index valuation is easy. As hinted by the previous proof, different valuations on Ind r correspond to different arrangements of Ind r with respect to equality. In fact, one can show that valuations on Ind r correspond exactly to arrangements of Ind r with respect to equality (or in other terms, to equivalence relations over Ind r ). Hence there are Bn such valuations, where Bn is the n-th Bell number, and n is the size of Ind r . As a comparison, many SMT approaches rely on introducing case splits on the (dis)equality of i and j for every read-over-write term select(store(t, i, e), j). This approach introduces 2n2 case splits in the worst case.

It is known that Bn = O (( n log n )n) [Berend and Tassa, 2010], while 2n2 = (2n )n . Although this comparison does not take into account the various optimisations and heuristics used in practice by SMT solvers and FD solvers, the difference is significant. For small values of n, the difference in search space size is already huge, for example B5 = 52 while 252 ≥ 33.106 .

5 Experimental Evaluation

Implementation Our implementation is built on top of fdcc [Bardin and Gotlieb, 2012]. fdcc relies on update constraints and SICStus clpfd for arithmetic constraints. The implementation is approximately 2000 lines of Prolog, and includes an interface to the SMT-LIB [Barrett et al., 2015] format (only array and integer related theories are supported).

Goal and Protocol The experiments presented below aims at evaluating the benefits of array reduction. The goal is to answer precisely the following questions:

1. Does array reduction indeed lift standard FD techniques to unbounded formulas?
2. How useful is array reduction when implemented on top of FD solvers for solving formulas with bounded arrays?
3. How does array-augmented FD solvers perform w.r.t. top-class SMT solvers, especially do we manage to bridge the gap between FD and SMT?

We consider a benchmark of 2200 formulas obtained as follow. First we take the 550 array formulas from the SMTCOMP benchmark, the standard competition in SMT solving - with formulas coming essentially from hard verificationoriented industrial and academic case-studies. We consider here only pure array formulas (no additional arithmetic constraints). They typically include up to a hundred variables and dozens of array constraints (including long store chains), with the largest ones containing more than one hundred arrays, 60 distinct indices and a thousand constraints (including 120 array updates). Most formulas include extensionality constraints, but no size constraint. Then, we automatically duplicate these formulas with additional size constraints of 10, 100, 1000. These sizes, and small ones in particular, are representative of the ones found in real programs.

In our experiments, we compared fd which is the standard clpfd library of SICStus Prolog augmented with an implementation of the store operator using the global constraint interface [Charreteur et al., 2009], fdcc [Bardin and Gotlieb, 2012] which augments clpfd with congruence closure reasoning over arrays, fdr and fdccr which are similar to fd and fdcc but augmented with array reduction. The augmented features for these four tools are fully implemented in Prolog on top of clpfd. We could not use MiniZinc [Nethercote et al., 2007] and Gecode [Schulte and Tack, 2005] as these solvers do not provide any constraint for handling the store operator which is present in all the formulas. For the sake of completeness, we also ran four SMT-solvers which are among the best competitors of the SMT competition: Yices [Dutertre, 2014], MathSAT [Cimatti et al., 2013], CVC4 [Barrett et al., 2011] and the Microsoft Z3 solver [De Moura and Bjørner, 2008] 1 . These SMT-solvers are among the best-known approaches for the theory of arrays, they result from more than 10 years of intensive development by teams of experienced engineers and are finely tuned for SMTCOMP.

We compare each solver on the number of successfully resolved formulas (solver answers were checked against each other and the formula oracle, no conflict was reported ), with a timeout set to 30 seconds - this is a rather low value, yet it is representative of timeouts used in some verification settings, where thousands of constraints must be solved. The results for a timeout of 120 seconds are also shown without discussion, since there is only very little difference. Experiments were run on a Intel(R) Core(TM) i7-5600U (2,6 GHz) (2 cores), 16GB RAM, running Linux Fedora 22.

Results and Conclusion Results are presented in Table 2.

First, it can be seen that array reduction does allow FD techniques to solve unbounded formulas in practice, and actually it allows to solve a large majority of the formulas (526/550 for fdr and fdccr ).

Second, array reduction allows a dramatic improvement of standard FD techniques on fixed-size arrays (between 2.5x and 6.5x more formulas), and the larger size, the larger improvement (for size 1000, fdr solves 526 formulas, while fd alone solves only 79 formulas); interestingly, the reduction allows also to bridge the gap between fd and fdcc. For small array sizes. fd-like cheaper propagation even gives fdr a slight advantage (544 vs 536) since it can exhaust all valuations for reduced indices more quickly. Yet, array reduction does not amount to adding full symbolic reasoning to FD solvers, and there are classes of formulas (not represented in SMT-COMP) that require fdcc's global reasoning to be solved.

Finally, array reduction allows FD to compete with the best SMT approaches: our technique clearly surpasses SMT on small size arrays - at worst 536 vs at best 463 (small sizes yield many pigeonhole-like problems, notoriously hard to solve with SMT), while it is only slightly inferior on largersize and unbounded formulas - 526 vs 550. Arrays of small

1 Yices, MathSAT, Z3 and CVC4, in this order, achieved the four first places in the 2016 SMT-COMP.

• . fdr and fd: Constraint solver, with and without array reduction
• . fdccr and fdcc: Hybrid solver, with and without array reduction
• . size: array size - #f: n. of formulas

sizes are ubiquitous in real-world programs, hence they are of particular importance in practice.

6 RelatedWork

Standard SMT and FD approaches for arrays and how they relate to our reduction-based method have already been presented and discussed through the paper (especially, see Table 1, Sections 3 and 4.1).

FD While array accesses have been dealt with for a long time through constraint ELEMENT [Hentenryck and Carillon, 1988], only very few work consider array updates [Gotlieb, 2009]. For example, both Minizinc [Nethercote et al., 2007] and Gecode [Schulte and Tack, 2005] propose the former but not the latter. All these approaches are size-dependent and cannot deal with unbounded arrays. While string constraints [Jaffar, 1990] are highly expressive, size constraints are often weak or not well treated. Indeed, solving constraints over regular expressions extended with arithmetic is often undecidable. Depending on the approach, sizes must be bounded, sizes must be unbounded, or the decision procedure does not guarantee termination. The fdcc approach [Bardin and Gotlieb, 2012] complements the standard local filteringbased FD reasoning on array with global symbolic reasoning to produce an efficient solver for fixed-size arrays. Array reduction and fdcc are complementary. Finally, array reduction is not about automatically finding symmetries in a given CSP. Rather, we take advantage of existing symmetries for reducing the initial problem to an efficient finite-domain problem.

SMT Standard symbolic approaches for pure arrays complement symbolic read-over-write preprocessing (in the vein of fdcc) with enumeration on (dis-)equalities, yielding a potentially huge search space.

New array lemmas can be added on-demand or incrementally discovered through an abstraction-refinement scheme [Brummayer and Biere, 2009]. Size and arithmetic constraints can in principle be recovered through the Nelson-Oppen solver combination scheme [Nelson and Oppen, 1979], but the communication cost can be much more expensive than satisfiability checking [Bruttomesso et al., 2009] on non-convex theories - such as array theory, as it requires to propagate all implied disjunctions of equalities. Delayed theory cooperation [Bozzano et al., 2005; Bruttomesso et al., 2009] requires only equality propagation, at the price of adding new Boolean variables for all potential variable equalities. Model-based theory cooperation [Marre and Blanc, 2005] aims at mitigating this overhead through lazy equality propagation. Decision procedures have been developed for expressive extensions of the array theory, such as the array property fragment [Bradley et al., 2006], which enables limited forms of quantification over indices, and arithmetic constraints. While such theories are more expressive than our extended array constraints, the associated decision procedures are highly expensive (translation to Presburger arithmetic). Moreover, these techniques require indices to be integers (bitvectors, for example, are not supported), while our approach is mostly independent of the elements' and indices' types (only equality and disequality are required over elements, while indices additionally require an ordering).

7 Conclusion

This papers introduces a formula transformation that can produce a fixed-size array formula equisatisfiable to any formula with extended array constraints, including extensional unbounded arrays, and combination with arithmetic constraints on indices and elements. In addition, the transformation induces a powerful search space reduction and has remarkable properties including a strong correspondence between the models to the input and transformed formulas. This work opens the way for automated constraint-based reasoning on large classes of data structures, with reasonable theory combination costs, and follows the trend initiated in previous works of proposing CP as a viable alternative to the well established techniques in automated proof, relying largely on the use of DPLL based SMT solvers.