Lately I’ve been distracted by an open research problem left over from my PhD thesis. It’s a problem about lower bounds. When people design and analyze algorithms, they are proving upper bounds on the complexity of a problem. A lower bound, on the other hand, is a proof that the problem cannot be solved without using a certain amount of time (or some other resource), at least within a certain model of computation. Perhaps the most well-known lower bound is the statement that sorting an array of length n requires at least Ω(n log n) binary decisions—comparisons, for example.

So let me define a simple problem, which can be trivially solved in O(n²) steps using a simple pair of nested for-loops. The open question is whether there is a faster algorithm.

AlignedSumLess:
Input: arrays A[0..n], B[0..n], and C[0..2n] of real numbers.
Question: Is A[i] + B[j] < C[i+j] for any indices i and j?1

I repeat: Nobody knows whether this problem can be solved in subquadratic time.2 The best lower bound in any general model of computation (algebraic computation trees, or equivalently, the so-called Real RAM) is Ω(n log n), and this derives essentially from the same information-theoretic argument as the sorting lower bound.

(What do I mean by a “general model of computation”? A technical definition is a bit difficult, but essentially I mean a definition of “algorithm” that doesn’t seem tailored to the problem, or even worse, to the algorithms that we already know for solving the problem. What I most certainly do not mean is “Turing machine”—we want to allow primitive operations that Turing machines can’t do quickly (like random access memory) or at all (like exact real arithmetic). Here there be dragons, or at least, cans of worms.)

It’s not hard to prove an Ω(n²) lower bound in a model where the algorithm is only allowed to branch using questions of the form “Compare A[i]+B[j] to C[k]”. The proof uses an adversary argument. Imagine a game of “(n+1)² questions” between two players, one (the algorithm) asking questions, the other (the input) answering those questions. The algorithm’s goal is to solve the problem as quickly as possible; the input player’s goal is to drag out the game as long as possible. The algorithm wins if he can produce the correct answer after asking fewer than (n+1)² questions; otherwise, the input player wins.

Now imagine that the input player actually an all-powerful malicious adversary. Rather than thinking of a specific input in advance and answering questions accordingly, the adversary chooses answers on the fly to make the algorithm’s life difficult, but always in a way that is consistent with some input. In other words, the adversary can cheat as much as he likes, as long as he doesn’t get caught. Moreover, the adversary knows everything about the algorithm—the code is written on the wall, so to speak—but the algorithm knows only what the adversary tells it.

So here’s our adversary strategy. During the game, we pretend that A[k]=B[k]=6k and C[k]=6k-5 for all k, and we answer every question honestly. With this input, the algorithm’s correct answer is No. Now suppose the algorithm declares a solution without comparing A[i]+B[j] to C[i+j]. We can modify the input, setting A[i] = 6i-2, B[j] = 6j-2, and C[i+j] = 6i+6j-3 but leaving everything else unchanged, and then triumphantly (and correctly) declare “Aha! You’re wrong!” All of our earlier answers are consistent with this newly modified input, so as far as the algorithm knows, that was the input all along! The only way that the algorithm can avoid being fooled is to compare A[i]+B[j] to C[i+j], for all (n+1)² pairs of indices i and j. The adversary always wins!

So in the worst case, the algorithm must ask at least (n+1)² questions to obtain the correct answer, QED.

In my thesis, I extended this adversary argument to allow a larger class of questions, like “Is the expression α A[i] + β B[j] + γ C[k] + δ positive, negative, or zero?” where α,β,γ,δ are arbitrary real numbers. Algorithms that onlly ask questions of this form are called 3-linear decision trees, because the questions ask about the sign of linear expressions involving three of the input values.

Now let’s consider the following related problem, called min-convolution, min-sum convolution, infimal convolution, inf-convolution, or tropical convolution, depending on who you ask. This problem has lots of applications.

(Min,+)-convolution:3
Input: arrays A[0..n] and B[0..n] of real numbers.
Question: For each integer k between 0 and 2n, compute min_i (A[i] + B[k-i]).

Like the earlier problem, we can easily solve this one in O(n²) time with a pair of nested for-loops, and nobody knows whether that is the fastest algorithm.4 Unlike the earlier problem, however, we don’t have a quadratic lower bound for (min,+)-convolution in any model of computation. Our ignorance is complete!

If we had a fast algorithm for this problem, we could easily transform it into a fast algorithm for AlignedSumLess, just by comparing the (min,+)-convolution of A and B to the input array C. Conversely, if we could prove a Ω(n²) lower bound on the complexity of AlignedSumLess, that would immediately imply a Ω(n²) lower bound on the complexity of (min,+)-convolution.

But we have a Ω(n²) lower bound on the complexity of AlignedSumLess, at least in a restricted model of computation. Why aren’t we done? Because the model of computation is too weak! Intuitively, we can’t solve (min,+)-convolution at all without allowing comparisons of the form A[i]+B[j] <? A[i’]+B[j’], and our model of computation doesn’t allow that: too many input variables are involved.

What we need is a Ω(n²) lower bound for AlignedSumLess in the 4-linear decision tree model. I don’t have a clue how to do this. The earlier adversary argument completely breaks down once we allow these four-variable questions.5 Nir Ailon and Bernard Chazelle recently made some progress on proving that harder variants of this problem are, in fact, harder, but their techniques also break down for problems that are this simple.

It’s hard to prove that easy problems aren’t trivial!

Computational geometers might wonder whether there is any connection between these apparently-quadratic problems and the problem 3SUM: Giiven a sett of numbers, do any three sum to zero? The answer is yes, but not the way you might like. Both 3SUM and AlignedSumLess are provably harder than the following totally artificial problem (at least in restrictions of the algebraic decision tree model):

Polyhedral 3SUM:6
Input: arrays A[0..n], B[0..n], and C[0..2n] of real numbers, such that A[i] + B[j] ≤ C[i+j] for all indices i and j.
Question: Is A[i] + B[j] = C[i+j] for any indices i and j?

Don’t ask how we know those input inequalities are satisfied. Let’s just say the knowledge comes down from Mt. Sinai engraved on stone tablets. Can this problem be solved in subquadratic time? Not in the 3-linear decision tree model, but beyond that, nobody knows.

Perhaps the “right” way to think about this problem is geometrically. We are given a point x inside a particularly nice closed (4n+3)-dimensional polyhedron defined by (n+1)² inequalities. Does the point lie on the boundary of the polyhedron? Sure, we can just check each inequality one at a time, each in constant time, but can we do better? The earlier adversary argument implies that none of the inequalities is redundant—the polyhedron has exactly (n+1)² facets. But maybe there’s a hyperplane that separates the facets nicely, or something. Or maybe not. We just don’t know!7

Here’s a nice open problem that I’ve only thought about long enough to convince myself that it’s interesting. The problem comes out of a common and legitimate criticism of my recent computational topology research, which deals with finding various kinds of minimal graph structures on so-called combinatorial surfaces.

A combinatorial surface consists of an abstract 2-manifold M, a graph G embedded in M so that every face of the embedding is a topological disk, and an assignment of non-negative real weights to the edges of G. Roughly speaking, we only allows paths and cycles that are walks or circuits in the graph G; the length of such a path is defined in the usual way, by adding up the weights of the edges along the path, with the right multiplicity. (If a path π traverses an edge e twice, the length of e is counted twice in the length of π.) Paths that cross through the faces of G are not even considered. This definition includes nonconvex polyhedra—like the Stanford bunny—but the edge lengths don’t have to correspond to any nice embedding of the surface. Given two vertices on a combinatorial surface, we can compute the shortest path between them (in G, remember) in O(n log n) time using Dijkstra’s algorithm.

Most people who see this model for the first time ask immediately why I’m interested in something so restrictive. What do results in the combintorial surface model imply about “real” surfaces, where paths can go anywhere and path lengths are continuous rather than discrete? As it turns out, most of the topological results seem to generalize without too much trouble, but the algorithmic results are not so accommodating. (There are also some extremely nasty numerical issues, but to keep the discussion focused, let’s just assume we are working on a real RAM with square roots.)

Here’s a more general and very natural surface model. A piecewise-linear triangulated surface is a collection of n Euclidean triangles, where some pairs of edges (of equal length) are glued together. To keep things simple, let’s imagine that each of the 3n triangle edges is glued to exactly one other edge, so that the resulting topological space is a 2-manifold. Anyone who has played with paper models of polyhedra is already used to this definition.

Any PL surface has a natural metric, inherited from the Euclidean triangles: the length of any path is measured by adding up the lengths of the subpaths within each triangle. Consequently, the intersection of any geodesic (or locally shortest path) with a triangle is a striaght line segment, and if a geodesic crosses an edge, it enters and leaves at the same angle. PL geodesics can only “bend” if they go through vertices.

Okay, so here’s the open problem: Describe an algorithm to compute the shortest path between two points on the same triangle in a piecewise-linear triangulated surface, where the running time is bounded by a function of the number of triangles.

Pretty simple, huh? Obviously, the shortest path is just a line segment insidee the triangle, right? That’s exactly right if the surface can be embedded in some Euclidean space so that every triangle is flat, but not every PL surface has such an embedding. In general, like many “obvious” things, this claim is actually false.

Here’s a simple example1 of a PL surface that has the combinatorial structure of a tetrahedron, but different geometric structure. In particular, there’s no way to actually embed this surface in any Euclidean space so that every triangle lies in a plane. Moreover, the three obtuse vertices are all identified to a single point with total angle greated than 2π, so this can’t fold into a convex polytope. The red line segments show the shortest path between two points on the “big” face.

In fact, as Gunter Rote observed, the number of times that a shortest path can cross through the same triangle is not bounded by any function of the number of triangles. Here’s a simple PL surface I call a “toilet paper tube”. It’s made from four long thin triangle, glued in a cycle along their long edges. There’s no way to embed this surface so that every triangle lies flat in a plane. The shortest path between the two red vertices crosses through each triangle 3 times. By making the triangles longer, we can replace 3 with any positive integer.

We can compute shortest paths in PL surfaces by simulating an expanding circular wavefront from one of the two points. Whenever the wavefront meets a vertex, an edge, or itself, we update our internal description of how the front intersects the facets of the surface. An efficient version of this method was developed by Mitchell, Mount, and Papadimitriou [SICOMP 1987], later refined by Chen and Han [SOCG 1990], and even more recently implemented by Surazhsky et al. [SIGGRAPH 2005]. However, the running time of those algorithms will not be bounded by a function of n, because the wavefront could collide with the same edge arbitrarily many times.

The shortest path problem is open even when the PL surface is isometric to the surface of a 3-dimensional convex polytope, or equivalently by Alexandrov’s theorem, if the angles around every vertex in a PL surface sum to at most 2π. For example, take the toilet paper roll and squeeze the ends together into line segments. Voila! A long skinny tetrahedron!

So now let me repeat a very special case of the open problem. Describe an algorithm to compute the shortest path between two vertices of a PL surface consisting of four triangles and isometric to a convex tetrahedron, using a constant number of exact real arithmetic operations (+,-,×,÷,√,<0?). Should be easy, right?

Right?

Even though we have no hope of computing an explicit list of edges crossed by the shortest path, the crossing sequence might have a concise encoding, similar to the grammars used by Schaefer, Sedgwick, and Stefankovic [COCOON 2002] to encode the normal coordinates of a curve on a triangulated surface. More ambitiously, perhaps the entire shortest path structure has a concise encoding, which can be computed on the fly using the wavefront approach. Alternately, perhaps one could quickly find an isometric PL surface—a decomposition of the same PL surface into different triangles—in which any shortest paths can cross each edge only a constant number of times, and then run the usual wavefront algorithms on the new structure.

And here we hit on the crux of the problem—the edges in a PL surface are red herrings. The actual metric is perfectly flat everywhere except at the vertices, where the surface looks like the top of a cone. The edges tell us only where these cone points are located relative to each other, but the choice of edges is not unique. For example, we can glue two triangles together and then cut the resulting quadrilateral into two different triangles. In fact, every PL surface has an infinite number of isometric representations.

There is a canonical choice of edge for any PL surface: the Delaunay triangulation of the cone points. Just like in the plane, the Delaunay triangulation is the dual of the Voronoi diagram of the cone points, and it can be obtained by repeatedly flipping any pair of triangles whose opposite angles sum to more than π until there are no such pairs. Unfortunately, there is no bound on the number of flips required. Somewhat confusingly, the Delaunay triangulation of the surface of a convex polytope need not have the same facet structure as the polytope itself. It’s also not necessarily a simplicial complex; triangles can be glued to themselves, and pairs of triangles can be glued together more than once.

Can the Delaunay triangulation of a given PL surface be computed quickly? Can shortest paths in Delaunay PL surfaces be computed quickly? Given two points in the same trangle in a Delaunay PL surface, is the shortest path between them a line segment in that triangle? Is there a PL equivalent of the stereographic lifting map? How many licks does it take to get to the Tootsie Roll center of a Tootsie Pop? How much Zen would a Zen master master if a Zen master could master Zen?

By an amazing coincidence, Michael Nielsen is also thinking about shortest paths.

1

Added later: These geometric exampes should be credited to Alexandrov’s 1941 paper where he proves his theorem about nets of convex polyhedra. Alexandrov’s Figure 1 shows the first two of an infinite sequence of nets for the regular tetrahedron; my “toilet paper tube” is equivalent to a later net in this sequence. Figure 2(a) shows a non-standard net of a tetrahedron that cannot be embedded keeping every face flat. Figure 2(b) shows the canonical net, and Figure 2(c) shows the edges of the first net as geodesics on resulting tetrahedron.

Can I get into a top graduate school for computer science with a 3.6 GPA? What schools would I be eligible for? (I have a decent amount of research experience but all of my research is applying CS to other topics)

Every top computer science graduate school regularly admits applicants with 3.6 GPAs. Your GPA definitely won’t get you into a top computer science graduate school, because that’s not how anyone gets in, but it won’t keep you out either.

Here’s some real data from my own CS department, which has been ranked #5 in the country by US News for more than 20 years. We received more than 1450 applicants for Fall 2023 admission to our PhD program. I sorted these by normalized undergraduate GPA—breaking ties randomly—and partitioned them into 100-student cohorts. Here are GPA ranges and numbers of admission offers for the top 12 cohorts, plus a 13th “cohort” for all lower GPAs. (Yes, we got more than 100 applications with perfect 4.00 GPAs, and yes, we rejected most of them.)

1. 4.00 ≤ GPA ≤ 4.00 — 30 admission offers

2. 3.95 ≤ GPA ≤ 4.00 — 31 admission offers

3. 3.92 ≤ GPA ≤ 3.95 — 28 admission offers

4. 3.88 ≤ GPA ≤ 3.92 — 20 admission offers

5. 3.82 ≤ GPA ≤ 3.88 — 19 admission offers

6. 3.77 ≤ GPA ≤ 3.82 — 22 admission offers

7. 3.72 ≤ GPA ≤ 3.77 — 19 admission offers

8. 3.65 ≤ GPA ≤ 3.72 — 13 admission offers

9. 3.59 ≤ GPA ≤ 3.65 — 14 admission offers

10. 3.53 ≤ GPA ≤ 3.59 — 13 admission offers

11. 3.46 ≤ GPA ≤ 3.53 — 13 admission offers

12. 3.38 ≤ GPA ≤ 3.46 — 13 admission offers

13. GPA ≤ 3.38 — >20 admission offers (out of >250 applicants)

All else being equal, a typical applicant with a 3.6 GPA had about 13% chance of admission. For comparison, our overall PhD admission rate this year was about 17%.

But of course, not all else is equal. Admissions committees are looking primarily for concrete evidence of research potential. Your research experience should increase your chances, especially if your statement or purpose describes your research efforts in the fluent technical language of active researchers (as opposed to starry-eyed but uninformed “passion”), and you have supportive letters of recommendation that describe your research efforts in credible, technical, and personal detail. The fact that your experience is all in “applying CS to other topics” is not a problem; with the right spin, your expertise outside CS could be sold as a significant advantage.

This is my response to a recent email from a student, who shall of course remain anonymous.

While doing some web browsing on quantum algorithms, I stumbled upon your page. I noticed that you boast that you have the lowest undergraduate GPA of any professor you have ever met. I am an undergraduate computer science student who dreams of one day obtaining a PhD, but my GPA is less than impressive. If you have a moment, I would love to know how you were able to convince graduate admissions and more importantly, yourself, that you were up to the task of getting a PhD.

Hard work, arrogance, and pure dumb luck.

I always wanted to go to grad school, but I was a LAZY undergrad.1 I spent more time hacking on independent programming projects than on homework or studying for exams. Anything I found boring, I spent no time on whatsoever. Usually, by the time final exams rolled around, I was too far behind to catch up. (I’d love to claim that I spent all that time partying, but I was also a geek.) I aced the programming classes (which landed me some student TA jobs), and I did lots of independent study projects, but I bombed everything else. It wasn’t that I couldn’t understand the material or do the work (at least, if I’d kept up); I just didn’t care.

Hey, it worked in high school. I got into college, despite almost failing English and history, because I was years ahead at math.

My senior year in college, a couple of other computer science majors started their own software company. They hired one of my friends; he suggested they hire me (since I was good at programming). That was where I finally learned to work. School was great, because if I didn’t get something done by the deadline, I didn’t have to do it anymore! Sure, there’s a bad grade, but whatever. At the startup, if I didn’t get something done by the deadline, I still had to do it -- unless I wanted to pay back all the money they’d given me -- only now my boss and co-workers were pissed off. After a few months of this, it finally sunk in that it would be easier just to do the work. I still have to remind myself of this sometimes.

The first time I applied to grad school, I didn’t get in ANYWHERE, despite high GRE scores. I got some rec letters through my undergrad TA jobs, but they all said “he’s smart but lazy”, which is the kiss of death.

The startup was bought by a bigger company in Silicon Valley (which is now part of Apple, or dead, depending on who you ask). By this point I’d learned to work, but I discovered (or remembered) that I was more interested in doing things RIGHT than doing them NOW, which is bad news in the software industry; this wasn’t the place for me. On the other hand, I got a reputation for being able to answer hard math-y questions, and I found myself working through automata theory textbooks for fun while I waited for my program to compile. So I decided to apply again, this time saying I wanted to do software engineering (since I’d been a software engineer for four years) and getting letters from my managers (who said I could work hard) in addition to my old profs (who still remembered me as smart but lazy). I retook the GREs and did well.

This time, I got into a couple of schools. When I arrived at UC Irvine, the director of graduate admissions, a software engineer, told me he had burned some political capital to get me admitted despite my crappy GPA, that he had a lot riding on my success, that he’d gambled on me because of my work experience, and that I’d better not let him down. (That was the last time I ever talked to him. A month later, I realized I didn’t want to do software engineering.)

I think one big reason I got in despite my grades was good timing. I started at Irvine in 1990, at the height of the PC software boom/bubble. It was basically a smaller version of the .com boom/bubble ten years later.2 Most good CS students were getting high-paying programming jobs, or even starting their own companies, right out of college. So fewer people were applying to graduate school, but undergrad demand was up, so more faculty were being hired, so there was more room for grad students. The bar for admissions must have been lower.

Five years later (as I was finishing my PhD), the software bubble burst, and the pendulum swung the other way -- it was hard to find programming jobs, undergrad enrollment dropped, faculty hiring went down, more people applied to grad school. The bar for grad admissions (and faculty jobs) went back up.

The same thing happened later with the .com bust, only this time I saw it from within the grad admission committee. At UIUC, we get many more, and much better, domestic grad school applications now than in previous years. (International applicants are more complicated. Yay 9/11.3) Good grades are a minimum requirement for admission now. Most incoming grad students already have some research experience; some of them even have publications.4 That was not true five years ago.

When grad applications arrive, one of our department secretaries sorts them roughly into three equal piles -- MAYBE, PROBABLY NOT, and NO -- based almost entirely on GPA, weighted by the quality of the school, and GREs. (Penn has a very good program, so this works in your favor.) The committee looks at the MAYBE pile, and if there’s still space, maybe the top of the PROBABLY NOT pile. If a student’s GPA is under 3.0, it’s very likely that no one on the committee will even look at their application. (This is a bit of an oversimplification.)5

...unless they’re rescued by someone on the faculty. Occasionally, I’ll get an email from someone I know at another school asking me to look out for their student’s application and pointing out their other strengths: independent study projects, research experience, internships, other employment, etc. If the student looks interesting, I’ll pass the note to the committee, asking them to look at the file. That doesn’t guarantee that they’ll be admitted, of course -- especially if they’re in the NO pile -- but if a faculty member really wants to admit someone, it’s harder for the committee to say no.

That’s how I got into grad school. Someone on the faculty liked my application, despite my bad grades, and they pulled for me.

Free advice is usually worth exactly what you pay for it, but let me offer one concrete suggestion: Talk to faculty in your department who do the things you’re most interested in. (Penn’s a big department, so you’ll have to hunt them down.) If you’re good at their subject, tell them you’re interested and ask if they can suggest something for you to study further. If you’re not so good at their subject, tell them you’re interested anyway and ask if they have any suggestions for how to improve. Don’t be discouraged if they don’t have time; just ask for suggestions for other faculty to talk to. Figure out what you’re best at, and do something visible with that!

I hope this helps. Good luck!

-- Jeff

Subscribe now

Another One Bites the Dust

I started a TypePad blog “Ernie’s 3D Pancakes” in the early 2000s. Sadly, TypePad closed shop on September 30, 2025. Everything is gone, except through the invaluable services of the Internet Archive’s Wayback Machine.

In concordance with Sturgeon’s Law, most of what my blog was ephemeral fluff, best left in the dustbin of history, but a few posts have received a lot of positive feedback, and even a few citations in the research literature. As a starting point for this Substack, I plan to repost those posts here, along some more recent updates and corrections. I may also repost some of my writing on other platforms like TCS StackExchange, Academia StackExchange, and (most recently) Quora. Hopefuly some people will find these reposts helpful, or at least amusing.

Welcome!