Inspired by concepts of constraint-based local search, we present a novel scheme for automatically relaxing a given high-level model into an optimisation model that is better suited for large neighbourhood search (LNS). By exploiting the variable sharing and semantics of the constraints in a model, our scheme (1) identifies constraints that can easily be satisfied simultaneously and can thus constrain the neighbourhood, and (2) relaxes the remaining constraints. As a side effect, our scheme enables the LNS solving of a constraint satisfaction problem, by transforming it into an optimisation problem, and the faster solving of a difficult-to-satisfy constrained optimisation problem, by finding the initial incumbent faster. This scheme can be used with any CP-based LNS solver. We tested a portfolio of CP-based LNS variants running in parallel, with a multi-armed bandit to select which LNS variant to run. Our results show that this approach is very competitive.

In constraint-based local search, an assignment to the search variables is improved upon by an iterative procedure that replaces the current assignment with a similar assignment. The latter is selected by a heuristic that assesses the qualities of a subset of all similar assignments, where the quality of such assignments is determined via a process called invariant graph propagation. Since, typically, many similar assignments are considered in every iteration, invariant graph propagation must be as efficient as possible. Since invariant graph propagation is independent of the selection heuristic, any comparison between different invariant graph propagation styles under different selection heuristics can be misleading. In this paper, we describe and compare both theoretically and empirically the throughput of several invariant graph propagation styles, and give criteria when one style or another is to be used.

Constraint programming is a widely used paradigm to solve combinatorial problems. High-level constraint modelling languages, such as MiniZinc, GAMS, OPL, and AMPL, encourage the separation of instance parameters and models, where the number of variables and constraints depend on values of instance parameters. This paper investigates an extension of treewidth suitable for studying the complexity high-level constraint models.

The aim of solver-independent modelling is to create a model of a satisfaction or optimisation problem independent of a particular technology. This avoids early commitment to a solving technology and allows easy comparison of technologies. MiniZinc is a solver-independent modelling language, supported by CP, MIP, SAT, SMT, and constraint-based local search (CBLS) backends. Some technologies, in particular CP and CBLS, require not only a model but also a search strategy. While backends for these technologies offer default search strategies, it is often beneficial to include in a model a user-specified search strategy for a particular technology, especially if the strategy can encapsulate knowledge about the problem structure. This is complex since a local-search strategy (comprising a neighbourhood, a heuristic, and a meta-heuristic) is often tightly tied to the model. Hence we wish to use the same language for specifying the model and the local search. We show how to extend MiniZinc so that one can attach a fully declarative neighbourhood specification to a model, while maintaining the solver-independence of the language. We explain how to integrate a model-specific declarative neighbourhood with an existing CBLS backend for MiniZinc.

Integer time series are often subject to constraints on the aggregation of the features of all occurrences of some pattern within the series. For example, the number of inflexions may be constrained, or the sum of the peak maxima, or the minimum of the valley widths. Many time-series constraints can be described by transducers. The output alphabet of such a transducer consists of symbols that denote the phases of identifying the maximal occurrences of a pattern. It was recently shown how to synthesise automatically a constraint propagator and a constraint checker from such a transducer, which however has to be designed manually from a pattern. Here we define a large class of patterns, present an algorithm for automatically generating a low-level transducer from such a high-level pattern, and prove it correct. This class covers all 20 patterns of the Time-Series Constraint Catalogue, which can now be automatically extended at will.

Constraints over finite sequences of variables are ubiquitous in sequencing and timetabling. This led to general modelling techniques and generic propagators, often based on deterministic finite automata (DFA) and their extensions. We consider counter-DFAs (cDFA), which provide concise models for regular counting constraints, that is constraints over the number of times a regular-language pattern occurs in a sequence. We show how to enforce domain consistency in polynomial time for at-most and at-least regular counting constraints based on the frequent case of a cDFA with only accepting states and a single counter that can be increased by transitions. We also show that the satisfaction of exact regular counting constraints is NP-hard and that an incomplete propagator for exact regular counting constraints is faster and provides more pruning than the existing propagator from (Beldiceanu, Carlsson, and Petit 2004). Finally, by avoiding the unrolling of the cDFA used by COSTREGULAR, the space complexity reduces from O(n · |Σ| · |Q|) to O(n · (|Σ| + |Q|)), where Σ is the alphabet and Q the state set of the cDFA.

Within telecommunications development it is vital to have frameworks and systems to replay complicated scenarios on equipment under test, often there are not enough available scenarios. In this paper we study the problem of testing a test harness, which replays scenarios and analyses protocol logs for the Public Warning System service, which is a part of the Long Term Evolution (LTE) 4G standard. Protocol logs are sequences of messages with timestamps; and are generated by different mobile network entities. In our case study we focus on user equipment protocol logs. In order to test the test harness we require that logs have both incorrect and correct behaviour. It is easy to collect logs from real system runs, but these logs do not show much variation in the behaviour of system under test. We present an approach where we use constraint logic programming (CLP) for both modelling and test generation, where each test case is a protocol log. In this case study, we uncovered previously unknown faults in the test harness.

Automata, possibly with counters, allow many constraints to be expressed in a simple and high-level way. An automaton induces a decomposition into a conjunction of already implemented constraints. Generalised arc consistency is not generally maintained on decompositions induced by counter automata with more than one state or counter. To improve propagation of automaton-induced constraint decompositions, we use automated tools to derive loop invariants from the constraint checker corresponding to the given automaton. These loop invariants correspond to implied constraints, which can be added to the decomposition. We consider two global constraints and derive implied constraints to improve propagation even to the point of maintaining generalised arc consistency.

We present a domain for string decision variables of bounded length, combining features from fixed-length and unbounded-length string solvers to reason on an interval defined by languages of prefixes and suffixes. We provide a theoretical groundwork for constraint solving on this domain and describe propagation techniques for several common constraints.

Wireless sensor networks have become increasingly popular for environmental and activity monitoring, such as temperature, pollution, parking space, traffic, and crowd monitoring. Mobile users can collect and visualise sensing data by communicating with wireless sensors along their walks using Bluetooth or NFC. They can also share the sensing data on the Internet through 3G or WiFi connectivity. Nevertheless, mobile users may not be able to collect all the data from the sensors due to limited contact times and batteries. It is crucial to collect data with a maximum amount of information from the available resources. In this paper, we tackle the problem by prioritising the sensing data to maximise the data utility considering the quality of information of the sensing data and the communication overhead. We formulate the optimisation problem and propose a greedy algorithm for clustering the sensors and scheduling the data collection. Our greedy algorithm coordinates the mobile users in the sensing field in order to avoid the collection of redundant sensing data. We evaluate the data utility and energy consumption of the proposed algorithm using real mobility traces from the North Carolina state fair. The results demonstrate that our algorithm can significantly improve data utility at low communication overhead compared with an existing algorithm.

We consider a novel application in wireless sensor networks where mobile phones and wireless sensors can collaborate to collect sensing data. Although mobile phones can perform sensing at different locations, it is a challenge to provide stable sensing quality and availability over the entire area. One approach is to deploy stationary sensors at specific locations to maintain the sensing quality and availability. In this paper, we present a mathematical programming model to minimise the deployment cost by placing a minimum number of sensors at optimal locations. The problem is modelled by integer linear programming considering the sensing capabilities of both the mobile phones and wireless sensors. We evaluated the performance of our solution in terms of sensing quality, number of required sensors, and computation time. The results demonstrate that our approach satisfies the required sensing quality with optimal number of sensors in small sensing fields. It achieves near optimal solution with low computation time for large sensing fields.

We explore the idea of using automata to implement new constraints for local search. This is already a successful approach in constraint-based global search. We show how to maintain the violations of a constraint and its variables via a deterministic

Some constraint problems have a combinatorial structure where the constraints allow the sequence of variables to be rotated (necklaces), if not also the domain values to be permuted (unlabelled necklaces), without getting an essentially different solution. We bring together the fields of combinatorial enumeration, where efficient algorithms have been designed for (special cases of) some of these combinatorial objects, and constraint programming, where the requisite symmetry breaking has at best been done statically so far. We design the first search procedure and identify the first symmetry-breaking constraints for the general case of unlabelled necklaces. Further, we compare dynamic and static symmetry breaking on real-life scheduling problems featuring (unlabelled) necklaces.