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

A Jack polynomial can have a very long expression which can be considerably 
reduced if the polynomial is written in the basis formed by the monomial 
symmetric polynomials instead. This is the motivation of this module.
-}

module Math.Algebra.Jack.SymmetricPolynomials
  ( isSymmetricSpray
  , msPolynomial
  , msCombination
  , prettySymmetricNumSpray
  , prettySymmetricQSpray
  , prettySymmetricQSpray'
  , prettySymmetricSymbolicQSpray
  ) where
import qualified Algebra.Ring                     as AlgRing
import qualified Data.Foldable                    as DF
import           Data.List                        ( foldl1', nub )
import           Data.Map.Strict                  ( Map )
import qualified Data.Map.Strict                  as DM
import           Data.Sequence                    ( Seq )
import           Math.Algebra.Hspray              (
                                                    (^+^)
                                                  , (*^)
                                                  , Spray
                                                  , QSpray
                                                  , QSpray'
                                                  , SymbolicQSpray
                                                  , fromList
                                                  , getCoefficient
                                                  , numberOfVariables
                                                  , prettyRatioOfQPolynomials
                                                  , showNumSpray
                                                  , showQSpray
                                                  , showQSpray'
                                                  , showSpray
                                                  , toList
                                                  , zeroSpray
                                                  )
import           Math.Algebra.Jack.Internal       ( Partition , _isPartition )
import           Math.Combinat.Permutations       ( permuteMultiset )
import           Math.Combinat.Partitions.Integer ( fromPartition, mkPartition )

-- | Monomial symmetric polynomials

--

-- >>> putStrLn $ prettySpray' (msPolynomial 3 [2, 1])

-- (1) x1^2.x2 + (1) x1^2.x3 + (1) x1.x2^2 + (1) x1.x3^2 + (1) x2^2.x3 + (1) x2.x3^2

msPolynomial :: (AlgRing.C a, Eq a) 
  => Int       -- ^ number of variables

  -> Partition -- ^ integer partition

  -> Spray a
msPolynomial :: forall a. (C a, Eq a) => Int -> [Int] -> Spray a
msPolynomial Int
n [Int]
lambda
  | Int
n Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
< Int
0                     = [Char] -> Spray a
forall a. HasCallStack => [Char] -> a
error [Char]
"msPolynomial: negative number of variables."
  | Bool -> Bool
not ([Int] -> Bool
_isPartition [Int]
lambda) = [Char] -> Spray a
forall a. HasCallStack => [Char] -> a
error [Char]
"msPolynomial: invalid partition."
  | Int
llambda Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
> Int
n               = Spray a
forall a. (Eq a, C a) => Spray a
zeroSpray
  | Bool
otherwise                 = [([Int], a)] -> Spray a
forall a. (C a, Eq a) => [([Int], a)] -> Spray a
fromList ([([Int], a)] -> Spray a) -> [([Int], a)] -> Spray a
forall a b. (a -> b) -> a -> b
$ [[Int]] -> [a] -> [([Int], a)]
forall a b. [a] -> [b] -> [(a, b)]
zip [[Int]]
permutations [a]
coefficients
    where
      llambda :: Int
llambda      = [Int] -> Int
forall a. [a] -> Int
forall (t :: * -> *) a. Foldable t => t a -> Int
length [Int]
lambda
      permutations :: [[Int]]
permutations = [Int] -> [[Int]]
forall a. (Eq a, Ord a) => [a] -> [[a]]
permuteMultiset ([Int]
lambda [Int] -> [Int] -> [Int]
forall a. [a] -> [a] -> [a]
++ Int -> Int -> [Int]
forall a. Int -> a -> [a]
replicate (Int
nInt -> Int -> Int
forall a. Num a => a -> a -> a
-Int
llambda) Int
0)
      coefficients :: [a]
coefficients = a -> [a]
forall a. a -> [a]
repeat a
forall a. C a => a
AlgRing.one

-- | Checks whether a spray defines a symmetric polynomial; this is useless for 

-- Jack polynomials because they always are symmetric, but this module contains 

-- everything needed to build this function and it can be useful in another context

isSymmetricSpray :: (AlgRing.C a, Eq a) => Spray a -> Bool
isSymmetricSpray :: forall a. (C a, Eq a) => Spray a -> Bool
isSymmetricSpray Spray a
spray = Spray a
spray Spray a -> Spray a -> Bool
forall a. Eq a => a -> a -> Bool
== Spray a
spray' 
  where
    assocs :: [([Int], a)]
assocs = Spray a -> [([Int], a)]
forall a. C a => Spray a -> [([Int], a)]
msCombination' Spray a
spray
    n :: Int
n      = Spray a -> Int
forall a. Spray a -> Int
numberOfVariables Spray a
spray
    spray' :: Spray a
spray' = (Spray a -> Spray a -> Spray a) -> [Spray a] -> Spray a
forall a. HasCallStack => (a -> a -> a) -> [a] -> a
foldl1' Spray a -> Spray a -> Spray a
forall a. (C a, Eq a) => Spray a -> Spray a -> Spray a
(^+^) 
      (
        (([Int], a) -> Spray a) -> [([Int], a)] -> [Spray a]
forall a b. (a -> b) -> [a] -> [b]
map (\([Int]
lambda, a
x) -> a
x a -> Spray a -> Spray a
forall a. (C a, Eq a) => a -> Spray a -> Spray a
*^ Int -> [Int] -> Spray a
forall a. (C a, Eq a) => Int -> [Int] -> Spray a
msPolynomial Int
n [Int]
lambda) [([Int], a)]
assocs
      )

-- | Symmetric polynomial as a linear combination of monomial symmetric polynomials

msCombination :: AlgRing.C a => Spray a -> Map Partition a
msCombination :: forall a. C a => Spray a -> Map [Int] a
msCombination Spray a
spray = [([Int], a)] -> Map [Int] a
forall k a. Ord k => [(k, a)] -> Map k a
DM.fromList (Spray a -> [([Int], a)]
forall a. C a => Spray a -> [([Int], a)]
msCombination' Spray a
spray)

msCombination' :: AlgRing.C a => Spray a -> [(Partition, a)]
msCombination' :: forall a. C a => Spray a -> [([Int], a)]
msCombination' Spray a
spray = 
  ([Int] -> ([Int], a)) -> [[Int]] -> [([Int], a)]
forall a b. (a -> b) -> [a] -> [b]
map (\[Int]
lambda -> ([Int]
lambda, [Int] -> Spray a -> a
forall a. C a => [Int] -> Spray a -> a
getCoefficient [Int]
lambda Spray a
spray)) [[Int]]
lambdas
  where
    lambdas :: [[Int]]
lambdas = [[Int]] -> [[Int]]
forall a. Eq a => [a] -> [a]
nub ([[Int]] -> [[Int]]) -> [[Int]] -> [[Int]]
forall a b. (a -> b) -> a -> b
$ (([Int], a) -> [Int]) -> [([Int], a)] -> [[Int]]
forall a b. (a -> b) -> [a] -> [b]
map (Partition -> [Int]
fromPartition (Partition -> [Int])
-> (([Int], a) -> Partition) -> ([Int], a) -> [Int]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. [Int] -> Partition
mkPartition ([Int] -> Partition)
-> (([Int], a) -> [Int]) -> ([Int], a) -> Partition
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ([Int], a) -> [Int]
forall a b. (a, b) -> a
fst) (Spray a -> [([Int], a)]
forall a. Spray a -> [([Int], a)]
toList Spray a
spray)

-- helper function for the showing stuff

makeMSpray :: (Eq a, AlgRing.C a) => Spray a -> Spray a
makeMSpray :: forall a. (Eq a, C a) => Spray a -> Spray a
makeMSpray = [([Int], a)] -> Spray a
forall a. (C a, Eq a) => [([Int], a)] -> Spray a
fromList ([([Int], a)] -> Spray a)
-> (Spray a -> [([Int], a)]) -> Spray a -> Spray a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Spray a -> [([Int], a)]
forall a. C a => Spray a -> [([Int], a)]
msCombination'

-- show symmetric monomial like M[3,2,1]

showSymmetricMonomials :: [Seq Int] -> [String]
showSymmetricMonomials :: [Seq Int] -> [[Char]]
showSymmetricMonomials = (Seq Int -> [Char]) -> [Seq Int] -> [[Char]]
forall a b. (a -> b) -> [a] -> [b]
map Seq Int -> [Char]
showSymmetricMonomial
  where
    showSymmetricMonomial :: Seq Int -> String
    showSymmetricMonomial :: Seq Int -> [Char]
showSymmetricMonomial Seq Int
lambda = Char
'M' Char -> [Char] -> [Char]
forall a. a -> [a] -> [a]
: [Int] -> [Char]
forall a. Show a => a -> [Char]
show (Seq Int -> [Int]
forall a. Seq a -> [a]
forall (t :: * -> *) a. Foldable t => t a -> [a]
DF.toList Seq Int
lambda)

-- | Prints a symmetric spray as a linear combination of monomial symmetric polynomials

--

-- >>> putStrLn $ prettySymmetricNumSpray $ schurPol' 3 [3, 1, 1]

-- M[3, 1, 1] + M[2, 2, 1]

prettySymmetricNumSpray :: (Num a, Ord a, Show a, AlgRing.C a) => Spray a -> String
prettySymmetricNumSpray :: forall a. (Num a, Ord a, Show a, C a) => Spray a -> [Char]
prettySymmetricNumSpray Spray a
spray = 
  ([Seq Int] -> [[Char]]) -> (a -> [Char]) -> Spray a -> [Char]
forall a.
(Num a, Ord a) =>
([Seq Int] -> [[Char]]) -> (a -> [Char]) -> Spray a -> [Char]
showNumSpray [Seq Int] -> [[Char]]
showSymmetricMonomials a -> [Char]
forall a. Show a => a -> [Char]
show Spray a
mspray
  where
    mspray :: Spray a
mspray = Spray a -> Spray a
forall a. (Eq a, C a) => Spray a -> Spray a
makeMSpray Spray a
spray

-- | Prints a symmetric spray as a linear combination of monomial symmetric polynomials

--

-- >>> putStrLn $ prettySymmetricQSpray $ jackPol' 3 [3, 1, 1] 2 'J'

-- 42*M[3,1,1] + 28*M[2,2,1]

prettySymmetricQSpray :: QSpray -> String
prettySymmetricQSpray :: QSpray -> [Char]
prettySymmetricQSpray QSpray
spray = ([Seq Int] -> [[Char]]) -> QSpray -> [Char]
showQSpray [Seq Int] -> [[Char]]
showSymmetricMonomials QSpray
mspray
  where
    mspray :: QSpray
mspray = QSpray -> QSpray
forall a. (Eq a, C a) => Spray a -> Spray a
makeMSpray QSpray
spray

-- | Same as `prettySymmetricQSpray` but for a `QSpray'` symmetric spray

prettySymmetricQSpray' :: QSpray' -> String
prettySymmetricQSpray' :: QSpray' -> [Char]
prettySymmetricQSpray' QSpray'
spray = ([Seq Int] -> [[Char]]) -> QSpray' -> [Char]
showQSpray' [Seq Int] -> [[Char]]
showSymmetricMonomials QSpray'
mspray
  where
    mspray :: QSpray'
mspray = QSpray' -> QSpray'
forall a. (Eq a, C a) => Spray a -> Spray a
makeMSpray QSpray'
spray

-- | Prints a symmetric symbolic spray as a linear combination of monomial symmetric polynomials

--

-- >>> putStrLn $ prettySymmetricSymbolicQSpray "a" $ jackSymbolicPol' 3 [3, 1, 1] 'J'

-- { 4*a^2 + 10*a + 6 }*M[3,1,1] + { 8*a + 12 }*M[2,2,1]

prettySymmetricSymbolicQSpray :: String -> SymbolicQSpray -> String
prettySymmetricSymbolicQSpray :: [Char] -> SymbolicQSpray -> [Char]
prettySymmetricSymbolicQSpray [Char]
a SymbolicQSpray
spray = 
  (RatioOfQPolynomials -> [Char])
-> ([Char], [Char])
-> ([Seq Int] -> [[Char]])
-> SymbolicQSpray
-> [Char]
forall a.
(a -> [Char])
-> ([Char], [Char]) -> ([Seq Int] -> [[Char]]) -> Spray a -> [Char]
showSpray ([Char] -> RatioOfQPolynomials -> [Char]
prettyRatioOfQPolynomials [Char]
a) ([Char]
"{ ", [Char]
" }") 
            [Seq Int] -> [[Char]]
showSymmetricMonomials SymbolicQSpray
mspray
  where
    mspray :: SymbolicQSpray
mspray = SymbolicQSpray -> SymbolicQSpray
forall a. (Eq a, C a) => Spray a -> Spray a
makeMSpray SymbolicQSpray
spray