Macaulay2 » Documentation
Packages » BettiCharacters » decomposeCharacter
next | previous | forward | backward | up | index | toc

# decomposeCharacter -- decompose a character into irreducible characters

- Usage:
    `decomposeCharacter(c,T)`
    `c/T`
- Inputs:
  - c, an instance of the type Character, of a finite group
  - T, an instance of the type CharacterTable, of the same finite group
- Outputs:
  - an instance of the type CharacterDecomposition,

## Description

Use the decomposeCharacter method to decompose a character into a linear combination of irreducible characters in a character table. The shortcut c/T is equivalent to the command decomposeCharacter(c,T).

As an example, we construct the character table of the symmetric group on 3 elements, then use it to decompose the character of the action of the same symmetric group permuting the variables of a standard graded polynomial ring.

    i1 : s = {2,3,1}

    o1 = {2, 3, 1}

    o1 : List

    i2 : M = matrix{{1,1,1},{-1,0,2},{1,-1,1}}

    o2 = | 1  1  1 |
         | -1 0  2 |
         | 1  -1 1 |

                  3       3
    o2 : Matrix ZZ  <-- ZZ

    i3 : R = QQ[x_1..x_3]

    o3 = R

    o3 : PolynomialRing

    i4 : P = {1,2,3}

    o4 = {1, 2, 3}

    o4 : List

    i5 : T = characterTable(s,M,R,P)

    o5 = Character table over R

             |   2   3  1
         ----+-----------
         X0  |   1   1  1
         X1  |  -1   0  2
         X2  |   1  -1  1

    o5 : CharacterTable

    i6 : acts = {matrix{{x_2,x_3,x_1}},matrix{{x_2,x_1,x_3}},matrix{{x_1,x_2,x_3}}}

    o6 = {| x_2 x_3 x_1 |, | x_2 x_1 x_3 |, | x_1 x_2 x_3 |}

    o6 : List

    i7 : A = action(R,acts)

    o7 = PolynomialRing with 3 actors

    o7 : ActionOnGradedModule

    i8 : c = character(A,0,10)

    o8 = Character over R

         (0, {0}) => | 1 1 1 |
         (0, {1}) => | 0 1 3 |
         (0, {2}) => | 0 2 6 |
         (0, {3}) => | 1 2 10 |
         (0, {4}) => | 0 3 15 |
         (0, {5}) => | 0 3 21 |
         (0, {6}) => | 1 4 28 |
         (0, {7}) => | 0 4 36 |
         (0, {8}) => | 0 5 45 |
         (0, {9}) => | 1 5 55 |
         (0, {10}) => | 0 6 66 |

    o8 : Character

    i9 : decomposeCharacter(c,T)

    o9 = Decomposition table

                    |  X0  X1  X2
         -----------+------------
          (0, {0})  |   1   0   0
          (0, {1})  |   1   1   0
          (0, {2})  |   2   2   0
          (0, {3})  |   3   3   1
          (0, {4})  |   4   5   1
          (0, {5})  |   5   7   2
          (0, {6})  |   7   9   3
          (0, {7})  |   8  12   4
          (0, {8})  |  10  15   5
          (0, {9})  |  12  18   7
         (0, {10})  |  14  22   8

    o9 : CharacterDecomposition

The results are shown in a table whose rows are indexed by pairs of homological and internal degrees, and whose columns are labeled by the irreducible characters. By default, irreducible characters in a character table are labeled as X0, X1, ..., etc, and the same labeling is inherited by the character decomposition. The user may pass custom labels in a list using the option Labels when constructing the character table.

## See also

- characterTable -- construct a character table

### Menu

- CharacterDecomposition -- the class of all finite group character decompositions

## Ways to use decomposeCharacter:

- `decomposeCharacter(Character,CharacterTable)`

## For the programmer

The object decomposeCharacter is a method function.

The source of this document is in /build/macaulay2-88fgJW/macaulay2-1.25.11+ds/M2/Macaulay2/packages/BettiCharacters.m2:2859:0.