{-|
Module      : Math.Algebra.Jack
Description : Evaluation of Jack polynomials.
Copyright   : (c) Stéphane Laurent, 2024
License     : GPL-3
Maintainer  : laurent_step@outlook.fr

Evaluation of Jack polynomials, zonal polynomials, Schur polynomials and skew Schur polynomials. 
See README for examples and references.
-}

{-# LANGUAGE BangPatterns        #-}
{-# LANGUAGE ScopedTypeVariables #-}
module Math.Algebra.Jack
  (
  -- * The `Partition` type  

    Partition
  -- * Evaluation of Jack polynomials

  , jack
  , jack'
  -- * Evaluation of zonal polynomials

  , zonal
  , zonal'
  -- * Evaluation of Schur and skew Schur polynomials

  , schur
  , schur'
  , skewSchur
  , skewSchur'
  )
  where
import           Prelude 
  hiding ((*), (+), (-), (/), (^), (*>), product, fromIntegral, fromInteger)
import           Algebra.Additive           ( (+), (-), zero )
import           Algebra.Ring               ( (*), product, one, (^), fromInteger )
import qualified Algebra.Field              as AlgField
import qualified Algebra.Ring               as AlgRing
import           Control.Lens               ( (.~), element )
import           Data.Array                 ( Array, (!), (//), listArray )
import           Data.Maybe                 ( fromJust, isJust )
import qualified Data.Map.Strict            as DM
import           Math.Algebra.Jack.Internal ( _N, jackCoeffC
                                            , jackCoeffP, jackCoeffQ
                                            , _betaratio, _isPartition
                                            , Partition, skewSchurLRCoefficients
                                            , isSkewPartition, _fromInt )
import Math.Algebra.Hspray                  ( (.^) )

-- | Evaluation of a Jack polynomial.

jack' 
  :: [Rational] -- ^ values of the variables

  -> Partition  -- ^ partition of integers

  -> Rational   -- ^ Jack parameter

  -> Char       -- ^ which Jack polynomial, @'J'@, @'C'@, @'P'@ or @'Q'@

  -> Rational
jack' :: [Rational] -> Partition -> Rational -> Char -> Rational
jack' = [Rational] -> Partition -> Rational -> Char -> Rational
forall a. (Eq a, C a) => [a] -> Partition -> a -> Char -> a
jack

-- | Evaluation of a Jack polynomial.

jack :: forall a. (Eq a, AlgField.C a)
  => [a]       -- ^ values of the variables

  -> Partition -- ^ partition of integers

  -> a         -- ^ Jack parameter

  -> Char      -- ^ which Jack polynomial, @'J'@, @'C'@, @'P'@ or @'Q'@

  -> a
jack :: forall a. (Eq a, C a) => [a] -> Partition -> a -> Char -> a
jack []       Partition
_      a
_     Char
_     = [Char] -> a
forall a. HasCallStack => [Char] -> a
error [Char]
"jack: empty list of variables."
jack x :: [a]
x@(a
x0:[a]
_) Partition
lambda a
alpha Char
which =
  case Partition -> Bool
_isPartition Partition
lambda of
    Bool
False -> [Char] -> a
forall a. HasCallStack => [Char] -> a
error [Char]
"jack: invalid integer partition."
    Bool
True -> case Char
which of 
      Char
'J' -> a
resultJ
      Char
'C' -> Partition -> a -> a
forall a. C a => Partition -> a -> a
jackCoeffC Partition
lambda a
alpha a -> a -> a
forall a. C a => a -> a -> a
* a
resultJ
      Char
'P' -> Partition -> a -> a
forall a. C a => Partition -> a -> a
jackCoeffP Partition
lambda a
alpha a -> a -> a
forall a. C a => a -> a -> a
* a
resultJ
      Char
'Q' -> Partition -> a -> a
forall a. C a => Partition -> a -> a
jackCoeffQ Partition
lambda a
alpha a -> a -> a
forall a. C a => a -> a -> a
* a
resultJ
      Char
_   -> [Char] -> a
forall a. HasCallStack => [Char] -> a
error [Char]
"jack: please use 'J', 'C', 'P' or 'Q' for last argument."
      where
      jck :: Int -> Partition -> Array (Int, Int) (Maybe a) -> a
jck Int
m Partition
kappa Array (Int, Int) (Maybe a)
arr = Int
-> Int -> Partition -> Partition -> Array (Int, Int) (Maybe a) -> a
jac Int
m Int
0 Partition
kappa Partition
kappa Array (Int, Int) (Maybe a)
arr 
      n :: Int
n = [a] -> Int
forall a. [a] -> Int
forall (t :: * -> *) a. Foldable t => t a -> Int
length [a]
x
      resultJ :: a
resultJ = Int -> Partition -> Array (Int, Int) (Maybe a) -> a
jck Int
n Partition
lambda Array (Int, Int) (Maybe a)
forall {a}. Array (Int, Int) (Maybe a)
arr0 
      nll :: Int
nll = Partition -> Partition -> Int
_N Partition
lambda Partition
lambda
      arr0 :: Array (Int, Int) (Maybe a)
arr0 = ((Int, Int), (Int, Int)) -> [Maybe a] -> Array (Int, Int) (Maybe a)
forall i e. Ix i => (i, i) -> [e] -> Array i e
listArray ((Int
1, Int
1), (Int
nll, Int
n)) (Int -> Maybe a -> [Maybe a]
forall a. Int -> a -> [a]
replicate (Int
nll Int -> Int -> Int
forall a. C a => a -> a -> a
* Int
n) Maybe a
forall a. Maybe a
Nothing)
      jac :: Int -> Int -> Partition -> Partition 
             -> Array (Int,Int) (Maybe a) 
             -> a
      jac :: Int
-> Int -> Partition -> Partition -> Array (Int, Int) (Maybe a) -> a
jac Int
m Int
k Partition
mu Partition
nu Array (Int, Int) (Maybe a)
arr 
        | Partition -> Bool
forall a. [a] -> Bool
forall (t :: * -> *) a. Foldable t => t a -> Bool
null Partition
nu Bool -> Bool -> Bool
|| Int
nu0 Int -> Int -> Bool
forall a. Eq a => a -> a -> Bool
== Int
0 Bool -> Bool -> Bool
|| Int
m Int -> Int -> Bool
forall a. Eq a => a -> a -> Bool
== Int
0 = a
forall a. C a => a
one
        | Int
ellNu Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
> Int
m Bool -> Bool -> Bool
&& Partition
nu Partition -> Int -> Int
forall a. HasCallStack => [a] -> Int -> a
!! Int
m Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
> Int
0      = a
forall a. C a => a
zero
        | Int
m Int -> Int -> Bool
forall a. Eq a => a -> a -> Bool
== Int
1                        = 
            if Int
nu0 Int -> Int -> Bool
forall a. Eq a => a -> a -> Bool
== Int
1
              then 
                a
x0
              else 
                let as :: [a]
as = [Int
i Int -> a -> a
forall a. (C a, Eq a) => Int -> a -> a
.^ a
alpha a -> a -> a
forall a. C a => a -> a -> a
+ a
forall a. C a => a
one | Int
i <- [Int
1 .. Int
nu0Int -> Int -> Int
forall a. C a => a -> a -> a
-Int
1]] in
                [a] -> a
forall a. C a => [a] -> a
product [a]
as a -> a -> a
forall a. C a => a -> a -> a
* a
x0 a -> Integer -> a
forall a. C a => a -> Integer -> a
^ (Int -> Integer
forall a. Integral a => a -> Integer
toInteger Int
nu0)
        | Int
k Int -> Int -> Bool
forall a. Eq a => a -> a -> Bool
== Int
0 Bool -> Bool -> Bool
&& Maybe a -> Bool
forall a. Maybe a -> Bool
isJust Maybe a
maybe_a =
            Maybe a -> a
forall a. HasCallStack => Maybe a -> a
fromJust (Maybe a -> a) -> Maybe a -> a
forall a b. (a -> b) -> a -> b
$ Maybe a
maybe_a
        | Bool
otherwise = a
s
          where
            nu0 :: Int
nu0 = Partition
nu Partition -> Int -> Int
forall a. HasCallStack => [a] -> Int -> a
!! Int
0
            ellNu :: Int
ellNu = Partition -> Int
forall a. [a] -> Int
forall (t :: * -> *) a. Foldable t => t a -> Int
length Partition
nu
            xm :: a
xm = [a]
x [a] -> Int -> a
forall a. HasCallStack => [a] -> Int -> a
!! (Int
m Int -> Int -> Int
forall a. C a => a -> a -> a
- Int
1)
            xmi :: a -> a
xmi a
i = a
xm a -> Integer -> a
forall a. C a => a -> Integer -> a
^ (a -> Integer
forall a. Integral a => a -> Integer
toInteger a
i)
            _N_lambda_nu_m :: (Int, Int)
_N_lambda_nu_m = (Partition -> Partition -> Int
_N Partition
lambda Partition
nu, Int
m)
            maybe_a :: Maybe a
maybe_a = Array (Int, Int) (Maybe a)
arr Array (Int, Int) (Maybe a) -> (Int, Int) -> Maybe a
forall i e. Ix i => Array i e -> i -> e
! (Int, Int)
_N_lambda_nu_m
            wMu :: Int
wMu = Partition -> Int
forall a. Num a => [a] -> a
forall (t :: * -> *) a. (Foldable t, Num a) => t a -> a
sum Partition
mu
            jck' :: Partition -> Array (Int, Int) (Maybe a) -> a
jck' Partition
kappa Array (Int, Int) (Maybe a)
array = Int -> Partition -> Array (Int, Int) (Maybe a) -> a
jck (Int
mInt -> Int -> Int
forall a. C a => a -> a -> a
-Int
1) Partition
kappa Array (Int, Int) (Maybe a)
array a -> a -> a
forall a. C a => a -> a -> a
* (Int -> a
forall {a}. Integral a => a -> a
xmi (Int
wMu Int -> Int -> Int
forall a. C a => a -> a -> a
- Partition -> Int
forall a. Num a => [a] -> a
forall (t :: * -> *) a. (Foldable t, Num a) => t a -> a
sum Partition
kappa))
            s :: a
s = a -> Int -> a
go (Partition -> Array (Int, Int) (Maybe a) -> a
jck' Partition
nu Array (Int, Int) (Maybe a)
arr) (Int -> Int -> Int
forall a. Ord a => a -> a -> a
max Int
1 Int
k)
            go :: a -> Int -> a
            go :: a -> Int -> a
go !a
ss Int
ii
              | Int
ellNu Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
< Int
ii Bool -> Bool -> Bool
|| Int
u Int -> Int -> Bool
forall a. Eq a => a -> a -> Bool
== Int
0 = 
                  a
ss
              | Int
ellNu Int -> Int -> Bool
forall a. Eq a => a -> a -> Bool
== Int
ii Bool -> Bool -> Bool
&& Int
u Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
> Int
0 Bool -> Bool -> Bool
|| Int
u Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
> Partition
nu Partition -> Int -> Int
forall a. HasCallStack => [a] -> Int -> a
!! Int
ii = 
                  a -> Int -> a
go (a
ss a -> a -> a
forall a. C a => a -> a -> a
+ a
tt) (Int
ii Int -> Int -> Int
forall a. C a => a -> a -> a
+ Int
1)
              | Bool
otherwise = 
                  a -> Int -> a
go a
ss (Int
ii Int -> Int -> Int
forall a. C a => a -> a -> a
+ Int
1)
                where
                  jj :: Int
jj = Int
ii Int -> Int -> Int
forall a. C a => a -> a -> a
- Int
1
                  u :: Int
u = Partition
nu Partition -> Int -> Int
forall a. HasCallStack => [a] -> Int -> a
!! Int
jj
                  nu' :: Partition
nu' = (Int -> IndexedTraversal' Int Partition Int
forall (t :: * -> *) a.
Traversable t =>
Int -> IndexedTraversal' Int (t a) a
element Int
jj ((Int -> Identity Int) -> Partition -> Identity Partition)
-> Int -> Partition -> Partition
forall s t a b. ASetter s t a b -> b -> s -> t
.~ Int
u Int -> Int -> Int
forall a. C a => a -> a -> a
- Int
1) Partition
nu
                  gamma :: a
gamma = Partition -> Partition -> Int -> a -> a
forall a. C a => Partition -> Partition -> Int -> a -> a
_betaratio Partition
mu Partition
nu Int
ii a
alpha
                  tt :: a
tt = a
gamma a -> a -> a
forall a. C a => a -> a -> a
* a
y
                    where
                      y :: a
y
                        | Int
u Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
> Int
1 =
                            Int
-> Int -> Partition -> Partition -> Array (Int, Int) (Maybe a) -> a
jac Int
m Int
ii Partition
mu Partition
nu' Array (Int, Int) (Maybe a)
arr 
                        | Partition
nu' Partition -> Int -> Int
forall a. HasCallStack => [a] -> Int -> a
!! Int
0 Int -> Int -> Bool
forall a. Eq a => a -> a -> Bool
== Int
0 =
                            Int -> a
forall {a}. Integral a => a -> a
xmi Int
wMu
                        | Bool
otherwise =
                            Partition -> Array (Int, Int) (Maybe a) -> a
jck' Partition
nu' (Array (Int, Int) (Maybe a)
arr Array (Int, Int) (Maybe a)
-> [((Int, Int), Maybe a)] -> Array (Int, Int) (Maybe a)
forall i e. Ix i => Array i e -> [(i, e)] -> Array i e
// [((Int, Int)
_N_lambda_nu_m, a -> Maybe a
forall a. a -> Maybe a
Just a
ss)]) 

-- | Evaluation of a zonal polynomial. The zonal polynomials are the 

-- Jack \(C\)-polynomials with Jack parameter \(\alpha=2\).

zonal' 
  :: [Rational] -- ^ values of the variables

  -> Partition  -- ^ integer partition 

  -> Rational
zonal' :: [Rational] -> Partition -> Rational
zonal' = [Rational] -> Partition -> Rational
forall a. (Eq a, C a) => [a] -> Partition -> a
zonal

-- | Evaluation of a zonal polynomial. The zonal polynomials are the 

-- Jack \(C\)-polynomials with Jack parameter \(\alpha=2\).

zonal :: (Eq a, AlgField.C a)
  => [a]       -- ^ values of the variables

  -> Partition -- ^ partition of integers

  -> a
zonal :: forall a. (Eq a, C a) => [a] -> Partition -> a
zonal [a]
x Partition
lambda = [a] -> Partition -> a -> Char -> a
forall a. (Eq a, C a) => [a] -> Partition -> a -> Char -> a
jack [a]
x Partition
lambda (Integer -> a
forall a. C a => Integer -> a
fromInteger Integer
2) Char
'C'

-- | Evaluation of a Schur polynomial. The Schur polynomials are the 

-- Jack \(P\)-polynomials with Jack parameter \(\alpha=1\).

schur'
  :: [Rational] -- ^ values of the variables

  -> Partition  -- ^ integer partition 

  -> Rational
schur' :: [Rational] -> Partition -> Rational
schur' = [Rational] -> Partition -> Rational
forall a. C a => [a] -> Partition -> a
schur

-- | Evaluation of a Schur polynomial. The Schur polynomials are the 

-- Jack \(P\)-polynomials with Jack parameter \(\alpha=1\).

schur :: forall a. AlgRing.C a 
  => [a]       -- ^ values of the variables

  -> Partition -- ^ partition of integers 

  -> a
schur :: forall a. C a => [a] -> Partition -> a
schur []       Partition
_      = [Char] -> a
forall a. HasCallStack => [Char] -> a
error [Char]
"schur: empty list of variables"
schur x :: [a]
x@(a
x0:[a]
_) Partition
lambda =
  case Partition -> Bool
_isPartition Partition
lambda of
    Bool
False -> [Char] -> a
forall a. HasCallStack => [Char] -> a
error [Char]
"schur: invalid integer partition"
    Bool
True -> Int -> Int -> Partition -> Array (Int, Int) (Maybe a) -> a
sch Int
n Int
1 Partition
lambda Array (Int, Int) (Maybe a)
forall {a}. Array (Int, Int) (Maybe a)
arr0
      where
        n :: Int
n = [a] -> Int
forall a. [a] -> Int
forall (t :: * -> *) a. Foldable t => t a -> Int
length [a]
x
        nll :: Int
nll = Partition -> Partition -> Int
_N Partition
lambda Partition
lambda
        arr0 :: Array (Int, Int) (Maybe a)
arr0 = ((Int, Int), (Int, Int)) -> [Maybe a] -> Array (Int, Int) (Maybe a)
forall i e. Ix i => (i, i) -> [e] -> Array i e
listArray ((Int
1, Int
1), (Int
nll, Int
n)) (Int -> Maybe a -> [Maybe a]
forall a. Int -> a -> [a]
replicate (Int
nll Int -> Int -> Int
forall a. C a => a -> a -> a
* Int
n) Maybe a
forall a. Maybe a
Nothing)
        sch :: 
          Int -> Int -> [Int] -> Array (Int,Int) (Maybe a) -> a
        sch :: Int -> Int -> Partition -> Array (Int, Int) (Maybe a) -> a
sch Int
m Int
k Partition
nu Array (Int, Int) (Maybe a)
arr
          | Partition -> Bool
forall a. [a] -> Bool
forall (t :: * -> *) a. Foldable t => t a -> Bool
null Partition
nu Bool -> Bool -> Bool
|| Int
nu0 Int -> Int -> Bool
forall a. Eq a => a -> a -> Bool
== Int
0 Bool -> Bool -> Bool
|| Int
m Int -> Int -> Bool
forall a. Eq a => a -> a -> Bool
== Int
0 = a
forall a. C a => a
one
          | Int
ellNu Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
> Int
m Bool -> Bool -> Bool
&& Partition
nu Partition -> Int -> Int
forall a. HasCallStack => [a] -> Int -> a
!! Int
m Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
> Int
0 = a
forall a. C a => a
zero
          | Int
m Int -> Int -> Bool
forall a. Eq a => a -> a -> Bool
== Int
1 = a
x0 a -> Integer -> a
forall a. C a => a -> Integer -> a
^ (Int -> Integer
forall a. Integral a => a -> Integer
toInteger Int
nu0)
          | Maybe a -> Bool
forall a. Maybe a -> Bool
isJust Maybe a
maybe_a = 
              Maybe a -> a
forall a. HasCallStack => Maybe a -> a
fromJust Maybe a
maybe_a
          | Bool
otherwise = a
s
            where
              nu0 :: Int
nu0 = Partition
nu Partition -> Int -> Int
forall a. HasCallStack => [a] -> Int -> a
!! Int
0
              ellNu :: Int
ellNu = Partition -> Int
forall a. [a] -> Int
forall (t :: * -> *) a. Foldable t => t a -> Int
length Partition
nu
              xm :: a
xm = [a]
x [a] -> Int -> a
forall a. HasCallStack => [a] -> Int -> a
!! (Int
m Int -> Int -> Int
forall a. C a => a -> a -> a
- Int
1)
              _N_lambda_nu_m :: (Int, Int)
_N_lambda_nu_m = (Partition -> Partition -> Int
_N Partition
lambda Partition
nu, Int
m)
              maybe_a :: Maybe a
maybe_a = Array (Int, Int) (Maybe a)
arr Array (Int, Int) (Maybe a) -> (Int, Int) -> Maybe a
forall i e. Ix i => Array i e -> i -> e
! (Int, Int)
_N_lambda_nu_m
              sch' :: Partition -> Array (Int, Int) (Maybe a) -> a
sch' Partition
kappa Array (Int, Int) (Maybe a)
array = Int -> Int -> Partition -> Array (Int, Int) (Maybe a) -> a
sch (Int
mInt -> Int -> Int
forall a. C a => a -> a -> a
-Int
1) Int
1 Partition
kappa Array (Int, Int) (Maybe a)
array 
              s :: a
s = a -> Int -> a
go (Partition -> Array (Int, Int) (Maybe a) -> a
sch' Partition
nu Array (Int, Int) (Maybe a)
arr) Int
k
              go :: a -> Int -> a
              go :: a -> Int -> a
go !a
ss Int
ii
                | Int
ellNu Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
< Int
ii Bool -> Bool -> Bool
|| Int
u Int -> Int -> Bool
forall a. Eq a => a -> a -> Bool
== Int
0 = 
                    a
ss
                | Int
ellNu Int -> Int -> Bool
forall a. Eq a => a -> a -> Bool
== Int
ii Bool -> Bool -> Bool
&& Int
u Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
> Int
0 Bool -> Bool -> Bool
|| Int
u Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
> Partition
nu Partition -> Int -> Int
forall a. HasCallStack => [a] -> Int -> a
!! Int
ii = 
                    a -> Int -> a
go (a
ss a -> a -> a
forall a. C a => a -> a -> a
+ a
tt) (Int
ii Int -> Int -> Int
forall a. C a => a -> a -> a
+ Int
1)
                | Bool
otherwise = 
                    a -> Int -> a
go a
ss (Int
ii Int -> Int -> Int
forall a. C a => a -> a -> a
+ Int
1)
                  where
                    jj :: Int
jj = Int
ii Int -> Int -> Int
forall a. C a => a -> a -> a
- Int
1
                    u :: Int
u = Partition
nu Partition -> Int -> Int
forall a. HasCallStack => [a] -> Int -> a
!! Int
jj
                    nu' :: Partition
nu' = (Int -> IndexedTraversal' Int Partition Int
forall (t :: * -> *) a.
Traversable t =>
Int -> IndexedTraversal' Int (t a) a
element Int
jj ((Int -> Identity Int) -> Partition -> Identity Partition)
-> Int -> Partition -> Partition
forall s t a b. ASetter s t a b -> b -> s -> t
.~ Int
u Int -> Int -> Int
forall a. C a => a -> a -> a
- Int
1) Partition
nu
                    tt :: a
tt 
                      | Int
u Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
> Int
1 =
                          a
xm a -> a -> a
forall a. C a => a -> a -> a
* Int -> Int -> Partition -> Array (Int, Int) (Maybe a) -> a
sch Int
m Int
ii Partition
nu' Array (Int, Int) (Maybe a)
arr
                      | Partition
nu' Partition -> Int -> Int
forall a. HasCallStack => [a] -> Int -> a
!! Int
0 Int -> Int -> Bool
forall a. Eq a => a -> a -> Bool
== Int
0 =
                          a
xm 
                      | Bool
otherwise =
                          a
xm a -> a -> a
forall a. C a => a -> a -> a
* Partition -> Array (Int, Int) (Maybe a) -> a
sch' Partition
nu' (Array (Int, Int) (Maybe a)
arr Array (Int, Int) (Maybe a)
-> [((Int, Int), Maybe a)] -> Array (Int, Int) (Maybe a)
forall i e. Ix i => Array i e -> [(i, e)] -> Array i e
// [((Int, Int)
_N_lambda_nu_m, a -> Maybe a
forall a. a -> Maybe a
Just a
ss)]) 

-- | Evaluation of a skew Schur polynomial

skewSchur' 
  :: [Rational] -- ^ values of the variables

  -> Partition  -- ^ the outer partition of the skew partition

  -> Partition  -- ^ the inner partition of the skew partition

  -> Rational
skewSchur' :: [Rational] -> Partition -> Partition -> Rational
skewSchur' = [Rational] -> Partition -> Partition -> Rational
forall a. (Eq a, C a) => [a] -> Partition -> Partition -> a
skewSchur

-- | Evaluation of a skew Schur polynomial

skewSchur :: forall a. (Eq a, AlgRing.C a) 
  => [a]       -- ^ values of the variables

  -> Partition -- ^ the outer partition of the skew partition

  -> Partition -- ^ the inner partition of the skew partition

  -> a
skewSchur :: forall a. (Eq a, C a) => [a] -> Partition -> Partition -> a
skewSchur [a]
xs Partition
lambda Partition
mu = 
  if Partition -> Partition -> Bool
isSkewPartition Partition
lambda Partition
mu 
    then (a -> Partition -> Int -> a) -> a -> Map Partition Int -> a
forall a k b. (a -> k -> b -> a) -> a -> Map k b -> a
DM.foldlWithKey' a -> Partition -> Int -> a
f a
forall a. C a => a
zero Map Partition Int
lrCoefficients
    else [Char] -> a
forall a. HasCallStack => [Char] -> a
error [Char]
"skewSchur: invalid skew partition"
  where
    lrCoefficients :: Map Partition Int
lrCoefficients = Partition -> Partition -> Map Partition Int
skewSchurLRCoefficients Partition
lambda Partition
mu
    f :: a -> Partition -> Int -> a
    f :: a -> Partition -> Int -> a
f a
x Partition
nu Int
k = a
x a -> a -> a
forall a. C a => a -> a -> a
+ (Int -> a
forall a. (C a, Eq a) => Int -> a
_fromInt Int
k) a -> a -> a
forall a. C a => a -> a -> a
* ([a] -> Partition -> a
forall a. C a => [a] -> Partition -> a
schur [a]
xs Partition
nu)