Navigation

Informally, a crystal \(\mathcal{B}\) is an oriented graph with edges
colored in some set \(I\) such that, for each \(i\in I\), each node \(x\)
has:

at most one \(i\)-successor, denoted \(f_i x\);

at most one \(i\)-predecessor, denoted \(e_i x\).

By convention, one writes \(f_i x=\emptyset\) and \(e_i x=\emptyset\) when
\(x\) has no successor resp. predecessor.

One may think of \(\mathcal{B}\) as essentially a deterministic
automaton whose dual is also deterministic; in this context, the
\(f_i\)’s and \(e_i\)’s are respectively the transition functions of the
automaton and of its dual, and \(\emptyset\) is the sink.

Let \(C\) be a Cartan type (CartanType) with index set \(I\),
and \(L\) be a realization of the weight lattice of the type \(C\).
Let \(\alpha_i\) and \(\alpha^{\vee}_i\) denote the simple roots and
coroots respectively.

Some further conditions are required to guarantee that this data
indeed models a representation of a Lie algebra. For finite simply
laced types a complete characterization is given by Stembridge’s local
axioms [Ste2003].

EXAMPLES:

We construct the type \(A_5\) crystal on letters (or in representation
theoretic terms, the highest weight crystal of type \(A_5\)
corresponding to the highest weight \(\Lambda_1\)):

Time complexity: \(O(nF)\) amortized for each produced
element, where \(n\) is the size of the index set, and \(F\) is
the cost of computing \(e\) and \(f\) operators.

Memory complexity: \(O(D)\) where \(D\) is the depth of the crystal.

Principle of the algorithm:

Let \(C\) be a classical crystal. It’s an acyclic graph where each
connected component has a unique element without predecessors (the
highest weight element for this component). Let’s assume for
simplicity that \(C\) is irreducible (i.e. connected) with highest
weight element \(u\).

One can define a natural spanning tree of \(C\) by taking
\(u\) as the root of the tree, and for any other element
\(y\) taking as ancestor the element \(x\) such that
there is an \(i\)-arrow from \(x\) to \(y\) with
\(i\) minimal. Then, a path from \(u\) to \(y\)
describes the lexicographically smallest sequence
\(i_1,\dots,i_k\) such that
\((f_{i_k} \circ f_{i_1})(u)=y\).

Morally, the iterator implemented below just does a depth first
search walk through this spanning tree. In practice, this can be
achieved recursively as follows: take an element \(x\), and
consider in turn each successor \(y = f_i(x)\), ignoring
those such that \(y = f_j(x^{\prime})\) for some \(x^{\prime}\) and
\(j<i\) (this can be tested by computing \(e_j(y)\)
for \(j<i\)).