# Jacobsthal Elements

The Jacobsthal elements, $$\mathcal{J}_n$$ of $$\text{TL}_n$$ are defined by Boyd and Hepworth12. They are so named as the number of diagrams in their support is given by the Jacobsthal numbers. There is an exact sequence $0 \xrightarrow{} \mathcal{F}_n \xrightarrow{} \text{TL}_n\xrightarrow{-\cdot\mathcal{J}_n} \text{TL}_n$ where $$\mathcal{F}_n$$ is the mysterious “Fineberg” module.

We present some of the Jacobsthal elements and some information about them below. In these calculations, $$X = \mu/ \lambda = -v$$ and the loop resolves to a factor of $$v + v^{-1} = -X - X^{-1}$$.

$$\mathcal{J}_1$$ pdf data $$\mathcal{J}_2$$ pdf data $$\mathcal{J}_3$$ pdf data
$$\mathcal{J}_4$$ pdf data $$\mathcal{J}_5$$ pdf data $$\mathcal{J}_6$$ pdf data
$$\mathcal{J}_7$$ pdf data $$\mathcal{J}_8$$ pdf data $$\mathcal{J}_9$$ pdf data

## Derivation

The Jacobsthal elements are defined as

$\mathcal{J}_n = (-1)^{n-1}\sum_{\substack{n > a_1> \cdots > a_r > 0\\n-a_1 \text{odd}}} \left(\frac \mu\lambda\right)^r U_{a_1}\cdots U_{a_r}$

The relevant code to generate the above is this:

use itertools::Itertools;
use temperley_lieb_cat::structures::*;
use temperley_lieb_cat::*;

/// Returns all sequences l-1 >= a_1 > a_2 > ... > a_r >= 1 with l - a_1 odd
/// If r = 0 then either return nothing if l even or an empty sequence if l odd.
fn good_runs(l: usize, r: usize) -> Vec<Vec<usize>> {
match (l, r) {
(l, 0) if l % 2 == 1 => {
vec![vec![]]
}
(l, 0) if l % 2 == 0 => {
vec![]
}
(l, r) => {
(1..l)
.combinations(r)
.filter(|x| (l - x.last().unwrap()) % 2 == 1)
.collect()
}
}
}

// We assume run is sorted from smallest to largest
fn make_run_elt(n: usize, l: usize, run: &[usize]) -> TLMorphism<Laurent> {
let mut ans = TLMorphism::id(n);
ans.repoint(Some(-Laurent::gen() - Laurent::inv_gen()));
for ai in run {
ans = TLMorphism::u(n, n - (ai + n - l)) * ans;
}
ans
}

fn jacobsthal(n: usize, l: usize) -> TLMorphism<Laurent> {
assert!(n >= l);
let mut ans = TLMorphism::id_zero(n);
let mut mu_by_lambda = if n % 2 == 1 {
Laurent::one()
} else {
-Laurent::one()
};
for r in 0..=l - 1 {
for run in good_runs(l, r) {
ans = ans + make_run_elt(n, l, &run) * &mu_by_lambda;
}
mu_by_lambda = mu_by_lambda * Laurent::gen();
}
ans
}

fn main() {
let n = std::env::args()
.nth(1)
.expect("pass in n as a parameter")
.parse()
.expect("pass in a number");
let mut elt = jacobsthal(n, n);
elt.repoint(Some(-Laurent::gen() - Laurent::inv_gen()));
elt.to_file(std::path::Path::new("./j.data"));
let after = if n > 4 {
String::new()
} else {
let basis_diagrams = TLDiagram::all(n, n);
let matrix_r = matrix_for_elt(&elt, true, &basis_diagrams);
let matrix_l = matrix_for_elt(&elt, false, &basis_diagrams);
format!(
"$\\\\\n\nIn the basis\\\\\n\n${}$\\\\\n\nthis acts by right multiplication as\\\\\n\n${}$\\\\\n\nand by left multiplication by\\\\\n\n${}",
basis_diagrams.into_tex(),
matrix_r,
matrix_l
)
};
render_tex(&format!(
"\\mathcal{{J}}_{{ {0} }} = {1}$\\\\\n\n$\\mathcal{{J}}_{{ {0} }}^2 = {2}{3}",
n,
elt.into_tex(),
(&elt * &elt).into_tex(),
after
));
}

fn matrix_for_elt(e: &TLMorphism<Laurent>, right: bool, basis_diagrams: &[TLDiagram]) -> String {
let mut rows = Vec::new();
let basis: Vec<_> = basis_diagrams
.iter()
.map(|x| TLMorphism::<Laurent>::from(*x))
.collect();
for col in basis {
let mul = if right { &col * e } else { e * &col };
let mut row = Vec::new();
for b in basis_diagrams {
row.push(mul.coeffs.get(b).unwrap_or(&Laurent::zero()).clone());
}
rows.push(row);
}
matrix_for_rows(&rows)
}
fn matrix_for_rows<T: Tex>(rows: &[Vec<T>]) -> String {
let mut matrix = "\\begin{pmatrix}".to_owned();
let mut first_row = true;
for row in rows {
if !first_row {
matrix = matrix + "\\\\\n";
}
first_row = false;
let mut first = true;
for col in row {
if !first {
matrix = matrix + "&";
}
matrix = matrix + &col.into_tex();
first = false;
}
}
matrix + "\\end{pmatrix}"
}


1. Boyd, Rachael, and Richard Hepworth. “Combinatorics of injective words for Temperley-Lieb algebras.” Journal of Combinatorial Theory, Series A 181 (2021): 105446. ↩︎

2. The paper on the ArXiv. ↩︎