Suppose we want to find the number of strings of length \( n \) (sourced from some given alphabet \( V \)), which don't contain any of a given set of strings \( B \) as a substring. Is there a fast way to do this?

The most basic case is excluding a string of a single character, in which case there are \( n^{\left|V\right| - 1} \) total strings. But past single character strings, reasoning becomes a bit more difficult. It's always true (and we will show) that the total number of strings follows a linear recurrence and so calculating the first few results using DP and using Berlekamp Massey will give a fast way, though we will show a way to compute a generating function directly.

Let's first define the weight \( W_R \) of some word \( w = w_1 \dots w_n \in V^* \) of length \( n \), and \( R \in \mathbb{Z}^+ \). We will define it using the set of variables \( x\left[w'\right] \) for all \( w' \in V^* \) of length \( R \) or less as follows:

\[ W_R(w) = \prod_{k = 1}^n \prod_{m = k}^{\min(k + R, n)} x\left[w_k \dots w_m\right] \]

Note some factors may appear more than once, for example:

\[ W_2(HELL) = x\left[H\right]x\left[E\right]x\left[L\right]^2x\left[HE\right]x\left[EL\right]x\left[LL\right] \]

Now, we define the generating function over \( x[w] \) where \( w \) has length \( \le R \) as:

\[ \Phi_R = \sum_{w \in V^*} W_R(w) \]

Our strategy will be to perform substitutions on \( \Phi_R \) in order to recover the generating functions we want. For example the mapping:

Will give us the generating function \( \sum a_n x^n \) where \( a_n \) is the number of words of length \( n \) not containing any \( w \in B \) as a substring. We'll denote this generating function by \( f_B(x) \).

For large alphabets and \( R \) the method above will result in a lot of computational effort; our system alone will be of size \( \left|V\right|^R \). We'll introduce the Goulden-Jackson Cluster method as a means of reducing our work.

In this section we'll add a couple of restrictions on our set of bad words \( B \). Firstly, no bad word should appear as a substring of any other bad word - the bigger bad word can be removed from \( B \) for the same end result. Secondly, all \( b \in B \) should be of length at least two. If this is not true, we can equivalently remove \( v \in B \) from our alphabet \( V \).

1. Is the following equivalent to our definition of a cluster: "Define \( (w, S) \) as a cluster if it cannot be decomposed as the concatenation (defined how you would expect) of two nonempty marked words"?
2. How may we find the generating function of the number of words of length \( n \) in which every letter must be contained in a bad word?

• https://uwaterloo.ca/math/sites/default/files/uploads/documents/gjjlms1979.pdf (original paper)
• https://sites.math.rutgers.edu/~zeilberg/mamarim/mamarimPDF/gj.pdf
• https://arxiv.org/pdf/1508.02793.pdf
• https://en.wikipedia.org/wiki/Penney%27s_game

Off the bat, by default the Proced buffer will not update automatically. An update can be manually triggered via g, but to emulate something similar to top / htop behaviour we can set:

(setq-default proced-auto-update-flag t)
(setq proced-auto-update-interval 1)

proced-auto-update-flag enables auto updating the Proced buffer (by default) every five seconds, and we use proced-auto-update-interval to shorten this to every second. We need setq-default for the first of these rather than setq since proced-auto-update-flag is a buffer-local variable (we can make use of this by calling proced-toggle-auto-update within a Proced buffer which will toggle auto-update without changing the global value of proced-auto-update-flag). I'm also not a fan of the default formats, but it's easy to define one yourself and set this as the default:

(add-to-list
 'proced-format-alist
 '(custom user pid ppid sess tree pcpu pmem rss start time state (args comm)))
(setq-default proced-format 'custom)

The car of the value you're adding is the name of the new format, and the other symbols are values which appear in list-system-processes (for more information see proced-format-alist). list-system-processes also gives a nice rundown on the meaning of each attribute. You can also add your own custom attributes, here's a great example I found in legoscia's Emacs config.

Something else you may notice is that moving down a row also sets the column you're in to args, personally I find this annoying, but you can turn this off:

(setq proced-goal-attribute nil)

The final cherry on top is that from Emacs 29 onwards, you can enable colouring for various attributes:

(setq proced-enable-color-flag t)

Which, using our new default format, leaves us with:

Full customisation (using use-package's :custom to handle the vagaries of global and buffer-local variable customisation, thanks to u/deaddyfreddy from reddit for this)

(use-package proced
  :ensure nil
  :commands proced
  :bind (("C-M-p" . proced))
  :custom
  (proced-auto-update-flag t)
  (proced-goal-attribute nil)
  (proced-show-remote-processes t)
  (proced-enable-color-flag t)
  (proced-format 'custom)
  :config
  (add-to-list
   'proced-format-alist
   '(custom user pid ppid sess tree pcpu pmem rss start time state (args comm))))

proced-grammar-alist opens the door for a lot of control over how attributes are shown in Proced buffers. The documentation goes into a lot of detail, but I'll provide a quick example here to give an idea.

Suppose our goal is to set the colour of Java executables in the args column to that strange orangey-brown colour that everyone seems to associate with Java. We can start by first defining our format function:

(defun my-format-java-args (args)
  (pcase-let* ((base (proced-format-args args))
               (`(,exe . ,rest) (split-string base))
               (exe-prop
                (if (string= exe "java")
                    (propertize exe 'font-lock-face '((t (:foreground "#f89820"))))
                  exe)))
    (mapconcat #'identity (cons exe-prop rest) " ")))

Now, we just need to tell proced-grammar-alist to use this function for the args attribute:

(setf (alist-get 'args proced-grammar-alist)
      '("Args"               ; name of the column
        my-format-java-args  ; format function
        left                 ; alignment within column
        proced-string-lessp  ; defines the sort method (ascending)
        nil                  ; non-nil reverses sort order
       (args pid)            ; sort scheme
       (nil t nil)))         ; refiner for custom refinement logic - see proced-refine

And you should see the results straight away:

Thanks to Michael Albinus, from Emacs 29 onwards invoking proced when default-directory is remote (for example, your current buffer points to a remote file) and proced-show-remote-processes is non-nil, will prompt Proced to show processes from the remote system instead of your local machine, which can make proced a lot more useful when working with tramp.

• https://www.masteringemacs.org/article/displaying-interacting-processes-proced
• https://emacsredux.com/blog/2013/05/02/manage-processes-with-proced/

For brevity, lets let \( k = 974170 \). Now, the first part of question is equivalent to finding \( a,b \) such that: \[ \frac{a}{b} * \frac{a - 1}{b - 1} = \frac{1}{k} \]

Multiplying out:

Where the second step just follows from the quadratic formula. Clearly, if \( b \) is positive we can disregard the negative sign, and note that radicand is always odd, hence if it's square, then the root will also be odd and thus the numerator even, and hence \( b \) will be a whole number.

So our problem reduces to finding \( a \) values such that the expression \( 1 + 4ka^2 -4ka \) is itself square. Now suppose \( 1 + 4ka^2 - 4ka = x^2 \) for some \( x \). Then we can complete and square and rearrange to obtain:

Which is of the form of a generalised Pell's equation (letting \( y = 2a - 1, -k + 1 = N \)), which are quite tricky to solve. Solutions generalised Pell's equations can be grouped into seperate classes, and the fundamental solutions of each class can then be used to generate all solutions for that particular class. A fast method for solving these equations can be found here.

We find the fundamental solutions for each class in our case to be:

\[ (x, y) \in \{(-229969, 233), (-1, 1), (1, 1), (229969, 233), (974169, 987)\} \]

In order to determine all solutions for each class, consider \( r = x + y\sqrt{974170} \). We see \( (x, y) \) is a solution to (1) iff \( M(r) := r \bar{r} = (x + y\sqrt{974170})(x - y\sqrt{974170}) = -974169 \). Now it is straighforward to show \( M: \mathbb{Z}[\sqrt{974170}] \to \mathbb{Z} \) is multiplicative, and so if we can find an \( r' = a + b\sqrt{974170} \in \mathbb{Z}[\sqrt{974170}] \) such that \( M(r') = 1 \) we can generate an infinite stream of solutions.

However, \( M(r') = 1 \iff (a + b\sqrt{974170})(a - b\sqrt{974170}) = 1 \iff a^2 -974170b^2 = 1 \) which is just a regular Pell's equation! This has fundamental solution \( (a, b) = (1948339, 1974) \) and so we can formulate new solutions to (1) using \( x_n + y_n\sqrt{974170} = (1948339 + 1974\sqrt{974170})^n(x + y\sqrt{974170}) \) and it turns out all solutions are of this form when \( (x, y) \) are the fundamental solutions to (1).

\( (x_n, y_n) \) grow exponentially in relation to \( n \), so computing \( y \) as to make \( b \) of at least 100 digits can be done extremely quickly. The smallest such \( (x, y) \) are:

Finding the corresponding \( a \) and \( b \) is left to the reader (:

This is nice and all, but what if I was wrapping some kind of markdown, specifically Github Markdown? The biggest problem here would be wrapping links, whose character length far exceeds the length of the link description (which would be rendered):

>>> import textwrap
>>> textwrap.wrap("`avy` is a GNU Emacs package for jumping to visible text using a char-based decision tree.  See also [ace-jump-mode](https://github.com/winterTTr/ace-jump-mode) and [vim-easymotion](https://github.com/Lokaltog/vim-easymotion) - `avy` uses the same idea.")
['`avy` is a GNU Emacs package for jumping to visible text using a',
 'char-based decision tree.  See also',
 '[ace-jump-mode](https://github.com/winterTTr/ace-jump-mode) and',
 '[vim-easymotion](https://github.com/Lokaltog/vim-easymotion) - `avy`',
 'uses the same idea.']

But if we were to use this, it would be rendered as:

`avy` is a GNU Emacs package for jumping to visible text using a
char-based decision tree.  See also
ace-jump-mode and
vim-easymotion - `avy`
uses the same idea.

Essentially, we want the length of Github links to be taken from the length of their descriptions alone. It isn't immediately clear how this can be achieved looking at textwrap.TextWrapper, but digging a little deeper in the textwrap module source code we see:

while chunks:
    l = len(chunks[-1])

    # Can at least squeeze this chunk onto the current line.
    if cur_len + l <= width:
        cur_line.append(chunks.pop())
        cur_len += l

    # Nope, this line is full.
    else:
        break

And further, chunks is set from a TextWrapper._split call. This suggests if we create our own TextWrapper subclass and identify links in our _split method, we can set the length by somehow jumbling link strings so they return the length of their description rather than their true length on a len call. We can do this by subclassing str:

import re
from textwrap import TextWrapper


class MarkdownLink(str):
    def __new__(cls, url, description):
        obj = str.__new__(cls, f"[{description}]({url})")
        obj.url = url
        obj.description = description
        return obj

    def __len__(self):
        return len(self.description)


class MarkdownTextWrapper(TextWrapper):
    """A TextWrapper which handles markdown links."""

    LINK_REGEX = re.compile(r"(\[.*?\]\(\S+\))")
    LINK_PARTS_REGEX = re.compile(r"^\[(.*?)\]\((\S+)\)$")

    def _split(self, text):
        split = re.split(self.LINK_REGEX, text)
        chunks: List[str] = []
        for item in split:
            match = re.match(self.LINK_PARTS_REGEX, item)
            if match:
                chunks.append(MarkdownLink(match.group(2), match.group(1)))
            else:
                chunks.extend(super()._split(item))
        return chunks

Lets use it:

>>> import textwrap
>>> textwrap.wrap("`avy` is a GNU Emacs package for jumping to visible text using a char-based decision tree.  See also [ace-jump-mode](https://github.com/winterTTr/ace-jump-mode) and [vim-easymotion](https://github.com/Lokaltog/vim-easymotion) - `avy` uses the same idea.")
['`avy` is a GNU Emacs package for jumping to visible text using a char-based',
 'decision tree.  See also [ace-jump-mode](https://github.com/winterTTr/ace-jump-mode) and [vim-easymotion](https://github.com/Lokaltog/vim-easymotion) - `avy` uses the same',
'idea.']

Which renders as:

`avy` is a GNU Emacs package for jumping to visible text using a char-based
decision tree.  See also ace-jump-mode and vim-easymotion - `avy` uses the same
idea

Nice! 👌

Given some images, if we want three images per row, something like:

montage -geometry +0+0 starship-troopers.jpeg a-spell-for-a-chameleon-l.jpeg the-caves-of-steel.jpeg the-count-of-monte-cristo.jpeg a-wizard-of-earthsea.jpeg tmp.jpeg

Gives us:

ImageMagick has done its best to set the distance between images as zero, but this appears to have lead to inconsitency of column sizes. Generally different sized images aren't going to work too nicely with one another.

In the example above I've made it so that larger images are 4x the size of the smaller ones (ie 2x width and 2x height). A "nice" tiling is possible if we make all of the images the same size… by splitting up the larger images into quarters.

We split larger images into four smaller ones, taking care that we always align the bottom two images on the same columns below the top two images. I've offloaded this tiling specification of our "split" images to a script.

But does this work? Yes!

Strangely enough there exists no such polynomial if \( P \) has some non integer coefficient. Proof is thanks to this mathoverflow answer:

First define \( D(X) \in \mathbb{Z}[X] \) as \( D(X) = \prod (X - x_i) \), ie the monic polynomial of degree \( n \) whose roots are the \( x \) coordinates of our points.

Next, suppose \( F(X) \) has coefficients all integers. Since \( D(X) \) is monic we can write:

\[ F(X) = D(X)Q(X) + R(X) \]

Where \( Q(X), R(X) \in \mathbb{Z}[X] \), and also \( deg(R(X)) < deg(D(X)) \).

Now we must have \( F(x_i) = R(x_i) \), but this implies that \( R(X) \) is the Lagrange interpolating polynomial since it has degree less than \( n \) and satisfies \( R(x_i) = P(x_i) \) for all \( i \). Thus we can re-write:

\[ P(X) = F(X) - D(X)Q(X) \]

Which implies that \( P(X) \in \mathbb{Z}[X] \) since that latter set is closed under addition and multiplication.

If we stack each pass of the process on top of one another, we obtain the diagram:

Note starting with more 1s in the first row simply extends the diagram to the right and does not change the triangle left of the new column. It can be seen from our definition above, each element in the diagram (above the first row) is equal to the sum of the element above it and the element immediately to the left of it, save for the elements we are interested in, which are equal solely to the elements above them.

However, we can incorporate these elements into the relation by making the following edit to our diagram:

Let \( n \) span accross the columns, and \( k \) span accross the rows (like Pascal's triangle), ie so that \( f(3, 1) = 3 \) and consider the diagram again. We obtain:

Formally:

We can reason from the above recursion that each number in the diagram can be written as some sum of the leftmost nonzero elements on each row, added to some sum of elements in the first row (\( k = 0 \)), which also happen to be equal to the leftmost element of the first row (\( f(0, 0) = 1 \)). These are the numbers we are interested in. ie:

\[ f(n) = \sum_{r=1}^{n-1} A_r * f(r) \]

Where \( A_r \) is some constant to be determined. Now we can consider how each \( f(r) \) contributes to \( f(n) \) via the following diagram:

Where \( C, B, D \) are constants consisting of sums of other \( f(s) \). Note we do not arrow constributions to \( f(r+1) \) as these are the source of the contributions and we need to keep these "atomic". We can observe from this diagram that:

\[ A_r = f(n - r) \]

This also works for the base row, as we can just rewrite 1 = f(1) (thus all constants are 0), and hence:

\[ f(n) = \sum_{r=1}^{n - 1} f(r)*f(n - r) \]

First of all lets let \( f(0) = 0 \) which will make things a little simpler, now let's define the generating function:

\[ F(x) = \sum_{n=0} f(n)x^n \]

And now sum our recursion over all \( n \) where it's valid (\( n > 2 \)):

\[ \sum_{n=2} f(n)x^n = \sum_{n=2}\sum_{r=0}^{n} f(r)*f(n - r)x^n \]

Simplifying the LHS and using the definition of multiplication in the ring of formal power series on the RHS:

\[ F(x) - x = \sum_{n=0}f(n)x^n \sum_{n=0}f(n)x^n \]

Simplifying and collecting terms:

\[ F(x)^2 - F(x) + x = 0 \]

Quadratic formula (neglecting + sign, this will give us \( f(0) = 1 \) ):

\[ F(x) = \frac{1 - \sqrt{1 - 4x}}{2} \]

Attempt to extract \( x \) coefficients using binomial expansion:

\[ F(x) = \frac{-1}{2}\left( \frac{\frac{1}{2}}{1!}\left(-4x\right) + \frac{\frac{1}{2}\frac{-1}{2}}{2!}\left(-4x\right)^2 + ... \right) \]

After some arduous simplifications, we find the general \( x \) coefficient is given by:

\[ \frac{(2n - 2)!}{n! * (n - 1)!} \]

Which is the (n - 1)th Catalan number, ie \( f(n) = C_{n - 1} \).

Consider some valid partition \( P \) of \( n \):

\[ P = (a_1, a_2, ...) \]

And let:

\[ f(P) = a_1 * a_2 * ... \]

Note that all natural numbers > 1 can be written as a sum of 2s and 3s exclusively, ie

\[ a_1 = 2 + 2 + ... + 3 + 3 + ... \]

What we will now show is that taking all the elements in the partition and breaking them up into 2s and 3s, will give a better partition.

Lemma 1: The product of some sequence of 2s and 3s is always greater or equal to the corresponding sum with equality holding iff the sequence is (2, 2), (2,) or (3,). Proof:

\[ 2 * 2 = 2 + 2 \] \[ 3 * 2 > 3 + 2 \] \[ 3 * 3 > 3 + 3 \]

Hence if:

\[ P_a_1 = (2, 2, ..., 3, 3, ...) \]

Then

\[ ka_1 \leq k f(P_a_1) \ \forall k \in R+ \]

With equality holding iff \( a_1 < 5 \). From this it is clear that the optimal partition will consist of some sequence of 2s and 3s. For most numbers however there are many ways to split a number into sums of 2s and 3s. We will now show how to find the optimal partition. Note:

\[ 3 + 3 = 2 + 2 + 2 \] \[ 3 * 3 > 2 * 2 * 2 \]

This implies that there will be no more than two lots of 2s in the optimal partition. If \( 3 | n \) then the optimal partition is three lots of \( \frac{n}{3} \). If we consider trying to improve upon this partition by breaking up a 3 into a 2 and a 1 , we decrease the product. And if we try to improve upon the partition by combining 3s we decrease the product by lemma 1. Therefore the partition is optimal in this case. Now consider:

\[ 1) n \equiv 1 \ mod \ 3 \Rightarrow \exists k \in N \ s.t \ n = 3k + 1 \] \[ 2) n \equiv 2 \ mod \ 3 \Rightarrow \exists k \in N \ s.t \ n = 3k + 2 \]

For 1) we can choose from (1, 3 k times) or (2, 2, 3 (k - 1)) times. Given 2 * 2 > 3 * 1 we can identify the latter case as optimal.

For 2) the only option containing no ones or less than three 2s is (2, 3 k times).

What if \( n \in R+ \) and the elements of the partition can be any positive real?

Unlike the previous solution we will use some calculus. Consider:

\[ (x, x), \ (x - a, x + a) \]

Where \( x, a \in R^+ , \ x > a \).

Note the two tuples have the same sum but:

\[ x^2 > x^2 - a^2 \]

From this it is apparent that all elements of the optimal partition must be the same number. Let this number be \( k_n \) Consider the function:

\[ f(x) = x^\frac{n}{x} \]

For some constant \( n \). Then \( k_n \) is the maximum of this function with the added restriction that \( x | n \).

Rewrite \( f(x) \):

\[ f(x) = e^\frac{n\ln{x}}{x} \]

We find the stationary point by differentiating and equating to 0:

\[ \left(\frac{n}{x^2} - \frac{n\ln{x}}{x^2}\right) e^\frac{n\ln{x}}{x} = 0 \]

\( f(x) \not = 0 \ \forall x \in R \) hence we have:

\[ \left(\frac{n}{x^2} - \frac{n\ln{x}}{x^2}\right) = 0 \]

\[ \Rightarrow ln{x} = 1 \]

\[ \Rightarrow x = e \]

Hence the sole stationary point of the function occurs at \( x = e \) and is independent of \( n \). If we note that:

\[ \lim_{x \to 0+}f(x) = \lim_{x \to \infty}f(x) = 0 \]

Then we can identify the stationary point as a global maximum of the function, and reason that our desired k_n lies somewhere around \( e \).