#![allow(
clippy::cast_possible_truncation,
clippy::cast_sign_loss,
clippy::cast_possible_wrap
)]
use crate::coeff::Ring;
use crate::partition::Partition;
use crate::qt::QtPoly;
use crate::sym::SymFn;
pub fn kostka_foulkes<C: Ring>(lambda: &Partition, mu: &Partition) -> QtPoly<C> {
if lambda.size() != mu.size() {
return QtPoly::zero();
}
crate::hall_littlewood::<C>(mu).coeff(lambda)
}
pub fn kostka_foulkes_column<C: Ring>(mu: &Partition) -> Vec<(Partition, QtPoly<C>)> {
crate::hall_littlewood::<C>(mu)
.terms()
.iter()
.map(|(lambda, k)| (lambda.clone(), k.clone()))
.collect()
}
pub fn kostka_foulkes_table<C: Ring>(n: u32) -> Vec<Vec<QtPoly<C>>> {
let parts = crate::memo::partitions_cached(n);
let index: std::collections::HashMap<&Partition, usize> =
parts.iter().enumerate().map(|(i, p)| (p, i)).collect();
let mut table = vec![vec![QtPoly::zero(); parts.len()]; parts.len()];
for (j, (mu, hl)) in crate::hall_littlewood_table::<C>(n).into_iter().enumerate() {
crate::interrupt::poll();
debug_assert_eq!(&mu, &parts[j], "hall_littlewood_table must share the order");
for (lambda, k) in hl.terms() {
table[index[lambda]][j] = k.clone();
}
}
table
}
#[cfg(test)]
mod tests {
use super::*;
use crate::charge::kostka_foulkes_by_charge;
fn part(v: &[u32]) -> Partition {
Partition::new(v.iter().copied())
}
type Q = QtPoly<i64>;
#[test]
fn agrees_with_the_charge_enumeration() {
for n in 0..=8u32 {
let parts = crate::partitions_of(n);
for lambda in &parts {
for mu in &parts {
assert_eq!(
kostka_foulkes::<i64>(lambda, mu),
kostka_foulkes_by_charge(lambda, mu),
"K_{lambda}{mu}(t)"
);
}
}
}
}
#[test]
fn specializes_to_kostka_at_one() {
for n in 0..=9u32 {
let parts = crate::partitions_of(n);
let table = kostka_foulkes_table::<i64>(n);
let plain = crate::kostka::kostka_table(n);
for i in 0..parts.len() {
for j in 0..parts.len() {
assert_eq!(
table[i][j].eval(&0, &1) as u128,
plain[i][j],
"K_{}{}(1)",
parts[i],
parts[j]
);
}
}
}
}
#[test]
fn table_column_and_single_value_agree() {
for n in 0..=8u32 {
let parts = crate::partitions_of(n);
let table = kostka_foulkes_table::<i64>(n);
for (j, mu) in parts.iter().enumerate() {
let column: std::collections::HashMap<_, _> =
kostka_foulkes_column::<i64>(mu).into_iter().collect();
for (i, lambda) in parts.iter().enumerate() {
let want = &table[i][j];
assert_eq!(&kostka_foulkes::<i64>(lambda, mu), want);
let from_column = column.get(lambda).cloned().unwrap_or_else(QtPoly::zero);
assert_eq!(&from_column, want, "column at {lambda}, {mu}");
}
}
}
}
#[test]
fn known_values() {
let k: Q = kostka_foulkes(&part(&[2, 1]), &part(&[1, 1, 1]));
assert_eq!(k.coeff(0, 1), 1);
assert_eq!(k.coeff(0, 2), 1);
assert_eq!(k.len(), 2, "{k}");
let l = part(&[3, 2, 1]);
assert_eq!(kostka_foulkes::<i64>(&l, &l), <Q as Ring>::one());
assert_eq!(kostka_foulkes::<i64>(&l, &part(&[2, 1])), QtPoly::zero());
}
#[test]
fn at_t_zero_the_transition_is_the_identity() {
for n in 0..=8u32 {
let parts = crate::partitions_of(n);
let table = kostka_foulkes_table::<i64>(n);
for i in 0..parts.len() {
for j in 0..parts.len() {
assert_eq!(table[i][j].eval(&0, &0), i64::from(i == j), "at t = 0");
}
}
}
}
}