When I mentioned how important smart constructors are for Brzozowski derivatives on Twitter, when Prabhakar Ragde raised an interesting question:

I saw Brzozowski in the hall once and asked him if there was any bound on the growth of regex size. He didn’t know of any work on the subject!

— Prabhakar Ragde (@plragde) May 7, 2020

The question is subtle: it’s not about how many possible derivatives there, but rather a question about size in the worst case. If I start parsing a string s with a regular expression `e`, how big might the nth derivative of `e` be?

I livecoded an empirical answer. TL;DR: the worst-case derivatives are exponentially large!

I hacked up a driver that would (a) enumerate all regular expressions of a certain size and (b) calculate their 1st through nth derivatives, while (c) logging the largest size seen at each step. (You can get the raw CSV from the repo.)

Data in hand, I did some simple analysis in R. First, I plotted the data on a logarithmic graph with linear fit: et voilà, it’s exponential.

With that graph, I granted myself permission to fit an exponential curve:

So: as you take Brzozowski derivatives, your regular expression will—in the worst case—grow exponentially. That sucks. Unsurprisingly smart constructors don’t give asymptotic savings, even though they save you a huge amount of overhead.

## What do you mean, ‘big’?

In my empirical analysis, I used one measure of size: the number of nodes, counting empty regexes as being of size 0. But there are others! In particular, there’s a *height* measure on regular expressions, too.

In the worst case, the size of a regular expression is exponential in its height. Can I characterize how the height of a regular expression grows with the Brzozowski derivative?

I built a small model in Coq and proved that:

- The height of the derivative of a regular expression E is no greater than twice the height of E itself (deriv_height). I doubt that this is a tight upper bound.
- There is no constant k that bounds the size increase of the derivative (deriv_height_constant_general). The general thrust of the proof is as follows. Consider
`e = seq (alt epsilon e1) empty`, where`e1`is a regex with maximal derivative height, i.e.,`h (d c e1) = k + h e1`for some`c`. Note that`alt epsilon e1`is nullable and also has maximal derivative height. We have that`h (d c e) = 2 + h (d c e1')`by definition; by assumption,`h (d c e) <= k + h e = k + 1 + h e1'`. By assumption again,`h (d c e1') = k + h e1'`. But then how can it be that`2 + k + h e1' <= k + 1 + h e1'`?

With these two proofs combined, we can be confident that the exponential growth here is real, and not an artifact of small models. It would be interesting to determine what the multiplier actually is.

In these proofs, I set `s empty = h empty = 0`. It felt right at the time, but maybe it’s a little weird. So I redid the proofs setting them to 1. The dude abides.

## Where next?

I have several remaining questions. Can we characterize which terms have large derivatives? Do they have equivalent forms with smaller derivatives? I suspect right-associating a `seq` will be better than left-associating it. Are there rewrites that ensure non-nullability (or minimize nullability) of the left-hand sides of `seq`s?