Satisﬁability Modulo Theories for Process Systems Engineering

Process systems engineers have long recognized the importance of both logic and optimization for automated decision-making. But modern challenges in process systems engineering could strongly beneﬁt from methodological contributions in computer science. In particular, we propose satisﬁability modulo theories (SMT) for process systems engineering applications. We motivate SMT using a series of test beds and show the applicability of SMT algorithms and implementations on (i) two-dimensional bin packing, (ii) model explainers, and (iii) MINLP solvers.


Introduction
Process systems engineers have long recognized the importance of both logic and optimization for automated decision-making (Jain and Grossmann 2001, Hooker and Ottoson 2003, Maravelias and Sung 2009, Trespalacios and Grossmann 2014).Early work on disjunctive programming is motivated by (i) the practical need to naturally model logical conditions such as dichotomies and implications and (ii) the theoretical insights gained from novel structural characterizations (Balas 1979).Contributions highlighting the importance of both logic and optimization have diverse applications, e.g.spatial layout (Sawaya and Grossmann 2005), modeling contracts in supply chain optimization (Park et al. 2006, Rodriguez andVecchietti 2009), and manufacturing systems (Fattahi et al. 2014).
While process systems engineers have been developing methods at the interface of logic and optimization, the computer science community has also been developing hybrid logic/optimization approaches.Typical computer science applications requiring both logic and optimization are operating system scheduling and motion planning in robotics (Aminof et al. 2011, Raman et  Figure 1: Mixed-integer nonlinear optimization problems (MINLP) may be solved as a series of mixed integer linear optimization problems (MILP).Satisfiability modulo theories problems (SMT) may be solved as a series of propositional satisfiability problems (SAT).
2013, Beaumont et al. 2015).The differences in application domains between process systems engineering and computer science have unfortunately led to a divergence in mathematical developments.
But modern challenges in process systems engineering could strongly benefit from methodological contributions in computer science.In particular, we propose satisfiability modulo theories (SMT) for process systems engineering applications.We motivate SMT using a series of test beds and show the applicability of SMT algorithms and implementations.
Section 2 reviews background in both optimization and logic.Section 3 discusses existing optimization/logic hybrids.Section 4 describes three domains where SMT is highly applicable to PSE: ( §4.1) two-dimensional bin packing, ( §4.2) model explainers, and ( §4.3) SMT-based MINLP solvers.Table 1 summarizes our position that SMT has complementary strengths and weaknesses with respect to mixed-integer nonlinear optimization (MINLP).We propose SMT as a methodology to address several challenges in process systems engineering.We also provide a needs analysis identifying the SMT development required by the process systems engineering community.
Parts of this paper have been previously published, e.g.Callia D'Iddio and Huth (2017) describe the Section 4.3 ManyOpt tool in detail.The purpose and novelty of this paper is to show the broad applicability of SMT to PSE.

Definitions & Background
Section 2.1 fixes variable notation.Sections 2.2 -2.4 review mixed-integer nonlinear optimization (MINLP), propositional satisfiability (SAT), and satisfiability modulo theories (SMT), respectively.Figure 1 diagrams how solving MINLP problems as a series of mixed integer linear optimization problems is analogous to solving SMT problems as a series of SAT problems.

Traditional Community
Computer science

Engineering
Division in developments stemming from divergent applications Logic and optimization requires three variable types: (i) continuous variables x ∈ R n C , (ii) integer variables y ∈ Z n I , and (iii) Boolean (propositional) variables Y ∈ {True, False} n B .Propositional connectives are: ∧ (and), ∨ (or), ¬ (not), → (if. . .then) and ↔ (if and only if).The shorthand i∈I Y i represents that exactly one of the propositional variables Y i is true.

Mixed-Integer Nonlinear Optimization
Traditional mathematical optimization formulations only incorporate continuous and integer variables.MINLP is defined as (Boukouvala et al. 2016): R ∪ {+∞} bound the set of variables N .We assume that it is possible to infer finite bounds on the variables x and that the image of f i is finite on x.

Propositional Satisfiability
Traditional propositional satisfiability only incorporates Boolean variables.SAT is defined: Given a propositional formula ϕ built from the variables Y i , is there a truth assignment that satisfies ϕ?
There exist efficient, satisfiability-preserving transformations from any propositional formula ϕ to conjunctive normal form (CNF), so SAT solvers typically assume that ϕ is written in CNF.In CNF: literals, i.e. propositional variables Y i or their negation ¬Y i , form clauses P j , i.e. disjunctions (∨) of literals.The final propositional formula ϕ = m j=1 P j is a conjunction of clauses.SAT applications include: planning (Kautz and Selman 1992), model checking (Biere et al. 1999) and scheduling (Zhang 2002).Although SAT is N P-complete (Cook 1971) and the worst-case complexity is exponential, modern SAT solvers can handle problems with hundreds of thousands of variables (Malik and Zhang 2009).
Most SAT solvers use the Davis-Putnam-Logemann-Loveland (DPLL) search algorithm (Davis andPutnam 1960, Davis et al. 1962).DPLL fixes variable Y i assignments, i.e. truth assignments, using a tree-based branching approach.DPLL propagates truth assignments to all clauses P j .Propagating truth values may allow DPLL to assign further variables a truth value.If DPLL finds that a partial assignment is unsatisfiable, i.e. cannot satisfy ϕ, then the algorithm backtracks and assigns a different value to one of the variables.DPLL continues until it either: (i) finds a combination of truth values for Y i satisfying ϕ or (ii) proves the formula ϕ is unsatisfiable.DPLL also has functionality supporting warm starts.
SAT solving techniques include (Biere et al. 2009): (i) Boolean constraint propagation, where the current fixed variable set implies variable assignments, (ii) resolution, where sets of clauses derive additional clauses, (iii) and conflict driven clause learning, where an unsatisfiable result derives extra clauses pruning the search tree (Davis and Putnam 1960, Davis et al. 1962, Silva and Sakallah 1996).SAT solving methods are highly applicable to optimization (Hooker andOsorio 1999, Achterberg 2007a).

Satisfiability Modulo Theories
SMT incorporates continuous, integer, and Boolean variables to assess constraint set satisfiability by separating truth value assignment from the correctness reasoning with respect to a theory.SMT consists of: (i) a SAT solver and (ii) a theory solver for a theory of our choice (de Moura and Bjørner 2008a).The SMT approach to constraint satisfaction uses powerful SAT solving to derive a, potentially smaller, set of constraints to assess theory satisfiability.A background theory is a set of axioms and symbols, e.g. the theory of arithmetic.An SMT solver consists of a SAT solver and a theory solver.The idea is to leverage the strength and robustness of modern SAT solvers to search for a feasible solution.The modeling framework exposed by SMT allows for Boolean variables to be used with background theory variables, e.g Y → (x ≥ 0) where x is continuous and Y is Boolean, so SMT is a natural choice when logical decisions form a part of the modeled system.
SMT research dates back to the 1970s with early work on decision procedures (Nelson and Oppen 1979, 1980, Shostak 1979, 1982).Available SMT theories include: Equality with Uninterpreted functions (EUF), linear arithmetic LA, and arrays AR (Biere et al. 1999).Most SMT solvers, e.g.Z3, can also handle nonlinear arithmetic, i.e. polynomial functions.DPLL(T ) generalizes DPLL (Ganzinger et al. 2004).SMT is primarily applied in program verification and formal methods, but it also has scheduling and planning applications (Bjørner and De Moura 2011).SMT provides a (provable) guarantee of feasibility/infeasibility. This is the different from the idea of a feasibility pump that uses heuristics to (hopefully) generate a feasible solution, e.g. in D' Ambrosio et al. (2012).
SMT assesses the satisfiability of a model and, if the model is satisfiable, the SMT solver returns a witness.If the model is unsatisfiable the SMT solver can return an unsatisfiable core, a mutually unsatisfiable subset of model constraints.An unsatisfiable core is a useful tool when addressing why a model does not behave how we expect or to understand why a model fails.Commonly used SMT solvers include Z3 (de Moura and Bjørner 2008a) and MathSAT (Cimatti et al. 2013).
Example 1. Suppose that we wish to satisfy Eq. (1).Equation (1) combines SAT and the theory of real arithmetic.
Then, the real arithmetic theory solver checks the propositional variable meaning.Here, the theory solver deduces that the assignment is incorrect because we cannot have both The theory solver encodes additional propositional clauses, e.g.(¬Y 1 ∨ ¬Y 3 ), augments Eq. ( 2), and passes Eq. ( 3) to the SAT solver: SMT iterates between the SAT and theory solvers until the algorithm terminates, in this case with the point Example 1 suggests that the SAT and theory solvers are disjoint, but the most efficient and stable SMT tools integrate the two components (Sebastiani 2007).Interaction between the theory solver and partial SAT solutions allow the theory solver to identify unsatisfiability in a partial assignment.
The efficacy of an SMT solver depends on the quality of the theory solver since a propositional encoding has to be created for the SAT solver.If the encoding is weak and the theory solver cannot strengthen it effectively, the SMT solver will, in worst case, enumerate all propositional solutions.

Disjunctive Programming
Balas developed disjunctive programming in the 1970s (Balas 1974(Balas , 1975(Balas , 1977(Balas , 1979)).A disjunctive program is given by a linear objective and the disjunction of systems of linear constraints: 4) may be written equivalently as a mixed-integer linear program (MILP) by introducing binary variables y and auxiliary continuous variables x i (Hooker 2002): (5) Disjunctive programming allows model developers to write certain problems more concisely and/or more meaningfully.For example, selecting one element i out of a set i ∈ { 1, . . ., n }, i.e. set partitioning, is a common constraint in process systems engineering: As a disjunctive constraint, Eq. ( 6) is easily identified as a selection constraint: Most approaches for solving disjunctive programs replace propositional variables with binary variables.In the resulting model, y i = 1 implies a set of active constraints and y i = 0 implies associated inactive constraints.Raman and Grossmann (1994) developed generalized disjunctive programming (GDP), an extension of disjunctive programming incorporating nonlinear functions.GDP offers a natural, intuitive framework to model applications with logical dependencies, e.g.(i) job shop scheduling and (ii) process network superstructure design (Türkay andGrossmann 1996, Lee andGrossmann 2000).A GDP is formulated (Grossmann and Ruiz 2012):

Generalized Disjunctive Programming
where f : R n → R, g : R n → R m , and r ik : R n → R p may be nonlinear nonconvex functions.Each disjunction k ∈ K is composed of conjunctions i ∈ D k , i.e. the Eq. ( 7 To leverage existing MINLP solvers and relaxation techniques, GDP models are often reformulated as MINLPs (Ruiz et al. 2012).A GDP model may be reformulated as using either the big-M (Nemhauser and Wolsey 1988) or hull relaxation (Lee and Grossmann 2000) reformulation.Both reformulations replace propositional variables Y ik with binary variables y ik where Y ik = True ↔ y ik = 1.The reformulations also substitute: for Ω(Y ) = True, where Eq. ( 8) corresponds to The big-M reformulation replaces the Eq. ( 7) disjunction with: whereas the hull reformulation uses the constraints: The hull relaxation is at least as tight as big-M but incorporates additional continuous variables (ν ik ).There has been significant research into appropriate algorithms for interesting classes of GDP's (Türkay and Grossmann 1996, Lee and Grossmann 2000, Vecchietti et al. 2003, Ruiz et al. 2012, Trespalacios and Grossmann 2016).

Mixed Logical-Linear Programming
Mixed logical-linear programming (MLLP) is formulated (Hooker and Osorio 1999): Eq. ( 10) splits the constraints into continuous and logical parts, on the left and right of the bar, respectively.The logical part consists of formulas q i (Y , y) where Y ∈ {True, False} n B and y ∈ Z n I .The continuous part is formulated as logical implications such that if p j (Y , y) is true then the constraint A j x ≤ a j is imposed.MLLP models are solved by branching on the propositional variables Y and discrete variables y.As branching takes place, MLLP progressively strengthens the relaxation by enforcing constraints A j x ≥ a j if the corresponding antecedent p j is true.Since the logical part is separated from the continuous part, MLLP enables propositional satisfiability algorithms to derive further logical constraints and prune the search space.
An MLLP model may look different from the equivalent MILP.For many cases, e.g.where MILP binary variables model existence or assignment, MLLP may result in an easier-to-comprehend model with fewer variables.MLLP may be extended to models with nonlinear constraints, i.e. to mixed logical-nonlinear programming (MLNLP) (Türkay and Grossmann 1996, Bollapragada et al. 2001, Bemporad and Giorgetti 2004, 2006, Carbonneau et al. 2011, 2012).

Optimization Methods based on Satisfiability Modulo Theories
Even advances such as GDP (Grossmann and Ruiz 2012) cannot compete with the expressiveness of constraints written in SMT solvers.SMT solvers support logical theories and dependencies, do precise arithmetic, and enable incremental solving.But SMT solvers may have performance issues with division, reasoning over integers, and only limited support for transcendental functions (de Moura and Passmore 2013).MINLP tools support the transcendental functions and scale well for mixed integer reasoning (Carvajal et al. 2014), but MINLP solvers cannot solve incrementally and have limited support for logical constraints and are sensitive to rounding errors.Table 1 summarizes distinctions between SMT and MINLP.
Two of the most prominent SMT-based optimization methods are optimization modulo theories and integer linear programming modulo theories.
Optimization modulo theories integrates optimization and SMT with respect to the theory of linear arithmetic over the rationals (LA(Q)) (Sebastiani and Tomasi 2015).The models are equivalent to MILP problems.Sebastiani and Tomasi (2015) consider different approaches to solve the MILP problems, e.g.offline and inline schemas with linear, binary or adaptive search.Sebastiani and Tomasi (2015) compare optimization modulo theories versus linear GDP using both a convex hull and a big-M relaxation.The comparisons, based on strip packing and job shop scheduling case studies (Sawaya and Grossmann 2005), show that an SMT solver may be used for optimization.
Integer linear programming modulo theories is an optimization framework where MILP, rather than SAT, is leveraged as the efficient solver (Manolios and Papavasileiou 2013).Integer linear programming modulo theories is an optimization framework in which difference logic is used to communicate with the solver.Manolios and Papavasileiou (2013) implement their framework as a constraint handler for the MILP solver SCIP (Achterberg 2007b(Achterberg , 2009)).A weakness of an MILP-based approach is that floating point calculations may lead to wrong answers.Errors based on floating point do not happen in SMT because all formulae evaluate to true or false only.

Logic-Based Benders Decomposition
Hybrid optimization/logic approaches have been developed combining mixed-integer linear programming (MILP) and constraint programming (CP), e.g.Jain and Grossmann (2001), Maravelias and Grossmann (2004), Li and Womer (2008), Sitek (2014), or multiple levels of MILP, e.g.Maravelias (2006).The hybrid formulations usually use logic-based Benders decomposition (LBBD) (Hooker and Ottoson 2003), a generalization of Benders decomposition (Benders 1962).The principles of Benders decomposition remain: we have a master problem and a subproblem which generates cuts if the solution from the master problem is infeasible.The difference is that LBBD requires a logic proof deriving an objective bound.Other hybrid algorithms use branch-and-check (Thorsteinsson 2001) or Lagrangian decomposition (Papageorgiou and Trespalacios 2016).
Hybrid MILP/CP methods are typically applied to scheduling and its variants (Sitek 2014).This is reasonable: CP is very good at assessing scheduling feasibility.The problem with hybrid MILP/CP is that, if the application does not have a suitable CP constraint, a hybrid method may be poor since bespoke CP constraints take full advantage of very specific mathematical structures.This manuscript evaluates satisfiability modulo theories as an alternative to CP in the hybrid scheme.

Satisfiability Modulo Theories for Process Systems Engineering
This section shows the applicability of SMT algorithms and implementations with respect to: (i) two-dimensional bin packing, (ii) model explainers, and (iii) MINLP solvers.

Two-Dimensional Bin Packing
Two-dimensional bin packing (2BP) is the problem: Given a set of rectangular items I. What is the minimum number of rectangular bins with width W and height H needed to pack all items I without overlapping or rotating the items?
This problem has typology class 2BP|O|F (Lodi et al. 1999), i.e. oriented and free cutting.See Table 2 for descriptions of the sets, parameters and variables mentioned in the formulations.

Logical Model
In 2BP a core constraint is: two different items in the same bin should not overlap.A logical formulation naturally captures this if-then relationship as the following model shows. min Equation ( 11a) minimizes the number of active bins.Equation (11b) fixes each item into a single bin.Equation (11c) ensures that any two items in the same bin do not overlap.Equation (11d) states that a bin must be active if it contains items.Equations ( 11e) and (11f) transform Boolean variables to binary variables to form the Eq.(11a) objective.

MILP Models
The MILP formulation (Pisinger and Sigurd 2007) is: Equation ( 12a) minimizes the number of active bins.Equation (12b) states that items are in different bins or that they do not overlap.Equations ( 12c) and (12d) characterize non-overlapping items.Equation (12e) characterizes items being placed in different bins.Equation (12f) assigns the maximal active bin to v. Equation ( 12g) is a symmetry breaking constraint.

Optimizing with SMT
SMT assesses feasibility of a constraint set C. When C is feasible, an SMT solver provides a feasible solution, otherwise SMT derives an unsatisfiable core.A simple iterative approach addresses the Eq. ( 11) optimization problem: Begin by removing the Eq.(11a) optimization objective which results in the Eqs.(11b) to (11h) feasibility problem, let this feasibility problem be F 0 .After solving F 0 with SMT, calculate U 1 , the objective function evaluated at the F 0 feasible solution.Define feasibility problem F 1 by extending i.e. bound the objective function.Repeat this process until the SMT solver proves some F i , i > 0, is infeasible, and thereby conclude that the F i−1 solution is optimal.This iterative approach solves successive feasibility problems to derive a sequence of decreasing objective values {U i }.The difference be-tween feasibility problems F 0 and F i is that F i has additional constraints: The Eq. ( 11) optimization problem may alternatively be addressed via SMT with (i) one of the Section 3.4 optimization frameworks or (ii) a blackbox SMT-based optimization solver (Bjørner et al. 2015, Sebastiani and Trentin 2015, Callia D'Iddio and Huth 2017).The following discussion uses SMT as a feasibility solver to leverage unsatisfiable cores for cut derivation and branching.Our methods are similar to using a logic-based Benders decomposition where the master problem is embedded into the algorithm.

Symmetry in Two-Dimensional Bin Packing
This section develops methods where an SMT solver assesses two decision problems.The first is the two-dimensional orthogonal packing problem (Baker et al. 1980): OPP(I , W, H) ( that questions whether a single bin of width W and height H packs all items in I .The constraints of feasibility problem OPP are the consequent of Eq. (11c) and Eq.(11g).As shorthand, we use OPP (I) since all bins are equivalent.The second decision problem is the 2BP decision problem: that questions whether k or fewer bins each of width W and height H can pack all items in I. To form the D2BP feasibility model, we remove the Eq.(11a) objective from the Eq. ( 11) optimization model and set: Propagating the Eq. ( 16) assignments reduces D2BP to variables and constraints that only involve bins b ∈ {1, . . ., k}.As shorthand, we use D2BP (k)  since our algorithms are only concerned with the number of available bins.Two-dimensional bin packing exhibits symmetry, e.g.permuting bin indices immediately results in an identical packing.For an optimal 2BP solution with objective k, the same solution occurs N k k! times.One approach to break this symmetry is by adding additional constraints, e.g.Eq. (12g).But additional constraints only handle symmetries at a global level and further symmetries arise at a local level when considering OPP.
Descending Strategy.Consider an algorithm that iteratively bounds the objective with Eq. ( 13) constraints.Assume that, in the current iteration, the algorithm checks for (k − 1) bins or fewer.Constraint ( 13) is problematic because it symmetrically allows any subset of (k − 1) active bins, i.e. the SMT solver checks D2BP (k-1) once for each subset of (k − 1) bins.We break the Eq. ( 13) symmetry by adding a constraint to deactivate bins, i.e.Eq. ( 16) sets ¬ζ b .Iteratively introducing Eq. ( 16) is the descending algorithm.Since bin deactivation becomes part of the algorithm, we remove variables z b (and associated constraints) from the Eq. ( 11) formulation.This algorithm aids satisfiability searches because the SMT conflict graph from any previous iteration is always valid in later iterations.
An alternative method is equivalent to binary search.Initialize the algorithm by setting an lower and upper bound on the problem (1 and N ).At each iteration, activate a number of bins that is halfway between the bounds.Update the lower/upper bound depending on whether the halfway problem is unsatisfiable/satisfiable. Terminate when the bounds are equal.We do not use the binary search algorithm because it assesses unsatisfiability, a costly operation for D2BP and therefore heuristically poor for this particular application.Section 4.3.8describes how MINLP solver ManyOpt enables binary search in a more generic context.
Ascending Strategy.While the descending algorithm progressively builds a conflict graph, it can struggle to efficiently prove optimality as symmetry occurs when addressing infeasibilities.For example, if OPP (I') is unsatisfiable for some subset of items I , then having items I in any bin for a D2BP (k) instance is a symmetry in unsatisfiability checks.The lower bounding ascending algorithm reduces symmetry in optimality proofs.This algorithm naturally extends to a branch-and-bound algorithm described in Section 4.1.5.
At a high level, the ascending and descending algorithms are opposites.The descending algorithm initially activates all bins and iteratively deactivates bins until the first unsatisfiable result (optimality proof).The ascending algorithm initially deactivates all but one bin and iteratively activates one additional bin until the first satisfiable (optimal) result, i.e. it assesses D2BP (k) for k = 1, . . ., N (in order) and terminates at the first satisfiable k.
Each unsatisfiable ascending algorithm iteration proves that we need at least one more bin.Also, each unsatisfiable iteration generates an unsatisfiable core.In the 2BP case, any Eq.(11c) constraints in the unsatisfiable core are a conflicting subset of items.Assuming that the k th iteration has k active bins and the items corresponding to Eq. (11c) constraints are {i 1 , . . ., i t }, the unsatisfiable core has the interpretation: items {i 1 , . . ., i t } cannot be packed into k bins.
In iteration (k + 1), the ascending algorithm derives cuts relating to this set of t items and thereby prevents symmetric unsatisfiability assessments.The symmetric property is: any set of items that cannot be packed in the same bin cannot be packed in any bin.Between ascending algorithm iterations, we run intermediate OPP checks on unsatisfiable core subsets and add: for any unsatisfiable result of OPP (I') .The MILP equivalent of Eq. ( 17) is: Eq. ( 17) and ( 18) have the same feasible space, but the Eq. ( 18) cut can lose its logical meaning in an MILP solving strategy with relaxed fractional values.Eq. ( 17) will not combine the I items because Eq. ( 17) is a propositional clause that is not relaxed in the SAT subsolve of an SMT solver.
When deriving the Eq. ( 17) cuts, deciding OPP is expensive for each unsatisfiable core subset since there are exponentially many such subsets.But the many OPP checks may be unnecessary since any unsatisfiable set of items dominates any superset for OPP.We leverage this dominance property by checking all subsets in ascending size order and filtering any dominated supersets.Filtering all subsets of a given size terminates the OPP checks and the ascending algorithm continues by assessing the next iteration (additional bin).Effectively, we're building a dictionary of previously checked subsets to prevent repeat checks.
The Eq. ( 17) cuts aid SMT unsatisfiability proofs by reducing the number of symmetric OPP checks required to assess D2BP.But, if k active bins are sub-optimal, the SMT solver will still have to derive an unsatisfiable core.Building this new core may contain redundant checks that the ascending algorithm has not yet investigated.We aim to (partially) break this symmetry by fixing items and thereby construct a partial optimal solution as the algorithm progresses, as Fig. 2 shows.The unsatisfiable core associated with D2BP (k) implies that we require at least (k + 1) bins to pack the items.Figure 2: How the algorithms fix initial items on iterations 1 and 2. Running the algorithm with one bin may return an unsatisfiable core with two items only (a), this means that these two items must be in their own bins as shown by (b).If later unsatisfiable cores only contain one unfixed item, e.g., (c), then the unfixed item is also placed in a separate bin as shown by (d).
Figure 3: A scenario where we cannot definitively choose an item to fix in the next bin.
The blue items are assigned to their respective bins (the position is not fixed within the bin) and the red (translucent) items are unfixed.Here one of the two red items must be placed in its own bin but we do not know which choice definitely leads to an optimal solution.
If the unsatisfiable core in first iteration (one bin) contains only two items, Fig. 2a, then we pack these items separately, Fig. 2b.On any later iteration, if the corresponding unsatisfiable core reduces to one item after filtering fixed items, then we know that this single unfixed item can be placed in the next bin, Figs.2c and 2d show this for iteration 2. We stop fixing items if, after filtering, the corresponding unsatisfiable core has more than one item.The description above concludes the ascending algorithm definition.this paragraph motivates the branch-and-bound extension described in the next section.The Fig. 2 process simply derives a set of items that must be placed separately in any feasible solution.When we stop fixing items, the corresponding unsatisfiable core, after filtering, contains more than one item.Here the interpretation is: one of the unfixed items must be placed in its own bin, see e.g.Fig. 3.As Fig. 3 shows, to continue fixing items requires assessing alternatives, motivating a branch-and-bound strategy.The second iteration derives unsatisfiable core of unfixed items {1, 2, 4, 6} (the alternative choices for bin 3) and fixes item 1 in bin 3. The third iteration finds fixing items 3, 5 and 1 separately is feasible.The remaining nodes are pruned since a feasible solution equal to their depth has already been found.There are no further branches after pruning, therefore the bottom left branch gives an optimal solution.

SMT Based Branch-and-Bound for 2BP
The branch-and-bound algorithm extends the ascending algorithm of Section 4.1.4by branching on alternative choices from an unsatisfiable core of unfixed items.Figure 4 provides an overview of the structure of the branchand-bound tree.Taking the root node as a special case where we pop an item from the first unsatisfiable core and fix it in the first bin, each node branches on the elements of the unfixed items in its corresponding unsatisfiable core.The branch-and-bound algorithm matches the ascending algorithm up to a chain of unary branches from the root node of the tree.If the branch-andbound algorithm requires a non-trivial decision, e.g.Fig. 3, it forms a set of branches, each of which corresponds to an unfixed item in the current unsatisfiable core.These branches form nodes at some depth d and fix their item into bin (d + 1).An SMT assessment at a given node addresses a slightly stricter version of D2BP since there is an item fixed in each bin, i.e. assessing whether we satisfy 2BP in exactly (d + 1) bins with the corresponding items fixes.Since the depth of a node corresponds to how many bins are active, the branch-and-bound algorithm does not search beyond the depth of any feasible node that it has found.The branch-and-bound algorithm terminates by exhausting each alternative path.
Since the branch-and-bound algorithm extends the ascending algorithm, it still derives Eq. ( 17) cuts in a local setting.Assuming that OPP (I') is unsatisfiable with j ∈ I and j fixed in bin b, the associated local cut is: Furthermore, any local cuts, i.e. cuts depending on a fixed item, are promoted to global cuts by including their corresponding fixed item when the branchand-bound algorithm investigates sibling or ancestor branches.So all Eq. ( 17) cuts can become global regardless of where in the tree they are derived.
Fixing items in the branch-and-bound tree reduces the number of symmetric checks on a given root to leaf path.Adding/promoting Eq. ( 17) cuts aids unsatisfiability proofs across the entire unexplored tree.But assessing alternative branches of a given unsatisfiable core retains the symmetry of bin permutations, hence sibling branches contain identical solutions.The main problem is that, if we have explored a particular branch having fixed item i 1 , then in a sibling branch, having the freedom to select any bin for i 1 includes paths explored by the first branch due to bin permutations.Lemma 1 derives push back cuts that remove this symmetry by forcing explored branch items to be pushed back into earlier bins.
Lemma 1. Assume that the branch-and-bound algorithm is assessing alternatives at some node of depth b − 1, i.e. each of the first b bins have one fixed item, and that this node is unsatisfiable.Let this node have unsatisfiable core of unfixed items I = {i 1 , . . ., i m }, m > 1, i.e. we have to assess each of these items being placed in bin (b + 1).When branching on element i then among all branches the best objective will match that of assessing these alternative branches without adding the Eq.(20) cuts.
Proof.Define OPT k , k ∈ K = {1, . . ., m} as the optimal objective of branch i k with its corresponding Eq. ( 20) cuts.Assume, for a contradiction, that there exists item i k , 1 < k ≤ m such that without adding its Eq. ( 20) cuts, gives optimal objective OPT that satisfies: Let f 1 map items to bins for the OPT solution.We define the set S (items that violate Eq. ( 20)) as: Clearly S is non-empty, otherwise OPT = OPT k ≥ min k∈K {OPT k }.Let k l = min S. We permute the bins such that item k l is in bin b + 1 with corresponding item to bin map: But f 2 is a feasible solution for branch i k l with its associated Eq. ( 20) cuts as k l = min S (note that branch i 1 does not add any cuts).Since f 2 has objective OPT : min contradicting the Eq. ( 21) assumption.
Repeatedly applying Lemma 1 in the branch-and-bound algorithm adds a level of independence between alternative search paths.Eq. ( 20) constraints aid unsatisfiability proofs when branching on later elements of I , since there are a larger number of pushed back items.Furthermore, we automatically remove pushed back items from new branch sets even though they are unfixed, thus reducing the number of branching decisions.Lemma 2 proves that, when pushing back item i, we also can push back all items i that are identical to i.
Lemma 2. Assume that the branch-and-bound algorithm is assessing alternatives at some node of depth (b − 1), i.e. each of the first b bins have one fixed item, and that this node is unsatisfiable.Let this node have unsatisfiable core of unfixed items I = {i 1 , . . ., i m }, m > 1, i.e. we have to assess each of these items being placed in bin (b + 1).Then when we push back item i ∈ I (according to Eq. (20)) we can also push back all items i ∈ I that are identical to i.
Proof.Let item i be identical to i such that i is not fixed or pushed back (the lemma holds trivially for these cases).With item i pushed back according to its Eq. ( 20) constraints, pick any feasible solution with i placed in bin b ≥ b + 1 and let f 1 be the associated item to bin map.Then the following map: permutes bins (b + 1) and b .But f 2 is a feasible solution for the item i branch if we swap identical items i and i .Since branch i contains any feasible solution with item i in bin b ≥ b + 1, we can also push back i as well as i.
Finally, since we only fix a single item per bin, we eliminate mirror and rotational symmetries of fixed items by limiting their center to the lower left quadrant of their bins with the constraints: Equation ( 22) cuts involve the continuous variables, so they correspond to the arithmetic theory solver aspect of an SMT solver.Since SAT solver checks relax the arithmetic theories, these cuts may be less effective in SMT.

Numerical Results
We solve the MILP and SMT models using CPLEX 12.7 and Gurobi 6.0.3, and Z3 4.5.1 (de Moura and Bjørner 2008a), respectively.The MILP models are in Pyomo (Hart et al. 2011(Hart et al. , 2012)), and the Z3 implementation is in Python.All test cases were run on a HP EliteDesk 800 G1 TWR with 16GB RAM and an Intel R Core TM i7-4770 @ 3.40Ghz running Ubuntu 16.04.1 LTS.The test set contains 500 instances grouped into 10 classes.Each class has 10 instances with 20, 40, 60, 80 and 100 items.These instances were originally generated by Berkey and Wang (1987).Martello and Vigo (1998) and Lodi et al. (1999) describe the differences between classes.
Figure 5 is a performance profile comparing time-to-convergence (Dolan and Moré 2002).We compare the descending, ascending and branch-andbound algorithm to CPLEX and Gurobi.We also add a can solve line for the Pisinger and Sigurd (2007) column generation and constaint programming results.We use SMT to assess OPP, Pisinger and Sigurd (2007) use a specialized algorithm for the underlying OPP decision problem, the 'P&S (2007) solved' can solve line in Fig. 5 gives an indication of the kind of performance improvement achieved by using more bespoke methods.We compare against the mixed-integer solvers in the subsequent analysis.The branch-and-bound algorithm performs well and solves most tractable problems within two orders of magnitude of the fastest solve time.The descending algorithm and the mixed-integer solvers perform similarly.The performance difference between the ascending and branch-and-bound algorithms, where the branch-and-bound algorithm solves twice as many instances in the hour, quantifies the effect of 2BP symmetry.Overall, the methods can solve about half of the instances within the hour.For the branch-and-bound algorithm,  this limitation is due to larger instances requiring deeper searches within the tree.Deeper searches require larger unsatisfiable cores when proving unsatisfiability and, for the initial part of the search, there are fewer Eq. ( 17) cuts present to aid such proofs.However, assuming that there has been sufficient exploration, i.e. we have generated push back constraints and symmetry breaking Eq. ( 17) cuts, SMT BB appears to speed up in its later assessments.
Table 3 displays the number of instances optimally solved in each class.The branch-and-bound algorithm generally outperforms the other solvers, but there is a fair amount of differences among classes.Generally, the classes where the branch-and-bound algorithm solves more instances contain larger items, i.e. problems with easy-to-generate unsatisfiability proofs.For classes 2, 4 and 6, where instances contain many small items, all methods exhibit inferior performance.While the optimal objective is smaller for these instances, for SMT the unsatisfiable cores are relatively large and therefore take longer to generate.Our algorithms use SMT as a black box for unsatisfiable core generation, so the branch-and-bound algorithm may not have sufficient time to explore the tree.The relative quality of the branch-and-bound algorithm shows the usefulness of an unsatisfiable core in algorithm design.
Figure 6 shows a performance profile comparing heuristic performance.The descending algorithm is a relatively good heuristic.The descending al-  gorithm progressively reduces the number of available bins, to reduce symmetry, while building a globally applicable conflict graph, that helps in finding heuristic solutions.The ascending algorithm performs less well as its first 'heuristic' solution is an optimal solution, i.e. it has to prove optimality.The branch-and-bound algorithm's heuristic performance is also quite good, this suggests that the tree depth should not be too far from the optimal depth, i.e. the branch-and-bound algorithm does not have to search too far.

Unsatisfiable Core for Cut Generation and Model Explainers
SMT solvers can derive an unsatisfiable core of a constraint set, i.e. a constraint subset that is unsatisfiable.This section discusses cut generation and model explainers as two applications of unsatisfiable cores.

Cut Generation
Logic-based Benders decomposition (LBBD) is a framework for solving problems with master-subproblem structure, e.g. a high level assignment and subproblem assessments resulting from the assignments.In LBBD, the subproblem generates cutting planes to add to the master problem.These cutting planes can be infeasibility cuts which exclude infeasible solutions or lower bounding cuts which enforce an objective bound.
In each major iteration, a subproblem can generate a cut incorporating all of its corresponding assignments, but the resulting cut is often weak because fewer assignments may give an equivalent cut, i.e. a smaller unsatisfiable core.Hooker (2007) develops an approach generating stronger cuts by repeating local subproblem assessments and removing subsets that do not change the underlying result.Hooker (2007) thereby derives a minimal unsatisfiable core, an unsatisfiable core where removing any constraint makes it satisfiable.SMT does not necessarily calculate minimal unsatisfiable cores, but the reported cores may be smaller than the entire assignment set.Smaller cores imply fewer of the expensive local iterations needed to reduce to a minimal unsatisfiable core.

Model Explainers
Practical applications of optimization models and algorithms involve using abstract modeling software.Consider a scenario where a mathematical model is known to be correct and an instance is known to be feasible.If a solver or algorithm states infeasibility, then an implementation needs to be corrected.Here SMT is a useful tool to aid development.Red nodes are unsatisfiable, green nodes are satisfiable and blue nodes are reported unsatisfiable nodes that we know a feasible solution for, i.e. an incorrect conclusion.The error assumed here is that we generate a local cut that item 15 is not in bin 4 at ( ), however the incorrect implementation fails to remove/promote the local cut before switching to branch ( †) giving the wrong conclusion.
A feasible but incorrect model may be over-or under-constrained.Overconstrained models may report an sub-optimal objective or infeasible constraints.Reasoning the incorrectness of a model implementation may be difficult because of various properties, e.g. the instance size or incorrect application of transformation techniques.Analyzing a concrete instance can be a time consuming task since it may have a large number of constraints.But an incorrect model still contains a constraint subset explaining what is wrong, i.e. an unsatisfiable core.
When an incorrect model is over-constrained, it is sufficient to limit our discussion to the infeasible case since, if the model reports a sub-optimal objective, we are questioning why a better objective is infeasible.The unsatisfiable core corresponding to the infeasible model may have many constraints, but we can filter, i.e. eliminate, correct constraints such as variable bounds.After filtering, the constraint subset may be much smaller than the entire instance and analysis becomes easier.If we assume further that we know a feasible solution, we can add constraints fixing variables to this solution.Fixing variables may produce an unsatisfiable core in terms of the feasible solution that we fed to the model.Fixing a solution is more useful when the incorrect model reports the wrong optimal objective (here we would need to know a feasible solution that is better than the reported optimal objective).
Another, more likely case for elusive bugs is when we have an algorithm that adds and removes constraints, i.e. an issue may only occur for larger instances.Compulsory computational considerations may be a reason for having such a case, e.g. a given node of a branch-and-bound algorithm can add and remove constraints to an existing instance, or build a fresh instance.However, we may prefer the former when considering the computational cost of building a fresh instance.Figure 7 provides a concrete example in the context of the branch-and-bound algorithm of Section 4.1.5.The incorrect implementation assumed here is that local cuts are not removed when switching to branches where they are no longer valid.As Fig. 7 shows, we get a reported optimal objective of 5 when we should get 4.After filtering constraints at ( †) in Fig. 7, e.g.variable bounds and inactive bins, an unsatisifable core consists of only 7 constraints among which are constraints generated by the algorithm.In particular, we have the constraint item 15 is not in bin 4, the significance of this constraint is that it corresponds to a local cut generated at ( ) therefore it is no longer valid telling us that there is an issue with handling of local cuts.The fact that we can limit our view to just a few constraints makes this error easier to find.Given just the result 'infeasible', finding such an error may require multiple re-solves with minor source code changes or log file parses, both of these tasks are time consuming (more so if the only failing instances are large).

νZ
The νZ extension to the SMT solver Z3 adds optimization functionality (Bjørner andPhan 2014, Bjørner et al. 2015).νZ addresses weighted Max-SAT/SMT and linear arithmetic problems.νZ also supports multi-objective optimization via: lexicographic, Pareto fronts and box objectives.The νZ algorithms resemble the Nieuwenhuis and Oliveras (2006) approach, but, instead of implementing additional rules, νZ updates a variable value as the search progresses.The solver also has a resolution-based approach that reasons based on the unsatisfiable core (Narodytska and Bacchus 2014).Bjørner and Phan (2014) solve the MILP subproblems by using SMT to find a feasible solution and invoking the simplex algorithm to minimize under the given integral assignment, the integral assignment is then rejected and a bounding constraint is placed on the objective.

OptiMathSAT
OptiMathSAT (Sebastiani and Trentin 2015) extends the SMT solver MATSAT5 (Cimatti et al. 2013).The optimization capabilities are similar to νZ, but the optimization constraints are formulated differently.Sebastiani and Tomasi (2015) compare OptiMathSAT to a GDP framework and show that the solver is competitive with the state-of-the-art.

Symba
Symba (Li et al. 2014) is built on top of Z3, but its implementation differs from νZ.Symba optimizes for linear real arithmetic (not limited to rational) however it does not support strict inequalities.The optimization process maintains a triple M, U, O where M is a set of models, U is an underapproximation and O is an overapproximation.The inference rules correspond to initialization, checking for unboundedness and tightening the under and over approximations.Symba only uses Z3 as a black box.

ManyOpt
ManyOpt (Callia D'Iddio and Huth 2017) is a deterministic -global optimization MINLP solver that extends SMT solving.ManySAT (Hamadi et al. 2009) inspires the ManyOpt design.The hypothesis is that no single method wins on a varied class of optimization problems.Therefore, ManyOpt parallelizes different approaches on a problem input and speeds up solving time by returning the first to "win" on that input.The ManyOpt solver is presented elsewhere, e.g.Callia D' Iddio and Huth (2017).The discussion here describes the relationship to the PSE community.

ManyOpt Tool Architecture
Figure 8 diagrams the ManyOpt structure.As input, ManyOpt takes (i) a relative optimality tolerance for the computed global optimum and (ii) an OSiL model (Fourer et al. 2010) of an MINLP problem.Since ManyOpt relies on exisiting SMT solvers, all nonlinearities must be polynomial.Then, ManyOpt executes in parallel a set of dataflows on the OSiL input.As shown in Fig. 8, one orange block is effectively a single feature and a feature vector is a selection of at least one feature from each layer, i.e. a feature vector realizes configurable tool layers.A feature is a particular method and a feature vector represents combining features to create an SMT-based optimizer.The tool layers are: pre-processing, integrality management, continuous relaxation optimization, and feasibility checking.Each layer contains an extensible feature list.For each feature vector, the data flow illustrated in Fig. 8 is: • SMTLIB 2.0 representation This layer transforms the OSiL input into several SMTLIB 2.0 representations.These representations reflect the different feature vectors that will subsequently compete in parallel.
• Pre-processing SMT solving is rooted in SAT solving, so Boolean variables Y ∈ {True, False} n B are most natural to SMT.Recognizing that binary variables approximate Boolean variables better than general integer variables, this phase may transform the SMTLIB 2.0 representation from an MINLP formulation allowing general integer variables to a formulation where all discrete variables are binary.Section 4.3.6 discusses the binarization and binarized flattening techniques.
• Integrality management This layer, the first of three in the main optimization process, develops logical equivalents of branch-and-bound.Section 4.3.7 discusses the one-by-one and all-in-one approaches.This layer produces a continuous relaxation on integer and binary variables only.The propositional formulas are not relaxed.The layer subsequently relies on the continuous relaxation optimization layer to solve them.SMT solvers typically accept nonlinear arithmetic coupled with Boolean constraints, so this layer transforms the MINLP into problem(s) the SMT solvers can handle.
• Continuous relaxation optimization This layer takes a nonlinear optimization problem with propositional formulas and reduces it to a series of feasibility checks, i.e.SMT solves.Section 4.3.8describes the naive, unbounded binary search, and hybrid features.
• Feasibility checking An SMT solver, using an SMTLIB 2. Many of the ManyOpt features mimick techniques familiar from MINLP optimization, but the ManyOpt approach tends to delegate algorithmic aspects to the SMT solver and focus on declarative aspects.In other words, ManyOpt solves MINLP by solving a series of SMT problems rather than directly developing the algorithmic machinery present in most MINLP solvers.

ManyOpt Pre-Processing Features
Disabled.The MINLP can be directly sent to the main optimization process.
Binarized flattening.An alternative to (algorithmic) branch-and-bound declaratively flattens the integer variables during the pre-processing stage, thus moving algorithmic complexity to the SMT solvers via the logical OR (∨) operator.In other words, binarized flattening reformulates all integer variables x ∈ Z with x LO ≤ x ≤ x UP into a continuous variable x ∈ R and Eq. ( 23) introduces one OR operator for each integer in the range [x LO , x UP ].
Binarization and binarized flattening.We can combine binarization and binarized flattening using 1 + log 2 (x UP − x LO ) OR operators.

ManyOpt Integrality Management Features
If the pre-processing layer uses the binarized flattening feature or if there are no discrete variables in the optimization problem, then this layer is irrelevant.Otherwise, this layer performs the same function as a standard branch-and-bound approach by developing a new constraint or set of constraints that enforce any integrality violated in the feasibility checking layer.
Disabled.Disabling integrality management delegates enforcing integrality to the feasibility checking layer, where SMT solvers can attempt to manage this -for example with integer type variables.
One-by-one.If a relaxed solution violates at least one integrality constraint, choose one variable x whose value v violates an integrality constraints and add the assertion x ≤ v ∨ x ≥ v to the optimization problem.Since disjunctions are supported in SMT as assertions, this avoids splitting into two optimization problems by delegating combinatorial complexity to the SAT engine of the SMT solver.
All-in-one.The one-by-one approach only adds one assertion per iteration, but SMT solvers permit adding more than one constraint at a time.The all-in-one approach collects all variables whose values violate integrality constraints in a feasible solution and adds the above disjunction as an assertion for all such variables simultaneously.

ManyOpt Continuous relaxation optimization features
This layer provides algorithms to solve nonlinear optimization problems with propositional formulas.ManyOpt supports: the naive method (Eén and Sörensson 2006), the unbounded binary search method (Beaumont et al. 2015, Callia D'Iddio andHuth 2017), and a hybrid combination of these two methods (Callia D'Iddio and Huth 2017).
Naive.The naive approach is equivalent to the Section 4.1.4descending strategy.It consists of a loop in which the feasibility checker (i) finds a value for the objective function and (ii) attempts to find a lower value by adding an assertion that the objective function must be smaller than that value, e.g.Eén and Sörensson (2006).When the problem becomes infeasible, the last found objective value, if there is one, is the optimal solution.Unbounded binary search.This method has two main phases: 1.The bounds search which establishes initial lower and upper bounds on the objective value.The optimal value is between these bounds.
2. The bisection phase, in which the interval between the lower and upper objective bound is split in two equal parts, until the optimal value of the objective is found, relative to the specified accuracy.
Hybrid method.This modifies unbounded binary search so that in each phase a naive step decides if the current value is optimal and the method can stop.

Manyopt experimental results
ManyOpt is not directly comparable to other MINLP solvers in the process systems engineering literature, e.g.ANTIGONE (Misener and Floudas 2014), because it has a different set of capabilities.ManyOpt relies on exact, rational arithmetic in an SMT solver, so it is robust to floating point rounding errors.In the Neumaier (2004) classification, ManyOpt is a rigorous method.Meanwhile, ANTIGONE (Misener and Floudas 2014) relies on floating point arithemtic in a linear programming solver and is therefore a complete method (Neumaier 2004), i.e.ANTIGONE assumes exact computations.At this writing, most SMT solvers only support nonlinearity in the form of polynomials.Since ManyOpt relies on the SMT solvers, it does not currently support transcendental functions.

Warm-starting enables what-if scenarios.
ManyOpt calls an SMT solver, so it directly inherits the warm-start capabilities of SMT.To see the advantage of warm-starting an MINLP solver, consider prob03 from MINLPLib2: min Solving prob03, ManyOpt accurately gives an objective value of 10 (x 1 = x 2 = 2).But what if, after inspecting the solution, we want to also add the constraint x 1 ≤ x 2 − 1?In ManyOpt, we can immediately add the constraint and, after warm-starting, get the new optimal objective value of 11 (x 1 = 1, x 2 = 4).Of course, an alternative (and the only option in most MINLP solvers) is to cold-start a new MINLP problem.
In the case of prob03, ManyOpt uses 37 calls to SMT solver Z3 for the initial solve and 19 additional Z3 calls for the warm-start.For a cold-start of the new problem, ManyOpt requires 39 Z3 calls.So, for prob03, using the warmstarting utility in ManyOpt saves 20 Z3 calls.Of course, SMT solvers use exponential algorithms, so there is no guarantee that warm-starting ManyOpt will improve performance.But the core ManyOpt strategy is to parallelize different approaches to a problem input, so the warm-starting utility offers a possibility of returning more quickly by giving more feature vectors.
ManyOpt has more opportunities to benefit from warm-starting if the problem has many integer variables.
Warm-starting enables model exploration.When solving the classical pooling problem haverly in MINLPLib2 with a relative optimality tolerance of 10 −6 , ManyOpt returns an objective value of -399.9997.The known optimal objective value is -400 and ManyOpt is correct with respect to the tolerance.Investigating a solution, ManyOpt also returns some small values for flows within the network, e.g.x 3 = 125/33554432, x 6 = x 8 = 1/4096.As engineers, we may wish to know: (i) are those flow effectively 0? or (ii) will setting those flows to 0 somehow damage the best feasible solution?In ManyOpt, we can set those three variables to 0, i.e. x 3 = x 6 = x 8 = 0, and warm-start the solver.The returned solution, with objective value −399.9999,shows that those flows are effectively 0.
Other experimental results.Appendix A gives some experimental results for MINLPLib (Bussieck et al. 2003) benchmarks solved by ManyOpt.The results show that ManyOpt is an effective MINLP solver and that ManyOpt can be used on a wide range of test instances.ManyOpt is frequently slower than state-of-the-art MINLP solvers, but it offers the trade-off of a completely different method to address the problem.

Conclusion
This manuscript proposes applying satisfiability modulo theories to process systems engineering.We motivate our position using three test beds: (i) two-dimensional bin packing, (ii) model explainers, and (iii) MINLP solvers.

Statistics for solved benchmarks
MINLP) where M, N , and I represent sets of constraints, variables, and discrete variables, respectively.The objective and constraints are functions f i : R N → R ∀ i ∈ {0, . . ., M }.Parameters b LO i ∈ R ∪ {−∞} and b UP i ∈ R ∪ {+∞} bound the set of constraints M; parameters x LO j ∈ R ∪ {−∞} and x UP j ∈ ) square brackets.Each conjunction has a Boolean variable Y ik , inequality r ik (x) ≤ 0, and cost variable c k .If Y ik = True then the formulation enforces both r ik (x) ≤ 0 and c k = Y ik .Otherwise they are ignored.Propositional formula Ω(Y ) = True typically contains an exclusive disjunction assumption i∈D k Y ik for each k ∈ K.The exclusive disjunction assumption ensures correctness by restricting c k to a single Y ik .

Figure 4 :
Figure4: An example branching tree for an instance with optimal objective 3.Each node contains an item i and a node's depth, d, corresponds to fixing item i in bin d + 1. Crossed nodes are pruned.In this instance the first iteration fixed items 3 and 5 in bins 1 and 2. The second iteration derives unsatisfiable core of unfixed items {1, 2, 4, 6} (the alternative choices for bin 3) and fixes item 1 in bin 3. The third iteration finds fixing items 3, 5 and 1 separately is feasible.The remaining nodes are pruned since a feasible solution equal to their depth has already been found.There are no further branches after pruning, therefore the bottom left branch gives an optimal solution.

Figure 5 :
Figure 5: Performance profile for 500 bin packing instances.Each solver has a timelimit of one hour.All solvers are limited to one thread.P&S (2007) is the number of problems thatPisinger and Sigurd (2007) solve to optimality.

Figure 6 :
Figure 6: Performance profile for 500 bin packing instances comparing heuristic times to optimality.Each solver has a timelimit of one hour.All solvers are limited to one thread.

Figure 7 :
Figure7: An example of a Section 4.1.5branch-and-bound tree where an incorrect implementation requires correction.Red nodes are unsatisfiable, green nodes are satisfiable and blue nodes are reported unsatisfiable nodes that we know a feasible solution for, i.e. an incorrect conclusion.The error assumed here is that we generate a local cut that item 15 is not in bin 4 at ( ), however the incorrect implementation fails to remove/promote the local cut before switching to branch ( †) giving the wrong conclusion.

Figure 8 :
Figure 8: The architecture, approach, and dataflow of ManyOpt (Callia D'Iddio and Huth 2017).Section 4.3.5 describes how each layer (yellow block) contains a number of possible features (orange blocks).A feature vector is a specific choice of a feature (or features) from each layer.ManyOpt competes many feature vectors in parallel.

Table 1 :
Complementary strengths in SMT/MINLP inspire applying SMT to PSE

Table 2 :
Model symbols for the two-dimensional bin packing (2BP) problem.
ij Activity of disjunct i, j, k, Binary x i , y i Lower left coordinate of item i v Largest active bin index