A Unified Framework for Symmetry Handling

Handling symmetries in optimization problems is essential for devising efficient solution methods. In this article, we present a general framework that captures many of the already existing symmetry handling methods. While these methods are mostly discussed independently from each other, our framework allows to apply different methods simultaneously and thus outperforming their individual effect. Moreover, most existing symmetry handling methods only apply to binary variables. Our framework allows to easily generalize these methods to general variable types. Numerical experiments confirm that our novel framework is superior to the state-of-the-art symmetry handling methods as implemented in the solver SCIP on a broad set of instances.


Introduction
We consider optimization problems OPT(f, Φ) := min{f (x) : x ∈ Φ} for a real-valued function f : R n → R and feasible region Φ ⊆ R n such that OPT(f, Φ) can be solved by (spatial) branch-and-bound (B&B) [1,2].This class of problems is very rich and captures problems such as mixed-integer linear programs and mixed-integer nonlinear programs.The core of B&B-methods is to repeatedly partition the feasible region Φ into smaller subregions Φ ′ and to solve the reduced problem OPT(f, Φ ′ ).Subregions do not need to be explored further if it is known that they do not contain optimal or improving solutions (i.e., pruning by bound), or if the region becomes empty (i.e., pruning by feasibility).The sketched mechanism allows to routinely solve problems with thousands of variables and constraints.If symmetries are present, however, plain B&B usually struggles with solving optimization problems as we explain next.
A symmetry of the optimization problem is a bijection γ : R n → R n that maps solution vectors x ∈ R n to solution vectors γ(x) while preserving the objective value and feasibility state, i.e., f (x) = f (γ(x)) holds for all x ∈ R n and x ∈ Φ if and only if γ(x) ∈ Φ. Resulting from this definition, the set of all symmetries of an optimization problem forms a group Γ.When enumerating the subregions Φ ′ in B&B, it might happen that several subregions at different parts of the branch-andbound tree contain equivalent copies of (optimal) solutions.This results in unnecessarily large B&B trees.By exploiting the presence of symmetries, one could enhance B&B by finding more reductions and pruning rules that further restrict the (sub-)regions without sacrificing finding optimal solutions to the original problem [3][4][5].
To handle symmetries, different approaches have been discussed in the literature.Two very popular classes of symmetry handling methods are symmetry handling constraints (SHCs) [4,[6][7][8][9][10][11][12][13][14] and variable domain reductions (VDRs) derived from the B&B-tree [15][16][17].Both approaches remove symmetric solutions from the search space without eliminating all optimal solutions.As we detail in Section 2, SHCs and VDRs come with a different flavor.SHCs usually use a static scheme for symmetry reductions, whereas VDRs dynamically find reductions based on decisions in the B&B-tree.In their textbook form, SHCs and VDRs are thus incompatible, i.e., they cannot be combined and that might leave some potential for symmetry reductions unexploited.Moreover, many SHCs and VDRs have only been studied for binary variables and for symmetries corresponding to permutations of variables, which restricts their applicability.
The goal of this article is to overcome these drawbacks.We therefore devise a unified framework for symmetry handling.The contributions of our framework are that it (C1) resolves incompatibilities between SHCs and VDRs, (C2) applies for general variable types, and (C3) can handle symmetries of arbitrary finite groups, which are not necessarily permutation groups.
Due to C1, one is thus not restricted anymore to either use SHCs or VDR methods.In particular, we show that many popular VDR techniques for binary variables such as orbital fixing [17] and isomorphism pruning [16,18], but also SHCs can be simultaneously cast into our framework.That is, our framework unifies the application of these techniques.To fully facilitate our framework regarding C2, the second contribution of this paper is a generalization of many symmetry handling techniques from binary variables to general variable types.This allows for handling symmetries in more classes of optimization problems, in particular classes with non-binary variables.
Regarding C3, we stress that this result is not based on the observation that every finite group is isomorphic to a permutation group by Cayley's theorem [19], because the space in which the isomorphic permutation group is acting might differ from R n .
Outline After providing basic notations and definitions, Section 2 provides an overview of existing symmetry handling methods.In particular, we illustrate the techniques that we will later on cast into our unified framework.The framework itself will be introduced in Section 3. Section 4 shows how existing symmetry handling methods can be used in our framework and how these methods can be generalized from binary to general variables.We conclude this article in Section 5 with an extensive numerical study of our new framework both for specific applications and benchmarking instances.The study reveals that our novel framework is substantially faster than the state-of-the-art methods on both SHCs and VDRs as implemented in the solver SCIP.

Notation and Definitions
Throughout the article, we assume that we have access to a group Γ consisting of (not necessarily all) symmetries of the optimization problem OPT(f, Φ).That is, Γ is a subgroup of Γ, which we denote by Γ ≤ Γ.We refer to Γ as a symmetry group of the problem.For solution vectors x ∈ R n , the set of symmetrically equivalent solutions is its Γ-orbit {γ(x) : γ ∈ Γ}.
In practice, the symmetry group Γ is either provided by a user or found using detection methods such as in [5,20].Detecting the full permutation symmetry group for binary problems, however, is NP-hard [21].For non-linear problems, depending on how the feasible region Φ is given, already verifying if γ is a symmetry might be undecidable [4].
To handle symmetries, among others, we will make use of variable domain propagation.The idea of propagation approaches is, given a symmetry reduction rule and domains for all variables, to derive reductions of some variable domains if every solution adhering to the symmetry rule is contained in the reduced domain.More concretely, let Φ ′ be the feasible region of some subproblem encountered during branch-and-bound.For every variable x i , i ∈ [n], let D i ⊆ R be its domain, which covers the projection of Φ ′ on x i , i.e., D i ⊇ {v ∈ R : x i = v for some x ∈ Φ ′ }.In an integer programming context, the domain D i corresponds to an interval in practice.A symmetry reduction rule is encoded as a set C ⊆ R n , which consists of all solution vectors that adhere to the rule.The goal of variable domain propagation is to find sets In this case, the domain of variable x i can be reduced to D ′ i .We say that propagation is complete if, for every i ∈ [n], domain D ′ i is inclusionwise minimal.
Throughout this article, we denote full B&B-trees by B = (V, E), i.e., we do not prune nodes by their objective value and do not apply enhancements such as cutting planes or bound propagation.This is only required to prove theoretical statements about symmetry handling and does not restrict their practical applicability as we will discuss below.If not mentioned differently, we assume B to be finite, which might not be the case for spatial branch-and-bound; the case of infinite B&B-trees will be discussed separately.For β ∈ V, let χ β be the set of its children and let Φ(β) ⊆ Φ be the feasible solutions at β, i.e., the intersection of Φ and the branching decisions.If β is not a leaf, we assume that Φ(ω), ω ∈ χ β , partitions Φ(β).In our definitions, this is even the case for spatial branch-and-bound, meaning that the partitioned feasible regions are not necessarily closed sets.We will discuss the practical consequences of this assumption below.

Overview of symmetry handling methods for binary programs
This section provides an overview of symmetry handling methods.The methods lexicographic fixing, orbitopal fixing, isomorphism pruning, and orbital fixing are described in detail, because we will later on show that these methods can be cast into our framework and can be generalized from binary to arbitrary variable domains.Further symmetry handling methods will only be mentioned briefly.We illustrate the different methods using the following running example.[22] consider the Noise Dosage Problem (ND).There are p machines, and on every machine a number of tasks must be executed.For machine i ∈ [p], there are d i work cycles, each requiring t i hours of operation, and each such work cycle induces α i units of noise.There are q workers to be assigned to the machines, each of which is limited to H hours of work.The problem is to minimize the noise dosage of the worker that receives the most units of noise.We extend this problem definition with the requirement that each worker can only be assigned once to the same machine, which makes the problem a binary problem (NDB), namely to minimize η, (NDB1)

Problem 1 (NDB). Sherali and Smith
α i ϑ i,j for all j ∈ [q], (NDB2) For a solution, ϑ represent the worker schedules in a p × q binary matrix.The value of variable ϑ i,j states how many tasks on machine i are allocated to worker j.Since all workers have the same properties in this model, symmetrically equivalent solutions are found by permuting the worker schedules.This corresponds to permuting the columns of the ϑ-matrix.As such, a symmetry group of this problem is the group Γ consisting of all column permutations of this p × q matrix.
For illustration purposes, we focus on an NDB instance with p = 3 machines and q = 5 workers.We stress that the symmetry handling methods work even if variable domain reductions inferred by the model constraints are applied.For the ease of presentation, however, we assume no such reductions are made in the NDB problem instance.For this reason, we do not specify d i , t i , and H.

Symmetry handling constraints based on lexicographic order
The philosophy of symmetry handling constraints (SHCs) is to restrict the feasible region of an optimization problem to representatives of the Γ-orbits of feasible solutions.A common way to do this, is to enforce that feasible solutions must be lexicographically maximal in their Γ-orbit [7].
Let x, y ∈ R n .We say x is lexicographically larger than y, denoted x ≻ y, if for some k ∈ [n] we have x i = y i for i < k, and x k > y k .If x ≻ y or x = y, we write x y.Since the lexicographic order specifies a total ordering on R n , to solve the optimization problem OPT(f, Φ), it is sufficient to consider only those solutions x that are lexicographically maximal in their Γ-orbit.Let Then, solving OPT(f, Φ ∩ X ) yields the same optimal objective and the same feasibility state as the original problem.Note, however, that deciding whether a vector x ∈ {0, 1} n is contained in X is coNP-complete [23].Complete propagation of the SHCs X is thus coNP-hard for general groups.
In practice, one therefore either neglects the group structure or applies specialized algorithms for particular groups [6,24].We discuss lexicographic fixing and orbitopal fixing as representatives for these two approaches.

Lexicographic fixing (LexFix)
Instead of handling x γ(x) for all γ ∈ Γ, one can handle this SHC for a single permutation γ only.For binary problems, [25] shows that x γ(x) is equivalent to the linear inequality n k=1 2 n−k x k ≥ n k=1 2 n−k γ(x) k .Due to the large coefficients, however, these inequalities might cause numerical instabilities.To circumvent numerical instabilities, [9] presents an alternative family of linear inequalities modeling x γ(x) in which all variable coefficients are either 0 or ±1 and that can be separated efficiently.
Alternatively, x γ(x) can also be enforced using a complete propagation algorithm that runs in linear time [24,26].Since a variable domain reduction in the binary setting corresponds to fixing a variable, we refer to this algorithm as the lexicographic fixing algorithm, or LexFix in short.
Using our running example NDB, we illustrate the idea of LexFix for the permutation γ that exchanges column 2 and 3 and fixes all remaining columns.Since the lexicographic order depends on a specific variable ordering, we assume that the variables of the ϑ-matrix are sorted row-wise.That is, x = (ϑ 1,1 , . . ., ϑ 1,5 ; . . .; ϑ 3,1 , . . ., ϑ 3,5 ).We omit η from the vector, since the orbit of η is trivial with respect to Γ.
When removing fixed points of the solution vector from γ, enforcement of ). Complete propagation of that constraint for the running example is shown in Figure 1.For instance, in the leftmost node, ϑ 1,3 can be fixed to 0, because any solution with ϑ 1,3 = 1 and satisfying the remaining local variable domains violates the lexicographic order constraint as

Orbitopal fixing
Note that LexFix neglects the entire group structure and thus might not find variable domain reductions that are based on the interplay of different symmetries.Since propagation for X is coNP-hard, special cases of groups have been investigated that appear very frequently in practice.One of these groups corresponds to the symmetries present in NDB, i.e., the symmetry group Γ acts on p × q matrices of binary variables by exchanging their columns.We refer to such matrix symmetries as orbitopal symmetries.Besides in NDB, orbitopal symmetries arise in many further applications such as graph coloring or unit commitment problems [6,10,27].
For the variable ordering discussed in Section 2.1.1 and Γ being a group of orbitopal symmetries, one can show that enforcing x γ(x) for all γ ∈ Γ is equivalent to sorting the columns of the variable matrix in lexicographically non-increasing order.Bendotti et al. [6] present a propagation algorithm for such symmetries, so-called orbitopal fixing.Kaibel et al. [10] discuss a propagation algorithm for the case that each row of the variable matrix has at most one 1-entry.Both algorithms are complete and run in linear time.Moreover, Kaibel and Pfetsch [11] derive a facet description of all binary matrices with lexicographically sorted columns and at most (or exactly) one 1-entry per row.That is, the SHC X can be replaced by the facet description in this case.
Given initial variable domains D ⊆ {0, 1} p×q , the algorithm of Bendotti et al. finds the tightest variable domains as follows.First, the lexicographically minimal and maximal matrices in X ∩ D are computed.Then, for each column in the variable matrix, the associated variables can be fixed to the value of the lexicographically extreme matrices up to the first row where these extremal matrices differ.If the columns of the extremal matrices are identical, the whole column can be fixed.
Applying orbitopal fixing then leads to the leftmost matrix in Figure 2.
Note that orbitopal fixing does not find any variable domain reduction after the first branching decision in Figure 2. The reason is that branching occurred for a variable in the second row.To still be able to benefit from some symmetry reductions in this case, Bendotti et al. [6] also discuss a variant of orbitopal fixing that adapts the order of rows based on the branching decisions.They empirically show that this adapted algorithm performs better than the original algorithm for the unit commitment problem.We discuss the adapted variant in more detail and with more flexibility in terms of our new framework in Section 3 in Example 12.

Symmetry reductions based on branching tree structure
Recall that the SHCs discussed in the previous section restrict the feasible region of an optimization problem.That is, already before solving the optimization problem, it is determined which symmetric solutions are discarded.A second family of symmetry handling techniques uses a more dynamic approach, which prevents to create symmetric copies of subproblems already created in the branch-and-bound tree.The motivation of this is that symmetry reductions can be carried out earlier than in a static setting as described in the previous section.Throughout this section, let B = (V, E) be a branch-and-bound tree, where branching is applied on a single variable.For a node β ∈ V, let B β 0 (resp.B β 1 ) be the set of variable indices of a solution vector that are fixed to 0 (resp.1) by the branching decisions on the rooted tree path to β.Moreover, we assume Φ ⊆ {0, 1} n as the techniques that we describe next have mostly been discussed for binary problems.

Isomorphism pruning
In classical branch-and-bound approaches, a node can be pruned if the corresponding subproblem is infeasible (pruning by infeasibility) or if the subproblem cannot contain an improving solution (pruning by bound).In the presence of symmetry, Margot [15,18] and Ostrowski [16] discuss another pruning rule that discards symmetric or isomorphic subproblems, so-called isomorphism pruning.
The least restrictive version of isomorphism pruning is due to Ostrowski [16].Note that the way how we phrase isomorphism pruning differs from the notation in [16].In terms of our unified framework that we discuss in Section 3, however, our notation is more suitable.
Let β ∈ V be a branch-and-bound tree node at depth m, and suppose that every branching decision corresponds to a single variable fixing.Let i k be the index of the branching variable at depth k ∈ [m] on the rooted path to β.Then, B β 0 ∪ B β 1 = {i 1 , . . ., i m }.Let π β ∈ S n be any permutation with π β (i k ) = k for k ∈ [m] and let y ∈ {0, 1} n such that y i = 1 if and only if i ∈ B β 1 .For a vector x ∈ R n and A ⊆ [n], we denote by x A its restriction to the entries in A.
Theorem 2 (Isomorphism Pruning).Let β ∈ V be a node at depth m.Node β can be pruned if there Testing if a vector is lexicographically maximal in its orbit is a coNP-complete problem [23].As such, deciding if β can be pruned by isomorphism is an NP-complete problem.Remark 3. Margot [27] also describes a variant of isomorphism pruning that can be used to handle symmetries of general integer variables.Margot's variant assumes a specific branching rule.We do not describe it in more detail as our framework can also handle general integer variables while not relying on any assumptions on the branching rule such as Ostrowski's version for binary variables.
Note that isomorphism pruning is a pruning method, which means that it does not find reductions.However, isomorphism pruning can be enhanced by fixing rules that allow to find additional variable fixings early on in the branch-and-bound tree as we discuss next.
Figure 4: Branch-and-bound tree for the NDB problem with fixings by orbital fixing.

Orbital fixing
Orbital fixing (OF) refers to a family of variable domain reductions (VDRs), whose common ground is to fix variables within orbits of already fixed variables.The exact definition of OF differs between different authors [15,17].The main difference is whether fixings found by branching decisions are distinguished from fixings found by orbital fixing.We describe the variant [17, Theorem 3], which is compatible with isomorphism pruning.Let β ∈ V.The group consisting of all permutations that stabilize the 1-branchings up to node β is denoted by all variables in the ∆ β -orbit of i can be fixed to 0. Figure 4 shows the branch-and-bound tree for applying this orbital fixing rule to the running example.Note that, if up to node β no variables are branched to one, ∆ β corresponds to the symmetry group Γ.This means that for zero-branchings its whole orbit of Γ (the corresponding row in ϑ) can be fixed to zero.
Since [17] does not distinguish variables fixed to 1 by branching or other decisions, ∆ β can be replaced by all permutations that stabilize the variables that are fixed to 1 (opposed to just branched to be 1).Note that neither definition of ∆ β contains the other, i.e., neither version of OF dominates the other in terms of the number of fixings that can be found.Another variant of OF that also finds 1-fixings is presented in [16], see also [5].

Further symmetry handling methods
Liberti and Ostrowski [14] as well as Salvagnin [28] present symmetry handling inequalities that can be derived from the Schreier-Sims table of group.Further symmetry handling inequalities are described by Liberti [13].In contrast to the constraints from Section 2.1, they are also able to handle symmetries of non-binary variables; their symmetry handling effect is limited though.Another class of inequalities, so-called orbital conflict inequalities, have been proposed in [29].Moreover, symmetry handling inequalities for specific problem classes are discussed, among others, by [8,11,22,30,31].
Besides the propagation approaches discussed above, also tailored complete algorithms that can handle special cyclic groups exist [24].Moreover, Ostrowski [16] presents smallest-image fixing, a propagation algorithm for binary variables.Instead of exploiting symmetries in a propagation framework, symmetries can also be handled by tailored branching rules [17,32].Furthermore, orbital shrinking [33] is a method that handles symmetries by aggregating variables contained in a common orbit, which results in a relaxation of the problem.Finally, core points [34][35][36] can be used to restrict the feasible region of problems to a subset of solutions.This latter approach does not coincide with lexicographically maximal representatives.

Unified framework for symmetry handling
As the literature review shows, different symmetry handling methods use different paradigms to derive symmetry reductions.For instance, SHCs remove symmetric solutions from the initial problem formulation, whereas methods such as orbital fixing remove symmetric solutions based on the branching history.At first glance, these methods thus are not necessarily compatible.
To overcome this seeming incompatibility, we present a unified framework for symmetry handling that easily allows to check whether symmetry handling methods are compatible.It turns out that, via our framework, isomorphism pruning and OF can be made compatible with a variant of LexFix.Moreover, in contrast to many symmetry handling methods discussed in the literature, our framework also applies to non-binary problems and is not restricted to permutation symmetries.Before we present our framework in Section 3.2, it will be useful to first provide an interpretation of isomorphism pruning through the lens of symmetry handling constraints.

Isomorphism pruning and orbital fixing revisited
Let β ∈ V be a node at depth m and let y be the incidence vector of 1-branching decisions as described in Section 2.2.1.Due to Theorem 2, node β can be pruned by isomorphism if solution vector y violates for some γ ∈ Γ.The latter condition looks very similar to classical SHCs, however, there are some differences: the variable order is changed via π β , not all variables are present in this constraint due to the restriction, and most importantly, every node has a potentially different reordering and restriction.Nevertheless, these modified SHCs can be used to remove all symmetries from a binary problem in the sense that, for every solution x of a binary problem, there exists exactly one node of B at depth n that contains a symmetric counterpart of x, see [16,Thm. 4.5].
Based on the modified SHCs, it is easy to show that isomorphism pruning and orbital fixing are compatible, provided one can show that both methods are compatible with the modified SHCs.Lemma 5. Let β ∈ V be a node at depth m.If β gets pruned by isomorphism, there is no x ∈ {0, 1} n that is feasible for the subproblem at β and that satisfies Proof.As in Section 2.2.1, let y ∈ {0, 1} n be such that . As the first m entries of π β (y) are branching variables and the remaining entries are 0, we find Lemma 6.Let β ∈ V be a node at depth m.Every fixing found by OF at node β is implied by , contradicting that x satisfies all SHCs.OF is thus compatible with the SHCs.
Isomorphism pruning and orbital fixing are thus compatible.While isomorphism pruning can become active as soon as one can show that no lexicographically maximal solution w.r.t. the modified SHCs is feasible at a node β, orbital fixing might not be able to find all symmetry related variable reductions.
Consequently, symmetry handling by isomorphism pruning and orbital fixing can be improved by identifying further symmetry handling methods that are compatible with the modified SHCs.

The framework
In this section, we present our unified framework for symmetry handling with the following goals: It should (G1) allow to check whether different symmetry handling methods are compatible.In particular, it should ensure compatibility of LexFix, isomorphism pruning, and OF.
(G3) apply to general variable types and general symmetries (not necessarily permutations).
To achieve these goals, we define a more general class of SHCs σ β (x) σ β (γ(x)), where γ ∈ Γ and β ∈ V, that are not necessarily based on branching decisions.
Let Φ ⊆ R n and let f : Φ → R be such that OPT(f, Φ) can be solved by (spatial) branchand-bound.Let Γ be a group of symmetries of OPT(f, Φ).Let B = (V, E) be a branch-andbound tree and let β ∈ V.In our modified SHCs, the map σ β : R n → R m β will be parameterized via a permutation π β ∈ S n , a symmetry ϕ β ∈ Γ, and an integer m β ∈ {0, . . ., n} as As in Ostrowski's approach, π β selects a variable ordering and m β allows to restrict the SHCs to a subset of variables.In contrast to [16], however, π β does not necessarily correspond to the branching order.Moreover, ϕ β provides more degrees of freedom as it allows to change the variable order imposed by π β .We refer to the structure (m β , π β , ϕ β ) β∈V as a symmetry prehandling structure for B. Note that this definition already achieves goal (G2) by setting ϕ β = id, using the same π β as in Section 3.1, and setting m β to be the number of different branching variables in node β.Theorem 8. Let Φ ⊆ R n and let f : Φ → R be such that OPT(f, Φ) can be solved by (spatial) branch-and-bound.Let Γ be a finite group of symmetries of OPT(f, Φ).Suppose that the branchand-bound method used for solving OPT(f, Φ) generates a finite full B&B-tree If (m β , π β , ϕ β ) satisfies so-called correctness conditions (C1-C4) for all nodes β ∈ V: then, for each x ∈ Φ, there is exactly one leaf ν of the B&B-tree containing a solution symmetric to x, i.e., for which there is ξ ∈ Γ with ξ(x) ∈ Φ(ν).
Before we apply and prove this theorem, we interpret the correctness conditions and provide some implications and consequences.We start with the latter.
• Enforcing (2) handles symmetries by excluding feasible solutions from the search space while guaranteeing that exactly one representative solution per class of symmetric solutions remains feasible (recall that B does not prune nodes by bound).Note that by enforcing (2), symmetry reductions can only take place on variables "seen" by σ β (x) σ β (γ(x)) for some γ ∈ Γ.We stress that it is not immediate how (2) can be enforced efficiently.We will turn to this question in Section 4.
• If we prune nodes by bound, (2) still can be used to handle symmetries.But not necessarily all x ∈ Φ have a symmetric counterpart feasible at some leaf (e.g., if x is suboptimal).
• If not all constraints of type ( 2) are completely enforced, we still find valid symmetry reductions, but not necessarily exactly one representative solution.
• If different symmetry handling methods can be expressed in terms of (2) having the same choice of the symmetry prehandling structure (m β , π β , ϕ β ) β∈V , then both symmetry handling methods can be applied at the same time, i.e., they are compatible.
• In practice, B&B is enhanced by cutting planes or domain propagation such as reduced cost fixing.Both also work in our framework if their reductions are symmetry compatible, i.e., if, for β ∈ V, the domain of a variable x i is reduced, the same reduction can be applied to all symmetric variables w.r.t.symmetries at β. Margot [15,Section 4] discusses this in detail for IsoPr.He refers to this as strict setting algorithms.
• For spatial branch-and-bound, the children of a node α do not necessarily partition Φ(α) (the feasible regions of children can overlap on their boundary).In this case, (2) can still be used to handle symmetries, but there might exist several leaves containing a symmetrically equivalent solution.
Remark 9.As propagating SHCs cuts off feasible solutions, such propagations are not symmetrycompatible.Therefore, we consider SHC reductions in our framework as special branching decisions, called improper: Node ω ′ can then be pruned by symmetry.Complementing this, traditional (standard) branching decisions are called proper.
Interpretation Theorem 8 iteratively builds SHCs σ β (x) σ β (γ(x)) that do not necessarily build upon a common lexicographic order for different nodes accepts an n-dimensional vector, considers a symmetrically equivalent representative solution hereof (ϕ β ), reorders its entries (π β ), and afterwards restricts them to the first m β coordinates.This way, σ β selects m β expressions (and their images) that appear in the SHCs (2).To ensure that consistent SHCs are derived, sufficient information needs to be inherited to a node's children in the B&B-tree, which is achieved as follows.
For the ease of explanation, let us first assume ϕ β is the identity id.Then, (C1) guarantees that a child has not less information than its parent.Moreover, siblings must not be too different, i.e., new information at one child also needs to be known to its siblings (C3).(C4) ensures that if two solutions x and ξ(x) appear identical for the SHCs in the sense σ β (x) = σ β (ξ(x)), feasibility of x should imply feasibility of ξ(x).In other words, if x and ξ(x) are identical with respect to σ β , it may not be that one solution is feasible at β while the other solution is not.
Conditions (C1), (C3), and (C4) describe how σ β (x) "grows" as nodes β follow a rooted path, and that siblings are handled in the same way.If ϕ β = id, for a node β with ancestor µ all variables and expressions of σ µ (x) also occur in the first m µ elements of σ β (x).Condition (C2) allows for more flexibility in this.Let α be the parent of β.If there is a symmetry γ ∈ Γ that leaves the feasible region of α invariant (i.e., Φ(α) = γ(Φ(α))), one can choose to handle the symmetries considering the symmetrically equivalent solution space as of node β.This degree of freedom might help a solver to find more symmetry reductions in comparison to just "growing" the considered representatives.For example, in Figure 2 at node α with (ϑ 2,3 , ϑ 1,2 , ϑ 1,3 ) ← (0, 1, 0) the feasible region Φ(α) is identical when permuting the first two columns or the last three columns.Suppose that one branches next on variable ϑ 3,3 , then the zero-branch will find two reductions (namely ϑ 3,4 , ϑ 3,5 ← 0) and the one-branch will find no reductions.If the solver has a preference to reduce the discrepancy between the number of reductions found over the siblings, one could exchange column 3 and 4 for the sake of symmetry handling.Effectively, this moves the branching variable to the fourth column.Applying orbitopal fixing on the matrix where these columns are exchanged leads to one fixing in either child.
Examples Let B = (V, E) be a B&B-tree, in which each branching decision partitions the domain of exactly one variable.We will show that there are many possible symmetry prehandling structures (m β , π β , ϕ β ) β∈V that satisfy the correctness conditions of Theorem 8. Hence, this gives many degrees of freedom to handle symmetries.In the following, we discuss choices that resemble three symmetry handling techniques: static SHCs, Ostrowksi's branching variable ordering, and a variant of orbitopal fixing that is more flexible than the setting of Bendotti et al..
By adapting the variable order used in LexFix to the order imposed by σ β , LexFix is thus compatible with isomorphism pruning and OF, i.e., the framework achieves goal (G1).In particular, the statement is true for non-binary problems if these methods can be generalized to arbitrary variable domains.We will discuss this in more detail in the next section.
The last symmetry prehandling structure accommodates orbitopal fixing.Bendotti et al. [6] already discussed a dynamic variant of orbitopal fixing, which reorders the rows of the orbitope matrix similar to Ostrowski's rank; columns, however, are not reordered.As described above, allowing also column reorderings might lead to more balanced branch-and-bound trees, which can be achieved as follows.
Example 12 (Specialized for orbitopal fixing).Let M be the p × q orbitope matrix corresponding to the problem variables via M i,j = x q(i−1)+j .That is, x is filled row-wise with the entries of M .Let β ∈ V.If β is the root node, define (m β , π β , ϕ β ) = (0, id, id).Otherwise, let α be the parent of β.If β arises from α by a proper branching decision on variable M î, and no variable in the î-th row has been used for branching before, set Consistent with Condition (C3), the choice of ψ α is the same for all children sharing the same parent α.If the variable is already included in the variable ordering or if the branching decision is improper, inherit (m β , π β , ϕ β ) = (m α , π α , ϕ α ).Effectively, this creates a new matrix in which the rows are sorted based on branching decisions and columns can be permuted as long as this does not affect symmetrically feasible solutions.
Completely handling SHCs (2) on β corresponds to using orbitopal fixing on the (m β /q) × qmatrix filled row-wise with the variables with indices in (π [6] introduce this without the freedom of permuting the matrix columns, i.e., for all β ∈ V they choose ϕ β = id.We call their setting row-dynamic, wheres we refer to our setting as row-and column-dynamic. Example 12 satisfies (C1-C4).Obviously, (C1-C3) hold.To show (C4), we use induction.As (C4) holds at the root node, the induction base holds.So, assume (C4) holds at node α with child β (IH).We show (C4) also holds at β.

Proof of Theorem 8
The examples illustrate that many symmetry prehandling structures are compatible with the correctness conditions, which shows that there are potentially many variants to handle symmetries based on Theorem 8. We proceed to prove this theorem.To this end, we make use of the following lemma.
Lemma 13.Let Φ ⊆ R n and let f : Φ → R be such that OPT(f, Φ) can be solved by (spatial) branchand-bound.Let Γ be a finite group of symmetries of OPT(f, Φ).Suppose that the branch-and-bound method used for solving OPT(f, Φ) generates a full B&B-tree B = (V, E).Let β ∈ V be not a leaf of the B&B-tree.If there is a feasible solution x ∈ Φ(β) with then β has exactly one child ω ∈ χ β for which there is ξ ∈ Γ such that Proof.Let x ∈ Φ(β) respect (3a).First, we show the existence of ω ∈ χ β satisfying (3b) and (3c).Thereafter, we show that ω is unique.
We are now able to prove Theorem 8.
Proof of Theorem 8. Recall that we assumed B = (V, E) to be finite and that we do not prune nodes by bound.Let B d be the tree arising from B by pruning all nodes at depth larger than d.
Let (m β , π β , ϕ β ) β∈V satisfy the correctness conditions.Let x ∈ Φ be any feasible solution to the original problem.We proceed by induction and show that, for every depth d of the tree, there is exactly one leaf node in B d for which a permutation of x is feasible and that does not violate the local SHCs (2).
Let d = 0.The only node at depth d is the root node α.Any feasible solution x ∈ Φ is feasible in the root node α ∈ V of the branch-and-bound tree B. In particular, we can permute x by any ξ ∈ Γ, and have a feasible symmetrical solution.For the root node, choose ξ ∈ Γ such that σ α ξ(x) σ α γξ(x) for all γ ∈ Γ.That is, ξ(x) is not cut off by (2) at α.
Let d > 0 and let x ∈ Φ.By induction, we may assume that there is exactly one leaf node β of B d at which a permutation ξ(x) is feasible and that is not cut off by (2).If β is also a leaf in B, we are done.Otherwise, since ξ(x) is not cut off by (2), we can apply Lemma 13 and find that β has exactly one child ω at which a permutation of ξ(x) is feasible and is not cut off by (2) at node ω.This concludes the proof.Remark 14.For spatial branch-and-bound algorithms, two subtleties arise.On the one hand, there might not exist a finite branch-and-bound tree.If all branching decisions partition a subproblem's feasible region, Theorem 8 holds true for all trees pruned at a certain depth level.On the other hand, branching decisions do not necessarily partition the feasible region.In this case, (2) can still be used to handle symmetries.However, in the depth-pruned tree there might exist more than one leaf containing a symmetric copy of a feasible solution.
Remark 15.Theorem 8 still holds in case of some infinite groups.The only place where finiteness is used is in the proof of Lemma 13, where it implies that a symmetry ξ ∈ Γ exists such that σ ω ξ(x) is lexicographically maximal for a fixed solution vector x ∈ Φ(β).For instance, for infinite groups of rotational symmetries, such a symmetry always exists.

Apply framework on generic optimization problems
Due to Theorem 8, we can completely handle all symmetries of an arbitrary problem OPT(f, Φ), provided we know how to handle Constraints (2).The aim of this section is therefore to find symmetry handling methods that can deal with non-binary variables.Since handling Constraints (2) is already difficult for binary problems, we cannot expect to handle all symmetries efficiently.Instead, we revisit the efficient methods LexFix, orbitopal fixing, and OF for binary variables and provide proper generalizations for non-binary problems, which allows us to partially enforce Constraints (2).We refer to these generalizations as lexicographic reduction, orbitopal reduction, and orbital symmetry handling, respectively.
Throughout this section, we assume that Γ ≤ S n .

The static setting
Assume the symmetry prehandling structure of Example 10 is used in Theorem 8.Then, the SHCs x γ(x) for all γ ∈ Γ are enforced at each node of the branch-and-bound tree.For all i ∈ [n], let D i ⊆ R n be the domain of variable x i at a node of the branch-and-bound tree and let D = (D i ) i∈[n] be the vector of variable domains.The aim of the lexicographic reduction (LexRed) algorithm is to find, for a fixed permutation γ ∈ Γ, the smallest domains , the reductions found by LexRed are equivalent to the reductions found by LexFix.For non-binary domains, similar ideas as for LexFix, which are described in [24,26], can be used: We iterate over the variables x i with indices in increasing order.If x j = γ(x) j for all indices j < i, we enforce x i ≥ γ(x) i , and we check if a solution with x i = γ(x) i exists.Before we provide a rigorous algorithm, we illustrate the idea.

Example 16. Let
In ( †), we restrict the domain of x 4 by propagating 0 , so we must have x 1 > x 4 .Since x 4 ∈ Z, x 4 must be fixed to −1.No further domain reductions can be derived from x γ(x).
We now proceed with our generalization of LexFix.To enforce x γ(x) for general variable domains D, some artifacts need to be taken into account.For example, if n = 3 and γ is the cyclic right-shift, then y ǫ := (1 + ǫ, 0, 1) γ(y ǫ ) = (1, 1 + ǫ, 0) for every ǫ > 0, but y 0 ≺ γ(y 0 ), i.e., {x ∈ R n : x γ(x)} is not necessarily closed.Since optimization software usually can only handle closed sets, we propose the following solution.We extend R by an infinitesimal symbol ε that we can add to or subtract from any real number to represent a strict difference.This results in a symbolically correct algorithm that is as strong as possible.For example, min{1+x : x > 1} = 2+ε, min{1 + x + ε : x > 1} = 2 + ε, max{1 + x : x < 2} = 3 − ε, and we do not allow further arithmetic with the ε symbol.In practice, however, we cannot enforce strict inequalities.We thus replace ε by 0, which will lead to slightly weaker but still correct reductions.That is no problem for our purposes, since we will only either apply the min-operator or the max-operator, the sign of ε will always be the same; namely, if ε appears, this has a positive sign in minimization-operations, and a negative sign in maximization-operations.Now, we turn to the generalization of LexFix to arbitrary variable domains.We introduce a timestamp t.At every time t, the current domain is denoted by D t .We initialize D 0 i = D i for all i ∈ [n], and for two timestamps t > t ′ , we will possibly strengthen the domains, i.e., D t i ⊆ D t ′ i .The core of LexRed is the observation that if x [t−1] = γ(x) [t−1] holds for some t ≥ 1, then constraint x γ(x) can only hold when x t ≥ γ(x) t = x γ −1 (t) .This observation is exploited in a two-stage approach.In the first stage, LexRed performs the following steps for all t = 1, . . ., n: 1.The algorithm propagates x t ≥ γ(x) t by updating the variable domains via )}, and 2. Then, it checks whether D t i = ∅ for all i ∈ [n] and whether x ∈ D t guarantees x [t] = γ(x) [t] .If this is the case, the algorithm continues with iteration t + 1.Otherwise, the first phase of LexRed terminates, say at time t ⋆ .
Of course, all variable domain reductions found during phase one are correct based on the previously mentioned observation.
At the end of phase one, three possible cases can occur: a variable domain is empty, phase one has propagated all variables, i.e., x = γ(x) for all x ∈ D n , or In either of the first two cases, the algorithm stops because it either has shown that no solution x ∈ D 0 exists with x γ(x) or all variables are fixed.In the last case, note that v > w holds due to the domain reductions at time t ⋆ .Since Consequently, the domains of variables x t ⋆ +1 , . . ., x n cannot be tightened.It might be possible, however, that the domains of x t ⋆ and γ(x) t ⋆ can be reduced further.Namely, if In this case, the other variable necessarily attains the same value, which means that a solution with x [t ⋆ ] = γ(x) [t ⋆ ] is created, which might lead to a contradiction with x γ(x) as illustrated in Example 16.
In the second stage of LexRed, it is checked whether one of these cases indeed leads to a contradiction.If this is the case, min D t ⋆ γ −1 (t ⋆ ) can be removed from the domain of x t ⋆ or max D t ⋆ t ⋆ can be removed from the domain of x γ −1 (t) .To detect whether a contradiction occurs, the second phase hypothetically fixes x t ⋆ or x γ −1 (t ⋆ ) to the respective value and continues with stage one since x [t ⋆ ] = γ(x) [t ⋆ ] now holds.If phase one then terminates because a variable domain becomes empty, this shows that the domain of x t ⋆ or x γ −1 (t ⋆ ) can be reduced.Otherwise, no further variable domain reductions can be derived.

Proposition 17.
Let τ be the time needed to perform one variable domain reduction in (5).Then, LexRed finds all possible variable domain reductions for x γ(x) in O(n • τ ) time.
Proof.Completeness of LexRed follows from the previous discussion.The running time holds as the first stage computes at most n domain reductions and the second stage triggers phase one at most twice.
In many cases, for instance, if variable domains are continuous or discrete intervals, τ = O(1), turning lexicographic reduction into a linear time algorithm.

Dynamic settings
Theorem 8 shows that σ β (x) σ β γ(x) is a valid symmetry handling constraint for certain symmetry prehandling structures (m β , π β , ϕ β ) β∈V .If Γ is a permutation group, σ β (x) and σ β (γ(x)) are just permutations of the solution vector entries and a restriction of this vector.In this case, lexicographic reduction can, of course, also propagate these SHCs by changing the order in which we iterate over the solution vector entries.
In particular, in the binary case and the symmetry prehandling structure of Example 11, the adapted version of LexRed is compatible with IsoPr and OF as we have seen in Section 3 that the latter two methods propagate σ β (x) σ β γ(x) for all γ ∈ Γ.

Orbitopal reduction
Bendotti et al. [6] present a complete propagation algorithm to handle orbitopal symmetries on binary variables.In this section, we generalize their algorithm to arbitrary variable domains.We call the generalization of orbitopal fixing orbitopal reduction as it does not necessarily fix variables.

The static setting
Suppose that Γ is the group that contains all column permutations of a p × q variable matrix X.Further, assume that Theorem 8 uses the symmetry prehandling structure from Example 10, where we assume that the variable vector x associated with the p • q variables in X is such that enforcing x γ(x) for all γ ∈ Γ corresponds to sorting the columns of X in lexicographic order.With slight abuse of notation, for γ ∈ Γ, we write X γ(X) if and only if the corresponding vector x ∈ R pq satisfies x γ(x).
We use the following notation.For any M ∈ R p×q and (i, j) ∈ [p] × [q], we denote by M i the i-th row of M , by M j the j-th column of M , and by M j i the entry at position (i, j).For every variable X j i , we denote its domain by D j i ⊆ R. Using the same matrix notation, D ⊆ R p×q denotes the p × q-matrix where entry (i, j) corresponds to D j i .For given domain D ⊆ R p×q , we denote by M (D) and M (D) the lexicographically smallest and largest element in D, respectively.Whenever the domain D is clear from the context, we just write M and M .Moreover, let O p×q := {X ∈ R p×q : X γ(X) for all γ ∈ Γ} be the set of all matrices with lexicographically sorted columns.Our goal is to find all possible VDRs of the SHCs X γ(X) for γ ∈ Γ, i.e., we want to find the smallest D ⊆ R p×q such that It turns out that, as for the binary case [6], the matrices M (D) and M (D) contain sufficient information for finding D. In the following, recall that we (implicitly) use the infinitesimal notation introduced in the previous section to represent strict inequalities.
This theorem is proven by the following two lemmas.The first lemma shows that no tighter VDRs can be achieved: for every (i, j) ∈ [p] × [q] and v ∈ Dj i a lexicographically non-increasing solution matrix X exists with Xj i = v.The second lemma shows that the VDRs are valid: for every (i, j) Proof.We define two matrices A, B ∈ D, for which entries (i, j) and From these two matrices, we show that for any We call such a matrix X a certificate for x.In the following, we first provide a construction for these certificates, and after that we show that they are contained in D ∩ O p×q .
), and X j ′ i ′ = x.Note that X ∈ D. We finally show that X ∈ O p×q , concluding the proof.The first j ′ − 1 columns of X correspond to M .That is, they satisfy X j X j+1 for all 1 ≤ j < j ′ − 1.Similarly, the columns after column j ′ correspond to M .Hence, X j X j+1 for all j ′ < j < q.By the definition of A and B, M . As the columns of X are either columns of A or B, or equal to A j ′ up to one entry while remaining lexicographically larger than B j ′ , we find . So, for all consecutive j ∈ [q − 1], we have X j X j+1 , and hence X ∈ O p×q ∩ D.

Lemma 20. Suppose that
Proof.Suppose the contrary, i.e., for By symmetry, it suffices to consider the case i ′′ .This contradicts that i ′ is supposed to be minimal with i ′ , since for i ′′ < i ′ we satisfy the second condition.This is a contradiction.
Proof of Theorem 18. Lemmas 19 and 20 prove the assertion for i ′ ≤ i j ′ .Since the domains for i ′ > i j ′ are not restricted in comparison to D, domain Dj ′ i ′ is valid.To show that it is as tight as possible, we can reconsider in the proof of Lemma 19 the matrix A ∈ D ∩ O p×q .Replacing entry (i ′ , j ′ ) in A with any value in D j ′ i ′ yields a matrix Ã.If i ′ > i j ′ , this change does not affect the lexicographic order constraint, so Ã ∈ D ∩ O p×q is a certificate of tightness.Combining these statements shows of Theorem 18.
We conclude this section with an analysis of the time needed to find D. The crucial step is to find the matrices M and M .To find these matrices, we adapt the idea from [6] for the binary case.Denote by lexmin(•) and lexmax(•) the operators that determine the lexicographically minimal and maximal elements of a set, respectively.We claim that for the lexicographically minimal element M , the j-th column is This can be computed iteratively, starting with the last column j = q, and then iteratively reducing j until the first column.The arguments for correctness are the same as in [6, Thm. 1, Lem. 2].
For this reason, we only describe how to compute the j-th column.Due to this iterative approach, when computing column M j for j > q, column M j+1 is known.The idea is to choose the entries of M j minimally such that M j M j+1 holds.This resembles the propagation method of the previous section (LexRed), by choosing the entries minimally such that the constraint holds when restricted to the first elements, then increasing the vector sizes by one iteratively.If this leads to a contradiction with the constraint, it is returned to the last step where the entry was not fixed, and this entry is increased to repair feasibility of the constraint.
More precisely, M j is found by iterating i from 1 to p as follows.If there is a row index i ′ < i with . This is possible, because row i ′ already guaranteed that M j ≻ M j+1 .If no such index exists, we may assume that all preceding rows i ′ < i have M j i = M j+1 i (otherwise, the j-th column cannot be lexicographically larger than column j + 1 as becomes clear in the following).In this case, denote , then stop the iteration, and for all i ′′ > i set M j i ′′ ← min(D j i ′′ ).This makes sure that M j is lexicographically strictly larger than M j+1 .On the other hand, if |S i | = 0, we cannot enforce M j ≻ M j+1 in row i.To ensure M becomes the lexicographically smallest element in O p×q ∩ D, we return to the largest i ′ < i with |S i ′ | > 1 and enforce a lexicographic difference by setting M j i ′ ← min{x ∈ D j i ′ : x > M j+1 i ′ }, and, for all i ′′ > i ′ , we assign M j i ′′ ← min(D j i ′′ ).If no i ′ < i exists with |S i ′ | > 1, column j cannot become lexicographically at least as large as column j + 1.That is, D ∩ O p×q = ∅.
Analogously, one computes M by

Dynamic settings
Similar to LexRed, also orbitopal reduction can be used to propagate SHCs σ β (x) σ β γ(x) for permutations γ from a group Γ of orbitopal symmetries.The only requirement is that σ β is compatible with the matrix interpretation of a solution x, which can be achieved by using the symmetry prehandling structure of Example 12.In this case, the static orbitopal reduction algorithm is only applied to the variables "seen" by σ β (x) σ β γ(x).
Note that this symmetry prehandling structure admits some degrees of freedom in selecting ϕ β .If ϕ β = id for all β ∈ V, this resembles the adapted version of orbitopal fixing as mentioned in Section 2.1.2.But also other choices are possible as we will discuss in Section 5.

Variable ordering derived from branch-and-bound
A natural question is whether also generalizations for isomorphism pruning and OF exist.The main challenge is that after branching on general variables, they are not necessarily fixed (in contrast to the binary setting).Thus, stabilizer computations as discussed in Section 2 might not apply in the generalized setting.Inspired by OF, we present a way to reduce variable domains of arbitrary variables based on symmetry, called orbital reduction.
For vectors x and y of equal length m, we write x ≤ y if x i ≤ y i for all i ∈ [m].Let β ∈ V be a node of the branch-and-bound tree, W β := {x ∈ R n : σ β (x) σ β (δ(x)) for all δ ∈ Γ}, and ∆ β := {γ ∈ Γ : σ β (x) ≤ σ β γ(x) for all x ∈ Φ(β) ∩ W β } be a group of symmetries.Similar to Section 2.2, we intend to use ∆ β to find VDRs.We first show that this is indeed a group.

Lemma 22.
Let β be a node of a B&B-tree using single variable branching with symmetry prehandling structure of Example 11.Then, ∆ β is a group.
Proof.Recall that we assume Γ ≤ S n in this section.Therefore, both Γ and ∆ β ⊆ Γ are finite.To show that it is a group, it suffices to show that compositions of elements of ∆ β are also contained therein.The identity and inverses follow implicitly.
Let γ 1 , γ 2 ∈ ∆ β , and suppose x ∈ Φ(β) ∩ W β .By definition of ∆ β , we have Since the correctness conditions are satisfied for Example 11, due to Condition (C4), the properties x ∈ Φ(β) and By analogy, the same results hold for γ 1 (x). Since We show two feasible reductions that are based on ∆ β .The first reduction shows that the variable domains of the variables in the ∆ β -orbit of the branching variable can possibly be tightened.To this end, denote the orbit of i in ∆ β by O β i := {γ(i) : γ ∈ ∆ β }.If the branching decision after node β decreased the upper bound of variable x i for some i ∈ [n], a valid VDR is to decrease the upper bounds of x j for all j ∈ O β i to the same value as we show next.
Lemma 23 (Orbital symmetry handling).Let B = (V, E) be a B&B-tree using single variable branching with symmetry prehandling structure of Example 11.Let ω ∈ V be a child of β ∈ V where x i is the branching variable for some i ∈ [n].Then, at node ω, each solution x ∈ Φ(ω) satisfying σ ω (x) σ ω (δ(x)) for all δ ∈ Γ (i.e., (2) for node ω) also satisfies x i ≥ x j for all j ∈ O β i .

Denote this result by ( †).
Due to Example 11, we have , variable x i appears in σ β (x)), and and x i ≥ γ(x) i .Note that this statement is the case independent from whether entry i is branched on before or not (i.e., whether i ∈ (π β ϕ β ) −1 ([m β ]) or not).Using ( †), the first of the two options cannot hold, so we must have Thus, for all j ∈ O β i , we can propagate x i ≥ x j .Second, recall our assumption that any VDR that is not based on our symmetry framework needs to be symmetry compatible, see Section 3. In practice, however, a solver might not find all symmetric VDRs, e.g., due to iteration limits.The following lemma allows us to find missing (but not necessarily all) VDRs based on symmetries, which corresponds to orbital fixing as discussed in [5] without the restriction to binary variables.Lemma 24.Let β be a node of a B&B-tree using single variable branching with symmetry prehandling structure of Example 11.Then, when SHCs (2) are enforced (i.e., solutions are in W β ), a valid VDR is to reduce the domain of x i to the intersection of all variable domains x j for j ∈ O β i .
Proof.Let x ∈ Φ(β) and let i ∈ [n].Let j ∈ O β i , i.e., there exists γ ∈ ∆ β with γ(i) = j.As γ ∈ ∆ β , σ β (x) ≤ σ β (γ(x)) holds.Since SHCs (2) are enforced, it must as well hold that σ β (x) σ β (γ(x)), and thus σ β (x) = σ β (γ(x)).Since Example 11 satisfies the correctness conditions, Condition (C4) yields γ(x) ∈ Φ(β).Thus, x i is not only contained in the domain of variable i, but also in the domain of variable x γ(i) .For this reason, the domain of x i can be restricted to the intersection of the domains for all variables x j for all j ∈ O β i .In practice, Lemma 23 and 24 cannot be used immediately as the orbits depend on ∆ β , which cannot be computed easily as it depends on Φ(β) and W β .Instead, we base ourselves on a suitably determined subgroup ∆β ≤ ∆ β , and apply the reductions induced by that subgroup.Because the reductions are based on variables in the same orbit, and orbits of the subgroup are subsets of the orbits of the larger group, VDRs found by ∆β would also be found by ∆ β .
For all i ∈ [n], let D β i ⊆ R be the (known) domain of variable x i at node β.In particular, we In particular, using (a subset of) the left set as generating set, one finds a permutation group that is a subgroup of ∆ β .For the computational results shown in Section 5 we discuss the subset selection procedure that we chose in our implementation.
We finish this section by showing that, in binary problems, VDRs yielded by OF from Section 2.2 are also yielded by the generalized setting of Lemma 23 and 24.

Lemma 25. Denote ∆ β
bin as the group ∆ β defined in Section 2.2, and ∆ β gen as the group with the same symbol defined here.If the symmetry group acts on binary variables exclusively, then ∆ β bin ≤ ∆ β gen .
Proof.In binary problems, branching on variables fixes their values.As such, because vector σ β (x) contains all branched variables, it is the same for all x ∈ Φ(β).Suppose γ ∈ ∆ β bin , i.e., γ ∈ Γ and γ(B β 1 ) = B β 1 .For all i ∈ [m β ], with σ β (x) i = 1, we have σ β (γ(x)) i = 1 for all x ∈ Φ(β).Similarly, for all i ∈ [m β ] with σ β (x) i = 0, we have σ β (γ(x)) i ≥ 0. This means that for all x ∈ Φ(β) we have σ β (x) ≤ σ β (γ(x)).This holds in particular for all x ∈ Φ(β) ∩ W β , i.e., γ ∈ ∆ β gen .By the OF rule described in Section 2.2, for all variable indices i where x i is branched to zero, all variables x j with j in the orbit of i in ∆ β bin can be fixed to zero, as well.Because ∆ β bin ≤ ∆ β gen , every orbit of ∆ β bin is contained in an orbit of ∆ β gen .As such, if x i is the branching variable at the present node, this is implied by x i ≥ x j in Lemma 23.Otherwise, this is implied by Lemma 24.

Computational study
To assess the effectiveness of our methods, we compare the running times of the implementations of the various dynamic symmetry handling methods of Section 4 (in the regime of Examples 11 and 12) to similar existing methods.To this end, we make use of diverse testsets.
The MIPLIB instances offer a diverse set of instances that contain symmetries, but these symmetries operate on binary variables predominantly.To evaluate the effectiveness of our framework for nonbinary problems, we consider the covering design and noise dosage instances.The symmetries of the former are orbitopal, whereas the latter has no orbitopal symmetries.
Although our framework allows to handle more general symmetries, we restrict the numerical experiments to permutation symmetries.On the one hand, SCIP can only detect permutation symmetries at this point of time.On the other hand, most symmetry handling methods discussed in the literature only apply to permutation symmetries.The development of methods for other kinds of symmetries is out of scope of this article.

Solver components and configurations
We use a development version of the solver SCIP 8.0.3.5 [26], commit 8443db21 , with LP-solver Soplex 6.0.3.SCIP contains implementations of the state-of-the-art methods LexFix, orbitopal fixing, and OF to which we compare our methods.We have extended the code with our dynamic methods.Our modified code is available on GitHub2 .This repository also contains the instance generators and problem instances for the noise dosage and covering design problems.
For all settings, symmetries are detected by finding automorphisms of a suitable graph [5, 20] using bliss 0.77 [39].We make use of the readily implemented symmetry detection code of SCIP, which finds a set of permutations Π that generate a symmetry group Γ of the problem, namely the symmetries implied by its formulation [5,20,21].This is a permutation group acting on the solution vector index space, so the setting of Section 2 and 4 applies.
If Γ is a product group consisting of k components, i.e., Γ = × i∈[k] Γ i , then by using simi- lar arguments as in [9, Proposition 5], the symmetries of the different components Γ i , i ∈ [k], can be handled independently; compositions of permutations from different components do not need to be taken into account.In particular, it is possible to select a different symmetry prehandling structure for the different components.We therefore decompose the set of permutations Π generating Γ that are found by SCIP in components, yielding generating sets Π 1 , . . ., Π k for components Γ 1 , . . ., Γ k .Symmetry in each component is handled separately.
For all settings, we disable restarts to ensure that all methods exploit the same symmetry information.We compare our newly implemented methods to the methods originally implemented in SCIP.
Our configurations For every component Γ i , we handle symmetries as follows, where we skip some steps if the corresponding symmetry handling method is disabled.
1.If a SCIP-internal heuristic, cf.[9,Sec. 4.1], detects that Γ i consists of orbitopal symmetries: (b) Otherwise, if the orbitope matrix contains only two columns (i.e., is generated by a single permutation γ), then use lexicographic reduction using the dynamic variable ordering of Example 11, as described in Section 4.1.
(c) Otherwise, if there are at least 3 rows with binary variables whose sum is at most 1 (so-called packing-partitioning type) then use the complete static propagation method for packing-partitioning orbitopes as described by Kaibel and Pfetsch [11], where the orbitope matrix is restricted to the rows with this structure.
(d) Otherwise, use dynamic orbitopal reduction as described in Section 4.2 using the dynamic variable ordering of Example 12.We select ϕ β that it swaps the column containing the branched variable to the middlemost (or leftmost) symmetrically equivalent column when propagating the SHCs (2) using static orbitopal reduction.
We also compare settings where orbitopal reduction, orbital reduction and lexicographic reduction are turned off.If orbitopal symmetries are not handled, we always resort to the second setting, where lexicographic reduction (if enabled) and/or orbital reduction (if enabled) are applied.
For orbitopal symmetries, we have chosen to handle certain common cases before refraining to the dynamic orbitopal reduction code that we devised.First, for single-row orbitopes, the symmetry is completely handled by the linear constraints.Since linear constraints are strong and work well with other components of the solver, we decided to handle those this way.If an orbitope only has two columns, the underlying symmetry group is generated by a single permutation of order 2. In that case, the symmetry is completely handled by lexicographic reduction.Third, it is well known that exploiting problem-specific information can greatly assist symmetry handling.If a packing-partitioning structure can be detected, we therefore apply specialized methods as discussed above.Otherwise, we use orbitopal reduction as discussed in Section 4.2.In Step 1d, the choice of ϕ β is inspired by the discussion in Section 3.2 ("Interpretation").By moving the branching variable to the middlemost possible column, balanced subproblems are created, whereas the leftmost possible column might lead to more reductions in one child than in the other.Below, we will investigate which technique is more favorable.
For the components that are do not consist of orbitopal symmetries, we decided to settle on the setting of Example 11 and use both compatible methods.Since the SCIP version that we compare to either uses orbital fixing or (static) lexicographic fixing for such components, our setting allows us to assess the impact of adapting lexicographic fixing to make it compatible with orbital fixing.

Comparison base
We compare to similar, readily implemented methods in SCIP.In SCIP jargon, these methods are called polyhedral and orbital fixing and can be enabled/disabled independently.The polyhedral methods consist of LexFix for the SHCs x γ(x) for γ ∈ Π i and methods to handle orbitopal symmetries; orbital fixing uses OF from [5].Note that only symmetries of binary variables are handled.
If a component consists of polytopal symmetries, the polyhedral methods handle these symmetries by carrying out the check of Step 1c.In case it evaluates positively, methods exploiting packing-partitioning structures are applied as described above.Otherwise, orbitopal symmetries of binary variables are handled by a variant of row-dynamic orbitopal fixing.The remaining components are either handled by static LexFix or orbital fixing, depending on whether the polyhedral methods or orbital fixing is enabled.Moreover, if polyhedral methods are disabled, orbital fixing is also applied to components consisting of orbitopal symmetries.

Results
All experiments have been run in parallel on the Dutch National supercomputer Snellius "thin" consisting of compute nodes with dual AMD Rome 7H12 processors providing a total of 128 physical CPU cores, and 256 GB memory.Each process has an allocation of 4 physical CPU cores and 8 GB of memory.In the results below we report the running times (column time) and time spent on symmetry handling (column sym) in shifted geometric mean n i=1 (t i + 1) 1 n − 1 to reduce the impact of outliers.We also report the number of instances solved within the time limit of 1 h (column #S).If the time limit is reached, the solving time that instance is reported as 1 h.None of the instances failed or exceeded the memory limit.We report the aggregated results for all instances, for all instances for which at least one setting solved the instance within the time limit, and for all instances solved by all settings.For each of these classes, we provide their size below.
We use abbreviations for the settings.We compare no symmetry handling (Nosym), traditional polyhedral methods (Polyh), traditional orbital fixing (OF), dynamic orbitopal reduction (OtopRed), dynamic lexicographic reduction (LexRed), orbitopal reduction (OR), and combinations hereof.Note that also setting Nosym reports a small symmetry time, because due to SCIP's architecture, handling the corresponding plug-in requires some time even if it is not used.Moreover, if symmetries are handled by linear constraints in the model (cf.Step 1a), these are not reported the symmetry handling figures.Recall from 1d that we consider two variants of selecting ϕ β for dynamic orbitopal fixing.We refer to these variants as first and median for the leftmost and middlemost column, respectively.As the noise dosage testset exclusively consists of orbitopal symmetries, we test both parameterizations there.For the remaining testsets, we restrict ourselves to median as it performs better on average for the noise dosage instances.
Since the covering design and noise dosage testsets are relatively small and contain many easy instances, performance variability is minimized by repeating each configuration-instance pair three times with a different global random seed shift.Due to the large number of instances, settings and large time requirements, only one seed is used for the MIPLIB instances.

MIPLIB
To compose our testset, we presolved all instances from the MIPLIB 2010 [37] and MIPLIB 2017 [38] benchmark testsets and selected those for which SCIP could detect symmetries.This results in 129 instances.We excluded instance mspp16 as it exceeds the memory limit during presolving.
The goal of our experiments for MIPLIB instances is twofold.On the one hand, we investigate whether our framework allows to solve symmetric mixed-integer programs faster than the stateof-the-art methods as implemented in SCIP.On the other hand, we are interested in the effect of adapting different symmetry handling methods for σ β (x) σ β γ(x) in comparison with their static counterparts.Table 1 shows the aggregate results of our experiments.
Regarding the first question, we observe that using any type of symmetry handling is vastly superior over the setting where no symmetry is handled.Considering all instances, the best of the traditional settings reports an average running time improvement of 24.9 % over Nosym, and the best of the dynamified methods report 28.8 %.Our framework thus allows to improve on SCIP's state-of-the-art by 5.2 %.On the instances that can be solved by at least one setting, this effect is even more pronounced and improves on SCIP's best setting by 8.6 %.We believe that this is a substantial improvement, because the MIPLIB instances are rather diverse.In particular, some of these instances contain only very few symmetries.
Regarding the second question, we compare the SCIP settings Polyh, OF, and Polyh + OF with their counterparts in our framework, being OtopRed + LexRed, OR, and OR + OtopRed, respectively.The running time of the pure polyhedral setting Polyh can be improved in our framework by 7.5 % when considering all instances, and by 12.4 % when considering only the instances solved by some setting within the time limit.Consequently, adapting symmetry handling to the branching order via the symmetry prehandling structure of Example 11 and 12 allows to gain substantial performance improvements.Our explanation for this behavior is that symmetry reductions can be found much earlier in branch-and-bound than in the static setting (cf. Figure 2, where no reductions can be found at depth 1 if no adaptation is used).Thus, symmetric parts of the branch-and-bound tree can be pruned earlier.
Comparing OF and OR, we observe that OR is slightly faster than OF.Both methods, however, are much slower than Polyh and OtopRed + LexRed.A possible explanation is that the latter methods make use of orbitopal fixing, which can handle entire symmetry groups, whereas OF and OR only find some reductions based on orbits.Among SCIP's methods, Polyh + OF performs best.Its counterpart OR + OtopRed in our framework performs comparably on all instances and the solvable instances, however, three fewer instances are solved.A possible explanation for the comparable running time is that traditional orbital fixing and the variant of row-dynamic orbitopal fixing are already dynamic methods.Thus, a comparable running time can be expected (although this does not explain the difference in the number of solved instance).Lastly, we discuss settings which are not possible in the traditional setting, i.e., combing LexRed and orbital reduction.Enhancing orbital reduction by LexRed indeed leads to an improvement of 2.4 % and allows to solve two more instances.The best setting in our framework, however, does not enable all methods in our framework.Indeed, the running time of OR + OtopRed + LexRed can be improved by 4.9 % when disabling orbital reduction.We explain this phenomenon with the fact that orbitopal reduction already handles a lot of group structure.Combining LexRed and orbital reduction on the remaining components only finds a few more reductions.The time needed for finding these reductions is then not compensated by the symmetry reduction effect.If no group structure is handled via orbitopal reduction, LexRed can indeed be enhanced by orbital reduction.
Recall that symmetries in MIPLIB instances act predominantly on binary variables.As opposed to the traditional settings that we compare to, the generalized setting can handle symmetries on non-binary variable domains.Thus, potentially more reductions can follow from larger symmetry groups that include non-binary variables.As shown in Appendix A, a larger group is detected in only 10 out of the 128 instances, and only 2 of these can be solved by some setting.When considering the subset of instances where symmetry is handled based on the same group, we report similar results as before.This shows that even if we only consider problems where symmetries act on the binary variables, our generalized methods outperform similar state-of-the-art methods.

Minimum t-(v, k, λ)-covering designs
Since the symmetries of MIPLIB instances predominantly act on binary variables, we turn the focus in the following to symmetric problems without binary variables to assess our framework in this regime.Let v ≥ k ≥ t ≥ 0 and λ > 0 be integers.Let V be a set of cardinality v, and let K (resp.T ) be the collections of all subsets of V having sizes k (resp.t).A t-(v, k, λ)-covering design is a multiset C ⊆ K if all sets T ∈ T are contained in at least λ sets of C, counting with multiplicity.A covering design is minimum if no smaller covering design with these parameters Symmetries in this problem re-label the elements of V , and these are also detected by the symmetry detection routine of SCIP.Note that, although the underlying group is symmetric, these symmetries in terms of the variables ν are not orbitopal.Margot [40] considers an instance with λ = 1, which is a binary problem.We consider all nonbinary instances with parameters λ ∈ {2, 3} and 12 ≥ v ≥ k ≥ t ≥ 1, and restricted ourselves to instances that were solved within 7200 s in preliminary runs and that require at least 10 s for some setting.This way, 58 instances remain.With 3 seeds per instance, we end up with 174 results.The aggregated results are shown in Table 2.Because the instances are non-binary, none of the considered traditional methods can be applied to handle the symmetries.As such, we can only compare to no symmetry handling.The best of our instances reports an improvement of 77.8 % over no symmetry handling.
If orbital reduction and LexRed are not combined, orbital reduction is the more competitive method as it improves upon LexRed by 47.2 %.Although LexRed is much faster than Nosym, this comparison shows that more symmetries can be handled when the group structure is exploited via orbits.Nevertheless, our framework allows to further improve orbital reduction by another 6.6 % if it is combined with LexRed.That is, orbital reduction is not able to capture the entire group structure and missing information can be handled by LexRed efficiently via our framework.

Noise dosage
To assess the effectiveness of orbitopal reduction isolated from other symmetry handling methods, we consider the noise dosage (ND) problem [22], which has orbitopal symmetries as explained in Problem 1.However, we replace the binary constraint (NDB5) by ϑ ∈ Z p×q ≥0 to be able to evaluate the effect of orbitopal reduction on non-binary problem.In particular, we are interested whether the choice of the left or median variants matters for the parameter ϕ β .
Symmetries in the ND problem can be handled by adding p i=1 M p−i ϑ i,j ≥ p i=1 M p−i ϑ i,j+1 for j ∈ {1, . . ., q − 1}, where M is an upper bound to the maximal number of tasks that one worker can perform on a machine, as described by Sherali and Smith [22].This is similar to fundamental domain inequalities [25] and the symmetry handling constraints of Ostrowski [16].Although these can be used to handle symmetries, it is folklore that problems with largely deviating coefficients can lead to numerical instabilities.These constraints work well for instances with a small number of machines p, such as in the original instances of Sherali and Smith.However, for our instance noise11_16_480_s2, such a constraint has minimal absolute coefficient 1 and maximal absolute coefficient 11 10 .Various warnings in the log files confirm the presence of numerical instabilities.
In fact, observable incorrect results follow.For instance, when adding these linear constraints, instance noise11_16_480_s1 finds infeasibility during presolving, whereas it is a feasible instance as illustrated by the no symmetry handling and dynamic orbitopal fixing runs.Moreover, for instance noise9_14_480_s3, no infeasibility is detected, but reports a wrong optimal solution.Thus, there is a need to replace these inequalities with numerically more stable methods.
We have removed these two instances from our testset as they obviously result in wrong results.The aggregated results for the remaining instances are presented in Table 3.We observe that the symmetry handling inequalities perform 22.0 % better than orbitopal reduction.However, the presented numbers for the inequality-based approach need to be interpreted carefully as reporting a correct objective value does not necessarily mean that the branch-and-bound algorithm worked correctly.For instance, nodes might have been pruned because of numerical inaccuracies although a numerical correct algorithm would not have pruned them.These issues do not occur for the propagation algorithm orbitopal reduction as it just reduces variable domains.
Comparing the two parameterizations of orbitopal fixing, we see that the median variant performs 4.7 % better than the first variant.This shows that the choice for the column reordering by symmetry ϕ β has a measurable impact on the running time for dynamic orbitopal reduction.A possible explanation for the median rule to perform better than the first rule is that median creates more balanced branch-and-bound trees, cf.Section 3.2.Consequently, the right choice of ϕ β might significantly change the performance of orbitopal reduction.We leave it as future research to find a good rule for the selection of ϕ β as this rule might be based on the structure of the underlying problem, e.g., size of the variable domains, number of rows, and number of columns.

Conclusions and future research
Symmetry handling is an important component of modern solver technology.One of the main issues, however, is the selection and combination of different symmetry handling methods.Since the latter is non-trivial, we have proposed a flexible framework that easily allows to check whether different methods are compatible and that does apply for arbitrary variable domains.Numerical results show that our framework is substantially faster than symmetry handling in the state-of-theart solver SCIP.In particular, we benefit from combining different symmetry handling methods, which is possible in our framework, but only in a limited way in SCIP.Moreover, due to our generalization of symmetry handling algorithms for binary problems to general variable domains, our framework allows us to reliably handle symmetries in different non-binary applications.
Due to the flexibility of our framework, it is not only applicable for the methods discussed in this article, but also allows to apply methods that will be developed in the future (provided they are compatible with SHCs (2)).This opens, among others, the following directions for future research.
In this article, we experimentally evaluated our framework only for permutation symmetries.As the framework also supports other types of symmetries such as rotational and reflection symmetries, further research could involve devising symmetry handling methods for such symmetries.Moreover, to handle permutation symmetries, we only used propagation techniques.In the future, these methods can be complemented in two ways.On the one hand, other techniques such as separation routines can be applied to handle SHCs (2).On the other hand, our symmetry handling methods have not exploited additional problem structure such as packing-partitioning structures in orbitopal fixing.Further research can focus on the incorporation of problem constraints in handling the symmetry handling constraint of Theorem 8.This includes a dynamification of packingpartitioning orbitopes, as well as introducing a way to handle overlapping orbitopal subgroups within a component.
Last, in the computational results we describe decision rules for enabling/disabling certain symmetry handling methods.If new symmetry handling methods are cast into our framework, however, these rules need to be updated.Future research could thus encompass the derivation of good rules for how to handle symmetries in our framework.

Figure 1 :
Figure 1: Branch-and-bound tree for the NDB problem.Fixings by LexFix are drawn red.

Figure 2 :
Figure 2: Branch-and-bound tree for the NDB problem.Fixings by orbitopal fixing are drawn red.

Figure 3 :
Figure 3: Branch-and-bound tree for the NDB problem with pruned nodes by isomorphism pruning.
1, and lexmax{X ∈ D j } otherwise.Since determining the j-th column of M and M requires to iterate over its elements a constant number of times, for each element a constant number of comparisons and variable domain reductions is executed.The time for finding M and M is therefore O(pqτ ), where τ is again the time needed to reduce variable domains.Combining all arguments thus yields the following result regarding orbitopal reduction.Let D ⊆ R p×q .Orbitopal reduction finds the smallest D ⊆ R p×q such that D ∩ O p×q = D ∩ O p×q holds in O(pqτ ) time.In particular, if all variable domains are intervals, orbitopal reduction can be implemented to run in O(pq) time.
2. Otherwise (i.e., if the symmetries are not orbitopal), use the symmetry prehandling structure of Example 11 and use two compatible methods simultaneously: (a) Lexicographic reduction as described in Section 4.1.(b) Orbital reduction as described in Section 4.3.Since computing ∆ β is non-trivial, we work with a subgroup of ∆ β , namely the group generated by all permutations γ ∈ Π i for which σ β

Table 2 :
Results for finding minimum t-(v, k, λ) covering designs ∈ {0, . . ., λ} K specifying the multiplicity of the sets K ∈ K for the minimum t-(v, k, λ)-covering design sought after.The problem is to

Table 3 :
Results for finding optimal solutions to the noise dosage problems