Symmetric Linear Model Predictive Control

Transcription

1244
IEEE TRANSACTIONS ON AUTOMATIC CONTROL, VOL. 60, NO. 5, MAY 2015
Symmetric Linear Model Predictive Control
Claus Danielson, Member, IEEE, and Francesco Borrelli, Senior Member, IEEE
Abstract—This paper studies symmetry in linear model predictive control (MPC). We define symmetry for model predictive
control laws and for model predictive control problems. Properties
of both MPC symmetries are studied by using a group theory
formalism. We show how to efficiently compute MPC symmetries
by transforming the search of MPC symmetry generators into a
graph automorphism problem. MPC symmetries are then used to
design model predictive control algorithms with reduced complexity. The effectiveness of the proposed approach is shown through a
simple large-scale MPC problem whose explicit solution can only
be found with the method presented in this paper.
Index Terms—Model predictive control (MPC).
I. I NTRODUCTION
T
HE main idea of predictive control is to use a model of
the plant to predict its future evolution. At each sampling
time, starting at the current state, an open-loop optimal control
problem is solved over a finite horizon. The optimal command
signal is applied to the process only during the following
sampling interval. At the next time step, a new optimal control
problem based on new measurements of the state is solved over
a shifted horizon. The resultant control algorithm is referred
to as Model Predictive Control (MPC). The popularity of MPC
stems from the fact that the resulting operating strategy respects
all the system constraints. This is difficult to accomplish using
other control techniques. One limitation of this approach is that
running the optimization algorithm on-line at each time step
requires substantial time and computational resources.
One alternative to online computation is to compute the
optimal control law offline and store it as a look-up table. In [3]
the authors showed that the solution to the constrained finitetime optimal control problem is a piecewise affine on polyhedra
state-feedback control law. This state-feedback law is often
called the explicit controller. Having this precomputed control
law greatly reduces the computational load. However the explicit controller can require an excessive amount of memory
to store. In this paper we reduce the memory requirements
for explicit model predictive control using a problem structure,
called symmetry, found in certain systems.
Symmetries are patterns of self-similarity. For a mathematical problem, a symmetry is a transformation of the problem
variables that does not change the problem structure. Many
Manuscript received November 8, 2013; revised June 9, 2014, June 12,
2014, and October 27, 2014; accepted November 4, 2014. Date of publication
November 20, 2014; date of current version April 18, 2015. This work was
supported by the National Science Foundation under Grant 0844456. Recommended by Associate Editor J. Imura.
C. Danielson is with Mitsubishi Electric Research Laboratory, Cambridge,
MA 02139–1955 USA (e-mail: [email protected]).
F. Borrelli is with the Unversity of California at Berkeley, Berkeley, CA
94720 USA (e-mail: [email protected]).
Color versions of one or more of the figures in this paper are available online
at http://ieeexplore.ieee.org.
Digital Object Identifier 10.1109/TAC.2014.2373693
large-scale systems tend to exhibit large symmetry groups.
For instance apartment and office buildings have many rooms
laid out in regular patterns [29]. Complex machines are built
from similar components arranged into specific patterns [43].
Multi-agent systems are composed of identical agents or a
small number of different types of agents [24]. Problems with
symmetry are simpler since they have less unique problem data.
However algorithms must be designed to recognize and exploit
symmetric problem structure.
Symmetry has been used extensively in numerous fields to
analyze and simplify complex problems. Symmetry is a standard analysis tool in physics [1] and chemistry [11]. In recent
years symmetry has been applied to optimization. In optimization theory symmetries are transformations of the decision
space that do not change the cost or the feasible region (see
surveys [19], [33] for details). In [5] the authors showed that
the optimal solution to a symmetric linear program lies in
a lower-dimensional subspace called the fixed-space of the
group. This result was extended to semi-definite programs and
integer programs in [6] and [37] respectively. In [23] symmetric
semi-definite programming was used to simplify the sum-ofsquares decomposition of polynomials. In [2] symmetric semidefinite programming was applied to the optimal design of truss
structures.
Symmetry has also been used to analyze and simplify control
design [41]. In control theory, symmetries are transformations
of the state-space, input-space, and output-space that map the
state-space matrices to themselves. Using group representation
theory a basis for the state-space, input-space, and output-space
can be found that decomposes the system into smaller decoupled subsystems [21], [39]. This basis is called the symmetry
adapted basis. In [20], [25] it was shown that controllability
and stability in large scale systems can be determined by using
symmetry and checking the smaller set of decoupled subsystems. In [13] symmetry adapted basis was used to simplify the
design of H2 and H∞ controllers. Using symmetry adapted
basis the authors designed H2 and H∞ controllers for each of
the decoupled subsystems. The H2 norm of the full system is
the sum of the H2 norms of the decoupled subsystems. The
H∞ norm of the full system is the max of the H∞ norm of the
decoupled subsystems. In [7] symmetry was used to simplify
the process of finding the transition probabilities of MarkovChains which produce the fastest convergence. The authors
used symmetry adapted basis to decompose the fastest-mixing
Markov chain problem into smaller semi-definite programs.
This paper studies symmetry for constrained linear control
with focus on model predictive control (MPC) [34]. We define
symmetry for model predictive control laws and model predictive control problems and show how to efficiently compute these symmetry groups. Symmetries are used to design
model predictive control algorithms of reduced complexity.
By applying the proposed approach one can compute MPC
0018-9286 © 2014 IEEE. Personal use is permitted, but republication/redistribution requires IEEE permission.
See http://www.ieee.org/publications_standards/publications/rights/index.html for more information.
DANIELSON AND BORRELLI: SYMMETRIC LINEAR MODEL PREDICTIVE CONTROL
feedback laws for classes of large-scale systems for which no
methodology exists today.
Next we present our contributions and detail the outline of the
paper. The paper is divided into four parts. In the first part of the
paper we define symmetry for a model predictive control problem and symmetry for an explicit model predictive control feedback law. A symmetry of a MPC problem is a state-space and
input-space transformation that preserves the dynamics, constraints, and cost. A symmetry of the MPC controller is a transformation of the state-space and input-space that preserves the
control law. In particular, by using the results from explicit MPC
[3], one can interpret the symmetries of a MPC controller as
a state-space and input-space transformations that permute the
pieces of the explicit controller. Thus symmetries relate the control law in different regions of the state-space. The set of all symmetries of the explicit controller form a group. We show that
symmetries of the MPC problem are also symmetries of the
MPC law. Through an example we show the MPC control law
may have additional symmetries not present in the underlying
MPC problem.
In the second part of the paper we provide algorithms for
finding the symmetries of the model predictive control problem
and explicit model predictive control law. We call the problem
of finding the symmetry group, symmetry identification. We
propose a method which transforms the symmetry identification
problem into graph automorphism problems. Graph automorphism problems can be solved efficiently using standard graph
automorphism software packages [18], [28], [35].
In the third and main part of the paper we present explicit
model predictive control designs which exploit symmetry to
reduce the memory requirements for storing the controller. We
propose two controller designs called the orbit controller and
the fundamental domain controller. We show how to synthesize
and implement these two controllers.
The orbit controller uses symmetry to organize the controller
pieces into equivalence classes called orbits. The orbit controller stores one representative controller pieces from each
orbit. The other controller pieces can be reconstructed online
using symmetry. We analyze the computational and memory
complexity of the orbit controller. We show that the orbit controller offers significant memory savings when the number of
group generators is small compared to the group size. We also
show that the time required for the evaluation of the orbit controller depends on the number of generators of the group symmetry. When the symmetry group of the controller has a small
number of generators the computational complexity of the orbit
controller is similar to the standard explicit model predictive
controller. The orbit controller can also be see as a generalization of the approach proposed in [40].
The fundamental domain controller solves the model predictive control problem on a subset of the state-space called
a fundamental domain. A fundamental domain is a subset that
contains at least one representative from each point orbit of a set
[21], [22]. Since the fundamental domain is a subset of the statespace, it contains fewer regions of the MPC controller which
leads to a reduction in the complexity of the controller. We also
analyze the computational complexity of the fundamental domain controller. We show that the computational complexity of
implementing the fundamental domain controller is comparable
to the computational complexity of the fastest implementation
of the full explicit controller [27].
1245
In the forth and final part of the paper we present two
examples that demonstrate the effectiveness of the proposed
approach. In the first example we consider a model predictive
controller for a quadcopter system [4], [10]. We use our symmetry identification algorithms to find the symmetries of the quadcopter system. Using these symmetries we construct the orbit
controller which reduces the memory requirements by a factor
of 12.8. In the second example we consider a network storage
system [17]. For this application, computing the explicit model
predictive controller is not feasible without using the techniques
proposed in this paper. In fact, the storage requirements of the
MPC controller is reduced by a factor of more than one billion.
A. Model Predictive Control
Consider the following model predictive control problem for
a constrained linear time-invariant system with quadratic cost
function and polytopic constraints
minimize
u0 ,...,uN −1
xTN P xN +
N
−1
xTk Qxk + uTk Ruk
(1a)
k=0
subject to xk+1 = Axk + Buk
xk+1 ∈ X for k = 0, . . . , N − 1
uk ∈ U for k = 0, . . . , N − 1
x0 = x ∈ X
(1b)
(1c)
(1d)
(1e)
where x0 = x ∈ Rn is the measured state, xk is the predicted
state under the control action uk ∈ Rm over the horizon N , X
and U are polytopic sets, and P = P T 0, Q = QT 0 and
R = RT 0.
Problem (1) can be written as a multi-parametric quadratic
program [3]
minimize
U
J(U, x)
subject to U ∈ T (x)
x∈X
(2a)
(2b)
(2c)
T
where U = [uT0 , . . . , uTN −1 ] is the input trajectory over the
horizon N , J(U, x) is a quadratic function, and T (x) is the
polytopic set of feasible input trajectories U that satisfy state
(1c) and input (1d) constraints under the dynamics (1b).
In [3] it was shown that (2) has a continuous piecewise affine
solution
F x + G for x ∈ CR
1
1
1
..
(3)
U (x) =
.
Fp x + Gp for x ∈ CRp
where CRi ⊆ X are polytopes called critical regions, and Fi ∈
RN m×n and Gi ∈ RN m are constant matrices. The set of initial
conditions x0 = x for which problem (2) is feasible is denoted
by X0 . The critical regions {CRi }pi=1 partition the set X0 , i.e.,
∪pi=1 CRi = X0 and int(CRi ) ∩ int(CRj ) = ∅ for all i = j.
The optimal state-feedback piecewise affine MPC control
law can be obtained by extracting the first m terms of the
optimal input trajectory U (x)
F1 x + G1 for x ∈ R1
..
u0 (x) = κ(x) =
(4)
.
Fr x + Gr for x ∈ Rr
where Fi ∈ Rm×n and Gi ∈ Rm are the optimal feedback
and feedforward gains. The regions Ri ⊆ X are unions of
critical region CRj where the first m components of U (x) are
1246
identical. A union of polytopes is called a P-collection. We
refer to the triple (Fi , Gi , Ri ) as the i-th piece of the controller
κ(x) and I = {1, . . . , r} is the index set of the controller
pieces. We call the partition {Ri }i∈I minimal if it contains the
smallest number |I| of pieces needed to express κ(x).
It is important to make a distinction between the optimal control law u0 (x) and its piecewise affine expression κ(x) defined
in (4). The optimal control law u0 : X0 → U is a function from
the set of feasible states X0 to the set of feasible control inputs
U . The piecewise affine controller κ(x) is one expression of
this function. The function u0 (x) is unique since the model
predictive control problem (1) is strictly convex. However the
expression (4) is not unique. Indeed the objective of this paper
is to find an alternative expression for u0 (x) that requires less
memory than the piecewise affine controller κ(x).
A simple implementation of controller (4) is shown in
Algorithm 1. First the algorithm determines the region Ri that
contains the measured state x ∈ Ri . This step is called the point
location problem. Next the optimal control u0 (x) = Fi x + Gi
is calculated. The computational complexity of this algorithm is
dominated by the point location problem which requires O(|I|)
set membership tests x ∈ Ri of complexity O(nci ) where ci
is the number of constraints that defines region Ri . Many
improvements of this basic implementation can be found in the
literature [12], [27], [31], [42].
texts [26], [32], [38]. Permutations will be described using
the Cayley notation. For instance the permutation π such that
π(1) = 2, π(2) = 3, and π(3) = 1 will be denoted as
π = 12 23 31 .
(5)
Algorithm 1 Standard Implementation
Input: Measured State x
Output: Optimal Control u
1: for i ∈ I do
2: if x ∈ Ri then
3:
return i
4: end if
5: end for
6: u0 = Fi x + Gi
II. M ATHEMATICAL BACKGROUND
A polytope X is the intersection of a finite number of halfspaces X = {x ∈ Rn : H̄x ≤ K}. A half-space is redundant if
removing it from the description of X does not change the set
X . If the polytope X contains the origin in its interior it can be
written in normalized form X = {x ∈ Rn : Hx ≤ 1}. Let A ∈
Rm×n and X ⊆ Rn then the set AX = {Ax : x ∈ X } ⊆ Rm is
the image X through A.
A graph Γ = (N , E) is a set of nodes N together with a list
of unordered pairs E ⊂ N × N called edges. Nodes i, j ∈ N
are called adjacent if (i, j) ∈ E is an edge. A path is a sequence
of adjacent nodes. Two nodes i, j ∈ N are called connected
if there exists a path connecting them. A subgraph is a graph
whose node set is a subset of N and whose edge set is a subset
of E. A connected component is a subgraph in which any two
nodes are connected.
A. Group Theory
This paper deals with groups of matrices and permutations.
In this section we review the relevant concepts, notation, and
results from group theory. Details can be found in standard
A group (G, ◦) is a set G along with a binary operator ◦
such that the operator is associative, the set G is closed under
the operation ◦, the set includes an identity element, and the
inverse of each element is included in the set. In matrix groups
the operator ◦ is matrix multiplication and the identity element
is the identity matrix I. In permutation groups the operator ◦
is function composition and the identity element is the identity
permutation e. A group that contains only the identity element
is called trivial. For notational simplicity we will drop the ◦ and
write gh for g ◦ h.
Let G be a finite group. A set S ⊆ G is called a generating set
if every element of G can be expressed as an arbitrary product of
the elements of S. The group generated by S is denoted by S.
The trivial group G = {e} is generated by the empty set S = ∅.
A group homomorphism is a function f : G → H between
groups that preserves the group structure: f (g)f (h) = f (gh)
for all g, h ∈ G. A bijective group homomorphism f is called
a group isomorphism and the groups G and H are called
isomorphic. If G and H are isomorphic groups and S ⊆ G
generates G = S then f (S) generates H = f (S).
A group G acts on a set X if its elements g ∈ G are functions
g : X → X on that set X . The orbit Gx := {g(x) : g ∈ G} of a
point x ∈ X is the set of images g(x) of the point x under every
element of the group g ∈ G. Algorithm 2 calculates the orbit
Gx of a point x ∈ X under the group G = S. This algorithm
is valid for both matrix and permutation groups. This algorithm
has computational complexity O(|S||Gx|) [38].
Algorithm 2 Orbit Construction
Input: Point x ∈ X and generators S of the group G = S
Output: Orbit O = Gx = Sx
1: Initialize orbit O = {x}
2: while Orbit O still growing do
3: for each g ∈ S do
4:
Expand orbit O = O ∪ g(O)
5: end for
6: end while
III. S YMMETRY G ROUPS
In this section we formally define symmetry in the context
of Model Predictive Control. We give two intuitive definitions
of symmetry and discuss how they are related. In particular we
define the symmetries of the model predictive control law (4)
and the model predictive control problem (1).
A. Symmetries of the Explicit Controller
A symmetry of the optimal control law u0 (x) is a transformation of the state-space Θ ∈ Rn×n and input-space Ω ∈ Rm×m
that preserves the control law, i.e., u0 (x) = Ω−1 u0 (Θx).
Definition 1: The pair of invertible matrices (Θ, Ω) is a symmetry of the optimal control law u0 (x) if Ωu0 (x) = u0 (Θx) for
all x ∈ X0 .
Definition 1 says that for every feasible point x ∈ X0 , the
control actions at points x and y = Θx are related by a linear
transformation Ω ∈ Rm×m . The set of all symmetries of the optimal control law u0 (x) is denoted by Aut(u0 ). The following
proposition shows that the set Aut(u0 ) is a group.
Proposition 1: The set Aut(u0 ) of all symmetries of the
control law u0 is a group under pairwise matrix multiplication.
Proof: We show that Aut(u0 ) under matrix multiplication
satisfies the axioms of group theory. Note that matrix multiplication is associative.
1) Identity: (In , Im ) ∈ Aut(u0 ) since
Im u0 (x) = u0 (In x)
∀ x ∈ X0 .
(6)
2) Inverse: Let (Θ, Ω) ∈ Aut(u0 ) then (Θ−1 , Ω−1 ) ∈
Aut(u0 ) since
Ωu0 (Θ−1 y) = u0 (y)
∀ y = Θx ∈ ΘX0 = X0 .
3) Closure: Let (Θ1 , Ω1 ), (Θ2 , Ω2 ) ∈
(Θ1 Θ2 , Ω1 Ω2 ) ∈ Aut(u0 ) since
(7)
Aut(u0 )
then
−1 −1 Ω−1
2 Ω1 u0 (Θ1 Θ2 x) = Ω2 u0 (Θ2 x) = u0 (x).
(8)
We are interested in symmetries of the piecewise affine
controller κ(x) in (4). A symmetry of the piecewise affine
controller κ(x) is a transformation of the state-space Θ and
input-space Ω that permutes the controller pieces (Fi , Gi , Ri )
for i ∈ I.
Definition 2: The pair of invertible matrices (Θ, Ω) is a
symmetry of the piecewise affine control law κ(x) in (4) if for
every i ∈ I there exists j ∈ I such that
ΩFi = Fj Θ
ΩGi = Gj
ΘRi = Rj .
(9a)
(9b)
(9c)
The set of all symmetries of the controller κ(x) is a group
denoted by Aut(κ). Definition 2 says that the state-space transformation Θ maps the i-th region Ri ⊆ X0 to the j-th region
Rj = ΘRi . Furthermore each symmetry (Θ, Ω) ∈ Aut(κ)
maps the control law in region Ri to the control law in region
Rj . The optimal control law for x ∈ Rj = ΘRi is
u0 (x) = ΩFi Θ−1 x + ΩGi
(10)
where Fi and Gi are the optimal feedback and feedforward
gains respectively for region Ri . The following example illustrates the concept of controller symmetry.
Example 1: Consider a model predictive control problem of
the form (1) with horizon N = 5, cost matrices Q = P = I and
R = I, dynamics matrices
1 1
0
A= 2
and
B
=
,
(11)
0 2
1 −1
and box constraints on the state and input
X = {x ∈ R2 : −1 ≤ xi ≤ 1, i = 1, 2}
U = {u ∈ R2 : −1 ≤ ui ≤ 1, i = 1, 2}.
(12a)
(12b)
The partition {Ri }i∈I of the explicit controller κ(x) for this
problem is shown in Fig. 1(a) and the vector field of the optimal
control law u0 (x) = κ(x) is shown in Fig. 1(b).
The symmetry group Aut(κ) of the explicit controller κ(x)
is the dihedral-4 group which consists of the planar rotations by
1247
Fig. 1. Partition {Ri }i∈I and vector field u0 (x) = κ(x) for the explicit
controller κ(x).
90 degree increments and the reflections of the plane about the
horizontal, vertical, and both diagonal axis. This group can be
generated by the 90 degree planar rotation and the reflection
about the vertical axis in the state-space and the 90 degree
planar rotation and the diagonal reflection in the input-space
0 −1 , 0 −1
(Θr , Ωr ) =
(13a)
1 0 1 0 −1 0 , 0 −1
(13b)
(Θs , Ωs ) =
0 1
−1 0
where (Θr , Ωr ) are the 90 degree rotation matrices and
(Θs , Ωs ) are the reflections about the vertical and diagonal axis
respectively.
The symmetry of the explicit controller κ(x) can be seen in
the controller partition {Ri }i∈I shown in Fig. 1(a). Rotating the
partition {Ri }i∈I by increments of 90 degrees does not change
the pattern of the partition. Likewise reflecting the partition
{Ri }i∈I about the horizontal, vertical, or either diagonal axis
does not change the partition.
The symmetry can also be seen in the vector field of the optimal control law u0 (x) shown in Fig. 1(b). Rotating the statespace by 90 degrees is equivalent to rotating the vector field
u0 (x) by 90 degrees Ωr u0 (x) = u0 (Θr x). The points x, y ∈
X0 shown in Fig. 1(b) are related y = Θs x by the vertical
reflection Θs . The vector field at these points is related by the
diagonal reflection Ωs
u0 (y) = u0 (Θs x) = Ωs u0 (x).
(14)
Clearly symmetries (Θ, Ω) ∈ Aut(κ) of the explicit controller κ(x) are symmetries of the underlying optimal control
law u0 (x). However symmetries (Θ, Ω) ∈ Aut(u0 ) of the optimal control law u0 (x) are not necessarily symmetries of the
piecewise affine controller κ(x) i.e., Aut(κ) ⊆ Aut(u0 ). The
symmetries (Θ, Ω) ∈ Aut(κ) of the piecewise affine controller
κ(x) depend on how the feasible region X0 is partitioned
{Ri }i∈I . For instance we can break symmetry by splitting
region Ri but not its image Rj = ΘRi . The following theorem
shows that when {Ri }i∈I is the minimal P-collection partition
for κ(x) then the symmetry group Aut(κ) of the piecewise affine controller κ(x) and the symmetry group Aut(u0 ) of the optimal control law u0 (x) are the same, i.e., Aut(κ) = Aut(u0 ).
Theorem 1: Let κ(x) be the piecewise affine controller (4)
where {Ri }i∈I is the minimal P-collection partition of X0 .
Then Aut(u0 ) = Aut(κ).
Proof: Any symmetry (Θ, Ω) ∈ Aut(u0 ) of the optimal
control law is a symmetry of its piecewise affine expression
κ(x). Thus Aut(κ) ⊆ Aut(u0 ). Next we show the converse.
1248
Suppose (Θ, Ω) ∈ Aut(u0 ) is not a symmetry of the piecewise affine controller κ(x). Then there exists i ∈ I such that
(9) does not hold for any j ∈ I.
Consider the set ΘRi ⊂ X0 . There exists a minimal finite
covering J ⊆ I of this set
int(ΘRi ) ⊆
Rj
(15)
j∈J
since {Ri }i∈I is a partition of the feasible region X0 and
ΘRi ⊆ X0 is a subset of the feasible region. The sets
Pj = (ΘRi ) ∩ Rj
(16)
for j ∈ J are full-dimensional since ΘRi is full-dimensional
and J is a minimal cover. Therefore each Pj contains a set of
affinely independent points. Since Ωu0 (x) = u0 (Θx) at each
of these affinely independent points we have
ΩFi = Fj Θ
ΩGi = Gj
(17a)
(17b)
for each j ∈ J . Thus (ΩFi Θ−1 , ΩGi , ΘRi ) and (Fj , Gj , Rj )
differ only by the partition ΘRi = Rj .
Suppose |J | = 1 then ΘRi ⊂ Rj since ΘRi = Rj . In this
case reverse the roles of i and j and consider a cover K of
Θ−1 Rj where |K| > 1. Since Aut(κ) is a group, (Θ−1 , Ω−1 ) ∈
Aut(κ) implies (Θ, Ω) ∈ Aut(κ). Thus we can assume without
loss of generality that |J | > 1.
For |J | > 1 we can merge the regions Rj for j ∈ J . However this contradicts the assumption that {Ri }i∈I is the minimal
partition. Therefore we conclude that (Θ, Ω) ∈ Aut(u0 ) is a
symmetry of the piecewise affine control law κ(x).
According to Definition 2 each transformation pair (Θ, Ω) ∈
Aut(κ) corresponds to a permutation π : I → I of the controller pieces I where j = π(i) for i and j satisfying (9). It
will be convenient to define a function Π that maps transformations (Θ, Ω) ∈ Aut(κ) to the corresponding permutation of the
controller pieces I.
Definition 3: Let Π : Aut(κ) → Sym(I) be the group
homomorphism that maps controller symmetries (Θ, Ω) ∈
Aut(κ) to the corresponding permutation π = Π(Θ, Ω) : I →
I of the controller pieces I.
The function Π is not necessarily a group isomorphism
since there may be symmetries (Θ, Ω) ∈ Ker(Π) = {(Θ, Ω) ∈
Aut(κ) : Π(Θ, Ω) = e} that map every controller piece i ∈ I
to itself e(i) = i where e is the identity permutation. Symmetries (Θ, Ω) ∈ Ker(Π) in this subgroup Ker(Π) do not help
reduce the memory requirements of storing the explicit model
predictive controller κ(x).
B. Symmetries of the MPC Problem
In this section we define the symmetries of the model predictive control problem (1) and show how they are related to
symmetries of the explicit model predictive controller κ(x).
Symmetries of the model predictive control problem (1) allow
us to determine symmetries of the explicit controller κ(x) without the computational expense of first constructing the controller.
A symmetry of the model predictive control problem (1) is
a transformation of the state-space Θ ∈ Rn×n and input-space
Ω ∈ Rm×m that preserves the cost (1a), dynamics (1b), and constraints (1c) and (1d) of the model predictive control problem.
Definition 4:
1) The pair of invertible matrices (Θ, Ω) is a symmetry of
the cost function (1a) if it satisfies
ΘT P Θ = P
ΘT QΘ = Q
ΩT RΩ = R.
(18a)
(18b)
(18c)
the dynamics (1b) if it satisfies
ΘA = AΘ
ΘB = BΩ.
(19a)
(19b)
the constraints (1c) and (1d) if it satisfies
ΘX = X
ΩU = U .
(20a)
(20b)
The set of all symmetries satisfying (18) is denoted
Aut(P, Q, R). For each (Θ, Ω) ∈ Aut(P, Q, R) the cost (1a)
N −1
of the state trajectory {x(t)}N
t=0 and input trajectory {u(t)}t=0
is the same as the cost (1a) of the state trajectory {Θx(t)}N
t=0
−1
and input trajectory {Ωu(t)}N
t=0 .
Aut(A, B). If the state and input trajectories {x(t)}∞
t=0 and
{u(t)}∞
t=0 are valid for the dynamics (1b) then so are the
∞
state and input trajectories {Θx(t)}∞
t=0 and {Ωu(t)}t=0 for any
(Θ, Ω) ∈ Aut(A, B). For an autonomous system (i.e., B = 0),
(19) says that the vector field f (x) = Ax is invariant under the
state-space transformation Θ, i.e., f (x) = Ax = ΘAΘ−1 x.
Aut(X , U ). This is the set of all state-space and input-space
transformations (Θ, Ω) that preserve the constraint sets ΘX =
X and ΩU = U . The state-space transformation Θ permutes
faces of the polytope X and the input-space transformation Ω
permutes face of the polytope U . In particular Θ and Ω permute
the vertices and facets of the polytopes X and U , respectively.
The symmetry group Aut(M P C) = Aut(P, Q, R)∩Aut(A,
B) ∩ Aut(X , U ) of the model predictive control problem (1)
is the intersection of the symmetry groups of the cost Aut(P,
Q, R), dynamics Aut(A, B), and constraints Aut(X , U ). The
symmetries (Θ, Ω) ∈ Aut(M P C) do not change the cost function J(U, x), feasible region T (x), and the feasible parameterspace X0 of the multi-parametric program (2).
Proposition 2: Each symmetry (Θ, Ω) ∈ Aut(M P C) of the
model predictive control problem (1) satisfies
J ((IN ⊗ Ω)U, Θx) = J(U, x)
(IN ⊗ Ω)T (x) = T (Θx)
ΘX0 = X0
(21a)
(21b)
(21c)
where J(U, x), T (x), and X0 are the cost function, feasible
region, and feasible parameter-space of the multi-parametric
program (2) of the model predictive control problem.
Proof: Define Q = diag(IN ⊗ Q, P ), R = IN ⊗ R, and
⎤
⎤
⎡
⎡
I
0
··· 0
⎥
⎢ A ⎥
⎢ B.
..
A = ⎣ .. ⎦ and B = ⎣
(22)
⎦
..
.
.
N
N −1
B ··· B
A
A
where ⊗ is the Kronecker product. Then the cost function of (2)
can be written
J(U, x) = (Ax + BU )T Q(Ax + BU ) + U T RU.
(23)
1249
By (18) and (19) we have
J ((IN ⊗ Ω)U, Θx)
= (AΘx + B(I ⊗ Ω)U )T Q (AΘx + B(I ⊗ Ω)U )
+ U T (I ⊗ Ω)T R(I ⊗ Ω)U
= (Ax + BU )T (I ⊗ Θ)T Q(I ⊗ Θ)(Ax + BU )
+ U T (I ⊗ Ω)T R(I ⊗ Ω)U
= J(U, x).
(24)
Consider the set
x
F=
: U ∈ U N , Ax + BU ∈ X N +1 .
U
(25)
By (19) and (20) this set satisfies
I
0
F
0 I ⊗Ω
x
=
: (I ⊗Ω)−1 U ∈ U N , Ax+B(I ⊗Ω)−1 U ∈ X N +1
U
x
N
N +1
=
: U ∈ (I ⊗ Ω)U , AΘx + BU ∈ (I ⊗ Θ)X
U
Θ 0
=
F.
(26)
0 I
Thus, (I ⊗ Ω)T (x) = T (Θx) since T (x) = {U : Ux ∈ F} is
the slice
of F at x. Also ΘX0 = X0 since X0 = {x : ∃U
s.t. Ux ∈ F} is the projection of F onto x.
T
T
Proposition 2 says that if U = [uT
is the
0 , . . . , uN −1 ]
optimal solution of the multi-parametric program (2) for x then
T
T
(IN ⊗ Ω)U = [ΩuT
is the optimal solution
0 , . . . , ΩuN −1 ]
to the multi-parametric program for y = Θx. Symmetries
(Θ, Ω) ∈ Aut(M P C) relate the optimal solutions to the multiparametric program (2) at different points x, Θx ∈ X0 in the
feasible region.
The following theorem shows that the symmetries (Θ, Ω) ∈
Aut(M P C) of the model predictive control problem (1) are
symmetries of the optimal control law u0 (x).
Theorem 2: The symmetry group Aut(M P C) of the model
predictive control problem (1) is a subgroup of the symmetry
group Aut(u0 ) of the optimal control law u0 (x).
Proof: Let U (x) be the optimal solution to the multiparametric program (2). By Proposition 2 for each (Θ, Ω) ∈
Aut(M P C) the function (IN ⊗ Ω)U (Θ−1 x) is a feasible and
optimal solution to the multi-parametric program (2). Since
(2) is strictly convex U (x) = (IN ⊗ Ω)U (Θ−1 x) is unique.
Therefore u0 (x) = Ωu0 (Θ−1 x).
It follows from Theorems 1 and 2 that symmetries (Θ, Ω) ∈
Aut(M P C) of the model predictive control problem are symmetries of the explicit controller κ(x) when {Ri }i∈I is the
minimal P-collection partition. In fact we can show that κ(x)
is symmetric with respect to Aut(M P C) when {Ri }i∈I is the
critical region partition.
Corollary 1: Let κ(x) be the optimal piecewise affine controller for the model predictive control problem (1) where
{Ri }i∈I = {CRi }pi=1 is the critical region partition of X0 .
Then Aut(M P C) ⊆ Aut(κ).
Proof: For each (Θ, Ω) ∈ Aut(M P C) there exists
CRj such that P = CRi ∩ ΘCRj is full-dimensional since
{ΘCRi }pi=1 covers ΘX0 = X0 . This set P contains an affinely
Fig. 2. Counter-example showing the symmetry group Aut(κ) of the explicit
controller can be larger than the symmetry group Aut(M P C) of the model
predictive control problem.
independent set of points. Thus Fi Θ = ΩFj and Gi = ΩGj
since (I ⊗ Ω)U (x) = U (Θx) by Proposition 2.
Next we show CRi = ΘCRj . The critical regions CRi is
define as
CRi = x : Fi x+Gi ∈ U N, (A+BFi )x+BGi ∈ X N
(27)
where A and B were defined in (22) and, Fi and Gi were
defined in (3). This region satisfies
ΘCR
i
= x : Fi Θx + Gi ∈ U N , (A + BFi )Θx + BGi ∈ X N
= x : (I ⊗ Ω)−1 Fj x + Gi ∈ U N ,
(I ⊗ Θ)−1 (A + BFj )x + BGi ∈ X N
= x : Fj x + Gj ∈ (I ⊗ Ω)U N ,
(A + BFj )x + BGj ∈ (I ⊗ Θ)X N
= CRj
(28)
by (19) and (20). Thus {CRi }i∈I = {ΘCRi }i∈I . Finally we
conclude that κ(x) = Ωκ(Θ−1 x) since κ(x) is the first m
components of U (x).
The following example shows that the explicit model predictive controller κ(x) can have symmetries (Θ, Ω) ∈ Aut(κ)
that do not appear in the model predictive control problem i.e.,
(Θ, Ω) ∈ Aut(M P C).
Example 2: Consider the model predictive control problem
of the form (1) where the dynamics matrices are
√ √
1 0
2 √2
√
A=
and B =
.
(29)
2
0 1
− 2
The cost matrices are P = Q = In ∈ Rn×n and R = ρIm ∈
Rm×m where ρ = 5 × 106 . The horizon is N = 1. The state
constraints are the octagon shown in Fig. 2(a) and the input
constraints are the box shown in Fig. 2(b).
The model predictive control problem is symmetric with
respect to rotations of the state-space and input-space by
90 degree increments. However the controller κ(x) is symmetric with respect to rotation of the state-space Θ and inputspace Ω by 45 degree increments. This symmetry can be seen
in Fig. 2(c) which shows the controller partition {Ri }i∈I .
The limiting factor in the symmetry group Aut(M P C) of
the model predictive control problem in this example is the input constraint set U . However the optimal controller κ(x) does
not use every possible control input u ∈ U . The image κ(X )
of the optimal control for each x ∈ X is shown in Fig. 2(d). It
can be seen that the optimal controller only uses an octagonal
subset of U . Therefore the explicit controller can have a larger
symmetry group than the model predictive control problem (1).
Likewise the symmetry group Aut(κ) could be strictly larger
than Aut(M P C) if the feasible state-space X0 ⊂ X has more
symmetries than X .
1250
IV. I DENTIFICATION OF S YMMETRY G ROUPS
In this section we describe how to find the symmetry groups
of the explicit controller Aut(κ) and model predictive control
problem Aut(M P C).
A. Identification of Controller Symmetries
In this section we address the problem of finding the set
of all state-space Θ and input-space Ω transformations that
satisfy Definition 2 i.e., (Θ, Ω) ∈ Aut(κ). We call this problem
controller symmetry identification.
Problem 1: Find a set S = {(Θ1 , Ω1 ), . . . , (Θs , Ωs )} of
state-space and input-space transformations that generate the
symmetry group Aut(κ) = S of the explicit controller κ(x).
The following proposition characterizes Aut(κ) as the set
of all linear transformations (Θ, Ω) that permute the extreme
points {xj }qj=1 of the controller partition {Ri }i∈I and the
value uj = κ(xj ) of the controller at these points. The extreme
points {xj }qj=1 of the partition {Ri }i∈I are the vertices of
each polytope Ri for i ∈ I. Similar results can be found in
[9] and [40].
Proposition 3: The symmetry group Aut(κ) of the controller κ(x) is the setof all linear transformations (Θ, Ω) that
q
where xj are the extreme points
permute the set { uxjj }
j=1
of the partition {Ri }i∈I and uj = κ(xj ) is the value of the
controller at these points.
Proof: See [9].
Proposition 3 means that we can identify the symmetry group
Aut(κ) by finding all linear transformations
that permute the
q
control at extreme points { uxjj } . The following theorem
j=1
characterizes the set of all linear transformations (Θ, Ω) ∈
q
n×n
m×m
R
×R
that permute a finite set of points { uxjj } .
j=1
In [8] the authors prove a similar theorem using graph theory
to identify the symmetries of polyhedra. Here we provide an
alternative proof based on linear algebra.
Theorem 3: Let {uj }qj=1 contain a linearly independent subset. The set of all linear transformations Θ and Ω that permute
{xj }qj=1 and {uj }qj=1 is isomorphic to the set of all permutation
matrices P satisfying
−1
−1
P X T (XX T ) X = X T (XX T ) XP
T
T −1
T
T −1
P U (U U ) U = U (U U ) U P
where X = [x1 , . . . , xq ] ∈ Rn×q
Rm×q with isomorphism
(30a)
−1
Procedure 1 Identification of Controller Symmetries
1: Calculate extreme points {xj }qj=1 of the controller partition {Ri }i∈I and control uj = κ(xj ) at these points.
2: Find generators P = {P1 , . . . , Ps } of the group of permutation matrices P ∈ Rq×q that satisfy (30).
3: Calculate generators S = {(Θ1 , Ω1 ), . . . , (Θs , Ωs )} of
Aut(κ) using isomorphism (31) with the permutation
generators P ∈ P.
This procedure can be very computationally intensive. It
requires calculating the full explicit controller κ(x) and finding
the extreme points {xj }qj=1 of the partition {Ri }i∈I . In our experience these steps, rather than finding Perm(κ), dominate the
computational complexity of this procedure. In practice we typically use a subgroup G ⊆ Aut(κ) that is known a priori or can
be calculated more efficiently. We propose using the symmetry
group Aut(M P C) ⊆ Aut(κ) of the model predictive control
problem. In the next section we will show how to identify
Aut(M P C).
(30b)
and U = [u1 , . . . , uq ] ∈
Θ = XP X T (XX T )
−1
Ω = U P U T (U U T ) .
several drawbacks to this approach. A mixed-integer solver will
return all elements of the group Perm(κ) instead of just a set of
generators P. Since the group size |Perm(κ)| can be exponentially larger than its generators |P| this significantly increases
the computational load. Additionally most standard mixedinteger solvers perform poorly on highly symmetric problems
[6], [33]. On the other hand graph automorphism software is
specifically designed to work with highly symmetric problems.
Graph automorphism software packages exploit special properties of groups to improve computation complexity. Additionally
graph automorphism software will find a set of generators P
with bounded cardinality |P| = q−1 for the group Perm(κ). Procedure 1 summarizes the steps for identifying the symmetry group Aut(κ) of the controller κ(x). First we enumerate the
extreme points {xj }qj=1 of the partition {Ri }i∈I and calculate
the value of the controller uj = κ(xj ) at these points. Next we
find a set of generators of the group Perm(κ) using graph automorphism software. Finally we calculate the generators of the
controller symmetry group Aut(κ) using the isomorphism (31).
(31a)
(31b)
Proof: See [14].
We denote the set of all permutation matrices P ∈ Rq×q that
satisfy (30) by Perm(κ). Finding this group can be posed as a
graph automorphism problem [15] and solved using standard
software packages [18], [28], [35]. Standard graph automorphism software packages can identify the group Perm(κ) for
partitions {Ri }i∈I containing thousands of extreme points
{xj }qj=1 .
Remark 1: An alternative approach to finding the set
Perm(κ) is to pose the problem as a mixed-integer feasibility
problem. This approach was taken in [40]. However there are
B. Identification of MPC Symmetries
In this section we address the problem of finding the set of
all state-space Θ and input-space Ω transformations that satisfy
Definition 4 i.e., (Θ, Ω) ∈ Aut(M P C). We call this problem
MPC symmetry identification.
Problem 2: Find a set S = {(Θ1 , Ω1 ), . . . , (Θs , Ωs )} of
state-space and input-space transformations that generate the
symmetry group Aut(M P C) = S of the model predictive
control problem (1).
The symmetry group Aut(M P C) of the model predictive
control problem (1) is a subgroup of the symmetry group
Aut(X , U ) of the constraint sets X and U . For bounded sets
X and U the symmetry group Aut(X , U ) is isomorphic to
a permutation group acting on the non-redundant half-spaces
of X and U . We will denote this group by Perm(X , U ). In
[8] the group Perm(X , U ) was characterized by the set of
1251
all permutation matrices (Px , Pu ) that satisfy the commutative
relationship
−1 T
Hx HxT Hx
Hx
0
Px 0
−1 T
0 Pu
Hu HuT Hu
H
T −1 0 T
u
Hx
0
Hx H x H x
Px 0
=
−1 T
0 Pu
0
Hu HuT Hu
Hu
(32)
Using standard graph automorphism software we can identify the symmetry group Aut(M P C) for constrained linear
systems with a large number of constraints. Identifying the
symmetry group Aut(M P C) of the model predictive control
problem (1) is less computationally demanding than using
Procedure 1 to identify the symmetry group Aut(κ) of the
controller κ(x).
where Hx and Hu are the normalized half-space matrices for X
and U , respectively
V. O RBIT C ONTROLLER
X = {x ∈ Rn : Hx x ≤ 1}
U = {u ∈ Rm : Hu u ≤ 1}.
(33a)
(33b)
The groups Aut(X , U ) and Perm(X , U ) are related by the
isomorphism
−1
Θ = (HxT Hx ) HxT Px Hx
−1
Ω = (HuT Hu ) HuT Pu Hu .
(34a)
(34b)
We extend the result in [8] to find the symmetry group
Aut(M P C) of the model predictive control problem (1).
The symmetry group Aut(M P C) is isomorphic to the group
Perm(M P C) of permutation matrices (Px , Pu ) that satisfies
the commutative relationships (32) and
−1
−1
Px Hx A(HxT Hx ) HxT = Hx A(HxT Hx ) HxT Px
−1
−1
Px Hx B(HuT Hu ) HuT = Hx B(HxT Hx ) HuT Pu
(35a)
(35b)
and
Px H̄x P H̄xT = H̄x P H̄xT Px
Px H̄x QH̄xT = H̄x QH̄xT Px
Pu H̄u RH̄uT = H̄u RH̄uT Pu
−1
(36a)
(36b)
(36c)
−1
where H̄x = Hx (HxT Hx ) and H̄u = Hu (HuT Hu ) .
Equation (35) ensures that the permutation matrices (Px , Pu )
are isomorphic to a transformation (Θ, Ω) that preserves the
dynamics ΘA = AΘ and ΘB = BΩ. Equation (36) ensures
that the permutation matrices (Px , Pu ) are isomorphic to a
transformation (Θ, Ω) that preserves the cost ΘT P Θ = P ,
ΘT QΘ = Q, and ΩT RΩ = R.
Theorem 4: Let Perm(M P C) be the set of all permutation matrices Px and Pu that satisfy (32), (35), and (36).
Then Perm(M P C) is isomorphic to Aut(M P C) with
isomorphism (34).
Proof: See [14], [15].
Procedure 2 summarizes the steps for identifying the symmetry group Aut(M P C) of the model predictive control problem
(1). First we find the generators of the group Perm(M P C) of
all permutation matrices (Px , Pu ) that satisfy (32), (35), and
(36). This can be posed as a graph automorphism problem
[35] and solved using standard software packages [18], [28],
[35]. Next we calculate the generators of the symmetry group
Aut(M P C) using the isomorphism (34).
Procedure 2 Identification of the MPC Symmetries
1: Find a set of generators P = {(Px1 , Pu1 ), . . . , (Pxs , Pus )}
of the permutation group Perm(M P C) that satisfy (32),
(35), and (36).
2: Calculate generators S = {(Θ1 , Ω1 ), . . . , (Θs , Ωs )} of
Aut(M P C) using isomorphism (34) with the permutation generators (Px , Pu ) ∈ P.
In this section we define the orbit controller κo (x) which
uses symmetry to reduce the memory complexity of storing the
optimal control law u0 (x). The results of this section hold for
any subgroup G ⊆ Aut(κ) of controller symmetries. In practice
we use G = Aut(M P C).
A. Orbit Controller
Symmetry tells us that pieces i, j ∈ I of the controller are related by state-space Θ and input-space Ω transformations. Thus
we need only store one of these controller pieces and the other
pieces can be recovered using the symmetry transformations.
This intuition is formalized and generalized using the concept
of a controller orbit.
Two controller pieces i, j ∈ I are symmetrically equivalent
if there exists a state-space and input-space transformation pair
(Θ, Ω) ∈ G ⊆ Aut(κ) that maps controller piece i to piece j =
π(i) for π ∈ Π(G). The set of all controller pieces equivalent to
the i-th piece is called a controller orbit
G(i) = {π(i) : π ∈ Π(G)} .
(37)
The set of controller orbits is denoted by I/G = {G(i1 ), . . . ,
G(ir )}, read as I modulo G, where {i1 , . . . , ir } is a set that
contains one representative controller piece ij from each orbit
G(ij ). With abuse of notation we will equate the set of controller orbits I/G with sets of representative controller pieces
I/G = {i1 , . . . , ir }. The controller orbits G(i) for i ∈ I/G
partition
the controller pieces I into disjoint equivalence classes
I = i∈I/G G(i).
Using orbits the memory requirements for the explicit model
predictive controller κ(x) can be reduced by storing only one
representative i ∈ G(i) from each controller orbit G(i). The
other controller pieces j ∈ G(i) can be recovered using the statespace and input-space transformations (Θ, Ω) ∈ G ⊆ Aut(κ)
and the symmetry relation (9). In terms of the controller orbits,
the optimal control law u0 (x) can be written as
u0 (x) = κo (x)
⎧
ΩFi1 Θ−1 x
⎪
⎪
⎪
⎪
⎪
⎨ +ΩGi1
..
=
.
⎪
⎪
−1
⎪
⎪
ΩF
Θ
x
i
r
⎪
⎩
+ΩGir
if x ∈ ΘRi1 for some (Θ, Ω) ∈ G
(38)
if x ∈ ΘRir for some (Θ, Ω) ∈ G
where {i1 , . . . , ir } = I/G is a set of representative controller
pieces. We call this representation of the optimal control law
u0 (x) the orbit controller κo (x).
The orbit controller κo (x) neglects part of the feasible statespace X0 where the optimal control law u0 (x) is symmetrically
1252
Fig. 3. Connected Components of the orbit graph Γ(S) for the explicit
controller κ(x). The dots represent the graph nodes N = I and the lines
represent the graph edges ES . The graph nodes are drawn inside the region
Ri of the controller piece (Fi , Gi , Ri ) they represent.
Fig. 4.
redundant. The orbit controller κo (x) only explicitly stores the
control law u0 (x) on a subset R̂ of the feasible region X0
R̂ =
Ri ⊂ X 0 .
(39)
i∈I/G
We can visualize the orbit controller in terms of the orbit
graph Γ(S) = (N , E). The node set N of the orbit graph Γ(S)
is the index set I of the controller pieces {(Fi , Gi , Ri )}i∈I . By
(9) the symmetries (Θ, Ω) ∈ Aut(κ) induce sets of edges
E(Θ,Ω) = {(i, π(i)) ∈ I × I : π = Π(Θ, Ω), i = π(i)} (40)
that related controller pieces {(Fi , Gi , Ri )}i∈I . For a subset
of symmetries S ⊆ Aut(κ) we can define the graph Γ(S) =
(N , ES ) whose node set isthe set of controller pieces N = I
and whose edge set ES = (Θ,Ω)∈S E(Θ,Ω) is the union of edge
sets induced by the symmetries (Θ, Ω) ∈ S.
Each connected component of the graph Γ(S) corresponds
to a controller orbit G(i) = {π(i) ∈ I : π ∈ Π(G)} where G = S
is the symmetry group generated by S. The orbit graph Γ(S)
has |I/G| connected components. An orbit controller κo (x)
can be created by selecting one representative controller piece
(Fi , Gi , Ri ) from each connected component of the orbit graph
Γ(S). The symmetries (Θ, Ω) ∈ S allow us to move along the
edges of the orbit graph Γ(S) between controller pieces (Fi ,
Gi , Ri ) for i ∈ I to reconstruct the full explicit controller κ(x).
Obviously the orbit controller κo (x) is not unique since the
choice of controller pieces from each component is arbitrary.
The following example shows the construction of an orbit
controller.
Example 3: In this example we construct an orbit controller
κo (x) for the model predictive control problem defined in
Example 1.
The connected components of the orbit graph Γ(S) =
(N , ES ) for the explicit controller κ(x) and the generating
set S = {(Θr , Ωr ), (Θs , Ωs )} are shown in Fig. 3. The nodes
i ∈ I = N of these components are drawn inside the regions
Ri of the corresponding controller piece (Fi , Gi , Ri ). The
edges are induced by the 90 degree rotation matrix Θr and
horizontal reflection Θs . The |I| = 33 pieces of the explicit
controller κ(x) are organized into |I/G| = 8 orbits: one orbit
of size |G(i)| = 1, six orbits of size |G(i)| = 4 and one orbit of
size |G(i)| = 8. Each of these orbits correspond to connected
components of the orbit graph Γ(S).
The orbit shown in Fig. 3(a) is a singleton orbit |G(i)| = 1.
The orbit shown in 3(e) contains |G(i)| = 8 controller pieces
Partition {Ri }i∈I/G of an orbit controller κo (x).
(Fi , Gi , Ri ). The regions Ri for i ∈ G(i) are related by the
reflections and rotations of the symmetry group Aut(κ) = S.
The feedback Fi and feedforward Gi gains in these regions are
related by (9). This can be seen in the vector field of the optimal
control law u0 (x) shown in Fig. 1.
An orbit controller κo (x) can be created by selecting one
representative controller piece from each orbit. The partition
{Ri }i∈I/G of an orbit controller κo (x) is shown in Fig. 4. The
colored regions represent the pieces of the controller explicitly
stored by κo (x). The control law in the gray regions is recovered using symmetry. This controller contains one node from
each connected component of the orbit graph Γ(S). The choice
of the pieces to store is arbitrary.
B. Synthesis of Orbit Controller
In this section we present a simple procedure for synthesizing
the orbit controller κo (x).
The orbit controller can be synthesized using the steps in
Procedure 3. The first step of this procedure is to generate
the explicit controller κ(x). This can be done using the MultiParametric Toolbox (MPT) [30]. Next a symmetry group G ⊆
Aut(κ) of the controller κ(x) is identified. This can be done using Procedures 1 or 2 to find G = Aut(κ) or G = Aut(M P C),
respectively. Next the orbits G(i) of the controller pieces I are
calculated using Algorithm 2. Finally the orbit controller κo (x)
is constructed by selecting one controller piece (Fi , Gi , Ri )
from each orbit G(i).
Procedure 3 Synthesis of Orbit Controller κo (x)
1: Generate the explicit controller κ(x).
2: Identify a symmetry group G ⊆ Aut(κ) for explicit controller κ(x)
3: Calculate the orbits Gi of the controller pieces I
4: Select a representative controller piece (Fi , Gi , Ri ) from
each orbit G(i).
This procedure can be interpreted in terms of the orbit graph
Γ(S). In the first step we construct the node set I of the orbit
graph Γ(S) by constructing the explicit controller κ(x). In the
second step we find the edge set ES of the orbit graph Γ(S). In
the third step we use the orbit algorithm to find the connected
components of the orbit graph Γ(S). Finally we chose one representative from each connected component of the orbit graph
Γ(S) to produce an orbit controller κo (x).
1253
C. Implementation of Orbit Controller
In this section we discuss the implementation of the orbit
controller κo (x).
The orbit controller κo (x) is implemented using Algorithm 3.
The implementation of the orbit controller κo (x) is similar to
the standard implementation of the explicit controller κ(x) in
Algorithm 1. The point location problem still requires searching
the partition {Ri }i∈I of the feasible region X0 . However this
step is divided into two nested loops. In the outer-loop the
algorithm searches the representative regions {Ri }i∈I/G . In
the inner-loop the algorithm searches the orbit {Rj }j∈G(i) =
{ΘRi }Θ∈G of the representative region Ri for the set Rj =
ΘRi which contains the measured state x ∈ ΘRi .
This search can be interpreted in terms of the orbit graph
Γ(S). In the outer-loop we search among the connected
components of the orbit graph Γ(S). The inner-loop searches
the components. This search can be done efficiently using the
standard orbit search in Algorithm 2 which can be interpreted
as a search of the orbit graph Γ(S) [14].
Algorithm 3 Implementation of Orbit Controller κo (x)
Input: Measured State x
Output: Optimal Control u0 (x)
1: for each Ri ∈ {Rj }j∈I/G do
2: for each Rj ∈ {ΘRi }Θ∈G do
3:
if x ∈ Rj = ΘRi then
4:
return i ∈ I/G and (Θ, Ω) ∈ G
5:
end if
6: end for
7: end for
8: u0 (x) = ΩFi Θ−1 x + ΩGi
Example 4: In this example we demonstrate the implementation of the orbit controller κo (x) in Example 3.
Consider the measured state x shown in Fig. 4. Since the
orbit controller κo (x) does not explicit store the optimal control
law u0 (x) at this state it must be reconstructed using symmetry.
This can be accomplished using Algorithm 3.
The outer-loop of Algorithm 3 searches {Ri }i∈I/G for the
orbit {Rj }i∈G(i) = {ΘRi }Θ∈G of the region Rj = ΘRi that
contains the measured state x ∈ Rj . This corresponds to
searching over the connected components of the orbit graph
Γ(S) shown in Fig. 3. After searching the connected components of the orbit graph Γ(S) shown in Fig. 3(a)–(d) the Algorithm will search the orbit shown in Fig. 3(e) which contains
the region R that contains the measured state x ∈ R. A larger
labeled version of this graph is shown in Fig. 5. This graph is
searched using Algorithm 2. This search returns the symmetry (Θ, Ω) = (Θs Θr Θr , Ωs Ωr Ωr ) ∈ Aut(κ) which maps the
state x into the representative region
x ∈ Θs Θr Θr R.
(42)
The optimal control is then given by
Once the region Rj = ΘRi containing the measured state x ∈
ΘRi has been found the appropriate control action u0 (x) is calculated using the symmetry relation (9). The optimal control is
u0 (x) = ΩFi Θ−1 x + ΩGi
Fig. 5. Connected component {Rj }j∈G(i) = {ΘRi }Θ∈G of the orbit graph
Γ(S) which contains the region ΘRi that contains the measured state x.
(41)
where Θ−1 x ∈ Ri .
The computational complexity of Algorithm 3 is dominated
by the point location problem. In the worst-case Algorithm 3
requires O(|I||S|) point
in set tests x ∈ ΘRi of complexity
O(nci ) where |I| = i∈I/G |G(i)| is the sum of orbit lengths
and S ⊆ Aut(κ) is the generating set of G = S.
The number of point in set tests for Algorithm 3 is worse than
the O(|I|) test used by the simple implementation in Algorithm 1.
The additional computational complexity is a result of the
properties of the domain R̂ ⊆ X0 of the orbit controller κo (x).
The set R̂ = i∈I/G Ri ⊆ X0 is in general non-convex and nonconnected. Thus we must use brute-force techniques to find a
state-space transformation Θ ∈ G that maps the measured state
x ∈ X0 into the domain R̂ ⊂ X0 of the orbit controller κo (x).
This is the main disadvantage of using the orbit controller
κo (x). This issue will be addressed by the fundamental domain controller defined in Section VI. Still the orbit controller
produces memory savings as we will discuss in the next section.
The implementation of the orbit controller is illustrated by
the following example.
u0 (x) = ΩF Θ−1 x + ΩG
= Ωs Ωr Ωr F (Θs Θr Θr )−1 x + Ωs Ωr Ωr G.
(43)
D. Memory Reduction
In this section we discuss the memory advantages of using
the orbit controller κo (x). The group structure of Aut(κ) is
instrumental in reducing the memory needed to store κo (x).
The orbit controller κo (x) saves memory by replacing controller pieces {(Fi , Gi , Ri )}i∈I with symmetries (Θ, Ω) ∈ G ⊆
Aut(κ). We observe that symmetries (Θ, Ω) ∈ G are less
expensive to store than controller pieces (Fi , Gi , Ri ). Each
symmetry (Θ, Ω) ∈ G requires O(n2 ) memory assuming the
number of states n is greater than the number of inputs m ≤ n.
The i-th controller piece (Fi , Gi , Ri ) requires O(nci ) memory
where ci is the number of half-spaces defining region Ri . Since
the regions Ri are bounded ci ≥ n + 1 we have a reduction in
memory O(n2 ) ≤ O(nci ). However for our analysis we will
conservatively assume O(nci ) = O(n2 ).
In practice the main memory savings comes from the fact
that a small number generators S can produces a large number
of symmetries G = S that related many controller pieces. The
orbit controller requires
O(n2 ) (|S| + |I/G|)
2
(44)
memory: O(n )|I/G| memory to store the representative controller pieces {(Fi , Gi , Ri )}i∈I/G and O(n2 )|S| memory to
store the generators of the group G = S ⊆ Aut(κ). On the
1254
other hand the full explicit controller κ(x) requires O(n2 )|I|
memory to store each piece I of the controller individually.
For any group G ⊆ Aut(κ)/Ker(Π) the memory requirements of storing the orbit controller κo (x) are no more than
storing the full explicit controller κ(x) since |S| + |I/G| ≤ |I|.
Proposition 4: Let G ⊆ Aut(κ)/Ker(Π). Then there exists
a generating set S such that |S| + |I/G| ≤ |I|.
Proof: Consider the stabilizer chain
G = G0 ⊇ · · · ⊇ GI/G = Ker (Π(G)) = ∅.
(45)
Let Si = (Gi−1/Gi )\{e} be a set of coset representatives
Gi−1/Gi minus the identity element {e}. By construction Si ∪Gi
I/G
generates Gi−1 = Si ∪Gi . Thus S = ∪i=1 Si generates G = S.
By the orbit-stabilizer theorem |Si | = |Gi−1 i| − 1 ≤ |Gi| −
1 since Gi−1 ⊆ G. Thus
|Gi| − 1 = |I| − |I/G|.
(46)
|S| ≤
i∈I
G
Typically the number of generators S ⊆ G needed to generate the symmetry group G = S will be small compared to the
number of redundant controller piece |S| |I| − |I/G|. For
instance if G = CN is a cyclic group then it can be arbitrarily
large |CN | = N ∈ N while requiring only a single generator
S = {(Θ, Ω)}. If G is an abelian group then it requires at most
k generators where |G| = pn1 1 · · · pnk k is the unique prime-factor
decomposition of its order [32]. If G is a non-abelian finite
simple group (no non-trivial subgroup H ⊂ G satisfies gH =
Hg ∀ g ∈ G) it can be generated by at most 2 generators [36].
Unfortunately quantifying the exact memory savings provided
by orbit controller κ(x) is non-trivial.
The following example shows how the orbit controller κo (x)
reduces the memory requirements of storing the optimal control
law u0 (x).
Example 5: In this example we examine the memory reduction offered by the orbit controller κo (x) defined in Example 3.
The explicit controller κ(x) requires 786 kilobytes to store
the |I| = 33 controller pieces (Fi , Gi , Ri ). The orbit controller
κo (x) requires 207 kilobytes to store the |I/G| = 8 representative controller pieces (Fi , Gi , Ri ) and 1.2 kilobytes to store
the |S| = 2 generators of the symmetry group Aut(κ) = S.
Thus the orbit controller κo (x) achieves nearly a one-quarter
reduction in memory.
VI. F UNDAMENTAL D OMAIN C ONTROLLER
In this section we define the fundamental domain controller
κ̂(x) which uses symmetry to reduce the memory complexity
of storing the optimal control law u0 (x).
A. Fundamental Domains
By the definition of controller symmetry, the optimal control
law u0 (x) at two feasible points x, y ∈ X0 is equivalent if there
exists a state-space transformation Θ ∈ Aut(u0 ) such that y =
Θx. Thus a group G ⊆ Aut(u0 ) will partition the feasible statespace X0 into disjoint point orbits Gx = {Θx : Θ ∈ G}. The
feasible region X0 is partitioned into an uncountable number
of point orbits X0 /G = {Gx : x ∈ X0 }. A fundamental domain
X̂0 ⊆ X0 of the feasible state-space X0 is any subset of X0 that
contains at least one representative from each orbit Gx ∈ X0 /G.
Fig. 6. A fundamental domain X̂ and its orbit for the square X under the
dihedral-4 symmetry group.
The set R̂ in (39) is a fundamental domain of X0 : Each
point x ∈ X0 is contained in some region Rj of the partition
{Ri }i∈I and each region Rj is contained in a controller orbit
Rj ∈ {ΘRi }Θ∈G . Thus R̂ contains at least one representative
x from each point orbit Gx. However working with the set R̂
is difficult since it is generally not convex nor connected. This
means we must use brute-force techniques in the synthesis and
implementation of the orbit controller.
We are interested in fundamental domains that are compact
polytopes. This is desirable since we will be solving an optimization problem on the fundamental domain. In addition we
would like our fundamental domain to be small to minimize the
number of critical regions it intersects. We call a fundamental
domain minimal if all its polytopic subsets are not fundamental
domains.
Definition 5: Let X ⊂ Rn be a polytope and G ⊆ Aut(X ) a
subgroup of symmetries Aut(X ) of this set X . A polytope X̂
is a fundamental domain of X with respect to G if it satisfies
X =
ΘX̂ .
(47)
Θ∈G
The fundamental domain X̂ is minimal if it satisfies
int(Θ1 X̂ ) ∩ int(Θ2 X̂ ) = ∅
(48)
for all Θ1 = Θ2 ∈ G.
The following example demonstrates the concept of a fundamental domain.
Example 6: In this example we construct a fundamental
domain X̂ for model predictive control problem defined in
Example 1. The state-space X = {x ∈ R2 : −1 ≤ x ≤ 1} is
the unit square and the symmetry group Aut(M P C) of the
model predictive control problem is the dihedral-4 group: the
set of planar rotations by 90 degree increments and the reflections about the horizontal, vertical, and both diagonal axis.
Fig. 6(a) shows a fundamental domain X̂ of the square X under the dihedral symmetry group G = Aut(MP C). The blue region is a fundamental domain Xˆ and the gray region is the set X .
Fig. 6(b) shows the orbit {ΘX̂ }Θ∈G of the fundamental
domain. From this figure it is clear that the union of the orbit
{ΘX̂ }Θ∈G covers the square X i.e., X = ∪Θ∈G ΘX̂ . Furthermore the fundamental domain X̂ only intersects its images ΘX̂
on its boundary. Thus the sets Θ1 X̂ ∩ Θ2 X̂ have no interior for
Θ1 = Θ2 . Therefore the set X̂ shown in Fig. 6(a) is a minimal
fundamental domain.
In [14] algorithms for constructing and searching fundamental domains are presented. These algorithms are used in
the synthesis and implementation of the fundamental domain
controller.
1255
B. Fundamental Domain Controller
In this section we show that the optimal control law u0 (x)
can be obtained by solving the model predictive control problem (1) on a fundamental domain X̂ .
Let us consider the model predictive control problem (1)
restricted to a fundamental domain X̂ of the state-space X with
respect to a subgroup of problem symmetries G ⊆ Aut(M P C)
minimize
u0 ,...,uN −1
xTN P xN +
N
−1
xTk Qxk + uTk Ruk
(49a)
k=0
subject to xk+1 = Axk + Buk
xk+1 ∈ X for k = 0, . . . , N − 1
uk ∈ U for k = 0, . . . , N − 1
x0 = x ∈ X̂ .
(49b)
(49c)
(49d)
(49e)
This problem is identical to the original model predictive problem (1) except that the initial state x0 = x is restricted to the
fundamental domain x ∈ X̂ . The feasible state-space X̂0 for
this problem is a fundamental domain of the feasible set X0
of the original model predictive control problem (1).
Lemma 1: The set of initial conditions for which (49) is
feasible X̂0 = X0 ∩ X̂ is a fundamental domain of X0 .
Proof: If x ∈ X̂ then problems (1) and (49) are identical.
Thus x ∈ X̂ is feasible for (49) if and only if it is feasible for (1)
i.e., x ∈ X0 ∩ X̂ . Therefore X̂0 = X0 ∩ X̂ is the set of feasible
initial conditions for (49).
Next we prove X̂0 = X0 ∩ X̂ is a fundamental domain. By
Definition 5 and the symmetry of X0 = ΘX0 the set X̂0 satisfies
ΘX̂0 =
ΘX0 ∩ ΘX̂ =
X0 ∩ ΘX̂ = X0 (50)
Θ∈G
Θ∈G
Fig. 7. The partition {R̂i }i∈Î and vector field u(x) = κ̂(x) of the fundamental domain controller κ̂(x).
Θ∈G
and
Θ1 X̂0 ∩ Θ2 X̂0 = Θ1 X0 ∩ Θ1 X̂ ∩ Θ2 X0 ∩ Θ2 X̂
= X0 ∩ (Θ1 X̂ ∩ Θ2 X̂ )
(51)
where Θ1 X̂ ∩ Θ2 X̂ has no interior for Θ1 = Θ2 . Thus X̂0 is a
fundamental domain of X0 for group G.
Problem (49) is a multi-parametric quadratic program and
therefore has a piecewise affine explicit solution
⎧
⎨ F̂1 x + Ĝ1 for x ∈ R̂1
..
κ̂(x) =
(52)
.
⎩
F̂r x + Ĝr for x ∈ R̂r̂
where Î = {1, . . . , r̂} is the index set of the controller pieces.
We call κ̂(x) the fundamental domain controller. We can extend
this controller from X̂0 to the feasible state-space X0 of (1)
using symmetry
⎧
−1
⎪
x)
for x ∈ Θ1 X̂
⎨ Ω1 κ̂(Θ
.. 1
κ̄(x) =
(53)
.
⎪
⎩ Ω|G| κ̂ Θ−1 x
X̂
.
for
x
∈
Θ
|G|
|G|
This solution covers X0 since {ΘX0 }Θ∈G is a partition of X0 .
The following theorem shows that κ̄(x) is an expression for the
optimal control law u0 (x).
Theorem 5: The controller κ̄(x) in (53) represents the optimal control law u0 (x) for the model predictive control problem
(1) i.e., u0 (x) = κ̄(x) for all x ∈ X0 .
Proof: Let
T
U (x) = u0 (x), . . . , uN −1 (x)
(54)
be the optimal solution of (1) for x ∈ X0 where κ(x) = u0 (x). Let
T
Û (x) = û0 (x), . . . , ûN −1 (x)
(55)
be the optimal solution of (49) for x ∈ X̂0 where κ̂(x) = û0 (x).
By Definition 5 for any state x ∈ X0 there exists y ∈ X̂0
and Θ ∈ G ⊆ Aut(M P C) such that x = Θy. Thus the input
trajectory (I ⊗ Ω)Û (Θ−1 x) = (I ⊗ Ω)Û (y) is defined since
y ∈ X̂0 is in the domain of the function Û . By Proposition 2
this is a feasible solution to (2) since
(I ⊗ Ω)Û (y) ∈ (I ⊗ Ω)T (y) = T (Θy) = T (x).
(56)
By Proposition 2 the cost of this solution satisfies
J (I ⊗Ω)Û (y), x = J (I ⊗Ω)Û (y), Θy = J Û (y), y (67)
where J(Û (y), y) = J(U (y), y) is optimal for y ∈ X̂0 in the
fundamental domain. By the symmetry of the optimal solution
U (x) and cost J(U, x) we have J(U (y), y) = J(U (x), x).
Thus the function
⎧
−1 ⎪
for x ∈ Θ1 X̂0
⎨ (IN ⊗ Ω1 )Û Θ1 x
..
Ū (x) = (58)
.
⎪
⎩ IN ⊗ Ω|G| Û Θ−1 x
X̂
for
x
∈
Θ
0
|G|
|G|
describes the unique optimal solution to (2). This implies
κ̄(x) = κ(x) since these controllers are taken from the first
terms Ū (x) and U (x) respectively. So κ̄(x) = u0 (x) describes the optimal control law.
The concept of a fundamental domain controller is illustrated
in the following example.
Example 7: In this example we construct a fundamental domain controller κ̂(x) for the model predictive control problem
described in Example 1.
We construct a fundamental domain controller κ̂(x) by solving the model predictive control problem on the fundamental
domain shown in Fig. 6(a). The partition {R̂i }i∈Î and vector
field u(x) = κ̂(x) of the resulting fundamental domain controller κ̂(x) are shown in Fig. 7(a) and (b) respectively. Comparing Figs. 1(a) and 7(a) it is clear that {R̂i }i∈Î is the intersection
of the partition {Ri }i∈I of the full explicit controller κ(x) with
the fundamental domain X̂ .
The blue region X̂0 in Fig. 7(b) is the domain of the fundamental domain controller κ̂(x). From this figure it is clear
that X̂0 = X̂ ∩ X0 is a fundamental domain of the feasible set
X0 of the original controller κ(x). Thus through symmetry the
1256
domain of the fundamental domain controller κ̂(x) covers the
entire feasible state-space X0 .
C. Synthesis of Fundamental Domain Controller
In this section we describe how to synthesize the fundamental
domain controller.
The synthesis of the fundamental domain controller κ̂(x)
is described by Procedure 4. First we identify the symmetries
Aut(M P C) of the model predictive control problem (1) using
Procedure 2. Next we construct a fundamental domain X̂ of
the state-space X for G ⊆ Aut(κ) using the method described
in [14]. Finally we solve the model predictive control problem
(49) using the Multi-Parametric Toolbox [30] for MATLAB.
The solution piecewise affine solution κ̂(x) to (49) completely
defines the control law u0 (x) = κ̄(x) for all x ∈ X0 .
Procedure 4 Synthesis of Fundamental Controller κ̂(x)
1: Identify the symmetries Aut(M P C) of the model predictive control problem (1) using Procedure 2.
2: Construct a fundamental domain X̂ of X under G =
Aut(M P C).
3: Solve the model predictive control problem (49) for the
fundamental domain controller κ̂(x).
D. Implementation of Fundamental Controller
In this section we describe the implementation of the fundamental domain controller κ̂(x).
The fundamental domain controller κ̂(x) is implemented
using Algorithm 4. The point location problem has two phases.
In the first phase the algorithm searches the symmetry group
G ⊆ Aut(κ) for a state-space transformation Θ ∈ G that maps
the measured state x ∈ X0 into the fundamental domain X̂0 .
This can be accomplished using the method described in [14].
In the second phase of the point location problem the algorithm
searches the partition {R̂i }i∈Î of the piecewise affine controller
κ̂(x) for the region that contains the state Θ−1 x ∈ R̂i . This
search can be implemented using any of the techniques proposed in the literature [12], [27], [31], [42].
Finally the optimal control is calculated using the symmetry
of the optimal control law
u0 = ΩF̂i Θ−1 x + ΩĜi
Fig. 8. Feasible set X̂0 of the fundamental domain controller κ̂(x) and its
images ΘX̂0 for each symmetry Θ ∈ G.
The computational complexity of Algorithm 4 is dominated
by the point location problem. Finding a state-space symmetry
Θ ∈ G that maps the measured-state x into the fundamental
domain x ∈ X̂ requires O(ncx ) time where cx is the number
of non-redundant half-spaces defining the state constraint set X
[15]. The computational complexity of searching the partition
{R̂}i∈Î of κ̂(x) is O(n log |Î|) [27].
Searching the group G and the controller partition
I have comparable computational complexities O(ncx ) =
O(n log |I|) since the number of critical region |I| grows exponentially with the number of constraints O(|I|) = 2c where c ≥
cx is the total number of constraints in the multi-parametric program (2). Thus the implementation of the fundamental domain
controller κ̂(x) has the same complexity as the implementation
of the full explicit controller κ(x).
The following example illustrates the implementation of the
fundamental domain controller.
Example 8: In this example we demonstrate the implementation of the fundamental domain controller κ̂(x) in Example 7.
Consider the measured state x shown in Fig. 7(a). Since this
state lies outside the domain X̂0 of the fundamental domain
controller κ̂(x) the optimal control at this point must be reconstructed using symmetry. This can be accomplished using
Algorithm 4.
The first step of Algorithm 4 searches the symmetry group
G = Aut(M P C) for a state-space transformation Θ ∈ G that
maps the measured state x into the fundamental domain X̂ . This
can be interpreted as searching a graph of the orbit {ΘX̂ }Θ∈G of
the fundamental domain X̂ shown in Fig. 8. This graph can be
searched using Algorithm 2. This search returns the symmetry
(Θ, Ω) = (Θs Θr Θr , Ωs Ωr Ωr ) ∈ Aut(κ) which maps the state
x into the fundamental domain
(59)
where (Θ, Ω) ∈ G is the symmetry found in the point location
phase, and (F̂i , Ĝi ) are the optimal feedback and feedforward
gains for region R̂i .
Algorithm 4 Implementation of Fundamental Controller
κ̄(x)
Input: Measured State x ∈ X0
Output: Optimal Control u0 (t) ∈ U
1: Find (Θ, Ω) ∈ G such that Θx ∈ X̂0
2: Find R̂j ∈ {R̂i }i∈Î such that Θx ∈ R̂j ⊆ X̂0
3: Calculate optimal control u0 (t) = Ω−1 F̂i Θx + Ω−1 Ĝi
x ∈ Θs Θr Θr X̂ .
(60)
Next Algorithm 4 searches the partition {R̂i }i∈Î of the
fundamental controller κ̂(x) for the region containing the state
(Θs Θr Θr )−1 x. In this case the yellow region shown in Fig. 7(a)
contains (Θs Θr Θr )−1 x. This provides us with the appropriate
feedback F and feedforward G gains.
Finally the optimal control is given by
u0 (t) = ΩF Θ−1 x + ΩG
= Ωs Ωr Ωr F (Θs Θr Θr )−1 x + Ωs Ωr Ωr G.
(61)
1257
TABLE I
C LASSIFICATION OF THE O RBITS G(i) FOR i ∈ I OF
C ONTROLLER P IECES FOR THE C ONTROLLER κ(x)
Fig. 9.
Quadcopter layout.
VII. A PPLICATIONS
In this section we demonstrate the results of this paper on
two applications.
A. Quadcopter
In this section we apply the methodology of this paper to
the construction of an explicit model predictive controller for a
quadcopter. A quadcopter is a type of unmanned aerial vehicle
shown in Fig. 9.
We use the linearized model and controller design presented
in [4], [10]. The model has n = 12 states: 6 cartesian position
and velocity states and 6 angular position and velocity states.
The quadcopter has m = 4 inputs corresponding to the four
rotors.
The quadcopter model predictive control problem has
|Aut(M P C)| = 16 symmetries generated by |S| = 3 generators Aut(M P C) = S. The generators of the state-space
transformations are
!
"
!
"#
1 0 0
−1 0 0
Θ1 = diag I2 ⊗ 0 −1 0 , I2 ⊗ 0 1 0
(62a)
0 0 1
0 0 1
!
"
!
"#
0 1 0
0 −1 0
(62b)
Θ2 = diag I2 ⊗ −1 0 0 , I2 ⊗ 1 0 0
0 0 1
0 0 1
!
"
!
"#
−1 0
0
−1 0
0
Θ3 = diag I2 ⊗ 0 −1 0 , I2 ⊗ 0 −1 0
0
0 −1
0
0 −1
(62c)
where ⊗ is the Kronecker product and diag represents a blockdiagonalization of matrices. The generators of the input-space
transformations are
⎡
⎤
1 0 0 0
0 0 1⎦
Ω1 = ⎣ 0
(63a)
0 0 1 0
0 1 0 0
⎡
⎤
0 1 0 0
0 1 0⎦
(63b)
Ω2 = ⎣ 0
0 0 0 1
1 0 0 0
⎡
⎤
−1 0
0
0
−1 0
0 ⎦
(63c)
Ω3 = ⎣ 0
0
0 −1 0 .
0
0
0 −1
The generator pair (Θ1 , Ω1 ) mirrors the quadrotor through
the xz-plane. The input-space transformation Ω1 swaps motors
2 and 4. The state-space transformation Θ1 reverses the y-axis.
Rotations about the x-axis are reversed since motors 2 and 4
have been swapped.
The generator pair (Θ2 , Ω2 ) rotates the quadrotor 90 degrees
about the z-axis. The input-space transformation Ω2 maps
motor 1 to 2, motor 2 to 3, motor 3 to 4, and motor 4 to 1. The
state-space transformation Θ2 maps the x-axis to the y-axis and
the y-axis to the negative x-axis. Rotations about the x- and y
axis are swapped and rotations about the x-axis are reversed.
The generator pair (Θ3 , Ω3 ) reverses the sign on all the states
and inputs. For any unconstrained system the pair (Θ3 , Ω3 ) =
(−In , −Im ) is a symmetry since (−In )A = A(−In ) and
(−In )B = B(−Im ). Furthermore (Θ3 , Ω3 ) does not change
the cost: (−In )T Q(−In ) = Q and (−Im )T R(−Im ) = R. In
this problem the constraints also happen to be symmetric
X = −X and U = −U . Thus (Θ3 , Ω3 ) is a symmetry of the
model predictive control problem.
We generated an explicit model predictive controller κ(x)
for the quadcopter system using MPT [30]. For a horizon of
N = 2 the explicit controller κ(x) has |I| = 10173 regions and
requires 53.7 megabytes of memory.
From the full explicit controller κ(x) we constructed an orbit
controller κo (x) by discarding pieces (Fi , Gi , Ri ) of the full
explicit controller κ(x) that are redundant under the symmetry
group G = Aut(M P C). The orbits G(i) ⊂ I of the explicit
controller κ(x) are classified by their size |G(i)| in Table I. The
total number of controller pieces in the orbit controller κo (x) is
|I/G| = 772 which requires 4.2 megabytes of memory.
Constructing the full explicit controller for a horizon of
N = 2 required 2.1 hours. We were unable to generate the
full explicit controller for a longer horizon. However using the
fundamental domain controller we able to extend the controller
horizon of N = 3. This is the horizon of the implicit MPC used
in [10]. The fundamental domain controller had 6493 regions
and required 0.8 hours to compute.
B. Network Storage
In this section we apply the methodology presented in this
paper to the network storage problem [17]. The network storage
problem considers the control of a set of a storage devices that
exchange resources through a network Γ = (N , E). The nodes
N of the graph Γ are the storage devices and the edges E are
physical links that allow resource to move between adjacent
storage devices. The storage devices are modeled as discretetime integrators
Ci xi (t + 1) = Ci xi (t) +
uij
(64)
j∈Ni
where Ci is the capacity of the i-th storage device, xi ∈ [0, 1]
is its percentage filled, Ci xi is the total amount of resource
stored in the i-th storage device, uij is the flow from the ith storage device to the j-th storage with uij = −uji , and
Ni = {j ∈ N : {i, j} ∈ E} is the set of nodes adjacent to the
i-th node. Equation (64) is the mass-balance of stored resource
in the i-th storage device.
1258
Fig. 10. Storage network with central storage device connected n − 1 peripheral storage devices.
The storage devices must satisfy box constraints x ∈ X ⊂
Rn for all t ∈ N where
X = {x ∈ Rn : 0 ≤ xi (t) ≤ 1,
∀ i ∈ N }.
(65)
We will consider upper and lower bounds on the network flow
U = {u ∈ Rm : −1 ≤ uij (t) ≤ 1,
∀{i, j} ∈ E}
(66)
where m = |E| is the number of inputs uij for {i, j} ∈ E.
In the network balancing problem the control objective is to
drive the states xi (t) of the storage devices to a common value
xi (t) = xj (t) for all i, j ∈ N . This can be accomplished by the
following one-step model predictive control problem [17]
x(t+1)T P x(t+1) + u(t)T Ru(t)
subject to x(t + 1) = x(t) +
uij (t)
minimize
u(t)
x(t + 1) ∈ X
u(t) ∈ U
x(t) ∈ X
(67a)
(67b)
j∈Ni
(67c)
(67d)
(67e)
where P = I − (1/n)11T and R = ρI.
Consider the storage network shown in Fig. 10. This network
features a central storage device connected to n − 1 peripheral
storage devices. This is a common configuration in Li-Ion
battery packs [16]. The central storage device is a capacitor or
inductor used to move charge between Li-Ion cells arranged
on the periphery. The storage network is used to balance
the battery cells which improves the effective capacity of the
battery network [16].
The number of critical regions |I| in the explicit controller
κ(x) for the model predictive control problem (67) can be
under-bounded by |I| ≥ 3m where m is the number of links.
This is because each link uij can either be saturated at the
upper-bound, saturated at the lower-bound, or not saturated.
The explicit controller κ(x) will have a piece (Fi , Gi , Ri ) for
each of these situations. For a battery pack containing m = 25
cells this means the explicit controller will have at least 847
billion regions. If we assume each of these regions is a simplex
in n = 26 dimensions, stored with single precision floating
point numbers then the explicit controller κ(x) will require on
the order of one petabyte of memory. Thus constructing the
full explicit controller κ(x) for (67) is impractical. However by
exploiting symmetry we can construct the fundamental domain
controller κ̂(x) for this problem.
The storage network shown in Fig. 10 is highly symmetric.
We can permute any of the peripheral nodes of the graph
without changing the structure of the model predictive control
problem (67). Let xn be the state of the central storage device
and x1 , . . . , xn−1 be the state of the peripheral storage devices.
Then the symmetry group Aut(M P C) of (67) consists of all
permutation matrices Θ ∈ Rn×n that fix the central storage
device xn
Ω 0
Θ=
(68)
0 1
where Ω ∈ Rm×m is any permutation matrix on Rm = Rn−1 .
This symmetry group Aut(MP C) is isomorphic to the set of all
permutations Sym(m) of {1, . . . , m} which has m! elements.
The following proposition allows us to analytically construct
a fundamental domain for this problem.
Proposition 5: Let G be the set of all permutation matrices
on Rn and let X satisfy ΘX = X . Then the set of sorted states
X̂ = {x ∈ X : x1 ≤ · · · ≤ xn }
(69)
is a fundamental domain of X with respect to G.
Proof: For any x ∈ X ⊆ Rn there exists a permutation
matrix Θ ∈ Rn×n that sorts the elements of x i.e., x1 ≤ . . . ≤
xn . Thus x ∈ Θ−1 X̂ and hence
X =
Θ−1 X̂ =
ΘX̂ .
(70)
Θ∈G
Θ∈G
Suppose that there are two (or more) permutation matrices Θ1
and Θ2 that sort x ∈ X . Then x̂i = x̂i+1 for some i where x̂ =
Θ1 x = Θ2 x. But the set x̂i = x̂i+1 has no interior since it is
lower dimensional. Therefore int(Θ1 X̂ ) ∩ int(Θ2 X̂ ) = ∅. From this proposition we conclude that the set of sorted
peripheral states is a fundamental domain of X with respect
to the group G = Aut(M P C) ∼
= Sym(m)
X̂ = {x ∈ X : x1 ≤ · · · ≤ xn−1 }.
(71)
This means we can design our explicit model predictive controller κ̂(x) with the assumption that the peripheral states are
sorted.
The fundamental domain controller κ̂(x) constructed on the
set of sorted states X̂ has only 598 regions requiring 8.42 megabytes of storage space. The fundamental domain controller
significantly reduced the size of the explicit model predictive controller without increasing the implementation complexity. Without symmetry the explicit controller would require
at least 847 billion regions and more than one petabyte of
memory.
Implementation of the fundamental domain controller κ̂(x)
follows Algorithm 4. The first step is to find a symmetry Θ ∈ G
that maps the state x into the fundamental domain X̂ . For this
problem we simply sort the states x1 , . . . , xn−1 of the peripheral nodes. This has complexity O(n log n). In the secondstep we search the partition {Ri }i∈I of the explicit controller
κ̂(x) for the region Ri that contains the sorted state Θx ∈ Ri .
Finally we reverse the symmetry to map the optimal control out
of the fundamental domain u0 = Ω−1 F̂i Θx + Ω−1 Ĝi . This is
accomplished by reversing the sort we did in the first step.
VIII. C ONCLUSION
This paper studied symmetry in linear model predictive
control. In the first part of this paper we defined symmetry for a
model predictive controller and the underlying model predictive
control problem. We showed that symmetries of the model predictive control problem are symmetries of the model predictive
controller. In the second part of the paper we presented methods
for efficiently finding the symmetries of a model predictive
controller and model predictive control problem using tools
from group and graph theory. In the third part of the paper
we presented two explicit model predictive control designs
that exploit symmetry to reduce memory requirements. The
orbit controller reduced memory by storing one representative
controller piece from each controller orbit. The fundamental
domain controller reduced memory by solving the constrained
finite-time optimal control problem on a subset of the statespace called a fundamental domain. Finally, we demonstrated
our control designs on a quadcopter and network storage control
problems.
R EFERENCES
[1] J. Avery, S. Rettrup, and J. Avery, Symmetry-adapted Basis Sets.
Singapore: World Scientific, 2012.
[2] Y. Bai, E. Klerk, D. Pasechnik, and R. Sotirov, “Exploiting group symmetry in truss topology optimization,” Optim. Eng., vol. 10, no. 3, pp. 331–
349, Sep. 2009.
[3] A. Bemporad, M. Morari, V. Dua, and E. Pistikopoulos, “The explicit
linear quadratic regulator for constrained systems,” Automatica, vol. 38,
no. 1, pp. 3–20, Jan. 2002.
[4] A. Bemporad and C. Rocchi, “Decentralized linear time-varying model
predictive control of a formation of unmanned aerial vehicles,” in Proc.
Conf. Decision Control, 2011, pp. 7488–7493.
[5] R. Bodi, T. Grundhofer, and K. Herr, “Symmetries of linear programs,”
Note di Matematica, vol. 30, no. 1, pp. 129–132, 2010.
[6] R. Bodi, K. Herr, and M. Joswig, “Algorithms for highly symmetric
linear and integer programs,” Math. Program., vol. 137, no. 1, pp. 65–90,
Feb. 2011.
[7] S. Boyd, P. Diaconis, P. Parrilo, and L. Xiao, “Fastest mixing markov
chain on graphs with symmetries,” J. Optim., vol. 20, no. 2, pp. 792–819,
Mar. 2009.
[8] D. Bremner, M. D. Sikiric, and A. Schuermann, “Polyhedral representation conversion up to symmetries,” in Proc. Workshop Polyhedral
Comput. Centre de Recherches Mathematiques, 2009, pp. 45–71.
[9] D. Bremner, M. Dutour Sikiric, D. Pasechnik, T. Rehn, and
A. Schuermann, “Computing symmetry groups of polyhedra,” 2012,
ArXiV e-prints.
[10] T. Bresciani, “Modeling, identification, and control of a quadrotor helicopter,” M.S. thesis, Lund Univ., Lund, Sweden, 2008.
[11] R. Carter, Molecular Symmetry and Group Theory. New York, NY,
USA: Wiley, 1997.
[12] F. Christophersen, Efficient Evaluation of Piecewise Control Laws Defined
Over a Large Number of Polyhedra. Berlin, Germany: Springer-Verlag,
2007.
[13] R. Cogill, S. Lall, and P. Parrilo, “Structured semidefinite programs for the
control of symmetric systems,” Automatica, vol. 44, no. 5, pp. 1411–1417,
May 2008.
[14] C. Danielson, “Symmetric constrained optimal control: Theory, algorithms, and applications,” Ph.D. dissertation, Univ. California, Berkeley,
CA, USA, 2014.
[15] C. Danielson and F. Borrelli, “Identication of the symmetries of linear
systems with polytopic constraints,” in Proc. Amer. Control Conf., 2014,
pp. 4218–4223.
[16] C. Danielson et al., “Balancing of battery networks via constrained optimal control,” in Proc. Amer. Control Conf., 2012, pp. 0743–1619.
[17] C. Danielson, F. Borrelli, D. Oliver, D. Anderson, and T. Phillips, “Constrained flow control in storage networks: Capacity maximization and
balancing,” Automatica, vol. 49, no. 9, pp. 2612–2621, Sep. 2013.
[18] P. Darga, K. Sakallah, and I. Markov, “Faster symmetry discovery using sparsity of symmetries,” in Proc. Des. Autom. Conf., Jun. 2008,
pp. 149–154.
[19] E. de Klerk, “Exploiting special structure in semidefinite programming:
A survey of theory and applications,” Eur. J. Oper. Res., vol. 201, no. 1,
pp. 1–10, Feb. 2010.
[20] F. Fagnani and J. Willems, “Representations of symmetric linear dynamical systems,” in Proc. Conf. Decision Control, 1991, pp. 17–18.
[21] A. Fässler and E. Stiefel, Group Theoretical Methods and Their Applications. Boston, MA, USA: Birkhäuser, 1992.
[22] E. Friedman, “Fundamental domains for integer programs with symmetries,” Combinatorial Optim. Appl., vol. 4616, no. 1, pp. 146–153, 2007.
[23] K. Gatermann and P. Parrilo, “Symmetry groups, semidefinite programs,
and sums of squares,” J. Pure Appl. Algebra, vol. 192, no. 1–3, pp. 95–
128, Sep. 2004.
[24] B. Goodwine and P. Antsaklis, “Multiagent coordination exploiting system symmetries,” in Proc. Amer. Control Conf., 2010, pp. 830–835.
[25] M. Hazewinkel and C. Martin, “Symmetric linear systems: An application
of algebraic systems theory,” Int. J. Control, pp. 1371–1384, 1983.
1259
[26] D. Holt, B. Eick, and E. O’Brien, Handbook of Computational Group
Theory (Discrete Mathematics and Its Applications). London, U.K.:
Chapman & Hall, 2005.
[27] C. Jones, P. Grieder, and S. V. Rakovic, “A logarithmic-time solution to the
point location problem for parametric linear programming,” Automatica,
vol. 42, no. 12, pp. 2215–2218, Dec. 2006.
[28] T. Junttila and P. Kaski, “Engineering an efficient canonical labeling tool
for large and sparse graphs,” in Proc. Analytic Algorithms Combinatorics,
2007, pp. 135–149.
[29] S. Koehler and F. Borrelli, “Building temperature distributed control via
explicit mpc and "trim and respond" methods,” Proc. Eur. Control Conf.,
pp. 4334–4339, 2013.
[30] M. Kvasnica, P. Grieder, and M. Baotic, Multi-Parametric Toolbox
(MPT), Jul. 2004.
[31] M. Kvasnica, I. Rauova, and M. Fikar, “Automatic code generation for
real-time implementation of model predictive control,” in Proc. Comput.Aided Control Syst. Des., Sep. 2010, pp. 993–998.
[32] S. Lang, Algebra. Berlin, Germany: Springer-Verlag, 2002.
[33] F. Margot, “Symmetry in integer linear programming,” in 50 years of linear programming 1958-2008. Berlin, Germany: Springer-Verlag, 2010.
[34] D. Q. Mayne, J. B. Rawlings, C. V. Rao, and P. O. M. Scokaert, “Constrained model predictive control: Stability and optimality,” Automatica,
vol. 36, no. 6, pp. 789–814, Jun. 2000.
[35] B. McKay and A. Piperno, “Practical graph isomorphism II,” J. Symbolic
Comput., vol. 60, no. 0, pp. 94–112, Jan. 2014.
[36] F. Menegazzo, The number of generators of a finite group, 2003.
[37] P. Parrilo and S. Lall, “Semidefinite programming relaxations and algebraic optimization in control,” Eur. J. Control, vol. 9, no. 2, pp. 307–321,
2003.
[38] Á. Seress, Permutation Group Algorithms. Cambridge, U.K.: Cambridge
Univ. Press, 2003.
[39] J. P. Serre, Linear representations of finite groups. New York, NY:
Springer-Verlag, 1977.
[40] A. Szucs, M. Kvasnica, and M. Fikar, “A memory-efficient representation of explicit mpc solutions,” in Proc. Conf. Decision Control, 2011,
pp. 1916–1921.
[41] A. Tannenbaum, Invariance and System Theory: Algebraic and Geometric
Aspects. Berlin, Germany: Springer-Verlag, 1981.
[42] P. Tondel, T. Johansen, and A. Bemporad, “Evaluation of piecewise affine
control via binary search tree,” Automatica, vol. 39, no. 5, pp. 945–950,
2003.
[43] Y. Wang and M. Morari, “Structure of hierarchical linear systems with
cyclic symmetry,” Syst. Control Lett., vol. 58, no. 4, pp. 241–247,
Apr. 2009.
Claus Danielson (M’14) received the Ph.D. degree
from the Model Predictive Control Laboratory, University of California, Berkeley, in 2014.
His research interests are in model predictive
control, constrained control, and network control
systems. His specialty is developing methods for
exploiting structure in large-scale control and optimization problems.
Francesco Borrelli (SM’10) received the Ph.D. degree from the Automatic Control Laboratory, ETHZurich, Switzerland, in 2002.
He is currently an Associate Professor with the
Department of Mechanical Engineering, University
of California at Berkeley. He is the author of
more than one hundred publications in the field of
predictive control. He is author of the book Constrained Optimal Control of Linear and Hybrid Systems (Springer Verlag). His research interests include
constrained optimal control, model predictive control
and its application to advanced automotive control and energy efficient building
operation.
Dr. Borrelli received the NSF CAREER Award in 2009 and the IEEE Control
System Technology Award in 2012. In 2008, he was appointed the Chair of the
IEEE Technical Committee on automotive control.

Symmetric Linear Model Predictive Control

Transcription

Similar documents

portable usb dj mixer + scratch controll er + dj software

PeopleSoft Finance - Pain Points/Talking Points

Mega Plexxus Instruction

handheld controller

X-Zec 5-W Schenck/Horiba dynamometers controller

SPCA1628 product brief

IMSce™ for V5/V6 - IMS Software, Inc.

VJ SOFTWADE

Your Partner in Taxi Safety Your Partner in Taxi Safety 1

Dynapower Anodize Process Controller