#![allow(
clippy::cast_possible_truncation,
clippy::cast_sign_loss,
clippy::cast_possible_wrap
)]
use std::collections::{BTreeMap, HashMap};
use crate::afrac::{AFrac, Linears};
use crate::coeff::{Field, Integral, Rational, Ring};
use crate::convert::{FromSchur, ToSchur};
use crate::macdonald::{arm, count_above, leg};
use crate::partition::Partition;
use crate::sym::{add_at, by_degree, Monomial, PowerSum, SymFn};
fn for_each_cell(shape: &[u32], visit: &mut impl FnMut(u32, u32)) {
for i in 0..shape.len() {
for j in 0..shape[i] as usize {
visit(arm(shape, i, j), leg(shape, i, j));
}
}
}
pub fn hook_lower(lambda: &Partition) -> Linears {
let mut f = Linears::new();
for_each_cell(lambda.parts(), &mut |a, l| {
*f.entry((a, l + 1)).or_insert(0) += 1;
});
f
}
pub fn hook_upper(lambda: &Partition) -> Linears {
let mut f = Linears::new();
for_each_cell(lambda.parts(), &mut |a, l| {
*f.entry((a + 1, l)).or_insert(0) += 1;
});
f
}
pub fn jack_norm_j(lambda: &Partition) -> Linears {
let mut f = hook_lower(lambda);
for (k, m) in hook_upper(lambda) {
*f.entry(k).or_insert(0) += m;
}
f
}
pub fn jack_norm_p(lambda: &Partition) -> Linears {
let mut f = hook_upper(lambda);
for (k, m) in hook_lower(lambda) {
*f.entry(k).or_insert(0) -= m;
}
f.retain(|_, m| *m != 0);
f
}
fn n_stat(parts: &[u32]) -> u32 {
parts.iter().enumerate().map(|(i, &x)| i as u32 * x).sum()
}
fn dominates(a: &[u32], b: &[u32]) -> bool {
let (mut sa, mut sb) = (0u32, 0u32);
for i in 0..a.len().max(b.len()) {
sa += a.get(i).copied().unwrap_or(0);
sb += b.get(i).copied().unwrap_or(0);
if sa < sb {
return false;
}
}
true
}
pub fn jack_p_lb<C: Integral>(kappa: &Partition) -> Monomial<AFrac<C>> {
let mut out = Monomial::zero();
let one = <AFrac<C> as Ring>::one();
if kappa.is_empty() {
out.add_term(Partition::default(), one);
return out;
}
let n = kappa.size();
let target: Vec<u32> = kappa.parts().to_vec();
let n_kappa = n_stat(&target);
let n_kappa_conj = n_stat(kappa.conjugate().parts());
let mut order: Vec<(Partition, u32, u32)> = crate::memo::partitions_cached(n)
.iter()
.map(|p| {
let conj = n_stat(p.conjugate().parts());
(p.clone(), n_stat(p.parts()), conj)
})
.collect();
order.sort_by_key(|(_, ns, _)| *ns);
let mut coeffs: HashMap<Partition, AFrac<C>> = HashMap::new();
coeffs.insert(kappa.clone(), one.clone());
out.add_term(kappa.clone(), one);
let mut moved: Vec<u32> = Vec::new();
for (lambda, n_lambda, n_lambda_conj) in &order {
crate::interrupt::poll();
if lambda == kappa || !dominates(&target, lambda.parts()) {
continue;
}
let lp = lambda.parts();
let mut acc = <AFrac<C> as Ring>::zero();
for i in 0..lp.len() {
for j in i + 1..lp.len() {
for t in 1..=lp[j] {
moved.clear();
moved.extend_from_slice(lp);
moved[i] += t;
moved[j] -= t;
let mu = Partition::new(moved.iter().copied());
if !dominates(&target, mu.parts()) {
continue;
}
if let Some(c) = coeffs.get(&mu) {
let w = i64::from(lp[i] - lp[j] + 2 * t);
acc.add_assign(&c.scale_int(w));
acc.reduce();
}
}
}
}
if acc.is_zero() {
continue;
}
let u = n_kappa_conj - n_lambda_conj;
let v = n_lambda - n_kappa;
debug_assert!(u > 0 && v > 0, "E(kappa) - E(lambda) must be positive");
let c = acc.div_linear(u, v);
coeffs.insert(lambda.clone(), c.clone());
out.add_term(lambda.clone(), c);
}
out
}
fn psi_alpha_factors(lam: &[u32], mu: &[u32]) -> Linears {
let width = lam.iter().copied().max().unwrap_or(0) as usize;
let met: Vec<bool> = (0..width)
.map(|j| count_above(lam, j) > count_above(mu, j))
.collect();
let mut f = Linears::new();
for i in 0..mu.len() {
if lam[i] == mu[i] {
continue; }
for j in 0..mu[i] as usize {
if met[j] {
continue; }
let (am, lm) = (arm(mu, i, j), leg(mu, i, j));
let (al, ll) = (arm(lam, i, j), leg(lam, i, j));
*f.entry((am, lm + 1)).or_insert(0) += 1;
*f.entry((am + 1, lm)).or_insert(0) -= 1;
*f.entry((al + 1, ll)).or_insert(0) += 1;
*f.entry((al, ll + 1)).or_insert(0) -= 1;
}
}
f.retain(|_, m| *m != 0);
f
}
pub fn jack_p_branching<C: Integral>(lambda: &Partition) -> Monomial<AFrac<C>> {
let mut out = Monomial::zero();
if lambda.is_empty() {
out.add_term(Partition::default(), <AFrac<C> as Ring>::one());
return out;
}
let target: Vec<u32> = lambda.parts().to_vec();
let mut cache: HashMap<(Vec<u32>, Vec<u32>), Linears> = HashMap::new();
let mut acc: Linears = BTreeMap::new();
for mu in crate::partitions_of(lambda.size()) {
crate::interrupt::poll();
let mut total = <AFrac<C> as Ring>::zero();
let mut chain: Vec<Vec<u32>> = vec![vec![0; target.len()]];
crate::charge::build(&target, mu.parts(), 0, &mut chain, &mut |ch| {
acc.clear();
for k in 1..ch.len() {
let key = (ch[k].clone(), ch[k - 1].clone());
let f = cache
.entry(key)
.or_insert_with(|| psi_alpha_factors(&ch[k], &ch[k - 1]));
for (&e, &m) in f.iter() {
*acc.entry(e).or_insert(0) += m;
}
}
acc.retain(|_, m| *m != 0);
total.add_assign(&AFrac::from_factors(&acc));
});
if !total.is_zero() {
total.reduce();
out.add_term(mu, total);
}
}
out
}
pub fn jack_j_tableaux<C: Integral>(lambda: &Partition) -> Monomial<AFrac<C>> {
let mut out = Monomial::zero();
if lambda.is_empty() {
out.add_term(Partition::default(), <AFrac<C> as Ring>::one());
return out;
}
let shape: Vec<u32> = lambda.parts().to_vec();
let n = lambda.size() as usize;
let mut offset = Vec::with_capacity(shape.len());
let mut cells: Vec<(usize, usize)> = Vec::with_capacity(n);
for (i, &row) in shape.iter().enumerate() {
offset.push(cells.len());
for j in 0..row as usize {
cells.push((i, j));
}
}
let mut st = KsWalk {
shape: &shape,
offset: &offset,
cells: &cells,
n: n as u32,
labels: vec![0; n],
weight: Linears::new(),
content: vec![0; n],
totals: HashMap::new(),
};
st.walk(0);
for mu in crate::partitions_of(lambda.size()) {
let mut key = mu.parts().to_vec();
key.resize(n, 0);
if let Some(mut v) = st.totals.remove(&key) {
v.reduce();
out.add_term(mu, v);
}
}
out
}
struct KsWalk<'a, C: Integral> {
shape: &'a [u32],
offset: &'a [usize],
cells: &'a [(usize, usize)],
n: u32,
labels: Vec<u32>,
weight: Linears,
content: Vec<u32>,
totals: HashMap<Vec<u32>, AFrac<C>>,
}
impl<C: Integral> KsWalk<'_, C> {
fn walk(&mut self, k: usize) {
if k == self.cells.len() {
let e = self
.totals
.entry(self.content.clone())
.or_insert_with(<AFrac<C> as Ring>::zero);
e.add_assign(&AFrac::from_factors(&self.weight));
return;
}
let (i, j) = self.cells[k];
'value: for v in 0..self.n {
for ip in 0..i {
if self.shape[ip] as usize > j && self.labels[self.offset[ip] + j] == v {
continue 'value;
}
if j > 0 && self.labels[self.offset[ip] + j - 1] == v {
continue 'value;
}
}
self.labels[k] = v;
self.content[v as usize] += 1;
let critical = (j > 0 && self.labels[self.offset[i] + j - 1] == v).then(|| {
let key = (arm(self.shape, i, j) + 1, leg(self.shape, i, j) + 1);
*self.weight.entry(key).or_insert(0) += 1;
key
});
self.walk(k + 1);
if let Some(key) = critical {
let e = self
.weight
.get_mut(&key)
.expect("this frame incremented the critical cell, and only it removes one");
*e -= 1;
if *e == 0 {
self.weight.remove(&key);
}
}
self.content[v as usize] -= 1;
}
}
}
pub fn jack_p<C: Integral>(lambda: &Partition) -> Monomial<AFrac<C>> {
jack_p_lb(lambda)
}
fn scale_by<C: Integral>(f: Monomial<AFrac<C>>, by: &Linears) -> Monomial<AFrac<C>> {
let mut out = Monomial::zero();
for (mu, c) in f.terms() {
let mut v = c.mul_factors(by);
v.reduce();
out.add_term(mu.clone(), v);
}
out
}
pub fn jack_q<C: Integral>(lambda: &Partition) -> Monomial<AFrac<C>> {
let mut f = hook_lower(lambda);
for (k, m) in hook_upper(lambda) {
*f.entry(k).or_insert(0) -= m;
}
f.retain(|_, m| *m != 0);
scale_by(jack_p(lambda), &f)
}
pub fn jack_j<C: Integral>(lambda: &Partition) -> Monomial<AFrac<C>> {
scale_by(jack_p(lambda), &hook_lower(lambda))
}
pub fn jack_table<C: Integral>(n: u32) -> Vec<(Partition, Monomial<AFrac<C>>)> {
crate::partitions_of(n)
.into_iter()
.map(|l| {
let p = jack_p(&l);
(l, p)
})
.collect()
}
pub fn jack_j_table<C: Integral>(n: u32) -> Vec<(Partition, Monomial<AFrac<C>>)> {
crate::partitions_of(n)
.into_iter()
.map(|l| {
let j = jack_j(&l);
(l, j)
})
.collect()
}
pub fn monomial_to_jack_p<C: Integral + Send + Sync + 'static>(
f: &Monomial<AFrac<C>>,
) -> BTreeMap<Partition, AFrac<C>> {
let mut out: BTreeMap<Partition, AFrac<C>> = BTreeMap::new();
for (n, terms) in by_degree(f) {
let parts = crate::memo::partitions_cached(n);
let index: HashMap<&Partition, usize> =
parts.iter().enumerate().map(|(i, p)| (p, i)).collect();
let table = cached_in_p_table::<C>(n);
for (mu, c) in terms {
crate::interrupt::poll();
for (lambda, v) in &table[index[mu]] {
add_at(&mut out, lambda, v.mul(c));
}
}
}
for v in out.values_mut() {
v.reduce();
}
out
}
pub fn monomial_to_jack_q<C: Integral + Send + Sync + 'static>(
f: &Monomial<AFrac<C>>,
) -> BTreeMap<Partition, AFrac<C>> {
let mut out = monomial_to_jack_p(f);
for (lambda, v) in &mut out {
*v = v.mul_factors(&jack_norm_p(lambda));
v.reduce();
}
out
}
pub fn monomial_to_jack_j<C: Integral + Send + Sync + 'static>(
f: &Monomial<AFrac<C>>,
) -> BTreeMap<Partition, AFrac<C>> {
let mut out = monomial_to_jack_p(f);
for (lambda, v) in &mut out {
let mut over_h = hook_lower(lambda);
for m in over_h.values_mut() {
*m = -*m;
}
*v = v.mul_factors(&over_h);
v.reduce();
}
out
}
fn cached_in_p_table<C: Integral + Send + Sync + 'static>(
n: u32,
) -> std::sync::Arc<Vec<BTreeMap<Partition, AFrac<C>>>> {
crate::memo::jack_p_inverse_cached(n, || monomial_in_p_table::<C>(n))
}
fn monomial_in_p_table<C: Integral>(n: u32) -> Vec<BTreeMap<Partition, AFrac<C>>> {
let parts = crate::memo::partitions_cached(n);
let table = jack_table::<C>(n);
let mut out: Vec<BTreeMap<Partition, AFrac<C>>> = vec![BTreeMap::new(); parts.len()];
for j in (0..parts.len()).rev() {
crate::interrupt::poll();
let mut acc = BTreeMap::new();
acc.insert(parts[j].clone(), <AFrac<C> as Ring>::one());
for l in (j + 1)..parts.len() {
let c = table[j].1.coeff(&parts[l]);
if c.is_zero() {
continue;
}
for (nu, v) in &out[l] {
add_at(&mut acc, nu, c.mul(v).neg());
}
}
for v in acc.values_mut() {
v.reduce();
}
out[j] = acc;
}
out
}
pub fn jack_element_add<C: Integral>(
f: &BTreeMap<Partition, AFrac<C>>,
g: &BTreeMap<Partition, AFrac<C>>,
) -> BTreeMap<Partition, AFrac<C>> {
let mut out = f.clone();
for (mu, c) in g {
add_at(&mut out, mu, c.clone());
}
for v in out.values_mut() {
v.reduce();
}
out.retain(|_, v| !v.is_zero());
out
}
pub fn jack_element_scale<C: Integral>(
f: &BTreeMap<Partition, AFrac<C>>,
c: &AFrac<C>,
) -> BTreeMap<Partition, AFrac<C>> {
let mut out = BTreeMap::new();
for (mu, v) in f {
let mut w = v.mul(c);
w.reduce();
if !w.is_zero() {
out.insert(mu.clone(), w);
}
}
out
}
fn expand_jack<C: Integral>(
f: &BTreeMap<Partition, AFrac<C>>,
one: fn(&Partition) -> Monomial<AFrac<C>>,
) -> Monomial<AFrac<C>> {
let mut acc: BTreeMap<Partition, AFrac<C>> = BTreeMap::new();
for (lambda, c) in f {
crate::interrupt::poll();
for (mu, v) in one(lambda).terms() {
add_at(&mut acc, mu, v.mul(c));
}
}
let mut out = Monomial::zero();
for (mu, mut v) in acc {
v.reduce();
out.add_term(mu, v);
}
out
}
pub fn jack_p_to_monomial<C: Integral>(f: &BTreeMap<Partition, AFrac<C>>) -> Monomial<AFrac<C>> {
expand_jack(f, jack_p::<C>)
}
pub fn jack_q_to_monomial<C: Integral>(f: &BTreeMap<Partition, AFrac<C>>) -> Monomial<AFrac<C>> {
expand_jack(f, jack_q::<C>)
}
pub fn jack_j_to_monomial<C: Integral>(f: &BTreeMap<Partition, AFrac<C>>) -> Monomial<AFrac<C>> {
expand_jack(f, jack_j::<C>)
}
pub fn jack_j_powersum<C: Integral>(lambda: &Partition) -> PowerSum<AFrac<C>> {
PowerSum::<AFrac<C>>::from_schur(&jack_j::<C>(lambda).to_schur())
}
pub fn jack_powersum_table<C: Integral>(n: u32) -> Vec<(Partition, PowerSum<AFrac<C>>)> {
crate::partitions_of(n)
.into_iter()
.map(|l| {
let p = jack_j_powersum(&l);
(l, p)
})
.collect()
}
pub fn powersum_scalar<C: Integral>(f: &PowerSum<AFrac<C>>, g: &PowerSum<AFrac<C>>) -> AFrac<C> {
let mut out = <AFrac<C> as Ring>::zero();
for (mu, a) in f.terms() {
let Some(b) = g.terms().get(mu) else { continue };
let mut alpha_pow = Linears::new();
alpha_pow.insert((1, 0), mu.len() as i32); let term = a.mul(b).mul(&mu.z_in::<AFrac<C>>());
out.add_assign(&term.mul_factors(&alpha_pow));
}
out.reduce();
out
}
pub fn jack_scalar<C: Integral>(f: &Monomial<AFrac<C>>, g: &Monomial<AFrac<C>>) -> AFrac<C> {
let fp = PowerSum::<AFrac<C>>::from_schur(&f.to_schur());
let gp = PowerSum::<AFrac<C>>::from_schur(&g.to_schur());
powersum_scalar(&fp, &gp)
}
pub fn jack_structure_constant<C: Integral>(
la: &Partition,
mu: &Partition,
nu: &Partition,
) -> AFrac<C> {
if la.size() + mu.size() != nu.size() {
return <AFrac<C> as Ring>::zero();
}
let a = jack_j_powersum::<C>(la);
let b = jack_j_powersum::<C>(mu);
let c = jack_j_powersum::<C>(nu);
powersum_scalar(&a.mul(&b), &c)
}
pub fn stanley_table<C: Integral>(k: u32) -> Vec<(Partition, Partition, Partition, AFrac<C>)> {
let small = crate::partitions_of(k);
let large = crate::partitions_of(2 * k);
let ps: Vec<PowerSum<AFrac<C>>> = small.iter().map(jack_j_powersum::<C>).collect();
let qs: Vec<PowerSum<AFrac<C>>> = large.iter().map(jack_j_powersum::<C>).collect();
let mut out = Vec::new();
for (i, la) in small.iter().enumerate() {
for (j, mu) in small.iter().enumerate() {
let prod = ps[i].mul(&ps[j]);
for (l, nu) in large.iter().enumerate() {
let g = powersum_scalar(&prod, &qs[l]);
if !g.is_zero() {
out.push((la.clone(), mu.clone(), nu.clone(), g));
}
}
}
}
out
}
pub fn omega_alpha<C: Integral>(f: &PowerSum<AFrac<C>>) -> PowerSum<AFrac<C>> {
let mut out = PowerSum::zero();
for (mu, c) in f.terms() {
let mut alpha_pow = Linears::new();
alpha_pow.insert((1, 0), mu.len() as i32); let mut v = c.mul_factors(&alpha_pow);
if (mu.size() - mu.len() as u32) % 2 == 1 {
v = v.neg();
}
v.reduce();
out.add_term(mu.clone(), v);
}
out
}
pub fn specialize<C: Integral + Field>(f: &Monomial<AFrac<C>>, alpha: &C) -> Option<Monomial<C>> {
let mut out = Monomial::zero();
for (mu, c) in f.terms() {
out.add_term(mu.clone(), c.eval(alpha)?);
}
Some(out)
}
pub fn zonal_j(lambda: &Partition) -> Monomial<Rational> {
specialize(&jack_j::<Rational>(lambda), &Rational::from_int(2))
.expect("alpha = 2 is not a pole of any Jack hook")
}
pub fn zonal_p(lambda: &Partition) -> Monomial<Rational> {
specialize(&jack_p::<Rational>(lambda), &Rational::from_int(2))
.expect("alpha = 2 is not a pole of any Jack hook")
}
#[cfg(test)]
mod tests {
use super::*;
type F = AFrac<Rational>;
fn part(v: &[u32]) -> Partition {
Partition::new(v.iter().copied())
}
fn r(n: i128) -> Rational {
Rational::from_int(n)
}
#[test]
fn every_jack_polynomial_comes_back_as_itself() {
for n in 0..=7u32 {
for lambda in crate::partitions_of(n) {
let unit: BTreeMap<Partition, F> =
[(lambda.clone(), <F as Ring>::one())].into_iter().collect();
let p: Monomial<F> = jack_p(&lambda);
assert_eq!(monomial_to_jack_p(&p), unit, "m -> P of P_{lambda}");
let q: Monomial<F> = jack_q(&lambda);
assert_eq!(monomial_to_jack_q(&q), unit, "m -> Q of Q_{lambda}");
let j: Monomial<F> = jack_j(&lambda);
assert_eq!(monomial_to_jack_j(&j), unit, "m -> J of J_{lambda}");
}
}
}
#[test]
fn adding_and_scaling_commute_with_expanding() {
let a = Partition::new([2, 1]);
let b = Partition::new([1, 1, 1]);
let one = <F as Ring>::one();
let f: BTreeMap<Partition, F> = [(a.clone(), one.clone())].into_iter().collect();
let g: BTreeMap<Partition, F> = [(b.clone(), one.clone())].into_iter().collect();
let mut want: Monomial<F> = jack_p_to_monomial(&f);
for (mu, c) in jack_p_to_monomial(&g).terms() {
want.add_term(mu.clone(), c.clone());
}
assert_eq!(
jack_p_to_monomial(&jack_element_add(&f, &g)),
want,
"P_{a} + P_{b}"
);
let c = F::inv_linear(1, 1);
let mut scaled: Monomial<F> = Monomial::zero();
for (mu, v) in jack_p_to_monomial(&f).terms() {
let mut w = v.mul(&c);
w.reduce();
scaled.add_term(mu.clone(), w);
}
assert_eq!(
jack_p_to_monomial(&jack_element_scale(&f, &c)),
scaled,
"P_{a}/(alpha + 1)"
);
}
#[test]
fn every_monomial_comes_back_as_itself() {
for n in 0..=7u32 {
for mu in crate::partitions_of(n) {
let f: Monomial<F> = Monomial::monomial(mu.clone(), <F as Ring>::one());
assert_eq!(
jack_p_to_monomial(&monomial_to_jack_p(&f)),
f,
"P at m_{mu}"
);
assert_eq!(
jack_q_to_monomial(&monomial_to_jack_q(&f)),
f,
"Q at m_{mu}"
);
assert_eq!(
jack_j_to_monomial(&monomial_to_jack_j(&f)),
f,
"J at m_{mu}"
);
}
}
}
#[test]
fn expanding_is_linear_across_degrees() {
let a = Partition::new([2, 1]);
let b = Partition::new([2, 2]);
let two = <F as Ring>::from_i64(2);
let mixed: BTreeMap<Partition, F> = [(a.clone(), two.clone()), (b.clone(), two.clone())]
.into_iter()
.collect();
let mut want: Monomial<F> = Monomial::zero();
for lambda in [&a, &b] {
for (mu, c) in jack_p::<Rational>(lambda).terms() {
let mut v = c.mul(&two);
v.reduce();
want.add_term(mu.clone(), v);
}
}
assert_eq!(jack_p_to_monomial(&mixed), want, "2·P_{a} + 2·P_{b}");
}
#[test]
fn orthogonality_gives_the_same_coefficients_as_the_solve() {
for n in 1..=5u32 {
let parts = crate::partitions_of(n);
for mu in &parts {
let f: Monomial<F> = Monomial::monomial(mu.clone(), <F as Ring>::one());
let solved = monomial_to_jack_p(&f);
for lambda in &parts {
let mut paired = jack_scalar(&f, &jack_p::<Rational>(lambda));
let mut over = jack_norm_p(lambda);
for m in over.values_mut() {
*m = -*m;
}
paired = paired.mul_factors(&over);
paired.reduce();
let want = solved
.get(lambda)
.cloned()
.unwrap_or_else(<F as Ring>::zero);
assert_eq!(paired, want, "[P_{lambda}] m_{mu}");
}
}
}
}
#[test]
fn at_alpha_one_the_p_expansion_is_the_schur_expansion() {
for n in 0..=6u32 {
for mu in crate::partitions_of(n) {
let f: Monomial<F> = Monomial::monomial(mu.clone(), <F as Ring>::one());
let schur = Monomial::<Rational>::monomial(mu.clone(), r(1)).to_schur();
let mut at_one: BTreeMap<Partition, Rational> = BTreeMap::new();
for (lambda, c) in monomial_to_jack_p(&f) {
let v = c.eval(&r(1)).expect("α = 1 is not a pole of any Jack hook");
add_at(&mut at_one, &lambda, v);
}
assert_eq!(at_one, *schur.terms(), "m_{mu} at α = 1");
}
}
}
#[test]
fn the_three_normalizations_have_their_hand_values_at_free_alpha() {
let one = <F as Ring>::one();
let m2: Monomial<F> = Monomial::monomial(part(&[2]), one.clone());
let m11: Monomial<F> = Monomial::monomial(part(&[1, 1]), one.clone());
let in_p = monomial_to_jack_p(&m2);
assert_eq!(in_p[&part(&[2])], one, "m_2 is monic in P_2");
assert_eq!(
in_p[&part(&[1, 1])],
<F as Ring>::from_i64(-2).div_linear(1, 1),
"m_2 in P_11 is −2/(α+1), not −2α/(α+1)"
);
assert_eq!(
monomial_to_jack_p(&m11),
[(part(&[1, 1]), one.clone())].into_iter().collect(),
"m_11 = P_11"
);
let in_q = monomial_to_jack_q(&m11);
assert_eq!(in_q.len(), 1, "m_11 reaches Q_11 alone");
assert_eq!(
in_q[&part(&[1, 1])],
F::linear(1, 0).mul(&F::linear(1, 1)).div_int(2),
"m_11 in Q_11"
);
let in_j = monomial_to_jack_j(&m2);
let over = F::inv_linear(1, 1);
assert_eq!(in_j[&part(&[2])], over, "m_2 in J_2");
assert_eq!(in_j[&part(&[1, 1])], over.neg(), "m_2 in J_11");
}
#[test]
fn the_cached_jack_table_is_the_computed_table_for_each_ring() {
use crate::guard::GuardedRat;
for n in 0..=4u32 {
let want = monomial_in_p_table::<Rational>(n);
crate::clear_caches();
assert_eq!(*cached_in_p_table::<Rational>(n), want, "cold at {n}");
assert_eq!(*cached_in_p_table::<Rational>(n), want, "warm at {n}");
let wide = monomial_in_p_table::<GuardedRat>(n);
assert_eq!(
*cached_in_p_table::<GuardedRat>(n),
wide,
"a second ring read the first ring's entry at degree {n}"
);
}
crate::clear_caches();
}
#[test]
fn the_jack_expansions_are_linear_and_take_mixed_degrees() {
let two = <F as Ring>::from_i64(2);
let three = <F as Ring>::from_i64(3);
let mut f: Monomial<F> = Monomial::zero();
f.add_term(part(&[1]), <F as Ring>::one());
f.add_term(part(&[2]), two.clone());
f.add_term(part(&[1, 1]), three.clone());
for (name, to_basis) in [
(
"m -> P",
monomial_to_jack_p as fn(&Monomial<F>) -> BTreeMap<Partition, F>,
),
("m -> Q", monomial_to_jack_q),
("m -> J", monomial_to_jack_j),
] {
let mut want: BTreeMap<Partition, F> = BTreeMap::new();
for (mu, scalar) in [
(part(&[1]), <F as Ring>::one()),
(part(&[2]), two.clone()),
(part(&[1, 1]), three.clone()),
] {
let piece = to_basis(&Monomial::monomial(mu, <F as Ring>::one()));
for (lambda, c) in piece {
add_at(&mut want, &lambda, c.mul(&scalar));
}
}
for v in want.values_mut() {
v.reduce();
}
let mut got = to_basis(&f);
for v in got.values_mut() {
v.reduce();
}
assert_eq!(got, want, "{name} is linear across three degrees");
assert!(to_basis(&Monomial::zero()).is_empty(), "{name} of 0");
}
}
#[test]
fn the_convention_gate() {
let j: Monomial<F> = jack_j(&part(&[2]));
assert_eq!(j.coeff(&part(&[2])), F::linear(1, 1), "{j}");
assert_eq!(j.coeff(&part(&[1, 1])), <F as Ring>::from_i64(2), "{j}");
assert_eq!(j.terms().len(), 2);
}
#[test]
fn hand_values() {
assert_eq!(
jack_j::<Rational>(&part(&[1])).coeff(&part(&[1])),
<F as Ring>::one()
);
assert_eq!(
jack_j::<Rational>(&part(&[1, 1])).coeff(&part(&[1, 1])),
<F as Ring>::from_i64(2)
);
let p: Monomial<F> = jack_p(&part(&[2]));
assert_eq!(p.coeff(&part(&[2])), <F as Ring>::one());
let want = <F as Ring>::from_i64(2).div_linear(1, 1);
assert_eq!(p.coeff(&part(&[1, 1])), want, "{p}");
let psi = psi_alpha_factors(&[2], &[1]);
assert_eq!(F::from_factors(&psi), want, "psi = {psi:?}");
}
#[test]
fn hooks_are_three_distinct_families() {
let lam = part(&[2, 1]);
assert_eq!(
hook_lower(&lam),
Linears::from([((1, 2), 1), ((0, 1), 2)]),
"H_(21) = (α+2)·1·1"
);
assert_eq!(
hook_upper(&lam),
Linears::from([((2, 1), 1), ((1, 0), 2)]),
"H'_(21) = (2α+1)·α·α"
);
assert_ne!(hook_lower(&lam), hook_upper(&lam));
let d: Linears = Linears::from([((2, 2), 1), ((1, 1), 2)]);
assert_ne!(d, hook_lower(&lam));
assert_ne!(d, hook_upper(&lam));
}
#[test]
fn the_two_engines_agree() {
for n in 0..=7u32 {
for lambda in crate::partitions_of(n) {
let a: Monomial<F> = jack_p_lb(&lambda);
let b: Monomial<F> = jack_p_branching(&lambda);
assert_eq!(a, b, "P_{lambda}: LB {a} vs branching {b}");
}
}
}
#[test]
fn the_tableau_formula_agrees() {
for n in 0..=5u32 {
for lambda in crate::partitions_of(n) {
let a: Monomial<F> = jack_j(&lambda);
let b: Monomial<F> = jack_j_tableaux(&lambda);
assert_eq!(a, b, "J_{lambda}: scaled-P {a} vs tableaux {b}");
}
}
}
#[test]
fn expansion_is_unitriangular_in_dominance() {
for n in 0..=8u32 {
for lambda in crate::partitions_of(n) {
let p: Monomial<F> = jack_p(&lambda);
assert_eq!(p.coeff(&lambda), <F as Ring>::one(), "monic at {lambda}");
for mu in p.terms().keys() {
assert!(
dominates(lambda.parts(), mu.parts()),
"{mu} appears in P_{lambda} but λ does not dominate it"
);
}
}
}
}
#[test]
fn norms_and_the_dual_basis() {
for n in 0..=5u32 {
let parts = crate::partitions_of(n);
for lambda in &parts {
let p: Monomial<F> = jack_p(lambda);
let q: Monomial<F> = jack_q(lambda);
let j: Monomial<F> = jack_j(lambda);
assert_eq!(
j.coeff(lambda),
F::from_factors(&hook_lower(lambda)),
"[m_λ]J_{lambda} = H_λ"
);
assert_eq!(
jack_scalar(&j, &j),
F::from_factors(&jack_norm_j(lambda)),
"<J,J> at {lambda}"
);
assert_eq!(
jack_scalar(&p, &p),
F::from_factors(&jack_norm_p(lambda)),
"<P,P> at {lambda}"
);
for mu in &parts {
let got = jack_scalar(&p, &jack_q::<Rational>(mu));
let want = if lambda == mu {
<F as Ring>::one()
} else {
<F as Ring>::zero()
};
assert_eq!(got, want, "<P_{lambda}, Q_{mu}>");
}
let _ = q;
}
}
}
#[test]
fn the_deformed_power_sum_pairing() {
for n in 0..=5u32 {
let parts = crate::partitions_of(n);
for la in &parts {
for mu in &parts {
let a: PowerSum<F> = PowerSum::monomial(la.clone(), <F as Ring>::one());
let b: PowerSum<F> = PowerSum::monomial(mu.clone(), <F as Ring>::one());
let got = powersum_scalar(&a, &b);
if la == mu {
let mut f = Linears::new();
f.insert((1, 0), la.len() as i32);
let want = F::from_u128(la.z()).mul_factors(&f);
assert_eq!(got, want, "<p_{la}, p_{la}>");
} else {
assert!(got.is_zero(), "<p_{la}, p_{mu}> must vanish");
}
}
}
}
}
#[test]
fn knop_sahi_positivity_and_u_divisibility() {
for n in 0..=8u32 {
for lambda in crate::partitions_of(n) {
let j: Monomial<AFrac<i128>> = jack_j(&lambda);
for (mu, c) in j.terms() {
let poly = c
.clone()
.into_natural_poly()
.unwrap_or_else(|| panic!("[m_{mu}]J_{lambda} = {c} not in N[alpha]"));
let mut u: i128 = 1;
let mut i = 0;
let p = mu.parts();
while i < p.len() {
let mut mult = 0i128;
let v = p[i];
while i < p.len() && p[i] == v {
mult += 1;
i += 1;
}
u *= (1..=mult).product::<i128>();
}
for co in &poly {
assert_eq!(co % u, 0, "u_{mu} = {u} must divide {co} in {c}");
}
}
}
}
}
#[test]
fn at_alpha_one_it_is_the_schur_function() {
use crate::Schur;
for n in 0..=6u32 {
for lambda in crate::partitions_of(n) {
let j = specialize(&jack_j::<Rational>(&lambda), &r(1)).expect("α = 1 is no pole");
let mut hook = r(1);
for_each_cell(lambda.parts(), &mut |a, l| {
hook = hook.mul(&r(i128::from(a + l + 1)));
});
let s: Monomial<Rational> =
Monomial::from_schur(&Schur::monomial(lambda.clone(), hook));
assert_eq!(j, s, "J_{lambda} at α = 1");
}
}
}
#[test]
fn at_large_alpha_p_approaches_the_monomial() {
for lambda in crate::partitions_of(5) {
let p: Monomial<F> = jack_p(&lambda);
for (mu, c) in p.terms() {
if mu == &lambda {
continue;
}
let small = c.eval(&r(1000)).expect("no pole at α = 1000");
let big = c.eval(&r(10)).expect("no pole at α = 10");
assert!(
small.numer().abs() * big.denom().abs()
< big.numer().abs() * small.denom().abs(),
"[{mu}]P_{lambda} must shrink as α grows: {small:?} vs {big:?}"
);
}
}
}
#[test]
fn principal_specialization() {
for n in 0..=5u32 {
for lambda in crate::partitions_of(n) {
let j: Monomial<F> = jack_j(&lambda);
for nvars in lambda.len() as u32..=4 {
let mut got = <F as Ring>::zero();
for (mu, c) in j.terms() {
let count = arrangements(mu, nvars);
got.add_assign(&c.mul(&F::from_u128(count)));
}
got.reduce();
let mut want: Linears = Linears::new();
for (i, &row) in lambda.parts().iter().enumerate() {
for jj in 0..row {
let v = i64::from(nvars) - i as i64;
assert!(v >= 0, "N ≥ ℓ(λ) keeps every factor positive");
*want.entry((jj, v as u32)).or_insert(0) += 1;
}
}
assert_eq!(got, F::from_factors(&want), "J_{lambda}(1^{nvars})");
}
}
}
}
fn arrangements(mu: &Partition, n: u32) -> u128 {
let k = mu.len() as u32;
if k > n {
return 0;
}
let mut out: u128 = ((n - k + 1)..=n).map(u128::from).product();
let p = mu.parts();
let mut i = 0;
while i < p.len() {
let mut mult = 0u128;
let v = p[i];
while i < p.len() && p[i] == v {
mult += 1;
i += 1;
}
out /= (1..=mult).product::<u128>();
}
out
}
#[test]
fn the_two_zonal_normalizations_differ_by_the_hook_product() {
for n in 0..=5u32 {
for lambda in crate::partitions_of(n) {
let zj = zonal_j(&lambda);
let zp = zonal_p(&lambda);
let h = F::from_factors(&hook_lower(&lambda))
.eval(&r(2))
.expect("α = 2 is no pole");
for (mu, c) in zp.terms() {
assert_eq!(zj.coeff(mu), c.mul(&h), "Z_{lambda} at {mu}");
}
assert_eq!(zp.coeff(&lambda), r(1), "P is monic");
}
}
}
#[test]
fn stanley_structure_constants_are_observed_positive() {
for (na, nb) in [(1u32, 2u32), (2, 2), (2, 3), (3, 3)] {
for la in crate::partitions_of(na) {
for mu in crate::partitions_of(nb) {
for nu in crate::partitions_of(na + nb) {
let g: AFrac<i128> = jack_structure_constant(&la, &mu, &nu);
assert!(
g.clone().into_natural_poly().is_some(),
"<J_{la} J_{mu}, J_{nu}> = {g} left N[alpha] — REPORT, do not fix"
);
}
}
}
}
}
#[test]
fn the_batch_stanley_table_agrees_with_the_primitive() {
for k in 1..=3u32 {
let table = stanley_table::<i128>(k);
let seen: std::collections::HashMap<_, _> = table
.iter()
.map(|(a, b, c, g)| ((a.clone(), b.clone(), c.clone()), g.clone()))
.collect();
let mut checked = 0;
for la in crate::partitions_of(k) {
for mu in crate::partitions_of(k) {
for nu in crate::partitions_of(2 * k) {
let want: AFrac<i128> = jack_structure_constant(&la, &mu, &nu);
let key = (la.clone(), mu.clone(), nu.clone());
match seen.get(&key) {
Some(got) => assert_eq!(*got, want, "at {key:?}"),
None => {
assert!(want.is_zero(), "the table omits {key:?} but it is {want}")
}
}
checked += 1;
}
}
}
assert!(checked > 0);
}
}
#[test]
fn the_omega_alpha_duality() {
let mut asymmetric = 0;
for n in 0..=6u32 {
for lambda in crate::partitions_of(n) {
let p: PowerSum<F> = PowerSum::from_schur(&jack_p::<Rational>(&lambda).to_schur());
let left = omega_alpha(&p);
let conj = lambda.conjugate();
if conj != lambda {
asymmetric += 1;
}
let right: PowerSum<F> =
PowerSum::from_schur(&jack_q::<Rational>(&conj).to_schur());
for (mu, c) in left.terms() {
assert_eq!(
c.invert_alpha(),
right.coeff(mu),
"omega_alpha P_{lambda} vs Q_{conj} at p_{mu}"
);
}
for (mu, c) in right.terms() {
if left.coeff(mu).is_zero() {
assert!(
c.is_zero(),
"Q_{conj} has p_{mu} where omega_alpha P_{lambda} does not"
);
}
}
}
}
assert!(
asymmetric > 0,
"the sweep must include λ' ≠ λ, or it tests nothing"
);
}
#[test]
fn plain_omega_breaks_the_duality() {
let one = part(&[1]);
let p: PowerSum<F> = PowerSum::from_schur(&jack_p::<Rational>(&one).to_schur());
let q: PowerSum<F> = PowerSum::from_schur(&jack_q::<Rational>(&one).to_schur());
let twisted = omega_alpha(&p).coeff(&one).invert_alpha();
assert_eq!(twisted, q.coeff(&one), "with the twist it holds");
let plain = p.coeff(&one); assert_ne!(
plain.invert_alpha(),
q.coeff(&one),
"without the twist it must FAIL, or this test proves nothing"
);
}
#[test]
fn the_power_sum_expansion_round_trips() {
for n in 0..=5u32 {
for lambda in crate::partitions_of(n) {
let j: Monomial<F> = jack_j(&lambda);
let p: PowerSum<F> = jack_j_powersum(&lambda);
let back: Monomial<F> = Monomial::from_schur(&p.to_schur());
assert_eq!(back, j, "J_{lambda} through the p basis");
}
}
}
}