merge branch 'rewritten' into algebraic-sterography (squash)

_quarto.yml

@@ -2,7 +2,7 @@ project:
   type: website
 
 website:
-  favicon: ./logo.png
+  favicon: ./logo-favicon.png
   title: "zenzicubi.co"
   navbar:
     logo: "/logo-vector.svg"

index.qmd

@@ -2,8 +2,10 @@
 title: "Posts by topic"
 listing:
   contents:
-    - posts/polycount/index.*
+    - posts/permutations/index.*
+    - posts/chebyshev/index.*
     - posts/pentagons/index.*
+    - posts/polycount/index.*
     - posts/misc/*/index.*
-  sort: "date desc"
+  sort: false
 ---

posts/chebyshev/1/index.qmd

@@ -1,7 +1,7 @@
 ---
 title: "Generating Polynomials, Part 1: Regular Constructibility"
 description: |
-  "What kinds of regular polygons are constructible with compass and straightedge?"
+  What kinds of regular polygons are constructible with compass and straightedge?
 format:
   html:
     html-math-method: katex

posts/chebyshev/2/index.qmd

@@ -1,7 +1,7 @@
 ---
 title: "Generating Polynomials, Part 2: Ghostly Chains"
 description: |
-  "What do polygons without distance still know about planar geometry?"
+  What do polygons without distance still know about planar geometry?
 format:
   html:
     html-math-method: katex

posts/chebyshev/_metadata.yml

@@ -0,0 +1,5 @@
+# freeze computational output
+freeze: auto
+
+# Enable banner style title blocks
+title-block-banner: true

posts/chebyshev/extra/index.qmd

@@ -1,7 +1,7 @@
 ---
 title: "Generating Polynomials Extra: Legendary"
 description: |
-  "Another series of related, orthogonal polynomials"
+  Another series of related, orthogonal polynomials
 format:
   html:
     html-math-method: katex

posts/chebyshev/index.qmd

@@ -0,0 +1,10 @@
+---
+title: "Chebyshev Polynomials"
+listing:
+  contents: .
+  sort: "date"
+---
+
+Articles about the generating Chebyshev polynomials (and other related families).
+
+Publication dates correspond to the original WordPress publication dates.

posts/permutations/1/index.qmd

@@ -0,0 +1,491 @@
+---
+title: "A Game of Permutations, Part 1"
+description: |
+  Some basic, interesting connections between graph theory and permutation groups.
+format:
+  html:
+    html-math-method: katex
+jupyter: haskell
+date: "2022-01-18"
+date-modified: "2025-07-04"
+categories:
+  - graph theory
+  - group theory
+  - sorting algorithms
+---
+
+<style>
+.narrow {
+  max-width: 512px;
+}
+</style>
+
+In the time since [my last post](../chebyshev/2) discussing graphs,
+  I have been spurred on to continue playing with them, with a slight focus on abstract algebra.
+This post will primarily focus on some fundamental concepts before launching into some constructions which will make the journey down this road more manageable.
+However, I will still assume you are already familiar with what both a
+  [group](https://mathworld.wolfram.com/Group.html) and a
+  [graph](https://mathworld.wolfram.com/Graph.html) are.
+
+
+The Symmetric Group
+-------------------
+
+Some of the most important finite groups are the symmetric groups of degree *n* ($S_n$).
+They are the groups formed by permutations of lists containing *n* items.
+There is a group element for each permutation, so the order of the group is the
+  same as the number of permutations, *n!*.
+
+<details>
+  <summary> On lists versus sets </summary>
+
+  The typical definition of the symmetric group uses sets, which are fundamentally unordered.
+  This is potentially confusing, since it can appear as though an object after applying
+    a permutation is the same object as before.
+
+  For example, let *p* be the permutation swapping "1" and "3".
+  Then,
+
+  $$
+  \begin{align*}
+    p(\{ 1, 2, 3 \}) = \{ p(1), p(2), p(3) \} = \{ 3, 2, 1 \}
+    \\
+    p([ 1, 2, 3 ]) = [ p(1), p(2), p(3) ] = [ 3, 2, 1 ]
+  \end{align*}
+  $$
+
+  After applying *p*, the set is unchanged, since all of the elements are the same.
+  On the other hand, the lists differ in the first element and cannot be equal.
+
+  Sets are still useful as a container.
+  For example, the elements of a group are unordered.
+  To keep vocabulary simple, I will do my best to refer to objects in a group as
+    "group elements" and the objects in a list as "items".
+</details>
+
+There are many ways to denote elements of the symmetric group.
+I will take the liberty of explaining some common notations, each of which are useful in different ways.
+More information about them can be found [elsewhere](https://mathworld.wolfram.com/Permutation.html)
+  [online](https://en.wikipedia.org/wiki/Permutation#Notations)
+  as well as any adequate group theory text.
+
+
+### Naive List Notation
+
+Arguably the simplest way to do things is to denote the permutation by the result
+  of applying it to a canonical list.
+Take the element of $S_3$ which can be described as the action
+  "assign the first item to the second index, the second to the third, and the third to the first".
+Our canonical list in this case is $[1, 2, 3]$, matching the degree of the group.
+This results in $[3, 1, 2]$, since "1" is in now in position two, and similarly for the other items.
+
+Unfortunately, this choice is too result-oriented.
+This choice makes it difficult to compose group elements in a meaningful way, since all
+  of the information about the permutation is in the position of items in the list,
+  rather than the items of the list themselves.
+For example, under the same rule, $[c, b, a]$ is mapped to $[a, c, b]$.
+
+
+### True List Notations (Two- and One-line Notation)
+
+Instead, let's go back to the definition of the element.
+All we have to do is list out every index on one line, then the destination
+  of every index on the next.
+This is known as *two-line notation*.
+
+$$
+\begin{pmatrix}
+  1 & 2 & 3 \\
+  p(1) & p(2) & p(3)
+\end{pmatrix}
+= \begin{pmatrix}
+  1 & 2 & 3 \\
+  2 & 3 & 1
+\end{pmatrix}
+$$
+
+For simplicity, the first row is kept as a list whose items match their indices.
+
+This notation makes it easier to identify the inverse of a group element.
+All we have to do is sort the columns of the permutation by the second row,
+  then swap the two rows.
+
+$$
+\begin{pmatrix}
+  1 & 2 & 3 \\
+  2 & 3 & 1
+\end{pmatrix}^{-1}
+= \begin{pmatrix}
+  3 & 1 & 2 \\
+  1 & 2 & 3
+\end{pmatrix}^{-1}
+= \begin{pmatrix}
+  1 & 2 & 3 \\
+  3 & 1 & 2
+\end{pmatrix}
+$$
+
+Note that the second row is now the same as the result from the naive notation.
+
+Since the first row will be the same in all cases, we can omit it, which results in
+  *one-line notation*.
+The *n*th item in the list now describes the position in which *n* can be found after
+  the permutation.
+
+$$
+\begin{pmatrix}
+  1 & 2 & 3 \\
+  2 & 3 & 1
+\end{pmatrix}
+\equiv [\![2, 3, 1]\!]
+$$
+
+Double brackets are used to distinguish this as a permutation and not an ordinary list.
+
+These notations make it straightforward to encode symmetric group elements on a computer.
+After all, we only have to read the items of a list by the indices in another.
+Here's a compact definition in Haskell:
+
+```{haskell}
+-- convenient wrapper type for below
+newtype Permutation = P { unP :: [Int] }
+
+apply :: Permutation -> [a] -> [a]
+apply = flip (\xs ->
+  map (        -- for each item of the permutation, map it to...
+     (xs !!)   -- the nth item of the first list
+     . (+(-1)) -- (indexed starting with 1)
+   ) . unP)    -- (after undoing the type wrapping)
+-- written in a non-point free form
+apply' (P xs) ys = map ( \n -> ys !! (n-1) ) xs
+
+print $ P [2,3,1] `apply` [1,2,3]
+```
+
+Note that this means `P [2,3,1]` is actually equivalent to $[\![2, 3, 1]\!]^{-1}$,
+  since we don't get $[3, 1, 2]$.
+
+While these notations are fairly explicit and easy to describe to a computer,
+  it's easy to misinterpret an element as its inverse.
+There is also some redundancy: $[\![2, 1]\!]$ and $[\![2, 1, 3]\!]$ both describe a group element
+  which swaps the first two items of a list.
+On one hand, the $S_n$ each belongs to is explicit, but on the other,
+  every element of a smaller symmetric group also belongs to a larger one.
+The verbosity of these notations also makes composing group elements difficult[^1].
+
+[^1]: Composition is relatively easy to describe in two-line notation.
+    Recall that we reordered columns when finding an inverse.
+    We can do so to match rows of two elements, then compose a new element
+      by looking at the first and last rows.
+    For example, with group inverses:
+    $$
+    \begin{pmatrix}
+      1 & 2 & 3 \\
+      2 & 3 & 1
+    \end{pmatrix}
+    \begin{pmatrix}
+      1 & 2 & 3 \\
+      2 & 3 & 1
+    \end{pmatrix}^{-1}
+    = \begin{matrix}
+      \begin{pmatrix}
+        1 & 2 & 3 \\
+        \cancel{2} & \cancel{3} & \cancel{1}
+      \end{pmatrix}
+      \\
+      \begin{pmatrix}
+        \cancel{2} & \cancel{3} & \cancel{1} \\
+        1 & 2 & 3
+      \end{pmatrix}
+    \end{matrix}
+    = \begin{pmatrix}
+      1 & 2 & 3 \\
+      1 & 2 & 3
+    \end{pmatrix}
+    $$
+
+
+### Cycle Notation
+
+*Cycle notation* addresses all of these issues, but gets rid of the transparency with respect to lists.
+Let's try phrasing the element we've been describing differently.
+
+> assign the first item to the second index, the second to the third, and the third to the first
+
+We start at index 1 and follow it to index 2, and from there follow it to index 3.
+Continuing from index 3, we return to index 1, and from then we'd loop forever.
+This describes a *cycle*, denoted as $(1 ~ 2 ~ 3)$.
+
+Cycle notation is much more delicate than list notation, since the notation is nonunique:
+
+- Naturally, the elements of a cycle may be cycled to produce an equivalent one.
+    - $(1 ~ 2 ~ 3) = (3 ~ 1 ~ 2) = (2 ~ 3 ~ 1)$
+- Cycles which have no common elements (i.e., are disjoint) commute,
+  since they act on separate parts of the list.
+    - $(1 ~ 2 ~ 3)(4 ~ 5) = (4 ~ 5)(1 ~ 2 ~ 3)$
+
+
+#### Cycle Algebra
+
+The true benefit of cycles is that they are easy to manipulate algebraically.
+For some reason, [Wikipedia](https://en.wikipedia.org/wiki/Permutation#Cycle_notation)
+  does not elaborate on the composition rules for cycles,
+  and the text which I read as an introduction to group theory simply listed it as an exercise.
+While playing around with them and deriving these rules oneself *is* a good idea,
+  I will list the most important here:
+
+- Cycles can be inverted by reversing their order.
+    - $(1 ~ 2 ~ 3)^{-1} = (3 ~ 2 ~ 1) = (1 ~ 3 ~ 2)$
+- Cycles may be composed if the last element in the first is the first index on the right.
+  Inversely, cycles may also be decomposed by partitioning on an index and duplicating.
+    - $(1 ~ 2 ~ 3) = (1 ~ 2)(2 ~ 3)$
+- If an index in a cycle is repeated twice, it may be omitted from the cycle.
+    - $(1 ~ 2 ~ 3)(1 ~ 3) = (1 ~ 2 ~ 3)(3 ~ 1) = (1 ~ 2 ~ 3 ~ 1) = (1 ~ 1 ~ 2 ~ 3) = (2 ~ 3)$
+
+Going back to $(1 ~ 2 ~ 3)$, if we apply this permutation to the list $[1, 2, 3]$:
+
+$$
+(1 ~ 2 ~ 3) \left( \vphantom{0^{0^0}} [1, 2, 3] \right)
+  = (1 ~ 2)(2 ~ 3) \left( \vphantom{0^{0^0}} [1, 2, 3] \right)
+  = (1 ~ 2) \left( \vphantom{0^{0^0}} [1, 3, 2] \right)
+  = [3, 1, 2]
+$$
+
+Which is exactly what we expected with our naive notation.
+
+
+Generators, Permutation Groups, and Sorting
+-------------------------------------------
+
+If we have a group *G*, then we can select a set of elements
+  $\langle g_1, g_2, g_3, ... \rangle$ as *generators*.
+If we form all possible products -- not only the pairwise ones $g_1 g_2$,
+  but also $g_1 g_2 g_3$ and all powers of any $g_n$ -- then the products form a subgroup of *G*.
+Naturally, such a set is called a *generating set*.
+
+Symmetric groups are of primary interest because of their subgroups, also known as permutation groups.
+[Cayley's theorem](https://en.wikipedia.org/wiki/Cayley%27s_theorem),
+  a fundamental result of group theory, states that all finite groups
+  are isomorphic to one of these subgroups.
+This means that we can encode effectively any group using elements of the symmetric group.
+
+For example, consider the generating set $\langle (1 ~ 2) \rangle$, which contains a single element
+  that swaps the first two items of a list.
+Its square is the identity, meaning that its inverse is itself.
+The identity and $(1 ~ 2)$ are the only two elements of the generated group,
+  which is isomorphic to $C_2$, the cyclic group of order 2.
+Similarly, the 3-cycle in the generating set $\langle (1 ~ 2 ~ 3) \rangle$ generates $C_3$,
+  the cyclic group of order 3.
+
+However, the generating set $\langle (1 ~ 2), (1 ~ 2 ~ 3)\rangle$, which contains both of these permutations, generates the entirety of $S_3$.
+In fact, [
+    every symmetric group can be generated by two elements
+  ](https://groupprops.subwiki.org/wiki/Symmetric_group_on_a_finite_set_is_2-generated):
+  a permutation which cycles all elements once, and the permutation which swaps the first two elements.
+
+$$
+S_n = \langle (1 ~ 2), (1 ~ 2 ~ 3 ~ 4 ~ ... ~ n) \rangle
+$$
+
+
+### Sorting and 2-Cycles
+
+The proof linked to above, that every symmetric group can be generated by two elements,
+  uses the (somewhat obvious) result that one can produce any permutation of a list by picking two items,
+  swapping them, and repeating until the list is in the desired order.
+
+This is reminiscent of how sorting algorithms are able to sort a list by only comparing and swapping items.
+As mentioned earlier when finding inverses using in two-line notation, sorting is almost the inverse of permuting.
+However, not all 2-cycles are necessary to generate the whole symmetric group.
+
+
+### Bubble Sort
+
+Consider [bubble sort](https://en.wikipedia.org/wiki/Bubble_sort).
+In this algorithm, we swap two items when the latter is less than the former,
+  looping over the list until it is sorted.
+Until the list is sorted, the algorithm finds all such adjacent inversions.
+In the worst case, it will swap every pair of adjacent items, some possibly multiple times.
+This corresponds to the generating set
+  $\langle (1 ~ 2), (2 ~ 3), (3 ~ 4), (4 ~ 5), …, (n-1 ~\ ~ n) \rangle$.
+
+![
+  Bubble sort ordering a reverse-sorted list
+](./bubble_sort.gif){.narrow}
+
+
+### Selection Sort
+
+Another method, [selection sort](https://en.wikipedia.org/wiki/Selection_sort),
+  searches through the list for the smallest item and swaps it to the beginning.
+If this is the final item of the list, this results in the permutation $(1 ~ n)$.
+Supposing that process is continued with the second item and we also want it
+  to swap with the final item, then the next swap corresponds to $(2 ~ n)$.
+Continuing until the last item, this gives the generating set
+  $\langle (1 ~ n), (2 ~ n), (3 ~ n), (4 ~ n), …, (n-1 ~\ ~ n) \rangle$.
+
+![
+  Selection sort ordering a particular list, using only swaps with the final item
+](./selection_sort.gif){.narrow}
+
+This behavior for selection sort is uncommon, and this animation omits the selection of a swap candidate.
+The animation below shows a more destructive selection sort, in which the
+  candidate least item is placed at the end of the list (position 5).
+Once the algorithm hits the end of the list, the candidate is swapped to the least unsorted position,
+  and the algorithm continues on the rest of the list.
+
+![
+  "Destructive" selection sort.
+  The actual list being sorted consists of the initial four items, with the final item as temporary storage.
+](./destructive_selection_sort.gif){.narrow}
+
+
+Swap Diagrams
+-------------
+
+Given a set of 2-cycles, it would be nice to know at a glance if the entire group is generated.
+In cycle notation, a 2-cycle is an unordered pair of natural numbers which swap items of an *n*-list.
+Similarly, the edges of an undirected graph on *n* vertices (labelled from 1 to *n*)
+  may be interpreted as an unordered pair of the vertices it connects.
+
+If we treat the two objects as the same, then we can convert between graphs and sets of 2-cycles.
+Going from the latter to the former, we start on an empty graph on n vertices
+  (labelled from 1 to *n*).
+Then, we connect two vertices with an edge when the set includes the permutation swapping
+  the indices labelled by the vertices.
+
+Returning to the generating sets we identified with sorting algorithms,
+  we identify with each a graph family.
+
+- Bubble sort: $\langle (1 ~ 2), (2 ~ 3), (3 ~ 4), (4 ~ 5), …, (n-1 ~~ n) \rangle$
+    - The path graphs ($P_n$), which are precisely as they sound:
+      an unbranching path formed by *n* vertices.
+- "Selection" sort: $\langle (1 ~ n), (2 ~ n), (3 ~ n), (4 ~ n), …, (n-1 ~~ n) \rangle$
+    - The star graphs ($\bigstar_n$, as $S_n$ means the symmetric group),
+      one vertex connected to all others.
+- Every 2-cycle in $S_n$
+    - The complete graphs ($K_n$), which connect every vertex to every other vertex.
+
+![&nbsp;](./example_graphs.png)
+
+This interpretation of these objects doesn't have proper name, but I think the name "swap diagram" fits.
+They allow us to answer at least one question about the generating set from a graph theory perspective.
+
+
+### Connected Graphs
+
+A graph is connected if a path exists between all pairs of vertices.
+The simplest possible path is simply a single edge, which we already know to be an available 2-cycle.
+
+The next simplest case is a path consisting of two edges.
+Some cycle algebra shows that we can produce a third cycle which corresponds
+  to an edge connecting the two distant vertices.
+
+:::: {layout-ncol="2"}
+![&nbsp;](./induced_edge.png)
+
+::: {}
+$$
+\begin{align*}
+  &(m ~ n) (n ~ o) (m ~ n) \\
+    &= (m ~ n ~ o) (m ~ n) \\
+    &= (n ~ o ~ m) (m ~ n) \\
+    &= (n ~ o ~ m ~ n) \\
+    &= (o ~ m) = (m ~ o)
+\end{align*}
+$$
+Note that this is just the conjugation of $(n ~ o)$ by $(m ~ n)$
+:::
+::::
+
+In other words, if we have have two adjacent edges, the new edge corresponds to
+  a product of elements from the generating set.
+Graph theory has a name for this operation: when we produce *all* new edges by linking vertices
+  that were separated by a distance of 2, the result is called the *square of that graph*.
+In fact, higher [graph powers](https://en.wikipedia.org/wiki/Graph_power) will reflect connections
+  induced by more conjugations of adjacent edges.
+
+![
+  As you might be able to guess, this implies that $(1 ~ 4) = (3 ~ 4)(2 ~ 3)(1 ~ 2)(2 ~ 3)(3 ~ 4)$.
+  Also, $\bigstar_n^2 \cong K_n$.
+](./P4_powers.png)
+
+If our graph is connected, then repeating this operation will tend toward a complete graph.
+Complete graphs contain every possible edge, and so correspond to all possible 2-cycles,
+  which trivially generate the symmetric group.
+Conversely, if a graph has *n* vertices, then for it to be connected, it must have at least $n - 1$ edges.
+Thus, a generating set of 2-cycles must have at least $n - 1$ items to generate the symmetric group.
+
+Picking a different vertex labelling will correspond to a different generating set.
+For example, in the image of $P_4$ above, if the edge connecting vertices 1 and 2
+  is replaced with an edge connecting 1 and 4, then the resulting graph
+  is still $P_4$, even though it describes a different generating set.
+We can ignore these extra cases entirely -- either way, the graph power argument shows
+  that a connected graph corresponds to a set generating the whole symmetric group.
+
+
+### Disconnected Graphs
+
+A disconnected graph is the
+  [disjoint union](https://en.wikipedia.org/wiki/Disjoint_union_of_graphs) of connected graphs.
+Under graph powers, we know that each connected graph tends toward a complete graph,
+  meaning a disconnected graph as a whole tends toward a disjoint union of complete graphs,
+  or [cluster graph](https://en.wikipedia.org/wiki/Cluster_graph).
+But what groups do cluster graphs correspond to?
+
+The simplest case to consider is what happens when the graph is $P_2 \oplus P_2$.
+If there is an edge connecting vertices 1 and 2 and an edge connecting vertices 3 and 4,
+  it corresponds to the generating set $\langle (1 ~ 2), (3 ~ 4) \rangle$.
+This is a pair of disjoint cycles, and the group they generate is
+
+$$
+\{e, (1 ~ 2), (3 ~ 4), (1 ~ 2)(3 ~ 4) \}
+  \cong S_2 \times S_2
+  \cong C_2 \times C_2
+$$
+
+One way to look at this is by considering paths on each component:
+  we can either cross an edge on the first component (corresponding to $(1 ~ 2)$),
+  the second component (corresponding to $(3 ~ 4)$),
+  or both at the same time.
+This independence means that one group's structure is duplicated over the other's,
+  or more succinctly, gives the direct product.
+In general, if we denote *γ* as the map which "runs" the swap diagram and produces the group, then
+
+$$
+\gamma( A \oplus B ) = S_{|A|} \times S_{|B|},
+  ~ A, B \text{ connected}
+$$
+
+where $|A|$ is the number of vertices in *A*.
+
+*γ* has the interesting property of mapping a sum-like object onto a product-like object.
+If we express a disconnected graph *U* as the disjoint union of its connected components $V_i$, then
+
+$$
+\begin{gather*}
+  U = \bigsqcup_i V_i
+  \\
+  \gamma( U ) = \gamma \left( \bigsqcup_i V_i \right) = \prod_i S_{|V_i|}
+\end{gather*}
+$$
+
+This describes *γ* for every simple graph.
+It also shows that we're rather limited in the kinds of groups which can be expressed by a swap diagram.
+
+
+Closing
+-------
+
+This concludes the dry introduction to some investigations of mine into symmetric groups.
+While I could have omitted the sections about permutation notation and generators,
+  I wanted to be thorough and tie it to concepts which were useful to my understanding.
+The notion of a graph encoding a generating set in particular will be fairly important going forward.
+
+Originally, this post was half of a single, sprawling, meandering article.
+I hope I've improved the organization by keeping the digression about sorting algorithms
+  to this initial article.
+The [next post](../2) will cover some interesting structures which fill Euclidean space
+  and incredibly large graphs.
+
+Sorting and graph diagrams made with GeoGebra.

posts/permutations/2/graph_data/base.py

@@ -0,0 +1,141 @@
+from dataclasses import dataclass
+import sympy
+from sympy.abc import x
+
+
+def display_integral_root(
+    root: int, multiplicity: int, pad_to: int | None = None
+) -> str:
+    return (
+        "("
+        # denote sign
+        + ("\\pm" if root != 0 else "")
+        + str(root)
+        + ")^{"
+        + str(multiplicity)
+        # pad multiplicity
+        + (
+            ("\\phantom{" + ("0" * (pad_to - len(str(multiplicity))) + "}"))
+            if pad_to is not None and len(str(multiplicity)) < pad_to
+            else ""
+        )
+        + "}"
+    )
+
+
+@dataclass
+class SymmetricSpectrum:
+    """
+    Dataclass for symmetric spectra -- those for which, if a spectrum contains a root,
+    it also contains its negative.
+
+    If a root polynomial is not symmetric, then its symmetric counterpart will *not* be specified.
+    """
+
+    # Either the integral root or a polynomial with the root, and the multiplicity
+    roots: list[tuple[sympy.Expr | int, int]]
+    not_shown_count: int = 0
+
+    def to_markdown(self) -> str:
+        """
+        Display a spectrum as a markdown string
+        """
+        integer_roots = [
+            (root, multiplicity)
+            for root, multiplicity in self.roots
+            if isinstance(root, int)
+        ]
+        # symmetrify polynomials
+        polynomial_roots = [
+            (root, multiplicity)
+            for base_root, multiplicity in self.roots
+            if isinstance(base_root, sympy.Expr)
+            for root in set(
+                [base_root, (-1) ** (sympy.degree(base_root)) * base_root.subs(x, -x)]
+            )
+        ]
+
+        shown_roots = len(polynomial_roots) > 0 or len(integer_roots) > 0
+        not_shown_string = (
+            (
+                f"*Not shown: {self.not_shown_count} other roots*"
+                if shown_roots
+                else f"*Not shown: all {self.not_shown_count} roots*"
+            )
+            if self.not_shown_count > 0
+            else ""
+        )
+
+        # strictly integral spectra
+        if len(polynomial_roots) == 0 and len(integer_roots) != 0:
+            longest_integer = max(
+                len(str(multiplicity)) for _, multiplicity in integer_roots
+            )
+            return (
+                (
+                    "$$\\begin{gather*}"
+                    + " \\\\ ".join(
+                        display_integral_root(*rm, pad_to=longest_integer)
+                        for rm in integer_roots
+                    )
+                    + "\\end{gather*}$$"
+                )
+                if shown_roots
+                else ""
+            ) + not_shown_string
+
+        # conditionally split integral roots onto multiple lines
+        integral_roots_lines = (
+            " ".join(display_integral_root(*rm) for rm in integer_roots)
+            if len(integer_roots) < 5
+            else (
+                " ".join(
+                    display_integral_root(*rm)
+                    for rm in integer_roots[: len(integer_roots) // 2]
+                )
+                + "\\\\"
+                + " ".join(
+                    display_integral_root(*rm)
+                    for rm in integer_roots[len(integer_roots) // 2 :]
+                )
+            )
+        )
+
+        return (
+            (
+                "$$\\begin{gather*}"
+                + integral_roots_lines
+                + " \\\\ "
+                + " \\\\ ".join(
+                    sympy.latex(root**multiplicity)
+                    for root, multiplicity in polynomial_roots
+                )
+                + "\\end{gather*}$$"
+            )
+            if shown_roots
+            else ""
+        ) + not_shown_string
+
+
+def count_roots_spectrum(spectrum: SymmetricSpectrum) -> int:
+    return (
+        sum(
+            [
+                (
+                    (multiplicity * 2 if root != 0 else multiplicity)
+                    if isinstance(root, int)
+                    else (int(sympy.degree(root, x)) * multiplicity)
+                )
+                for root, multiplicity in spectrum.roots
+            ]
+        )
+        + spectrum.not_shown_count
+    )
+
+
+@dataclass
+class GraphData:
+    spectrum: SymmetricSpectrum
+    vertex_count: int | None = None
+    edge_count: int | None = None
+    distance_classes: list[int] | None = None

posts/permutations/2/graph_data/complete.py

@@ -0,0 +1,80 @@
+from .base import GraphData, SymmetricSpectrum
+
+# TODO: other non-spectral data
+data = {
+    3: GraphData(
+        vertex_count=6,
+        edge_count=9,
+        distance_classes=[1, 3, 2],
+        spectrum=SymmetricSpectrum([(0, 4), (3, 1)]),
+    ),
+    4: GraphData(
+        vertex_count=24,
+        edge_count=72,
+        distance_classes=[1, 6, 11, 6],
+        spectrum=SymmetricSpectrum([(0, 4), (2, 9), (6, 1)]),
+    ),
+    5: GraphData(
+        vertex_count=120,
+        edge_count=600,
+        distance_classes=[1, 10, 35, 50, 24],
+        spectrum=SymmetricSpectrum(
+            [
+                (0, 36),
+                (2, 25),
+                (5, 16),
+                (10, 1),
+            ]
+        ),
+    ),
+    6: GraphData(
+        vertex_count=720,
+        edge_count=5400,
+        distance_classes=[1, 15, 85, 225, 274, 120],
+        spectrum=SymmetricSpectrum(
+            [
+                (0, 256),
+                (3, 125),
+                (5, 81),
+                (9, 25),
+                (15, 1),
+            ]
+        ),
+    ),
+    7: GraphData(
+        vertex_count=5040,
+        edge_count=52920,
+        distance_classes=[1, 21, 175, 735, 1624, 1764, 720],
+        spectrum=SymmetricSpectrum(
+            [
+                (0, 400),
+                (1, 441),
+                (3, 1225),
+                (6, 196),
+                (7, 225),
+                (9, 196),
+                (14, 36),
+                (21, 1),
+            ]
+        ),
+    ),
+    8: GraphData(
+        vertex_count=40320,
+        spectrum=SymmetricSpectrum(
+            [
+                (0, 9864),
+                (2, 3136),
+                (4, 6125),
+                (7, 4096),
+                (8, 196),
+                (10, 784),
+                (12, 441),
+                (14, 400),
+                (20, 49),
+                (28, 1),
+            ]
+        ),
+    ),
+}
+
+# TODO (maybe): verify these quantities with outputs from Haskell

posts/permutations/2/graph_data/path.py

@@ -0,0 +1,100 @@
+from .base import SymmetricSpectrum, GraphData, x
+
+data = {
+    3: GraphData(
+        vertex_count=6,
+        edge_count=6,
+        distance_classes=[1, 2, 2, 1],
+        spectrum=SymmetricSpectrum([(1, 2), (2, 1)]),
+    ),
+    4: GraphData(
+        vertex_count=24,
+        edge_count=36,
+        distance_classes=[1, 3, 5, 6, 5, 3, 1],
+        spectrum=SymmetricSpectrum(
+            [
+                (1, 3),
+                (3, 1),
+                (x**2 - 3, 2),
+                (x**2 - 2 * x - 1, 3),
+                (x**2 + 2 * x - 1, 3),
+            ]
+        ),
+    ),
+    5: GraphData(
+        vertex_count=120,
+        edge_count=240,
+        distance_classes=[1, 4, 9, 15, 20, 22, 20, 15, 9, 4, 1],
+        spectrum=SymmetricSpectrum(
+            [
+                (0, 12),
+                (1, 6),
+                (4, 1),
+                (x**2 - 5, 6),
+                (x**2 + 5 * x + 5, 4),
+                (x**2 + 3 * x + 1, 4),
+                (x**2 + 2 * x - 1, 5),
+                (x**3 + 2 * x**2 - 5 * x - 4, 5),
+            ]
+        ),
+    ),
+    6: GraphData(
+        vertex_count=720,
+        edge_count=1800,
+        distance_classes=[1, 5, 14, 29, 49, 71, 90, 101, 101, 90, 71, 49, 29, 14, 5, 1],
+        spectrum=SymmetricSpectrum(
+            [
+                (0, 20),
+                (1, 25),
+                (2, 15),
+                (3, 5),
+                (4, 5),
+                (5, 1),
+                (x**2 - 3, 20),
+            ],
+            not_shown_count=558,
+        ),
+    ),
+    7: GraphData(
+        vertex_count=5040,
+        edge_count=15120,
+        distance_classes=[
+            1,
+            6,
+            20,
+            49,
+            98,
+            169,
+            259,
+            359,
+            455,
+            531,
+            573,
+            573,
+            531,
+            455,
+            359,
+            259,
+            169,
+            98,
+            49,
+            20,
+            6,
+            1,
+        ],
+        spectrum=SymmetricSpectrum(
+            [
+                (0, 35),
+                (1, 20),
+                (2, 45),
+                (6, 1),
+            ],
+            not_shown_count=4873,
+        ),
+    ),
+    8: GraphData(
+        vertex_count=40320, spectrum=SymmetricSpectrum([], not_shown_count=40320)
+    ),
+}
+
+# TODO (maybe): verify these quantities with outputs from Haskell

posts/permutations/2/graph_data/star.py

@@ -0,0 +1,85 @@
+from .base import SymmetricSpectrum, GraphData
+
+data = {
+    3: GraphData(
+        vertex_count=6,
+        edge_count=6,
+        distance_classes=[1, 2, 2, 1],
+        spectrum=SymmetricSpectrum([(1, 2), (2, 1)]),
+    ),
+    4: GraphData(
+        vertex_count=24,
+        edge_count=36,
+        distance_classes=[1, 3, 6, 9, 5],
+        spectrum=SymmetricSpectrum(
+            [
+                (0, 4),
+                (1, 3),
+                (2, 6),
+                (3, 1),
+            ]
+        ),
+    ),
+    5: GraphData(
+        vertex_count=120,
+        edge_count=240,
+        distance_classes=[1, 4, 12, 30, 44, 26, 3],
+        spectrum=SymmetricSpectrum(
+            [
+                (0, 30),
+                (1, 4),
+                (2, 28),
+                (3, 12),
+                (4, 1),
+            ]
+        ),
+    ),
+    6: GraphData(
+        vertex_count=720,
+        edge_count=1800,
+        distance_classes=[1, 5, 20, 70, 170, 250, 169, 35],
+        spectrum=SymmetricSpectrum(
+            [
+                (0, 168),
+                (1, 30),
+                (2, 120),
+                (3, 105),
+                (4, 20),
+                (5, 1),
+            ]
+        ),
+    ),
+    7: GraphData(
+        vertex_count=5040,
+        edge_count=15120,
+        distance_classes=[1, 6, 30, 135, 460, 1110, 1689, 1254, 340, 15],
+        spectrum=SymmetricSpectrum(
+            [
+                (0, 840),
+                (1, 468),
+                (2, 495),
+                (3, 830),
+                (4, 276),
+                (5, 30),
+                (6, 1),
+            ]
+        ),
+    ),
+    8: GraphData(
+        vertex_count=40320,
+        spectrum=SymmetricSpectrum(
+            [
+                (0, 3960),
+                (1, 5691),
+                (2, 2198),
+                (3, 6321),
+                (4, 3332),
+                (5, 595),
+                (6, 42),
+                (7, 1),
+            ]
+        ),
+    ),
+}
+
+# TODO (maybe): verify these quantities with outputs from Haskell

posts/permutations/2/index.qmd

@@ -0,0 +1,518 @@
+---
+title: "A Game of Permutations, Part 2"
+description: |
+  Notes on an operation which makes some very large graphs.
+format:
+  html:
+    html-math-method: katex
+jupyter: python3
+date: "2022-01-18"
+date-modified: "2025-07-06"
+categories:
+  - graph theory
+  - group theory
+---
+
+<style>
+.narrow {
+    max-width: 640px;
+}
+</style>
+
+```{python}
+#| echo: false
+
+from IPython.display import Markdown
+from tabulate import tabulate
+
+from graph_data import complete, path, star
+```
+
+
+This post assumes you have read (or at least skimmed over parts of) the [first post](../1),
+  which talks about graphs and the symmetric group.
+This post will contain some more "empirical" results, since I'm not an expert on graph theory.
+However, one hardly needs to be an expert to learn or to make computations, observations, and predictions.
+
+We left off talking about producing a group from a graph, so we begin now by considering how to do the reverse.
+
+
+Cayley Graphs
+-------------
+
+For a given generating set, we can assign every element in the group it generates to a vertex in a graph.
+Starting with each of the generators, we draw edges from one vertex to another when
+  the product of the initial vertex and a generator (in that order) is the product vertex.
+This process continues until there are no more arrows to draw.
+The resulting figure is known as a [Cayley graph](https://mathworld.wolfram.com/CayleyGraph.html)[^1].
+
+[^1]: The construction implies a labelling of edges by its generating set and a labelling
+      of vertices by the generated elements.
+    It is also common to describe an unlabelled graph as "Cayley" if it could
+      be generated by this procedure.
+
+Cayley graphs depend on the generating set used, so they can take a wide variety of shapes.
+Here are a few examples of Cayley graphs made from elements of $S_4$:
+
+![
+  Left: $\{(1 ~ 3 ~ 2 ~ 4), (3 ~ 4), (1 ~ 4 ~ 2 ~ 3)\}$, cube graph <br>
+  Middle: $\{(1 ~ 2 ~ 3), (2 ~ 3 ~ 4)\}$, cuboctahedral graph <br>
+  Right: $\{(2 ~ 3), (3 ~ 4), (2 ~ 3 ~ 4)\}$, octahedral graph <br>
+  Generating sets obtained from the previous MathWorld article.
+](./s4_cayley_graphs.png)
+
+Owing to the way in which they are defined, Cayley graphs have a few useful properties as graphs.
+At every vertex, we have as many outward edges as we do generators in the generating set,
+  so the outward (and in fact, inward) degree of each vertex is the same.
+In other words, it is a regular graph.
+More than that, it is [vertex-transitive](https://mathworld.wolfram.com/Vertex-TransitiveGraph.html),
+  since labelling a single vertex's outward edges will label that of the entire graph.
+
+In general, the Cayley graph is a directed graph.
+However, if for every member of the generating set, we also include its inverse,
+  every directed edge will be matched by an edge in the opposite direction,
+  and the Cayley graph may be considered undirected.
+
+
+Graphs to Graphs
+----------------
+
+All 2-cycles are their own inverse, so generating sets which include only them
+  produce undirected Cayley graphs.
+Since this kind of generating set can itself be thought of as a graph,
+  we may consider an operation on graphs that maps a swap diagram to its Cayley graph.
+
+![
+  An example of this operation, denoted as $\exp$.
+  The proper Cayley graphs for $(1 ~ 2)$ and $(3 ~ 4)$ are not shown;
+    they are isomorphic to the corresponding swap graphs, but have different vertex labels.
+](./exp_p2_oplus_p2.png)
+
+It seems to be the case that $\exp( A \oplus B ) = \exp( A ) \times \exp( B )$,
+  where $\oplus$ signifies the disjoint uinion and $\times$ signifies the
+  [Cartesian (box) product of graphs](https://en.wikipedia.org/wiki/Cartesian_product_of_graphs)[^2].
+Unlike *γ* from the previous post, both the input and output of this operation are graphs.
+Because of this and the sum/product relationship, I've taken to calling this operation the
+  "graph exponential"[^3].
+
+[^2]: Graphs have many product structures, such as the tensor product and strong product.
+    The Cartesian product is (categorically) more natural when paired with disjoint unions.
+
+[^3]: Originally, I called this operation the "graph factorial", since it involves permutations
+    and the number of vertices in the resulting graph grows factorially.
+
+This operation is my own invention, so I am unsure whether or not
+  it constitutes anything useful.
+In fact, the possible graphs grow so rapidly that computing anything about the exponential
+  of order 8 graphs starts to overwhelm a single computer.
+It is, however, interesting, as I will hopefully be able to convince.
+
+A random graph will not generally correspond to an interesting generating set,
+  and therefore, will also generally have an uninteresting exponential graph.
+Hence, I will continue with the examples used previously: paths, stars, and complete graphs.
+They are among the simplest graphs one can consider, and as we will see shortly,
+  have exponentials which appear to have natural correspondences to other graph families.
+
+
+Some Small Exponential Graphs
+-----------------------------
+
+Because of [the difficulty in determining graph isomorphism](
+    https://en.wikipedia.org/wiki/Graph_isomorphism_problem
+  ), it is challenging for a computer to find a graph in an encyclopedia.
+Computers think of graphs as a list of vertices and their outward edges,
+  but this implementation faces inherent labelling issues.
+These persist even if the graph is described as a list of (un)ordered pairs,
+  an adjacency matrix, or an incidence matrix,
+  the latter two of which have very large memory footprints[^4].
+
+[^4]: I was able to locate a project named the
+    [Encyclopedia of Finite Graphs](https://github.com/thoppe/Encyclopedia-of-Finite-Graphs),
+    but it is only able to build a database simple connected graphs which
+    can be queried by invariants (and is outdated since it uses Python 2).
+
+However, as visual objects, humans can compare graphs fairly easily
+  -- the name means "drawing" after all.
+Exponentials of order 3 and order 4 graphs are neither so small as to be uninteresting
+  nor so big as to be unparsable by humans.
+
+
+### Order 3
+
+![&nbsp;](./exp_order_3.png){.narrow}
+
+At this stage, we only really have two graphs to consider, since $P_3 = \bigstar_3$.
+Immediately, one can see that $\exp( P_3 ) = \exp( \bigstar_3 ) = C_6$,
+  the 6-cycle graph (or hexagonal graph).
+It is also apparent that $\exp( K_3 )$ is the utility graph, $K_{3,3}$.
+
+![
+  Graph exponential of a disconnected graph. <br>
+  Note that the red element commutes with the green and blue ones.
+  This produces two types of squares in the exponential graph.
+  Meanwhile, the green and blue elements have an order 3 product, and produce the hexagon.
+](./exp_p3_oplus_p2.png)
+
+Here, we can again demonstrate the sum rule of the graph exponential with $\exp( P_3 \oplus P_2 )$.
+Simplifying, since we know $\exp( P_3 ) = C_6$, the result is $C_6 \times P_2 = \text{Prism}_6$,
+  the hexagonal prism graph.
+
+
+### Order 4 (and beyond)
+
+::: {layout="[[1,1],[1]]"}
+![$\exp( P_4 )$](./exp_p4_networkx.png)
+
+![$\exp( \bigstar_4 )$](./exp_star4_networkx.png)
+
+![](./exp_order_4.png)
+:::
+
+With some effort, $\exp( P_4 )$ can be imagined as a projection of a 3D object,
+  the [truncated octahedron](https://en.wikipedia.org/wiki/Truncated_octahedron).
+Because of its correspondence to a 3D solid, this graph is planar.
+Both the hexagon and this solid belong to a class of polytopes called
+  [*permutohedra*](https://en.wikipedia.org/wiki/Permutohedron), which are figures
+  that are also formed by permutations of the coordinate (1, 2, 3, ..., *n*) in Euclidean space[^5].
+Technically, there is a distinction between the Cayley graphs and permutohedra
+  since their labellings differ.
+Both have edges generated by swaps, but in the latter case, the connected vertices are expected to be
+  separated by a certain distance.
+More information about the distinction can be found at this article on [Wikimedia](
+    https://commons.wikimedia.org/wiki/Category:Permutohedron_of_order_4_%28raytraced%29#Permutohedron_vs._Cayley_graph
+  )[^6].
+
+[^5]: In fact, these figures are able to completely tessellate the $n-1$ dimensional subspace of
+      $\mathbb{R}^n$ where the coordinates sum to the $n-1$th triangular number.
+    Note also that the previous graph in the sequence of $\exp(P_n)$, the hexagonal graph,
+      is visible in the truncated octahedron.
+    This corresponds to the projection $(x,y,z,w) \mapsto (x,y,z)$ over
+      the coordinates of the permutohedra.
+
+[^6]: Actually, if one considers a *right* Cayley graph, where each generator is right-multiplied
+      to the permutation at a node rather than left-multiplied, then a true correspondence is obtained,
+      at least for order 4.
+
+Meanwhile, $\exp( \bigstar_4 )$ is more difficult to identify, at least without rearranging its vertices.
+It turns out to be isomorphic to the [Nauru graph](https://mathworld.wolfram.com/NauruGraph.html),
+  a graph with many strange properties.
+Notably, whereas the graph isomorphic to the permutohedron is obviously a spherical polyhedron,
+  the Nauru graph can be topologically embedded on a torus.
+The Nauru graph also belongs to the family of
+  [permutation star graphs](https://mathworld.wolfram.com/PermutationStarGraph.html)
+  $PS_n$ (*n* = 4), which also includes the hexagonal graph (*n* = 3).
+The MathWorld article confirms some kind of correspondence, stating graphs of this form
+  are generated by pairwise swaps.
+
+My attempts at finding a graph isomorphic to $\exp( K_4 )$ have thus far ended in failure.
+It is certainly *not* isomorphic to $K_{4,4}$, since this graph has 8 vertices,
+  as opposed to 24 in $\exp( K_4 )$.
+
+
+Graph Invariants
+----------------
+
+While I have managed to identify the families to which some of these graphs belong,
+  I am rather fond of computing (and conjecturing) sequences from objects.
+Not only is it much easier to consult something like [the OEIS](https://oeis.org/) for these quantities,
+  but after finding a matching sequence, there are ample articles to consult for more information.
+By linking to their respective entries, I hope you'll consider reading more there.
+
+Even though I have obtained these values empirically, I am certain that the sequences for
+  $\exp( P_n )$ and $\exp( \bigstar_n )$ match the corresponding OEIS entries.
+I also have great confidence in the sequences I found for $\exp( K_n )$.
+
+
+### Edge Counts
+
+Despite knowing how many vertices there are (*n*!, the order of the symmetric group),
+  we don't necessarily know how many edges there are.
+
+```{python}
+#| echo: false
+#| classes: plain
+
+Markdown(tabulate(
+  [
+    [i, pathG.edge_count, starG.edge_count, completeG.edge_count]
+    for i in range(3, 8)
+    for pathG, starG, completeG in (
+      [path.data[i], star.data[i], complete.data[i]],
+    )
+  ] + [
+    [
+      "Sequence",
+      "Second column of Lah numbers <br> [OEIS A001286](http://oeis.org/A001286)",
+      "Same as previous",
+      "[OEIS 001809](http://oeis.org/A001809)",
+    ],
+    [
+      "Rule",
+      r"$L(n,2) = n!{(n-1)(n-2) \over 4}$",
+      "",
+      r"$n!{n(n-1) \over 4}$"
+    ]
+  ],
+  headers=[
+    "*n*",
+    r"$\#E(\exp( P_n ))$",
+    r"$\#E(\exp( \bigstar_n ))$",
+    r"$\#E(\exp( K_n ))$"
+  ]
+))
+```
+
+
+### Radius and Distance Classes
+
+The radius of a graph is the smallest possible distance which separates two maximally-separated vertices.
+Due to vertex transitivity, the greatest distance between two vertices is the same for every vertex.
+
+```{python}
+#| echo: false
+#| classes: plain
+
+Markdown(tabulate(
+  [
+    [i, len(pathG), len(starG), len(completeG)]
+    for i in range(3, 8)
+    for pathG, starG, completeG in (
+      [path.data[i].distance_classes, star.data[i].distance_classes, complete.data[i].distance_classes],
+    )
+  ] + [
+    [
+      "Sequence",
+      "Triangular numbers <br> [OEIS A000217](http://oeis.org/A000217)",
+      "Integers not congruent to 2 (mod 3) <br> [OEIS A032766](http://oeis.org/A032766)",
+      "*n* - 1"
+    ],
+    [
+      "Rule",
+      r"$\Delta_{n-1} = {n(n-1) \over 2}$",
+      r"$\lfloor {n-1 \over 2} \rfloor + n -\ 1$"
+    ]
+  ],
+  headers=[
+    "*n*",
+    r"$r(\exp( P_n ))$",
+    r"$r(\exp( \bigstar_n ))$",
+    r"$r(\exp( K_n ))$"
+  ]
+))
+```
+
+These quantities are somewhat reductive.
+If a vertex is distinguished, the remaining vertices may be partitioned into classes by their
+  distance from it.
+Including the vertex itself (which is distance 0 away), there will be $r + 1$ such classes,
+  where *r* is the radius.
+These classes are the same for every vertex due to transitivity.
+
+In the case of these graphs, they are a partition of *n*!.
+
+```{python}
+#| echo: false
+#| classes: plain
+
+half_break = lambda x: str(x[:len(x) // 2])[:-1] + "<br>" + str(x[len(x) // 2:])[1:]
+
+Markdown(tabulate(
+  [
+    [i, pathG if i <= 5 else half_break(pathG), starG, completeG]
+    for i in range(3, 8)
+    for pathG, starG, completeG in (
+      [path.data[i].distance_classes, star.data[i].distance_classes, complete.data[i].distance_classes],
+    )
+  ] + [
+    [
+      "Sequence",
+      "Mahonian numbers <br> [OEIS A008302](http://oeis.org/A008302)",
+      "Whitney numbers of the second kind (star poset) <br> [OEIS A007799](http://oeis.org/A007799)",
+      "Stirling numbers of the first kind <br> [OEIS A132393](http://oeis.org/A132393)"
+    ]
+  ],
+  headers=[
+    "*n*",
+    r"$\text{dists}(\exp( P_n ))$",
+    r"$\text{dists}(\exp( \bigstar_n ))$",
+    r"$\text{dists}(\exp( K_n ))$"
+  ]
+))
+```
+
+I am certain that the appearance of the Stirling numbers here is legitimate,
+  since these numbers count the number of permutations of *n* objects with *k* disjoint cycles.
+Obviously, the identity element is distance 1 from all 2-cycles since they are all in the generating set;
+  likewise, all 3-cycles are distance 2 from the identity (but distance 1 from the 2-cycles),
+  and so on until the entire graph has been mapped.
+The shapes induced by these classes were used to create the diagrams
+  of $\exp( K_3 )$ and $\exp( K_4 )$ above.
+
+
+#### Spectrum
+
+The eigenvalues of the adjacency matrix of a graph can be interesting
+  and sometimes help in identifying a graph.
+Unfortunately, eigenvalues are not necessarily integers, and therefore not easily
+  found in the OEIS (though they are always real for graphs).
+
+```{python}
+#| echo: false
+#| classes: plain
+
+Markdown(tabulate(
+  [
+    [i, pathG.to_markdown(), starG.to_markdown(), completeG.to_markdown()]
+    for i in range(3, 9)
+    for pathG, starG, completeG in (
+      [path.data[i].spectrum, star.data[i].spectrum, complete.data[i].spectrum],
+    )
+  ],
+  headers=[
+    "*n*",
+    r"$\text{Spec}(\exp( P_n ))$",
+    r"$\text{Spec}(\exp( \bigstar_n )$",
+    r"$\text{Spec}(\exp( K_n ))$"
+  ]
+))
+```
+
+From what I have been able to identify, the spectrum of an exponential graph is symmetric about 0,
+  by which I mean that the characteristic polynomial is even.
+This has been the case for all graphs I have tried testing, even outside these graph families.
+
+Since all eigenvalues of $\exp( \bigstar_n )$ calculated are integers,
+  it appears they are integral graphs, a fact of which I am reasonably sure
+  because of the aforementioned correspondence to permutation star graphs.
+Additionally, the eigenvalues are very conveniently the integers up to $n-1$ and down to $-n+1$.
+Unfortunately, despite the ease of reading the eigenvalues themselves,
+  there isn't an OEIS entry for the multiplicities.
+I was able to identify the multiplicity of the 0 eigenvalue with
+  [OEIS A217213](http://oeis.org/A217213), which counts orderings on Dyck paths.
+If this is truly the sequence being generated, it means there is a 1:1 correspondence between
+  these orderings and a basis of the nullspace of the adjacency matrix.
+
+It seems to be the case that $\exp( K_n )$ are also integral graphs.
+Perplexingly, the multiplicities for each of the eigenvalues appear to mostly be perfect powers.
+This is the case until n = 8, which ruins the pattern because neither of
+  $9864 = 2^3 \cdot 3^2 \cdot 137$ or $6125 = 5^3 \cdot 7^2$ are perfect powers.
+I find both this[^7] and the fact that such a large prime appears among the factorization of the former
+  rather creepy since all other primes which appear here are small -- 2, 3, 5, and 7.
+
+[^7]: Some physicists are fond of 137 for its closeness to the reciprocal
+      of the fine structure constant (a bit of mostly-harmless numerology).
+
+
+### Notes about Spectral Computation
+
+For *n* = 3 through 6, exactly computing the spectrum
+  (or more accurately, the characteristic polynomial)
+  is possible, although it takes upwards of 10 minutes for *n* = 6 on my machine using `sympy`.
+The spectra of *n* = 7, 8 are marked with an asterisk because they were computed numerically,
+  which still took nearly 8 hours in the case of the latter.
+In fact, these graphs grow so quickly that it becomes nearly impossible to compute
+  the spectrum without an explicit formula.
+
+For *n* = 8, even storing the adjacency matrix in memory is a problem.
+Assuming the use of single-precision floating point, this behemoth of a matrix is
+  $(8!)^2 \cdot 4 \text{ bytes} = 6.5\text{GB}$.
+This doesn't even factor in additional space requirements for eigenvalue algorithms,
+  and is the reason I certainly won't be attempting to compute the spectrum for *n* = 9.
+
+
+Gallery of Adjacency Matrices
+-----------------------------
+
+The patterns in adjacency matrices depend on an enumeration of $S_n$ so that the vertices
+  can be labelled from 1 to *n*!.
+While this is a fascinating topic unto itself, this post is already long enough,
+  and I feel comfortable with just sharing the pictures.
+
+
+### [Plain Changes](https://en.wikipedia.org/wiki/Steinhaus%E2%80%93Johnson%E2%80%93Trotter_algorithm)
+
+::: {layout-ncol="3"}
+![$P_5$](plain-changes/plain_path_5.png)
+
+![$\bigstar_5$](plain-changes/plain_star_5.png)
+
+![$K_5$](plain-changes/plain_k_5.png)
+
+![$P_6$](plain-changes/plain_path_6.png)
+
+![$\bigstar_6$](plain-changes/plain_star_6.png)
+
+![$K_6$](plain-changes/plain_k_6.png)
+:::
+
+
+### [Heap's Algorithm](https://en.wikipedia.org/wiki/Heap%27s_algorithm)
+
+:::: {}
+::: {layout-ncol="3"}
+![$P_5$](heap/heap_path_5.png)
+
+![$\bigstar_5$](heap/heap_star_5.png)
+
+![$K_5$](heap/heap_k_5.png)
+
+![$P_6$](heap/heap_path_6.png)
+
+![$\bigstar_6$](heap/heap_star_6.png)
+
+![$K_6$](heap/heap_k_6.png)
+:::
+
+Note: GHC's `Data.List.permutations` is slightly different from Heap's algorithm as displayed on Wikipedia
+::::
+
+
+Closing
+-------
+
+As previously stated, I am only mostly sure of the validity of the exponential law for graphs.
+It *seems* too good to be true, but testing it directly on some graphs by comparing the spectra
+  of the exponential of the sum against the product of the exponentials shows that they are at least cospectral.
+Try it yourself, preferably with a better tool than [the ones I made in Haskell](https://github.com/queue-miscreant/SymmetricGraph).
+
+From the articles I was able to find, permutation star graphs have applications to parallel computing,
+  which is somewhat ironic considering how little care I had for the topic when writing this article.
+If I needed ruthless efficiency, I probably could have used a library with GPU algorithms
+  (or taken a stab at writing a shader myself).
+However, I *was* able to use this as a learning experience regarding mutable objects in Haskell.
+With only immutable objects (and enough garbage to create an island in the Pacific),
+  I was running out of memory even with 16GB of RAM and 16GB of swap.
+Introducing mutability not only brought improvements in space, but also a great deal of speedup,
+  enough to make rendering adjacency matrix images of order 8 graphs just barely doable within
+  a reasonable time span.
+
+Said images are cursed.
+Remember, as raw bitmaps, these files are on the order of *gigabytes* big.
+On a much weaker computer than I used to render the images, merely opening my file explorer
+  to the folder containing *the folder containing* the images
+  caused its all-too-eager thumbnailer to run.
+This started consuming all of my system resources, crashed all of my browser's tabs,
+  distorted audio, and finally locked up the computer.
+Despite this, PNG is a wonderful format that is able to compress them down to just 4MB,
+  which demonstrates just how sparse these matrices are.
+
+Despite everything I was able to find about permutation star graphs and permutohedra,
+  I was surprised that there is no information about the Cayley graphs generated by *all*
+  2-cycles (or at least information which is easy to find).
+This is especially disappointing considering the phantom pattern which gets destroyed by 137,
+  and I would love to know more about why this happens in the first place.
+
+Graph diagrams made with GeoGebra and NetworkX (GraphViz).
+
+
+### Additional Links
+
+- [Whitney Numbers of the Second Kind for the Star Poset (
+    Paper from ScienceDirect
+  )](https://www.sciencedirect.com/science/article/pii/S0195669813801278)
+  - This article includes a section about representing a list of generators as a graph,
+    making me wonder if someone has tried defining this operation before
+- [Whitney Numbers (Josh Cooper's Mathpages)](https://people.math.sc.edu/cooper/graph.html)
+- [
+    The Many Faces of the Nauru Graph (Blogpost by David Eppstein)
+  ](https://11011110.github.io/blog/2007/12/12/many-faces-of.html)

posts/permutations/3/index.qmd

@@ -0,0 +1,424 @@
+---
+title: "A Game of Permutations, Part 3"
+description: |
+  Extending swap diagrams (with apologies to H.S.M. Coxeter).
+format:
+  html:
+    html-math-method: katex
+date: "2022-05-20"
+date-modified: "2025-07-06"
+categories:
+  - graph theory
+  - group theory
+---
+
+<style>
+.figure-img.narrow {
+  max-width: 768px;
+}
+
+.figure-img.narrower {
+  max-width: 640px;
+}
+
+.figure-img.narrowest {
+  max-width: 512px;
+}
+</style>
+
+
+This post assumes you have read the [first post](../1), which talks about swap diagrams
+  and the symmetric group.
+The section about Cayley graphs from the [second post](../2) will also be useful.
+
+To summarize from the first post, a swap diagram is a graph where each vertex represents
+  a list index and each edge represents the permutation which swaps the two entries.
+I singled out three graph families for their symmetry:
+
+- Paths, which link adjacent swaps
+- Stars, in which all swaps contain a distinguished index
+- Complete graphs, which contain all possible swaps
+
+Swap diagrams are ultimately limited by only being able to describe collections of 2-cycles.
+If we wanted to include higher-order elements, we'd require a weaker
+  mathematical structure called a [hypergraph](https://en.wikipedia.org/wiki/Hypergraph).
+These are even more difficult to draw than simple graphs, much less understand.
+
+Another way we are limited is in the kinds of groups which can be encoded.
+One can rather quickly notice that swap diagrams will only generate symmetric groups
+  and direct products thereof.
+Also, while edges are members of a generating set, the vertices contain information
+  which is ultimately irrelevant to the group.
+
+
+Upgrading Diagrams
+------------------
+
+What if we forgot the roles of the vertices, allowed the edges to take their place?
+In other words, we want to make a graph where the vertices represent generators,
+  rather than the edges.
+
+Ideally, we'd still like to preserve some information about coincident edges.
+Graph-theoretically, we can elevate the role of the edges to that of the vertices
+  by making a [line graph](https://en.wikipedia.org/wiki/Line_graph).
+This operation produces a graph such that
+
+- Every edge in the original graph becomes a vertex in the new graph
+- Coincident edges in the new graph are connected by an edge in the new graph
+    - In other words, we convert adjacent edges to adjacent vertices.
+
+![
+  While line graphs of paths simply shrink,
+    $\bigstar_5$ shrinks to $K_4$ before expanding to $K_{2,2,2}$
+](./line_graphs.png)
+
+The line graph of a swap diagram results in a graph where the vertices are the 2-cycles.
+In a swap diagram, when two distinct 2-cycles share an index (vertex), their product has order 3.
+Thus, in the line graph, the edges mean that the product of the two vertices has order 3.
+Non-adjacent vertices still have a product with order 2, since they represent disjoint 2-cycles.
+
+To push the group/graph correspondence the even further, we can impose a final restriction.
+Namely, a subgraph should represent a sub*group*.
+Specifically, we want an *induced* subgraph
+  (one where if two connected vertices are included, then so is the edge joining them)
+  since this maintains the relationship between the generators.
+Unfortunately, this restriction disqualifies many of the line graphs of swap diagrams.
+At least our beloved paths are left untouched, since $L(P_n) = P_{n-1}$.
+
+
+### Coxeter Diagrams
+
+As it turns out, these restrictions are significant and produce some very deep mathematical objects,
+  known as *Coxeter diagrams* (named for the same Coxeter as in [Goldberg-Coxeter](/posts/pentagons/1)).
+In this domain, the aforementioned rules about vertices and edges apply:
+  each vertex corresponds to an order 2 element and each edge signifies
+  that the product of two elements has order 3.
+Furthermore, *disconnected* vertices correspond to elements which commute with one another,
+  just like disjoint 2-cycles.
+However, each vertex need not correspond to a single 2-cycle,
+  and can instead be *any* element of order 2, i.e., a product of disjoint 2-cycles.
+
+
+<!-- TODO: better wikimedia imports -->
+<div class="quarto-figure quarto-figure-center">
+<figure class="figure">
+  <a title="Rgugliel, CC BY-SA 3.0 <https://creativecommons.org/licenses/by-sa/3.0>, via Wikimedia Commons" href="https://commons.wikimedia.org/wiki/File:Finite_coxeter.svg#/media/File:Finite_coxeter.svg">
+    <img src="https://upload.wikimedia.org/wikipedia/commons/thumb/e/e7/Finite_coxeter.svg/600px-Finite_coxeter.svg.png" style="background-color:white !important; border-radius: 5px; padding: 5px;" alt="Finite coxeter.svg">
+  </a>
+
+  <figcaption>
+    The most important Coxeter diagrams.
+    Note that the $A_n$ diagrams are just the familiar path graphs.
+    <br>
+    Source: Rgugliel, via Wikimedia Commons
+  </figcaption>
+</figure>
+</div>
+
+Coxeter diagrams are frequently extended to enable describing higher-order products
+  by labelling the edge[^1].
+For example, the product between $(1 ~ 2)(3 ~ 4)$ and $(2 ~ 3)$ has order 4.
+A diagram for these elements would therefore include two vertices connected
+  with an edge labelled "4", corresponding to $B_2$.
+
+[^1]: Unlabelled edges still have order 3.
+
+
+### How Big and What Shape?
+
+We already know how big the group a swap diagram generates.
+Each connected component with *n* vertices generates the group $S_n$.
+They combine via the direct product to give a group of order
+
+$$
+\left | \prod_i S_{n_i} \right | = \prod_i | S_{n_i} | = \prod_i n_i!
+$$
+
+Removing an edge from a swap diagram has the potential to make the graph disconnected.
+In this case, the graph is split into two parts, which map to $S_m$ and $S_n$.
+This tells us that $S_m \times S_n$ embeds in $S_{m + n}$.
+
+The subgroup restriction makes Coxeter diagrams a lot more sensitive to changes.
+We at least know that if we remove a vertex, the resulting diagram is a subgroup of the whole diagram.
+What we need is some way to measure the effect this has on the rest of the group.
+
+
+Coxeter-Todd Algorithm
+----------------------
+
+This is exactly what the [*Coxeter-Todd algorithm*](
+    https://en.wikipedia.org/wiki/Todd%E2%80%93Coxeter_algorithm
+  ) does.
+It more-or-less generalizes the procedure for creating Cayley graphs.
+Using the vertices of the Coxeter diagram as generators[^2], we convert products between
+  them to paths in a graph.
+
+[^2]: For clarity, I'll try to refer to these vertices specifically as "generators".
+
+Let's apply the algorithm to the diagram $A_3$.
+First, we need to label our generators as *a*, *b*, and *c*.
+Then, we select a select a generator to remove and create a graph according to the following steps:
+
+
+### 1. Initialization
+
+In a Cayley graph, we start out with a single vertex representing the identity.
+Here, the first vertex instead corresponds to the subgroup generated by all other generators.
+
+For each generator other than the one being removed, we attach loops to the vertex.
+This is because the subgroup is closed -- when we multiply the set of all elements
+  of the subgroup by any of its elements, it doesn't change the set.
+In other words, $hH = H, h \in H$.
+
+For the remaining generator, we draw an edge connecting to a new vertex,
+  which represents a new set of elements.
+This is a coset of the subgroup -- that is, each vertex we make in this new graph
+  corresponds to a disjoint partition of elements of the whole group.
+
+![
+  Left: the Coxeter diagram $A_3$ <br>
+  Right: the first step of generating a graph from removing generator *a*.
+  The (group generated by the) *bc* subdiagram is represented by the vertex with the *b* and *c* loops.
+](./steps/coxeter_todd_1.png)
+
+Note that all loops and edges we draw will be undirected, since all generators have order 2.
+Performing the same operation twice just takes us back to where we started.
+
+
+### 2. Loop Transference
+
+At the new vertex, we transfer over every loop whose label is not connected to the label of the edge.
+This is due to the rule stating that non-adjacent generators commute.
+In other words, their product has order 2.
+For our graph, this can be seen for $acac = a^2 c^2 = \text{id} = (ac)^2$, and means after following
+  labels *acac*, we end up at the same vertex we started at.
+
+![&nbsp;](./steps/coxeter_todd_step_2.png)
+
+
+### 3. Extension, Branching, and Rejoining
+
+At the new vertex, we still need an edge labelled *b*, but it cannot be a loop.
+Adjacent generators have a product whose order is the label (*n*) of the edge connecting them
+  (defaulting to 3 for unlabelled ones).
+This means we need to form a path alternating between the two generators,
+  such that following it would loop back to the vertex we started at.
+That is,
+
+$$
+(ab)^n = \stackrel{n \text{ times}}{\overbrace{(ab)(ab) ... (ab)(ab)}} = \text{id}
+$$
+
+![
+  Attaching a *b* edge to a new vertex with an *a* loop so that $ababab = \text{id}$
+](./steps/coxeter_todd_step_3.png)
+
+If the Coxeter diagram branches, then so does the generated graph.
+The labels of each pair of branching edges have a product with a known order,
+  so following a path alternating between two of them must return to the same vertex.
+Since it alternates between the two labels *n* times, this ends up producing even-sided polygons
+  in our generated graph.
+Commuting vertices form either a square or a pair of loops connected by an edge.
+The latter is actually a special case of the former, which can be seen by matching
+  a pair of opposite edges.
+
+![
+  Top: two nonadjacent vertices form a square <br>
+  Bottom: two adjacent vertices form a hexagon
+](./steps/coxeter_todd_cycles.png){.narrower}
+
+
+### 4. Finalization
+
+If we ensure at each new vertex that we can follow a valid path for every pair of generators,
+  then this process will either terminate or continue indefinitely with a repeating pattern.
+A quick sanity check on the resulting graph is to add the number of loops and edges at a vertex.
+The sum should be the number of generators.
+
+![
+  Final graph to the middle right. The *ab* and *bc* paths are shown above and below.
+](./steps/coxeter_todd_step_4.png){.narrower}
+
+As stated earlier, each vertex in the graph corresponds to a coset of the group
+  under the subgroup being considered.
+The number of cosets is the index of the subgroup, the quantity we were after the whole time.
+In this case, the index of the three-vertex diagram ($A_3$) on the two-vertex diagram
+  ($A_2$, the same diagram without *a*) is 4.
+
+
+### Results
+
+We can remove vertices one-by-one until we eventually reduce the graph to a single vertex,
+  which we know has order 2.
+Multiplying all of the indices at each stage together gives us the order of the group we are after.
+
+![
+  Coxeter diagrams (left) and the graphs generated by removing the a vertex (right). <br>
+  Permutations shown above vertices which give a permutation group embedding.
+](./coxeter_an.png){.narrow}
+
+It is readily shown that the group generated by $A_3$ has order $4 \cdot 3 \cdot 2 = 24$,
+  which coincides with the order of $S_4$.
+
+We can assign a permutation to each of our generators, so long as the edge condition
+  as it relates to their product is obeyed.
+In the diagrams above, $(1 ~ 2)$ and $(2 ~ 3)$ have a product of order 3,
+  but $(1 ~ 2)$ and $(3 ~ 4)$ have a product of order 2,
+  since the cycles (and in the diagram, the vertices) are disjoint.
+This argument generalizes nicely to higher $A_n$.
+
+
+Other Diagrams for $A_3$
+------------------------
+
+A path is hardly the most interesting diagram.
+However, there are yet more graphs which can be produced from $A_3$.
+
+
+### Starting in the Middle
+
+Selecting either endpoint of the diagram (generator *a* or *c*) will generate the same graph as shown above.
+This is easy to see if you read the generated graph right-to-left rather than left-to-right.
+However, the center point *b* has two neighbors.
+If we try generating a graph by removing this generator, our graph branches.
+
+![&nbsp;](./coxeter_a3_generator_b.png){.narrow}
+
+The index of 6 given by this graph is correct, since the remaining diagram
+  $A_1 A_1$ has an order of $2 \cdot 2 = 4$.
+This group is isomorphic to the [Klein four-group](https://en.wikipedia.org/wiki/Klein_four-group),
+  so this diagram shows that it occurs within $S_4$.
+
+
+### Removing Multiple Vertices
+
+We can remove more than one generator from the Coxeter diagram at once, as long as we follow all the rules.
+Instead, the initial vertex in the new graph branches immediately and has fewer loops.
+For example, removing two generators from $A_3$ produces a figure with squares and hexagons:
+
+![
+  Graph generated by removing any two vertices from $A_3$. <br>
+  For the circled generators *a* and *b*, the diagram starts from the circled vertex
+    on the right (or its identical neighbor). <br>
+  If *b* and *c* were removed instead, the diagram would start from
+    the similar vertices with *a* loops at the top of the graph. <br>
+  If *a* and *c* were removed, the diagram would start from either the leftmost or rightmost vertex,
+    which both have a *b* loop.
+](./coxeter_a3_pair.png){.narrow}
+
+A figure composed of squares and hexagons should be familiar from the previous post.
+The truncated octahedron also contains only squares and hexagons and is generated by $S_4$.
+In fact, the figure above is the truncated octahedron folded in half.
+It is folded in "half" specifically because the single remaining vertex in the Coxeter diagram has order 2.
+Consequently, the number of vertices in the graph must be half that
+  of the whole group (or complete permutahedron).
+
+If we remove both generators in $A_2$, we end up with a hexagon.
+
+![
+  Graph generated by removing both generators from $A_2$.
+  All vertices are identical, so all may be considered "starting" vertices.
+](./coxeter_a2_both.png){.narrow}
+
+Also from the previous post, we know this to be the Cayley graph for $S_3$ generated by a pair of swaps.
+In this way, the Cayley graph can be thought of as a sort of "limiting" graph of the Coxeter diagram,
+  where each coset contains only a single element.
+
+
+The Traditional Explanation
+---------------------------
+
+I must now admit that that I have not given anywhere near the whole explanation of Coxeter diagrams,
+  and have only succeeded in leading us down the proverbial algebraic rabbit hole.
+
+Coxeter diagrams also come equipped with a standard geometric interpretation.
+The "order 2 elements" we discussed previously are replaced with mirrors,
+  and the edge labels are the angle between mirrors,
+  interpreted as half of the central angle of a regular *n*-gon (triangle: 60°, square: 45°, ...).
+
+<!-- TODO: better wikimedia imports-->
+<div class="quarto-figure quarto-figure-center">
+<figure class="figure">
+  <a title="Tomruen, CC BY-SA 4.0 <https://creativecommons.org/licenses/by-sa/4.0>, via Wikimedia Commons" href="https://commons.wikimedia.org/wiki/File:Dihedral_symmetry_domains_3.png">
+    <img width="192" alt="Dihedral symmetry domains 3" src="https://upload.wikimedia.org/wikipedia/commons/e/e2/Dihedral_symmetry_domains_3.png">
+  </a>
+
+  <figcaption>
+  Fundamental domains of Coxeter diagram ![](coxeter_a2.png)
+  <br>
+  Source: Tomuren, via Wikimedia Commons
+  </figcaption>
+</figure>
+</div>
+
+The image above is composed of the mirrors specified by $A_2$.
+One of the generators is the red reflection and the other is the the green reflection.
+It is clear that alternating between red and green three times will take one back
+  to where they started, just like the algebra tells us.
+
+All of the plane ends up assigned to one of the domains.
+Note also that points along mirrors which are equidistant from the center
+  form a hexagon made up of six equilateral triangles, one in each domain.
+
+
+### Struggles in 3D
+
+$A_3$ has an additional vertex and edge.
+This means that an additional mirror needs to be placed in along every preexisting reflection.
+We end up reflecting into another dimension, and our domains shoot out into 3D space.
+It is easier to imagine the additional domains by rotating two of the axes around each other,
+  so that the pairs will join together into equilateral triangular "cones".
+
+![
+  Mirror axes in 3D for $A_3$.
+  The red, green, and blue lines all lie within the same plane, and correspond to $A_2$.
+  The cyan line is perpendicular to the red one, and is formed by rotating
+    either green about blue or blue about green by 60°.
+](./roots/roots_a3.png){.narrowest}
+
+In 2D, equidistant points form a hexagon; in 3D, the points instead form a cuboctahedron.
+Connecting the triangular faces of the cuboctahedron to the origin gives
+  a family of eight tetrahedra meeting at a point.
+At this point the reflections become clearer, since certain reflections
+  do the same thing as in the plane above, while others will "double" a tetrahedron.
+
+::: {layout-ncol="2" layout-valign="center"}
+![Cuboctahedron](./roots/cuboctahedron.png)
+
+![
+  Six of the eight tetrahedra formed by connecting equidistant points ("roots") to the origin.
+  Note how whole tetrahedra are reflected in a mirror axis.
+](./roots/roots_a3_with_domains.png)
+:::
+
+Personally, I think the geometric way of thinking becomes is difficult even in 3D.
+Every axis describes a separate rotation, which is simple enough.
+But we're trying to create infinite cones of symmetry domains in 3D space,
+  and we can only try to interact with this using a 2D screen.
+We're running out of room before even getting to 4D space,
+  where the visualization problems are even worse.
+Also, while the angle between two mirrors is 60°, it's easy to slip into thinking
+  about the dihedral angle between two faces (domains) of the cones, which is *not* 60°.
+
+
+Closing
+-------
+
+When I initially wrote the article about swap diagrams (a name I hadn't given them at the time)
+  I had no idea about how closely it related to something else which I was having trouble understanding.
+Now knowing better, I split the article and pushed the basics a little harder.
+I find this closeness between swap diagrams and Coxeter diagrams interesting.
+At the cost of simplicity, the latter enables the ability to encode higher-order cycles and give rise
+  to exceptional mathematical objects.
+
+It was difficult for me to find information documenting how to understand the algebraic perspective.
+It also bears mentioning that I know very little about Lie theory,
+  another field of math where Coxeter diagrams turn up.
+When I finally found [a group theory video](https://www.youtube.com/watch?v=BHezLvEH1DU)
+  by Professor Richard Borcherds, I was dismayed that there seems to be even less material
+  online which depicts the coset graphs.
+I have written [an appendix](../appendix) cataloguing some graphs that appear when applying
+  the Coxeter-Todd algorithm, since I believe they are interesting in their own right.
+
+Images from Wikimedia belong to their respective owners.
+All other diagrams created with GeoGebra.

posts/permutations/_metadata.yml

@@ -0,0 +1,5 @@
+# freeze computational output
+freeze: auto
+
+# Enable banner style title blocks
+title-block-banner: true

posts/permutations/appendix/b4_embedding.hs

@@ -0,0 +1,36 @@
+import Data.List (nub, sortOn)
+import Cayley.Group
+import Cayley.Symmetric
+
+-- generators of W(B_4), order 384
+goodB4Embedding = map read ["(1 3)", "(1 2)(3 4)(5 6)(7 8)", "(1 3)(2 6)(4 5)(7 8)", "(1 3)(2 4)(5 7)(6 8)"] :: [Perm]
+goodB4Edges = filter ((>2) . order) [x <> y | x <- goodB4Embedding, y <- goodB4Embedding]
+-- generators of H, order 192
+badb4Embedding = map read ["(1 2)(3 4)(5 6)(7 8)", "(1 3)(2 5)(4 7)(6 8)", "(1 2)(3 4)(5 7)(6 8)", "(1 2)(3 5)(4 6)(7 8)"] :: [Perm]
+
+
+-- Order 192 subgroup of only even permutations in W(B_4)
+goodB4EvenPermsSubgroup = filter ((==1) . pParity) $ generatingSet $ goodB4Embedding
+
+-- Count the orders in the group xs
+-- Should probably be done better in CayleyOps
+countOrders xs = sortOn fst $ map ((,) <*> flip numOrder xs) (nub $ map order xs)
+
+commutatorSubgroup xs = nub $ [commutator x y | x <- xs, y <- xs]
+
+printGroupData x = do
+  putStr "\tOrder: "
+  putStrLn $ show $ length x
+  putStr "\tElement order count: "
+  putStrLn $ show $ countOrders x
+  putStr "\tCommutator subgroup order: "
+  putStrLn $ show $ length $ commutatorSubgroup x
+
+
+main = do
+  putStrLn "Bad embedding:"
+  printGroupData $ generatingSet badb4Embedding
+  putStrLn "Even permutation subgroup of the good embedding:"
+  printGroupData goodB4EvenPermsSubgroup
+  putStrLn "Edge-generated subgroup of the good embedding:"
+  printGroupData $ generatingSet goodB4Edges

posts/permutations/appendix/index.qmd

@@ -0,0 +1,529 @@
+---
+title: "A Game of Permutations, Appendix"
+description: |
+  Partial Cayley graphs of Coxeter diagrams
+format:
+  html:
+    html-math-method: katex
+date: "2022-05-27"
+date-modified: "2025-07-11"
+categories:
+  - graph theory
+  - group theory
+---
+
+<style>
+.figure-img.narrower, img.narrower {
+  max-width: 512px;
+}
+
+.figure-img.narrow, img.narrow {
+  max-width: 768px;
+}
+</style>
+
+
+This post is an appendix to [another post](../3) discussing the basics of Coxeter diagrams.
+It focuses on transforming path-like swap diagrams into proper $A_n$ Coxeter diagrams,
+  which correspond to symmetric groups.
+This post focuses on the graphs made by the cosets made by removing a single generator
+  (i.e., a vertex of the Coxeter diagram).
+
+For finite diagrams whose order is not prohibitively big, I will also provide an embedding
+  as a permutation group by labelling each generator in the Coxeter diagram.
+Since each generator is the product of disjoint swaps, I will also show their swap diagrams,
+  as well as interactions via the edges.
+
+
+Platonic Symmetry
+-----------------
+
+The symmetric group $S_n$ also happens to describe the symmetries of an $(n-1)$-dimensional simplex.
+The 3-simplex is simply a tetrahedron and has symmetry group $T_h$, which is isomorphic to $S_4$.
+We know that $S_4$ can be encoded by the diagram $A_3$.
+
+The string {3, 3} can be read across the edges of $A_3$, denoting the order of certain symmetries.
+This happens to coincide with another datum of the tetrahedron:
+  its [Schläfli symbol](https://en.wikipedia.org/wiki/Schl%C3%A4fli_symbol).
+It describes triangles (the first 3) which meet in triples (the second 3) at a vertex.
+It may also be interpreted as the symmetry of the 2-dimensional components (faces) and the vertex-centered symmetry.
+[The Wikipedia article](https://en.wikipedia.org/wiki/Tetrahedron)
+  on the tetrahedron presents both of these objects in its information column.
+
+![
+  From the Wikipedia article on the tetrahedron.
+  The Conway notation, Schläfli symbol, Coxeter diagram, and symmetry groups are shown.
+](./tetrahedron_wikipedia.png)
+
+The image above shows more sophisticated diagrams alongside $A_3$,
+  which I will not attempt describing (mostly because I don't completely understand them myself).
+Other Platonic solids and their higher-dimensional analogues have different Schläfli symbols,
+  and correspond to different Coxeter diagrams.
+
+
+### $B_3$: Octahedral Group
+
+Adding an order-4 product into the mix makes things a lot more interesting.
+The cube (Schläfli symbol {4, 3}) and octahedron ({3, 4}) share a symmetry group, $O_h$,
+  which corresponds to the $B_3$ diagram[^1].
+
+[^1]: For groups without a common name, I'll instead use *W*(*diagram*)
+      (for [Weyl](https://en.wikipedia.org/wiki/Weyl_group)) to represent the generated group.
+    For example, in this case, $W(B_3) \cong O_h$.
+
+::: {layout-ncol="3" layout-valign="center"}
+![](./b3/coxeter_b3_generator_a.png){.lightbox group="b3"}
+
+![](./b3/coxeter_b3_generator_b.png){.lightbox group="b3"}
+
+![](./b3/coxeter_b3_generator_c.png){.lightbox group="b3"}
+:::
+
+The center graph is the first to have a hexagon created by removing a single generator.
+Meanwhile, the third graph is entirely path-like, similar to the ones created
+  by removing an endpoint from the $A_n$ diagrams.
+In the same vein, the graph for $B_3$ resembles the graph for $A_3$ made
+  by removing the center generator, albeit with two extra vertices.
+
+Going across left to right, the order suggested by each index is:
+
+- $8 \cdot |A_2| = 8 \cdot 6 = 48$
+- $12 \cdot |A_1 A_1| = 12 \cdot 4 = 48$
+- $6 \cdot |B_2| = 6 \cdot 8 = 48$
+    - $B_2$ describes the symmetry of a square (i.e., $\text{Dih}_4$, the dihedral group of order 8)
+
+Each diagram suggests the same order, which is good.
+A simple embedding which obeys the edge condition assigns $(1 ~ 2)(3 ~ 4)$ to *a*,
+  $(2 ~ 3)$ to *b*, and $(1 ~ 2)$ to *c*.
+Then $ab = (1 ~ 2 ~ 4 ~ 3)$ has order 4, $bc = (1 ~ 3 ~ 2)$ has order 3, and *ac* obviously has order 2.
+
+There's a problem though.
+These are all elements of $S_4$, and in fact, generate it
+  (in fact, $S_4 \cong O$, the rotational symmetries of a cube).
+The group we want is $O_h \cong S_4 \times \mathbb{Z}_2$.
+If we want to embed a group of order 48 in a symmetric group, we need one for which 48 divides its order.
+48 divides $|S_6| = 720$, and indeed, a quick fix is just to multiply each generator
+  by another disjoint 2-cycle like $(5 ~ 6)$.
+
+These two embeddings generate different (proper) Cayley graphs.
+The one for *O* has 24 vertices and is nonplanar.
+On the other hand, the one for $O_h$ is planar, and is the skeleton of the
+  [truncated cuboctahedron](https://en.wikipedia.org/wiki/Truncated_cuboctahedron),
+  a figure composed of octagons, hexagons, and squares.
+These shapes are exactly what those implied by the orders of the products in the Coxeter diagram.
+Note also that the [cuboctahedron](https://en.wikipedia.org/wiki/Cuboctahedron)
+  is the figure produced halfway between dualizing
+  the cube and octahedron by shrinking faces (their *rectification*).
+
+In either case, the products of adjacent generators (the permutations on the edges) are the same.
+When made into a Cayley graph, these products generate the
+  [rhombicuboctahedron](https://en.wikipedia.org/wiki/Rhombicuboctahedron),
+  which is another shape that is in some sense midway between the cube and octahedron.
+Since all of these generators are in $S_4$, it only has half the number of vertices
+  as the truncated cuboctahedron.
+
+<!-- TODO: embeddings are graphviz diagrams and could use python -->
+::: {layout="[[1,1,1],[1]]"}
+![
+  False embedding
+](./b3/false_octahedral_symmetry_graph.png)
+
+![
+  Good embedding
+](./b3/truncated_cuboctahedral_graph.png)
+
+![
+  Edge-generated
+](./b3/rhombicuboctahedral_graph.png)
+
+![
+  Left: false embedding, right: good embedding
+](./b3/octahedral_embedding.png){.narrow}
+:::
+
+
+### $H_3$: Icosahedral Group
+
+Continuing with groups based on 3D shapes, the dodecahedron (Schläfli symbol {5, 3})
+  and icosahedron ({3, 5}) also share a symmetry group.
+It is known as $I_h$ and corresponds to Coxeter diagram $H_3$.
+
+::: {layout-ncol="3" layout-valign="center"}
+![](./h3/coxeter_h3_generator_a.png){.lightbox group="h3"}
+
+![](./h3/coxeter_h3_generator_b.png){.lightbox group="h3"}
+
+![](./h3/coxeter_h3_generator_c.png){.lightbox group="h3"}
+:::
+
+Two of these graphs are similar to the cube/octahedron graphs.
+The middle contains a decagon, corresponding to the order 5 product between *a* and *b*.
+
+We have the orders:
+
+- $20 \cdot |A_2| = 20 \cdot 6 = 120$
+    - Graph resembles an extension of the graph of $B_3 / A_1 A_1$, as hexagons joining blocks of squares
+- $30 \cdot |A_1 A_1| = 30 \cdot 4 = 120$
+- $12 \cdot |H_2| = 12 \cdot 10 = 120$
+    - Graph resembles an extension of the graph of $B_3 / A_2$, as a single square joining paths
+
+The order 120 is the same as the order of $S_5$, which corresponds to diagram $A_4$.
+However, these are not the same group, since $I_h \cong \text{Alt}_5 \times \mathbb{Z}_2 \ncong S_5$.
+A naive (though slightly less obvious) embedding, found similarly to $B_3$'s,
+  incorrectly assigns the following:
+
+- $a = (1 ~ 2)(3 ~ 4)$
+- $b = (2 ~ 3)(4 ~ 5)$
+- $c = (2 ~ 3)(1 ~ 4)$
+
+This is certainly wrong, since all these permutations are within $S_5$.
+Actually, they are all even permutations and in fact generate $I \cong \text{Alt}_5$,
+  with order 60.
+Yet again, multiplying a disjoint 2-cycle (in this case, $(6 ~ 7)$) to each generator
+  boosts the order to 120 and gives a proper embedding of $I_h$.
+
+Similarly to $B_3$, the first, incorrect embedding gives a nonplanar Cayley graph.
+The second one gives a planar graph, the skeleton of the
+  [truncated icosidodecahedron](https://en.wikipedia.org/wiki/Truncated_icosidodecahedron).
+It consists of decagons, hexagons, and squares, just like those which appear in the graphs above.
+The icosidodecahedron is also the rectification of the dodecahedron and icosahedron.
+In this case, the edges generate the
+  [rhombicosidodecahedronal graph](https://en.wikipedia.org/wiki/Rhombicosidodecahedron).
+
+<!-- TODO: embeddings are graphviz diagrams and could use python -->
+::: {layout="[[1,1,1],[1]]" layout-valign="center"}
+![
+  False embedding
+](./h3/false_icosahedral_symmetry_graph.png)
+
+![
+  Good embedding
+](./h3/truncated_icosidodecahedral_graph.png)
+
+![
+  Edge-generated
+]( ./h3/rhomicosidodecahedral_graph.png)
+
+![
+  Left: false embedding, right: good embedding
+](./h3/icosahedral_embedding.png){.narrow}
+:::
+
+It is remarkable that the truncations of the rectifications[^2] have skeleta that are the same
+  as the Cayley graphs generated by their respective Platonic solids' Coxeter diagrams.
+In a way, these figures describe their own symmetry.
+Also, both of these figures belong to a class of polyhedra known as
+  [zonohedra](https://en.wikipedia.org/wiki/Zonohedron).
+
+[^2]: This composition is also called "omnitruncation".
+
+
+### $B_4$: Hyperoctahedral Group
+
+Up a dimension from the cube and octahedron lie their 4D counterparts:
+  the tesseract (Schläfli symbol {4, 3, 3}, interpreted as three cubes ({4, 3}) around an edge)
+  and 16-cell ({3, 3, 4}, four tetrahedra ({3, 3}) around an edge).
+They correspond to Coxeter diagram $B_4$.
+
+::: {layout-ncol="2" layout-valign="center"}
+![](./b4/coxeter_b4_generator_a.png){.lightbox group="b4"}
+
+![](./b4/coxeter_b4_generator_b.png){.lightbox group="b4"}
+
+![](./b4/coxeter_b4_generator_c.png){.lightbox group="b4"}
+
+![](./b4/coxeter_b4_generator_d.png){.lightbox group="b4"}
+:::
+
+Three of these graphs (those starting with *a*, *c*, and *d*) are *also* similar
+  to those encountered one dimension lower.
+The remaining graph is best understood in three dimensions, befitting the 4D symmetries it encodes.
+It appears to have similar regions to the
+  [omnitruncated tesseract](https://en.wikipedia.org/wiki/Runcinated_tesseracts#Omnitruncated_tesseract),
+  featuring both the truncated octahedron and hexagonal prism cells.
+
+We have the orders:
+
+- $16 \cdot |A_3| = 16 \cdot 24 = 384$
+    - Graph resembles an extension of $B_3 / A_2$, as squares connecting paths
+- $32 \cdot |A_1 A_2| = 32 \cdot 2 \cdot 6 = 384$
+- $24 \cdot |B_2 A_1| = 24 \cdot 8 \cdot 2 = 384$
+    - Graph resembles an extension of $B_3 / A_1 A_1$, as hexagons joining blocks of squares
+- $8 \cdot |B_3| = 8 \cdot 48 = 384$
+    - Graph resembles an extension of $A_3 / A_2$, a simple path
+
+The order of the group, 384, suggests that it needs to be embedded in at least $S_8$
+  since $384 ~ \vert ~ 8! ~ ( = 40320)$.
+Indeed, such an embedding exists (found by computer search rather than by hand):
+
+- $a = (1 ~ 3)$
+- $b = (1 ~ 2)(3 ~ 4)(5 ~ 6)(7 ~ 8)$
+- $c = (1 ~ 3)(2 ~ 6)(4 ~ 5)(7 ~ 8)$
+- $d = (1 ~ 3)(2 ~ 4)(5 ~ 7)(6 ~ 8)$
+
+Notably, this embedding takes advantage of an order 4 product between an order 2 and an order 4 element.
+
+A similar computer search yielded an insufficient embedding in $S_8$, with order 192:
+
+- $a = (1 ~ 2)(3 ~ 4)(5 ~ 6)(7 ~ 8)$
+- $b = (1 ~ 3)(2 ~ 5)(4 ~ 7)(6 ~ 8)$
+- $c = (1 ~ 2)(3 ~ 4)(5 ~ 7)(6 ~ 8)$
+- $d = (1 ~ 2)(3 ~ 5)(4 ~ 6)(7 ~ 8)$
+
+This false embedding *cannot* be "fixed" by multiplying some generators[^3] by $(9 ~ 10)$
+  (implicitly embedding in $S_{10}$ instead).
+Quickly "running" the generators shows that the order of the group is unchanged by this maneuver.
+Much of the structure permutations ensures that nonadjacent vertices still have order-2 products.
+
+[^3]: The only candidate choices are *a* and nothing else, every generator but *a*, or all generators.
+    All other choices violate edge/product constraints from the diagram.
+
+![](./b4/hyperoctahedral_embedding.png){.narrow}
+
+I won't try to identify either of these generating sets' Cayley graphs since it is impractical
+  to try comparing graphs of this size (and they likely correspond to a 4D object's skeleton).
+In fact, *H* appears to not be isomorphic to a subgroup of $W(B_4)$.
+The latter has at least 2 subgroups of order 192: one generated by the edges in the above embedding,
+  and one containing only the even permutations.
+These are distinct from one another, since the number of elements of a particular order is different.
+The latter subgroup is closer to *H*, matching the number of elements of each order,
+  but the even permutations have commutator subgroup of order 96 while *H* has a commutator subgroup of order 48.
+
+
+Other Finite Diagrams
+---------------------
+
+Higher-dimensional Platonic solids are hardly the limits of what these diagrams can encode.
+The following three diagrams also give rise to finite graphs.
+
+### $D_4$
+
+$D_4$ is the first Coxeter diagram with a branch.
+Like $B_4$ before it, it is corresponds to the symmetries of a 4D object.
+We only really have two choices in which generator to remove, which generate the following graphs:
+
+::: {layout-ncol="2" layout-valign="center"}
+![](./de/coxeter_d4_generator_a.png){.lightbox group="d4"}
+
+![](./de/coxeter_d4_generator_b.png){.lightbox group="d4"}
+:::
+
+While we could also remove *c* or *d*, this would just produce a graph identical
+  to the one on the left, just with different labelling.
+The right diagram is rather interesting, as it can be described geometrically
+  as two cubes attached to three hexagons sharing an edge.
+
+Both of these cases give the order
+
+- $8 \cdot |A_3| = 8 \cdot 24 = 192$
+- $24 \cdot |A_1 A_1 A_1| = 24 \cdot 8 = 192$
+
+The minimum degree of symmetric group is $S_8$, since $192 ~ \vert ~ 40320$.
+Fortunately, a computer search yields a correct embedding immediately:
+
+- $a = (1 ~ 8)(2 ~ 3)(4 ~ 7)(5 ~ 6)$
+- $b = (1 ~ 2)(3 ~ 4)(5 ~ 6)(7 ~ 8)$
+- $c = (1 ~ 5)(2 ~ 7)(3 ~ 4)(6 ~ 8)$
+- $d = (1 ~ 8)(2 ~ 4)(3 ~ 7)(5 ~ 6)$
+
+![&nbsp;](./de/d4_embedding.png){.narrower}
+
+In fact, the group generated by this diagram is isomorphic to the even permutation subgroup of $W(B_4)$.
+This can be verified by selecting order 2 elements from the latter which obey the laws in $D_4$.
+On the other hand, *H* and the edge-generated subgroup do not satisfy this diagram.
+
+<!-- TODO: code to find generators from even subgroup which satisfy relations from D_4 -->
+
+
+### $D_5$
+
+*D*-type diagrams continue by elongating one of the paths.
+The next diagram, $D_5$, has really only four distinct graphs, of which I will show only two:
+
+::: {layout-ncol="2" layout-valign="center"}
+![](./de/coxeter_d5_generator_a.png){.lightbox group="d5"}
+
+![](./de/coxeter_d5_generator_de.png){.lightbox group="d5"}
+:::
+
+First, note how the graph to the right is generated by removing the generator *e*,
+  but the left and right sides of the diagram are asymmetrical.
+This is because *d* and *e* are equivalent with respect to the branch,
+  and shows us that removing either generator *d* or *e* results in the same graph.
+
+The order suggested by each is
+
+- $10 \cdot |D_4| = 10 \cdot 192 = 1920$
+- $16 \cdot |A_4| = 16 \cdot 120 = 1920$
+
+If we were to remove generator *b*, we'd end up with the diagram $A_1 A_3$,
+  which generates a group of order 48.
+The graph would have 1920 / 48 = 40 vertices, which would be fairly difficult to render.
+Removing generator *c* would be even worse, since the resulting diagram, $A_2 A_1 A_1$,
+  has order 24, and the graph would require 80 vertices -- twice as many.
+
+Finding an embedding at this point is difficult.
+The order 1920 also divides $40320 = |S_8|$, but computer search has failed
+  to find an embedding in up to $S_{11}$.
+
+
+### $E_6$
+
+If one of the shorter paths of $D_5$ is extended, then we end up with the diagram $E_6$.
+I will only show one of its graphs.
+
+![&nbsp;](./de/coxeter_e6_generator_ae.png){.narrow}
+
+Similarly to one of the graphs for $D_5$, this graph goes in with *a* and comes out with *e*,
+  which are again symmetric with respect to the branch.
+I particularly like how on this graph, most of the squares are structured
+  so that they can bridge to the *ae* commuting square (middle, bottom).
+
+The order of this group is $27 \cdot 1920 = 51840$, which borders on the
+  incomprehensible (if that threshold hasn't been crossed already).
+The graphs not shown would have the following number of vertices
+  (which is precisely why I won't draw them out):
+
+- Removing *f*: $[E_6 : A_5] = 51840 / 720 = 72$ vertices
+- Removing *b* or *d*: $[E_6 : A_1 A_4] = 51840 / 240 = 216$ vertices
+- Removing *c*: $[E_6 : A_2 A_2 A_1] = 51840 / 72 = 720$ vertices
+
+Going by order alone, $E_6$ should embed in $S_9$ ($51840 ~ \vert ~ 9!$),
+  but since $S_{11}$ was too small for its subgroup $D_5$, this too optimistic.
+I don't know what the minimum degree is required to embed $E_6$,
+  but finding it directly it is beyond my computational power.
+
+The *E* diagrams continue with $E_7$ and $E_8$.
+Each of the three corresponds to the symmetries of semi-regular higher-dimensional objects,
+  whose significance and structure are difficult to comprehend.
+Their size alone makes continuing onward by hand a fool's errand,
+  and I won't be attempting to draw them out right just now.
+
+
+Infinite (Affine) Diagrams
+--------------------------
+
+Not every Coxeter diagram produces a finite, closed graph.
+Instead, they may proliferate vertices forever.
+They are termed either "affine" or "hyperbolic", depending respectively on whether the diagrams
+  join up with themselves or seem to require more and more room as the algorithm advances.
+This is also related to the collection of fundamental domains and roots that the diagram describes.
+
+Since hyperbolic graphs are difficult to draw, I'll be restricting myself to the affine diagrams.
+Unlike hyperbolic diagrams, which are unnamed, affine ones are typically named by altering finite diagrams.
+
+### $\widetilde A_2$
+
+The Coxeter diagram associated to the triangle graph $K_3$ is called $\widetilde A_2$.
+This graph is also the line graph of $\bigstar_3$ so it might make sense to assign
+  to the vertices the generators $(1 ~ 2)$, $(2 ~ 3)$, and $(1 ~ 3)$,
+  which we know to generate $S_3$.
+However, $S_3$ already has a diagram, $A_2$, which is clearly a subdiagram of
+  $\widetilde A_2$, so the new group must be larger.
+
+![&nbsp;](./affine/coxeter_a2tilde_generator_a.png){.narrower}
+
+Attempting to make a graph by following the generators results in an infinite hexagonal tiling.
+You might recall that $A_2$ generates a hexagon, so it is intriguing that this generates
+  a tiling based on this shape.
+There are three distinct types of hexagon -- *ab*, *ac*, and *bc*
+  -- since each pair of elements has a product of order 3.
+Removing a pair of vertices from the diagram would get rid of the initial edge (*a* in this case),
+  and the "limiting case" where all three vertices are removed is just the true hexagonal tiling.
+
+
+### $\widetilde G_2$
+
+The hexagonal tiling has Schläfli symbol {6, 3}, and is dual to the triangular tiling.
+As a Coxeter diagram, this symbol matches the Coxeter diagram $\widetilde G_2$.
+
+![&nbsp;](./affine/coxeter_g3tilde_generator_b.png){.narrower}
+
+The graph generated by removing a generator is another infinite tiling, in this case the
+  [truncated trihexagonal tiling](https://en.wikipedia.org/wiki/Truncated_trihexagonal_tiling).
+Once again, this tiling is the truncation of the rectification of the symmetry it typically describes.
+Each pair of prodcuts corresponds to a distinct polygon in the graph: *ab* to dodecagons, *ac* to squares,
+  and *bc* to hexagons.
+
+
+### $\widetilde C_2$
+
+The only remaining regular 2D tiling is the square tiling (Schläfli symbol {4, 4}),
+  whose Coxeter diagram is named $\widetilde C_2$.
+
+![&nbsp;](./affine/coxeter_c2tilde_generator_b.png){.narrower}
+
+The tiling generated by this diagram is known as the
+  [truncated square tiling](https://en.wikipedia.org/wiki/Truncated_square_tiling).
+Mirroring the other cases, it is also the truncated *rectified* square tiling,
+  since rectifying the square tiling merely produces another square tiling (rotated 45°).
+In this tiling, the squares always correspond to the product *ac*,
+  but there are octagons for both order-4 products, *ab* or *bc*.
+
+
+### $\widetilde A_3$
+
+The above diagrams are the only rank-2 affine diagrams.
+The simplest diagram of rank 3 is $\widetilde A_3$, which appears similar to 4-Cycle graph.
+
+::: {layout-ncol="2" layout-valign="center"}
+![](./affine/coxeter_a3tilde_generator_a.png){.lightbox group="a3_tilde"}
+
+![](./affine/coxeter_a3tilde.png){.lightbox group="a3_tilde"}
+:::
+
+Similar to how $\widetilde A_2$'s graph is the tiling of $A_2$'s,
+  its Cayley graph is the honeycomb of $A_3$'s.
+The left image shows the initial branches, while the right image shows
+  the four distinct cells which form the honeycomb.
+From left to right, the figures contain only edges labelled from
+  *abd*, *abc*, *bcd*, and *acd*, respectively.
+The squares always represent commuting pairs on opposite ends of the diagram: *ac* and *bd*.
+
+I am not certain in general whether $\widetilde A_n$ generates the honeycomb formed by $A_n$,
+  but this tessellation should always exist, since the solids formed
+  by the generators of $A_n$ are always permutohedra.
+
+
+Closing
+-------
+
+The diagrams I have studied here are only the smaller ones which I can either visualize or compute.
+I might have gotten carried away with studying the groups themselves in the 4D case,
+  since there appears to be so much contention.
+Despite this, I examined only half of the available Platonic solids in 4D, missing out on
+  the 24-cell (Schläfli symbol {3, 4, 3}, $F_4$),
+  120-cell (Schläfli symbol {5, 3, 3}, $H_4$),
+  and 600-cell (Schläfli symbol {3, 3, 5}, $H_4$).
+If 4D symmetries are hard to understand, then things can only get worse in higher dimensions.
+
+One of the things I'm curious about is the minimal degree of symmetric group
+  needed to embed the finite diagrams (hereafter $\mu$).
+While $S_6$ is minimal for the octahedral group, it doesn't appear to be big enough
+  for the icosahedral one.
+There is a trivial embedding for groups which are direct products given by
+
+$$
+\begin{align*}
+  G &\hookrightarrow S_m \sub S_{m+n} \\
+  H &\hookrightarrow S_n \sub S_{m+n} \\
+  G \times H &\hookrightarrow S_{m+n} \\
+  \mu(G \times H) &\le \mu(G) + \mu(H) = m + n
+\end{align*}
+$$
+
+but the groups we're interested in don't necessarily have this property.
+
+Coset and embedding diagrams made with GeoGebra.
+Cayley graph images made with NetworkX (GraphViz).
+
+
+### Additional Links
+
+- [Point groups in three dimensions](https://en.wikipedia.org/wiki/Point_groups_in_three_dimensions) (Wikipedia)
+- [Point groups in four dimensions](https://en.wikipedia.org/wiki/Point_groups_in_four_dimensions) (Wikipedia)
+- [
+    Finding the minimal n such that a given finite group G is a subgroup of Sn
+  ](https://math.stackexchange.com/questions/1597347/finding-the-minimal-n-such-that-a-given-finite-group-g-is-a-subgroup-of-s-n)
+  (Mathematics Stack Exchange)
+- [Omnitruncated](https://community.wolfram.com/groups/-/m/t/774393), by Clayton Shonkwiler

posts/permutations/index.qmd

@@ -0,0 +1,10 @@
+---
+title: "A Game of Permutations"
+listing:
+  contents: .
+  sort: "date"
+---
+
+Articles about diagrams at the intersection between graph theory and group theory.
+
+Publication dates correspond to the original WordPress publication dates.

posts/polycount/index.qmd

@@ -2,7 +2,7 @@
 title: "Polynomial Counting"
 listing:
   contents: .
-  sort: "date desc"
+  sort: "date"
 ---
 
 Articles about generalizations of positional number systems, explained using the concept of counting on polynomials.