A convex combination of these points is a weighted sum $\bm{x}=\sum_iw_i\bm{v}_i$ with non-negative weights $w_i$ satisfying $\sum_iw_i=1$. The convex hull of $\mathcal{V}$ is the set of all convex combinations of points in $\mathcal{V}$. Gathering the points in $\mathcal{V}$ into the columns of the matrix $\bm{V}=[\bm{v}_1,\dots,\bm{v}_n]$, we can write the convex hull as the set

where $\bm{e}$ is a vector of ones, $\bm{w}=[w_1,\dots,w_n]^T$ is the vector of weights, and the inequality is taken elementwise.

In this post, we explore how to put additional constraints on the weights $\bm{w}$ in $\eqref{1}$ and what the resulting set looks like.

Polyhedral Double Description

Let’s begin with some background on polyhedral geometry. A polyhedron is a geometric shape with flat sides (called faces). In this post we will assume we are talking about convex polyhedra; a polyhedron is convex when the line between any two points in the polyhedron is also completely contained in it. A bounded polyhedron is called a polytope and a two-dimensional polyhedron is called a polygon, some examples of which are shown in Figure 1 below.

Figure 1: Examples of two (convex) polygons, each of which can be defined as the convex hull of its vertices.

By the Minkowski-Weyl theorem, any polyhedron $\mathcal{P}$ can be equivalently represented in two different ways, together known as the double description of $\mathcal{P}$. These two representations are:

Vertex Representation

The vertex representation (V-rep) can be written as

where each column of $\bm{V}$ is a vertex and each column of $\bm{U}$ is a ray (together these are referred to as generators). When $\bm{U}=\bm{0}$, $\mathcal{P}$ is just a convex hull like $\eqref{1}$. When $\bm{V}=\bm{0}$, $\mathcal{P}$ instead reduces to a conical hull; however, we will only consider cases with $\bm{U}=\bm{0}$ in this post.

Halfspace Representation

The halfspace representation (H-rep) can be written as

which is a finite intersection of halfspaces. Equality constraints of the form $\bm{A}\bm{x}=\bm{b}$, which serve to restrict to the polyhedron to a lower-dimensional subspace of $\mathbb{R}^d,$ can also be included by equivalently using two inequalities:

Converting from H-rep to V-rep is called vertex enumeration, while converting from V-rep to H-rep is called facet enumeration. No provably polynomial-time algorithms are known for these conversions, but nevertheless they can be computed fairly quickly when the dimension and number of generators and faces is small, using a library like cddlib or its Python bindings pycddlib.

You can read more about polyhedral double description here and see some examples of its application in robotics in this paper as well as this more recent paper of mine.

Computing Constrained Convex Hulls

Now that we’re equipped with some background on polyhedra, you may notice that the set of weights we used to define the convex hull $\eqref{1}$ is itself the H-rep of the polyhedron

This particular polyhedron is known as a simplex and is a special case of the general form $\eqref{2}$ with

where $\bm{1}_n$ is the $n\times n$ identity matrix. To incorporate additional constraints $\bm{\ell}\leq\bm{w}\leq\bm{u}$, where $\bm{0}\leq\bm{\ell}\leq\bm{u}\leq\bm{e}$, $\bm{e}^T\bm{\ell}\leq1$, and $\bm{e}^T\bm{u}\geq1$ (without these latter two conditions, the constraints could be inconsistent because $\bm{e}^T\bm{w}=1$ is impossible to realize if $\bm{e}^T\bm{\ell}>1$ or $\bm{e}^T\bm{u}<1$), we add them to $\bm{A}$ and $\bm{b}$ to obtain

Converting this H-rep to V-rep, we get the set

with some matrix $\bm{Q}$ (note $\mathcal{W}'$ is no longer a simplex). Substituting $\bm{w}=\bm{Q}\bm{y}$ into $\eqref{1}$, we get the constrained convex hull

which is another V-rep polyhedron with weights $\bm{y}$ and vertices given by the columns of $\bm{V}\bm{Q}$.

Visualizing Constrained Convex Hulls

Now that we can compute the vertices of a constrained convex hull, we can plot it. Figure 2 below shows the constrained convex hulls for different values of $\bm{\ell}=\ell\bm{e}$ and $\bm{u}=u\bm{e}$. You can play with this yourself using the Python code here.

Figure 2: Examples of constrained convex hulls. The original convex hull is shown in blue, while each of the red polygons is the convex hull with different bounds applied. From top to bottom we have bounds: $(\ell,u)=(0.05, 1)$, $(\ell,u)=(0, 0.6)$, and $(\ell,u)=(0.05, 0.6)$.

As we can see, the lower bound $\bm{\ell}$ has the effect of “pulling” the hull in from the faces of the original polytope, while the upper bound $\bm{u}$ pulls the hull away from the vertices. We only consider bounds in this post, but in general we can add any desired affine constraints to $\bm{w}$.

Analytical Solutions

It turns out that when have only lower or upper bounds (not both) then we can calculate the vertices of the constrained convex hulls analytically (that is, without converting between V-rep and H-rep).

Lower Bounds

Let us first consider lower bounds $\bm{\ell}$. The $i$th vertex $\bm{v}_i$, which corresponds to weight $w_i\geq\ell_i$, pulls the convex hull toward it from each other vertex by a factor of $\ell_i$. An example with the shape from Figure 2 with a lower bound on only one of the vertex weights and no (additional) upper bounds is shown in Figure 3 below.

Figure 3: The constrained convex hull (red) of the polygon from Figure 2 (blue) with bounds $\bm{\ell}=[\ell,0,0,0,0]^T$, $\ell=0.2$, and $\bm{u}=\bm{e}$. The vertex corresponding to the non-zero lower bound is on the far left side. The lower bound has the effect of “pulling” each of the other vertices toward the bounded vertex, proportionally to the value of the bound. To see this, a line has been drawn between the bounded vertex and each other vertex, with a fraction proportional to $\ell$ coloured yellow and the remainder, proportional to $(1-\ell)$, in green (entire figure shown on gray background for better contrast).

Each vertex $\bm{v}_i'$ of the constrained convex hull depends on the bounds at all vertices of the original shape. To compute it, we have the formula

Implemented in Python code, it looks like

# V is the array of original vertices, one per row, shape (n, d) (yes, this is
# the transpose of the the definition of V in eq. (1) - sorry)
# l is the array of lower bounds, shape (n,)

V_new = []  # vertices of the lower-bounded convex hull
for i in range(n):
    v_new = V[i, :] + sum([l[j] * (V[j, :] - V[i, :]) for j in range(n)])
    V_new.append(v_new)

Upper Bounds

The upper bounds are a bit different. Each lower bound affected all other vertices, while each upper bound only affects the current vertex (i.e., the one corresponding to the bound), and this effect is a function of only the adjacent (i.e., neighbouring) vertices. Furthermore, unlike the lower-bounded case, the upper bound often results in a constrained convex hull with a different number of vertices than the original polytope. An example with the shape from Figure 2 with only a single upper bound on the vertex weights and no (additional) lower bounds is shown in Figure 4 below.

Figure 4: The constrained convex hull (red) of the polygon from Figure 2 (blue) with bounds $\bm{\ell}=\bm{0}$ and $\bm{u}=[u,1,1,1,1]^T$ with $u=0.6$. The vertex corresponding to the non-unity upper bound is on the far left side. The upper bound has the effect of pulling the hull toward the neighbouring vertices, proportionally to $(1-u)$, creating a new face (dashed line). To see this, a line has been drawn between the bounded vertex and its two neighbours, with a fraction proportional to $u$ coloured yellow and the remainder, proportional to $(1-u)$, in green.

Let $\mathcal{V}'$ be the set of vertices of the constrained convex hull, initially empty. Let $\mathcal{A}(\bm{v}_i)$ be the set of indices of the vertices adjacent to vertex $\bm{v}_i$. For each vertex $\bm{v}_i$ and each of its adjacent vertices $\bm{v}_j,j\in\mathcal{A}(\bm{v}_i)$, we compute

and add it to the set of new vertices:

Once we’ve gone through all vertices and their neighbours, we are left with the complete set of vertices $\mathcal{V}'$ of the upper-bounded convex hull. In Python, we have

# V is the array of original vertices, one per row, shape (n, d)
# u is the array of upper bounds, shape (n,)

# note I assume we have a function adj(V, i) that returns the indices of
# vertices adjacent to V[i, :], but this can be computed fairly efficiently (in
# my actual code I use pycddlib, which uses linear programming to compute
# adjacency)

V_new = []  # vertices of the upper-bounded convex hull
for i in range(n):
    for j in adj(V, i):
        v_new = V[j, :] + u[i] * (V[i, :] - V[j, :])
        V_new.append(v_new)

Note that this approach for computing the upper-bounded convex hull only works when $u_i+u_j\geq1$ for all $i=1,\dots,n$ and $j\in\mathcal{A}(\bm{v}_i)$. Otherwise, the new faces added for each upper bound can intersect with each other, which complicates the solution considerably.

Both Lower and Upper Bounds

If we have both lower and upper bounds, we can independently compute the resulting constrained convex hulls using the analytical formulas above. To combine them into a single constrained convex hull, we need to take their intersection—unfortunately, I am not aware of an analytical solution for this in the vertex representation. Instead, we must again turn to polyhedral double description.

Let $\mathcal{V}_\ell$ and $\mathcal{V}_u$ be the sets of vertices of the lower- and upper-bounded convex hulls, respectively. Then:

1. Convert both of these V-rep polytopes to the H-reps $\{\bm{x}\in\mathbb{R}^d\mid\bm{A}_\ell\bm{x}\leq\bm{b}_\ell\}$ and $\{\bm{x}\in\mathbb{R}^d\mid\bm{A}_u\bm{x}\leq\bm{b}_u\}$.
2. Stack the H-reps to combine them into the single polytope $\{\bm{x}\in\mathbb{R}^d\mid\bm{A}\bm{x}\leq\bm{b}\},$ where$$\begin{align*} \bm{A} &= \begin{bmatrix} \bm{A}_\ell \\ \bm{A}_u \end{bmatrix}, & \bm{b} &= \begin{bmatrix} \bm{b}_\ell \\ \bm{b}_u \end{bmatrix}. \end{align*}$$
3. Convert the combined H-rep polytope back into V-rep if desired (e.g., for plotting).

Uniform Padding

Finally, notice that the width of the padding between the boundary of the constrained convex hull and that of the original shape produced by the lower bound in Figure 2 is not uniform. If you do want uniform padding, do the following:

1. Convert the polytope to the H-rep $\{\bm{x}\in\mathbb{R}^d\mid\bm{A}\bm{x}\leq\bm{b}\}$.
2. For each row $\bm{a}_i^T$ of $\bm{A}$ and corresponding element $b_i$ of $\bm{b}$, normalize and subtract the desired padding width $r$:$$\begin{align*} b_i &\leftarrow b_i/\|\bm{a}_i\|_2 - r, \\ \bm{a}_i &\leftarrow\bm{a}_i/\|\bm{a}_i\|_2. \end{align*}$$
3. Convert back to the V-rep for plotting.

The normalization in the second step makes each row $\bm{a}_i$ a unit vector without changing the polytope defined by the inequalities. This ensures each inequality has the same scale, so that subtracting $r$ from each results in the same width of padding for each face. An example of uniform padding is shown in Figure 5 below.

Figure 5: The same polygon from Figure 2 inset with uniform padding of width $r=50$ pixels.

Thanks to Abhishek Goudar for reviewing a draft of this post.

Physics engines are widely used in games and simulators. These engines simulate an environment in a discrete manner: at a given time $t$, they compute the state of the environment (that is, the position and velocities of all objects) at the next time $t+\Delta t$, where $\Delta t>0$ is a small, usually fixed, time step. This process is repeated until the desired duration has elapsed or the simulation is otherwise ended.

One of the physics engine’s main tasks is collision detection; that is, checking if two objects are in contact or overlapping after each time step. For simple shapes like circles and spheres, conditions for collision can be easily derived by hand; for more general shapes, there are many interesting collision detection algorithms like SAT, GJK, and EPA.

However, what if the collision occurs during a time step? For example, consider the shapes in Figure 1 below. The circle (red) is moving with constant velocity toward the stationary wall (blue). As we can see, the circle should collide with the wall during the time step between times $t$ and $t+\Delta t$, but the two shapes are not colliding at times $t$ or $t+\Delta t$. This means that if we only check for collisions at these discrete instants in time, we would miss the collision entirely. This phenomenon is called tunnelling, and is more likely to occur with objects that are thin and/or moving quickly.

Figure 1: A circle (red) tunnelling through a wall (blue) during the time step between times $t$ and $t+\Delta t$.

The solution is continuous collision detection (CCD), in which we check for overlap between the swept areas (or swept volumes, in 3D) of the two objects over the time step. That is, we don’t just look at where the objects end up, but at all of the space they pass through over the time step. Figure 2 shows the swept area of the circle from Figure 1, which does overlap with the wall. Having computed the swept areas, we can use any of the algorithms mentioned above to check for a collision between them.

Figure 2: The swept area of the circle from Figure 1, which overlaps the wall in the hatched region.

When a collision is detected between two swept areas, we typically also want to compute exactly when the collision occurred during the time step, so that behaviour can be adjusted accordingly. For example, at the instant of collision between a ball and a wall, we may reverse the ball’s direction (normal to the wall) to simulate a bounce. We won’t get more into calculating collision time in this post, but you can read more about CCD in games here and here and in robot motion planning here. I also described a form of CCD I used in a research paper in this previous blog post.

As a Visual Effect

Last year I had some fun making a little browser-based game called Saber, in which the player swings around a lightsaber to destroy bouncing balls (if you haven’t played it before, I encourage you to go do so now—it’s fun and will make the rest of this post easier to follow). The saber itself is essentially a thin line segment which can move quite fast, so CCD is needed to reliably detect collisions between it and the balls.

However, the swept area of the saber is not straightforward to compute exactly. Indeed, since the saber experiences both linear and angular motion, the swept area may not even be a convex shape (convexity generally makes collision detection easier). Therefore, to simplify things, I just approximated the swept area over each time step as a quadrilateral (i.e., a four-sided polygon), as shown in the examples in Figure 3 below (the figure is animated—press the small play button in the bottom left corner).

As a collision detection method for the game, the quadrilateral approximation works well. While it may result in spurious detections for non-convex swept areas like the one on the right side of Figure 3, I haven’t really noticed this during gameplay. And besides, tunnelling would be far more jarring than a slightly conservative collision shape.

What I didn’t realize is that this application of CCD also produces a really cool visual effect (in my opinion) if the swept area is drawn at each time step: it looks like the light trail left by a swinging lightsaber, hence the name of the game. You can play with an interactive demo of this effect in Figure 4 (but you should also just go play the game).

Thanks to Galen Leir-Taha for reviewing a draft of this post.

for some eigenvector $\bm{v}$. A general real square matrix may have complex eigenvalues and eigenvectors, so we will limit ourselves to real symmetric matrices (that is, those satisfying $\bm{A}=\bm{A}^T$), which are guaranteed to have real eigenvalues and eigenvectors (note the converse is not true: a matrix does not necessarily have to be symmetric for all of its eigenvalues to be real). We denote the set of real symmetric $n\times n$ matrices as $\mathbb{S}^n$.

The eigenvector $\bm{v}$ in $\eqref{1}$ is free to take any non-zero magnitude, so we will assume $\|\bm{v}\|_2=1$. We can then left-multiply both sides of $\eqref{1}$ by $\bm{v}^T$ to obtain the relationship $\bm{v}^T\bm{A}\bm{v}=\lambda$. Thus the maximum eigenvalue $\lambda_{\max{}}(\bm{A})$ can be expressed as the optimization problem

It turns out that the maximum eigenvalue function $\lambda_{\max{}}:\mathbb{S}^n\to\R$ is convex, even though $\eqref{2}$ looks like a non-convex problem. Indeed, $\eqref{2}$ is a quadratically-constrained quadratic program (QCQP), but neither the objective function nor the constraint are convex (since we have made no definiteness assumptions about $\bm{A}$ and the constraint is a quadratic equality—we will come back to this).

We will explore the convexity of $\lambda_{\max{}}(\bm{A})$ in the rest of the post, which will allow us to have some fun with convex optimization and Lagrangian duality. Similar arguments also reveal that the minimum eigenvalue is a concave function, but we leave that as an exercise to the reader. If you’ve read Convex Optimization by Boyd and Vandenberghe (it’s freely available at the link provided) there shouldn’t be much here that’s totally new to you, but I think we can still enjoy ourselves.

Of course, if your goal is just to find the maximum eigenvalue of a (symmetric) matrix, there are much faster algorithms than the convex optimization problems we’ll explore in this post, but reasoning about eigenvalues is quite fundamental to convex programs arising in control theory, structural analysis, and portfolio optimization, among others. An interactive Python notebook that accompanies this post can be accessed directly in the browser here.

Convexity

Recall that a function is convex if a line segment drawn between any two points on the function lies on or above the function itself. In our case, we have a function of the form $g:\mathbb{S}^n\to\mathbb{R}$; by definition, it is convex if and only if

for any $\bm{A},\bm{B}\in\mathbb{S}^n$ and $t\in[0,1]$. Using $\eqref{2}$, we have

where we have used the fact that the sum of maxima is at least as large as the maximum of a sum, revealing that $\lambda_{\max{}}$ is indeed convex.

In general, the pointwise maximum over a family of convex functions is itself convex (see Figure 1 below for a visual example). That is, if a function $f(\bm{A},\bm{v})$ is convex in $\bm{A}$ for every $\bm{v}\in\mathcal{V}$, then the function

is also convex (see Section 3.2.3 of Convex Optimization). In our case, $f(\bm{A},\bm{v})\coloneqq\bm{v}^T\bm{A}\bm{v}$ is linear in $\bm{A}$, which means it is both convex and concave in $\bm{A}$, for every $\bm{v}$.

Figure 1: The function $g(x)\coloneqq\max_{i=1,2}\ f_i(x)$ (highlighted in red) is the pointwise maximum of two convex functions $f_1$ and $f_2$, and is therefore itself convex.

(Strong) Duality

Earlier we stated that $\eqref{2}$ is a QCQP, but that it is not a convex problem. For it to be convex, the constraint would need to define a convex set (for example, $\|\bm{v}\|_2\leq1$), and, since $\eqref{2}$ is a maximization problem, the objective function would need to be concave (with respect to the optimization variable $\bm{v}$). The function $\bm{v}^T\bm{A}\bm{v}$ is only concave if $\bm{A}$ is negative semidefinite, which means $\bm{v}^T\bm{A}\bm{v}\leq0$ for all $\bm{v}\in\mathbb{R}^n$, and which we denote as $\bm{A}\preccurlyeq\bm{0}$ (analogously, $\bm{A}$ is positive semidefinite if $\bm{v}^T\bm{A}\bm{v}\geq0$ for all $\bm{v}\in\mathbb{R}^n$, and is denoted $\bm{A}\succcurlyeq\bm{0}$). The eigenvalues of a negative semidefinite matrix are all non-positive (and those of a positive semidefinite matrix are all non-negative).

Luckily, despite its non-convexity, $\eqref{2}$ enjoys strong duality. This means that its (convex) dual problem has the same optimal value. To see this, let’s derive the dual problem. The Lagrangian of $\eqref{2}$ is

where $\bm{1}_n$ is the $n\times n$ identity matrix and $\lambda\in\mathbb{R}$ is the dual variable. The dual function is

where the $\sup$ is the supremum, or least upper bound (that is, it is the smallest value that is greater than every value of $\mathcal{L}(\bm{v},\lambda)$). When $\bm{A}-\lambda\bm{1}_n$ is negative semidefinite, the value $\bm{v}^T(\bm{A}-\lambda\bm{1}_n)\bm{v}$ is at most zero for any $\bm{v}\in\mathbb{R}^n$, and so $\mathcal{L}(\bm{v},\lambda)$ is at most $\lambda$; in all other cases it is unbounded above. Since we don’t care about the unbounded case, we restrict the domain to keep the dual function bounded. This yields the dual problem

which is a semidefinite program (SDP), because it includes a semidefinite constraint (that is, a linear matrix inequality). The dual problem is always convex, and SDPs in particular are a class of convex problems that can be solved efficiently with off-the-shelf software, as long as the number of optimization variables is not too large.

Diagonalization Interpretation

One way to interpret $\eqref{3}$ is to consider the eigendecomposition $\bm{A}=\bm{V}\bm{\Lambda}\bm{V}^T$, where $\bm{V}$ is the orthonormal matrix of eigenvectors and $\bm{\Lambda}$ is the diagonal matrix of eigenvalues, which we can use to rearrange the constraint $\bm{A}\preccurlyeq\lambda\bm{1}_n$ to the diagonalized form $\bm{\Lambda}\preccurlyeq\lambda\bm{1}_n$. Since both $\bm{\Lambda}$ and $\lambda\bm{1}_n$ are diagonal, the constraint simply requires $\lambda$ to be no smaller than the largest diagonal element (eigenvalue) of $\bm{\Lambda}$. Thus the minimum possible value of $\lambda$ is the maximum eigenvalue of $\bm{A}$, revealing that $\eqref{2}$ and $\eqref{3}$ have the same optimal values.

Extremal Interpretation

Another (related) way to interpret $\eqref{3}$ is as follows. We can rewrite the semidefinite constraint $\bm{A}\preccurlyeq\lambda\bm{1}_n$ as

Without loss of generality, take $\|\bm{v}\|_2=1$. Then the constraint becomes

which is equivalent to

Obviously, the minimum value of $\lambda$ is obtained at equality:

which is the same problem as $\eqref{2}$.

Geometric Interpretation

Finally, in the special case when $\bm{A}$ is positive definite (that is, all of its eigenvalues are strictly positive), it can be interpreted as defining an ellipsoid $\mathcal{E}$ in $n$-dimensional space centered at the origin:

where the eigenvectors of $\bm{A}$ define the direction of the principal semi-axes of $\mathcal{E}$ and the eigenvalues of $\bm{A}$ are the squares of the lengths of the semi-axes. The problem $\eqref{3}$ can then be interpreted as finding the (square of the) radius of the minimum-volume bounding sphere of $\mathcal{E}$. A two-dimensional example is shown in Figure 2.

Figure 2: The ellipse $\mathcal{E}$ can be defined by a $2\times2$ matrix $\bm{A}$ with eigenvalues $\lambda_1\geq\lambda_2>0$. The radius of the minimum-volume bounding sphere of $\mathcal{E}$ is $\sqrt{\lambda_1}$.

If you know of a good geometric interpretation of $\eqref{3}$ when $\bm{A}$ is a general real symmetric matrix with no definiteness assumptions, I’d like to hear about it!

General Semidefinite Constraints

Any semidefinite constraint is really just an eigenvalue constraint. For example, the constraint $\bm{Y}(\bm{x})\preccurlyeq\bm{0}$, where $\bm{x}$ is our optimization variable, just constrains the maximum eigenvalue of $\bm{Y}(\bm{x})$ to be at most zero. As long as $\bm{Y}$ is affine in $\bm{x}$, then the constraint $\bm{Y}(\bm{x})\preccurlyeq\bm{0}$ is convex. We can easily write the constraint from $\eqref{3}$ in this form by defining $\bm{Y}(\lambda)\coloneqq\bm{A}-\lambda\bm{1}_n$, which is affine in $\lambda$.

Trust Region Subproblem

In general, the problem of optimizing a quadratic objective function subject to a single quadratic constraint (equality or inequality) enjoys strong duality regardless of whether the objective and constraint are convex (see this paper as well as these slides for more information). This class of problem is often known as the trust region subproblem, because it arises as a step in trust region optimization methods. This result is the consequence of a theorem of alternatives known as the S-lemma.

Dual of the Dual

We can also take the dual of $\eqref{3}$. The Lagrangian of $\eqref{3}$ is

where $\mathrm{tr}(\cdot)$ denotes the matrix trace and $\bm{Z}\succcurlyeq\bm{0}$ is the dual variable. The dual function is

where $\inf$ is the infinimum, or greatest lower bound, so the dual problem is

which is also an SDP.

Relaxation Interpretation

It turns out that $\eqref{4}$ is just a semidefinite relaxation of $\eqref{2}$. To see this, observe that we can express $\eqref{2}$ in the equivalent form

which we obtained using the cyclic property of the trace. We can replace $\bm{v}\bm{v}^T$ with a matrix variable $\bm{Z}\succcurlyeq\bm{0}$ constrained to be rank one (because then $\bm{Z}$ can always be decomposed into the outer product $\bm{Z}=\bm{v}\bm{v}^T$), yielding

Finally, relaxing the problem by dropping the non-convex rank constraint gives us $\eqref{4}$. We say that this relaxation is tight because it retains the same optimal value as the original problem $\eqref{2}$.

Sum of the $k$ Largest Eigenvalues

Not only is the maximum eigenvalue of a real symmetric matrix a convex function, but so is the sum of the $k$ largest eigenvalues. If we arrange the eigenvalues of $\bm{A}$ in decreasing order $\lambda_1\geq\lambda_2\geq\dots\geq\lambda_n$, the sum of the $k$ largest is

where we have constrained each eigenvector to be orthonormal. We can also rewrite this problem in the nicer matrix form

where the columns of $\bm{V}\in\mathbb{R}^{n\times k}$ are the eigenvectors. This function is again the pointwise maximum over a family of convex functions, so it is itself convex.

Thanks to Connor Holmes for reviewing a draft of this post.