axiom-source 20170501-3 / usr / share / axiom-20170501 / src / algebra / REP1.spad

)abbrev package REP1 RepresentationPackage1
++ Authors: Holger Gollan, Johannes Grabmeier, Thorsten Werther
++ Date Created: 12 September 1987
++ Date Last Updated: 24 May 1991
++ References:
++ Jame81 The Representation Theory of the Symmetric Group
++ Grab87 The Evaluation of Irreducible Polynomial Representations
++ Goll90 Algorithms in Representation Theory 
++ Description: 
++ RepresentationPackage1 provides functions for representation theory
++ for finite groups and algebras.
++ The package creates permutation representations and uses tensor products
++ and its symmetric and antisymmetric components to create new
++ representations of larger degree from given ones.
++ Note that instead of having parameters from \spadtype{Permutation}
++ this package allows list notation of permutations as well:
++ for example \spad{[1,4,3,2]} denotes permutes 2 and 4 and fixes 1 and 3.
 
RepresentationPackage1(R) : SIG == CODE where 
  R : Ring

  OF    ==> OutputForm
  NNI   ==> NonNegativeInteger
  PI    ==> PositiveInteger
  I     ==> Integer
  L     ==> List
  M     ==> Matrix
  P     ==> Polynomial
  SM    ==> SquareMatrix
  V     ==> Vector
  ICF   ==> IntegerCombinatoricFunctions Integer
  SGCF  ==> SymmetricGroupCombinatoricFunctions
  PERM  ==> Permutation
 
  SIG ==> with
 
     if R has commutative("*") then

       antisymmetricTensors : (M R,PI) ->  M R
         ++ antisymmetricTensors(a,n) applies to the square matrix
         ++ a the irreducible, polynomial representation of the
         ++ general linear group GLm, where m is the number of
         ++ rows of a, which corresponds to the partition
         ++ (1,1,...,1,0,0,...,0) of n.
         ++ Error: if n is greater than m.
         ++ Note that this corresponds to the symmetrization of the 
         ++ representation with the sign representation of the symmetric group
         ++ Sn. The carrier spaces of the representation are the antisymmetric
         ++ tensors of the n-fold tensor product.
         ++
         ++X t1:=matrix [[a,b,c],[d,e,f]]
         ++X antisymmetricTensors(t1,2)

     if R has commutative("*") then

       antisymmetricTensors : (L M R, PI) -> L M R
         ++ antisymmetricTensors(la,n) applies to each 
         ++ m-by-m square matrix in
         ++ the list la the irreducible, polynomial representation
         ++ of the general linear group GLm 
         ++ which corresponds
         ++ to the partition (1,1,...,1,0,0,...,0) of n.
         ++ Error: if n is greater than m.
         ++ Note that this corresponds to the symmetrization of the 
         ++ representation with the sign representation of the symmetric group
         ++ Sn. The carrier spaces of the representation are the antisymmetric
         ++ tensors of the n-fold tensor product.

     createGenericMatrix : NNI -> M P R
       ++ createGenericMatrix(m) creates a square matrix of dimension k
       ++ whose entry at the i-th row and j-th column is the
       ++ indeterminate x[i,j] (double subscripted).

     symmetricTensors : (M R, PI) -> M R
       ++ symmetricTensors(a,n) applies to the m-by-m 
       ++ square matrix a the
       ++ irreducible, polynomial representation of the general linear
       ++ group GLm
       ++ which corresponds to the partition (n,0,...,0) of n.
       ++ Error: if a is not a square matrix.
       ++ Note that this corresponds to the symmetrization of the 
       ++ representation with the trivial representation of the symmetric 
       ++ group Sn.
       ++ The carrier spaces of the representation are the symmetric
       ++ tensors of the n-fold tensor product.

     symmetricTensors : (L M R, PI)  ->  L M R
       ++ symmetricTensors(la,n) applies to each m-by-m square matrix in the
       ++ list la the irreducible, polynomial representation
       ++ of the general linear group GLm
       ++ which corresponds
       ++ to the partition (n,0,...,0) of n.
       ++ Error: if the matrices in la are not square matrices.
       ++ Note that this corresponds to the symmetrization of the 
       ++ representation with the trivial representation of the symmetric 
       ++ group Sn.
       ++ The carrier spaces of the representation are the symmetric
       ++ tensors of the n-fold tensor product.

     tensorProduct : (M R, M R) -> M R
       ++ tensorProduct(a,b) calculates the Kronecker product
       ++ of the matrices a and b.
       ++ Note that if each matrix corresponds to a group representation
       ++ (repr. of  generators) of one group, then these matrices
       ++ correspond to the tensor product of the two representations.

     tensorProduct : (L M R, L M R) -> L M R
       ++ tensorProduct([a1,...,ak],[b1,...,bk]) calculates the list of
       ++ Kronecker products of the matrices ai and bi
       ++ for {1 <= i <= k}.
       ++ Note that if each list of matrices corresponds to a group 
       ++ representation (repr. of generators) of one group, then these 
       ++ matrices correspond to the tensor product of the two representations.

     tensorProduct : M R -> M R
       ++ tensorProduct(a) calculates the Kronecker product
       ++ of the matrix a with itself.

     tensorProduct : L M R -> L M R
       ++ tensorProduct([a1,...ak]) calculates the list of
       ++ Kronecker products of each matrix ai with itself
       ++ for {1 <= i <= k}.
       ++ Note that if the list of matrices corresponds to a group 
       ++ representation (repr. of generators) of one group, then these 
       ++ matrices correspond to the tensor product of the representation 
       ++ with itself.

     permutationRepresentation : (PERM I, I) -> M I
       ++ permutationRepresentation(pi,n) returns the matrix
       ++ (deltai,pi(i)) (Kronecker delta) for a permutation
       ++ pi of {1,2,...,n}.

     permutationRepresentation : L I -> M I
       ++ permutationRepresentation(pi,n) returns the matrix
       ++ (deltai,pi(i)) (Kronecker delta) if the permutation
       ++ pi is in list notation and permutes {1,2,...,n}.

     permutationRepresentation : (L PERM I, I) -> L M I
       ++ permutationRepresentation([pi1,...,pik],n) returns the list
       ++ of matrices [(deltai,pi1(i)),...,(deltai,pik(i))]
       ++ (Kronecker delta) for the permutations pi1,...,pik
       ++ of {1,2,...,n}.

     permutationRepresentation : L L I -> L M I
       ++ permutationRepresentation([pi1,...,pik],n) returns the list
       ++ of matrices [(deltai,pi1(i)),...,(deltai,pik(i))]
       ++ if the permutations pi1,...,pik are in 
       ++ list notation and are permuting {1,2,...,n}.
 
  CODE ==> add
 
     -- import of domains and packages
 
     import OutputForm
 
     -- declaration of local functions:
 
     calcCoef : (L I, M I) -> I
       -- calcCoef(beta,C) calculates the term
       -- |S(beta) gamma S(alpha)| / |S(beta)|
 
     invContent : L I -> V I
       -- invContent(alpha) calculates the weak monoton function f with
       -- f : m -> n with invContent alpha. f is stored in the returned
       -- vector
 
     -- definition of local functions
 
     calcCoef(beta,C) ==
       prod : I := 1
       for i in 1..maxIndex beta repeat
         prod := prod * multinomial(beta(i), entries row(C,i))$ICF
       prod
 
     invContent(alpha) ==
       n : NNI := (+/alpha)::NNI
       f : V I  := new(n,0)
       i : NNI := 1
       j : I   := - 1
       for og in alpha repeat
         j := j + 1
         for k in 1..og repeat
           f(i) := j
           i := i + 1
       f
 
     -- exported functions:
 
     if R has commutative("*") then

       antisymmetricTensors ( a : M R , k : PI ) ==
 
         nr      : NNI   := nrows a
	 nc     : NNI   := ncols a
         k = 1 => a
         k > min(nr,nc) =>
           error("second parameter for antisymmetricTensors is too large")
         mr     :   I   := binomial(nr,k)$ICF
         mc     :   I   := binomial(nc,k)$ICF	 
         ilr    : L L I   := [subSet(nr,k,i)$SGCF for i in 0..mr-1]
         ilc    : L L I   := [subSet(nc,k,i)$SGCF for i in 0..mc-1]	 
         b      :  M R   := zero(mr::NNI, mc::NNI)
         for i in 1..mr repeat
           for j in 1..mc repeat
             c : M R := zero(k,k)
             lr: L I := ilr.i
             lt: L I := ilc.j
             for  r in 1..k repeat
               for t in 1..k repeat
                 rr : I := lr.r
                 tt : I := lt.t
                 --c.r.t := a.(1+rr).(1+tt)
                 setelt(c,r,t,elt(a, 1+rr, 1+tt))
             setelt(b, i, j, determinant c)
         b
 
     if R has commutative("*") then

       antisymmetricTensors(la: L M R, k: PI) ==
         [antisymmetricTensors(ma,k) for ma in la]
 
     symmetricTensors (a : M R, n : PI) ==
       m : NNI := nrows a
       m ^= ncols a =>
         error("Input to symmetricTensors is not a square matrix")
       n = 1 => a
       dim : NNI := (binomial(m+n-1,n)$ICF)::NNI
       c : M R := new(dim,dim,0)
       f : V I := new(n,0)
       g : V I := new(n,0)
       nullMatrix : M I := new(1,1,0)
       colemanMatrix : M I
       for i in 1..dim repeat
         -- unrankImproperPartitions1 starts counting from 0
         alpha := unrankImproperPartitions1(n,m,i-1)$SGCF
         f := invContent(alpha)
         for j in 1..dim repeat
           -- unrankImproperPartitions1 starts counting from 0
           beta := unrankImproperPartitions1(n,m,j-1)$SGCF
           g := invContent(beta)
           colemanMatrix := nextColeman(alpha,beta,nullMatrix)$SGCF
           while colemanMatrix ^= nullMatrix repeat
             gamma := inverseColeman(alpha,beta,colemanMatrix)$SGCF
             help : R := calcCoef(beta,colemanMatrix)::R
             for k in 1..n repeat
               help := help * a( (1+f k)::NNI, (1+g(gamma k))::NNI )
             c(i,j) := c(i,j) + help
             colemanMatrix := nextColeman(alpha,beta,colemanMatrix)$SGCF
           -- end of while
         -- end of j-loop
       -- end of i-loop
       c
 
     symmetricTensors(la : L M R, k : PI) ==
       [symmetricTensors (ma, k) for ma in la]
 
     tensorProduct(a: M R, b: M R) ==
       n      : NNI := nrows a
       m      : NNI := nrows b
       nc     : NNI := ncols a
       mc     : NNI := ncols b
       c      : M R   := zero(n * m, nc * mc)
       indexr : NNI := 1                             --   row index
       for i in 1..n repeat
          for k in 1..m repeat
             indexc : NNI := 1                       --   column index
             for j in 1..nc repeat
                for l in 1..mc repeat
                   c(indexr,indexc) := a(i,j) * b(k,l)
                   indexc          := indexc + 1
             indexr := indexr + 1
       c
 
     tensorProduct (la: L M R, lb: L M R) ==
       [tensorProduct(la.i, lb.i) for i in 1..maxIndex la]
 
     tensorProduct(a : M R) == tensorProduct(a, a)
 
     tensorProduct(la : L M R) ==
       tensorProduct(la :: L M R, la :: L M R)
 
     permutationRepresentation (p : PERM I, n : I) ==
       -- permutations are assumed to permute {1,2,...,n}
       a : M I := zero(n :: NNI, n :: NNI)
       for i in 1..n repeat
          a(eval(p,i)$(PERM I),i) := 1
       a
 
     permutationRepresentation (p : L I) ==
       -- permutations are assumed to permute {1,2,...,n}
       n : I := #p
       a : M I := zero(n::NNI, n::NNI)
       for i in 1..n repeat
          a(p.i,i) := 1
       a
 
     permutationRepresentation(listperm : L PERM I, n : I) ==
       -- permutations are assumed to permute {1,2,...,n}
       [permutationRepresentation(perm, n) for perm in listperm]
 
     permutationRepresentation (listperm : L L I) ==
       -- permutations are assumed to permute {1,2,...,n}
       [permutationRepresentation perm for perm in listperm]
 
     createGenericMatrix(m) ==
       res : M P R := new(m,m,0$(P R))
       for i in 1..m repeat
         for j in 1..m repeat
            iof : OF := coerce(i)$Integer
            jof : OF := coerce(j)$Integer
            le : L OF := cons(iof,list jof)
            sy : Symbol := subscript(x::Symbol, le)$Symbol
            res(i,j) := (sy :: P R)
       res