We want to compute characters of wreath product Z_3^(Z_3)*Z_3

First, we represent the group in computer giving generators as permutations:

(1) -> pG := Permutation(Integer)

(1)

g1 := cycle([1,2,3])$pG

(2)

g2 := cycle([1,4,7])$pG*cycle([2,5,8])$pG*cycle([3,6,9])$pG

(3)

gens := [1$pG, g1, g2]

(4)

Check the order:

order(permutationGroup(gens))

(5)

Now, we compute list of elements. We will repeatedly multiply pending list of elements by generators. Due to length we do no print results.

mul_sets(s1, s2) ==
    l := [[g1*g2 for g1 in s1] for g2 in s2]
    removeDuplicates(reduce(append, l))

ls := gens;

for i in 1..20 repeat
    ls := mul_sets(ls, gens)

Compiling function mul_sets with type (List(Permutation(Integer)), 
      List(Permutation(Integer))) -> List(Permutation(Integer))

Check that we obtained all elements:

#ls

(6)

Now, we want to compute conjugacy classes. rl below is list of remaining elements to process.

classes : List(List(Permutation(Integer))) := []

(7)

rl := ls;

while not(empty?(rl)) repeat
    cl := removeDuplicates([g^(-1)*rl(1)*g for g in ls])
    classes := cons(cl, classes)
    rl := setDifference(rl, cl)

-- reverse for more natural order
classes := reverse!(classes);

-- check for correct number of classes
#classes

(8)

Now we want to compute multiplication table for classes.

-- Auxiliary function to multiply element g1 by class cl1.
-- Input:
--   g1       - element
--   cl1      - class
--   lcl      - list of all classes
product_of_classes(g1, cl1, lcl) ==
    res := []$List(Integer)
    els := [g1*g2 for g2 in cl1]
    for cl2 in lcl repeat
        sum := 0$Integer
        for g2 in els repeat
            if member?(g2, cl2) then sum := sum + 1
        res := cons(sum, res)
    reverse!(res)

-- Auxiliary function to multiply class cl1 by class cl2
-- Input:
--   cl1 and cl2    - classes
--   lcl            - list of all classes
--   ncll           - list of cardinalities of classes in lcl
product_of_classes2(cl1, cl2, lcl, nlcl) ==
    res1 : List(Integer) := product_of_classes(cl1(1), cl2, lcl)
    n := #cl1
    [((k*n) exquo l)::Integer for k in res1 for l in nlcl]

-- remember cardinalities of classes for future use
nlcl := [#cl for cl in classes]

(9)

-- empty multiplication table
mt := []$List(Matrix(Integer))

(10)

-- Fill the multiplication table
for i in 1.. for cl1 in classes repeat
    mti := new(17, 17, 0)$Matrix(Integer)
    for j in 1.. for cl2 in classes repeat
        pl := product_of_classes2(cl1, cl2, classes, nlcl)
        for k in 1.. for coeff in pl repeat
            mti(k, j) := coeff
    mt := cons(mti, mt)

Compiling function product_of_classes with type (Permutation(Integer
      ), List(Permutation(Integer)), List(List(Permutation(Integer))))
       -> List(Integer)

Compiling function product_of_classes2 with type (List(Permutation(
      Integer)), List(Permutation(Integer)), List(List(Permutation(
      Integer))), List(NonNegativeInteger)) -> List(Integer)

mt := reverse!(mt);

Computation of characters will be done over finite field, in particular for p = 1459 we have all needed roots of unity. We will produce matrix of multiplication by random element and compute its eigenvectors.

pF := PrimeField(1459)

(11)

A := reduce(_+, [(random()$pF)*m::Matrix(pF) for m in mt]);

-- check if eigenvalues are distinct
#eigenvalues(A)

(12)

-- list of eigenvectors
le1 := [eir.eigvec for eir in eigenvectors(A)];

-- convert to right type
le := [column(first(ev)::Matrix(PrimeField(1459)), 1) for ev in le1];

By normalizing and pass from g to g^(-1) we get characters from eigenvectors

-- Compute table of inverses for classes
inv := new(17, 0)$Vector(Integer);

for i in 1.. for cl1 in classes repeat
    g1 := first(cl1)^(-1)
    for j in 1.. for cl2 in classes repeat
        if member?(g1, cl2) then
            inv(i) := j
            break

-- Auxiliary function to compute scalar product <f, f> of central function
-- f with itself.  Input
--  f      - function as vector of values corresponding to classes
--  inv    - table of inverses for classes
--  nlcl   - list of cardinalities of classes
skalar_product(f, inv, nlcl) ==
    n : Integer := 0
    s : pF := 0
    for i in 1..17 for k in nlcl repeat
        n := n + k
        s := s + f(i)*f(inv(i))*(k::pF)
    s/(n::pF)

-- Auxiliary function to normalize eigenvectors so that <f, f>  = 1 and
-- value at e is positive.  Input
--   le      - list of eigenvectors
--   inv     - table of inverses
--   nlcl    - list of cardinalities of classes
normalize_vectors(le, inv, nlcl) ==
    res := []$List(Vector(pF))
    il := parts(inv)
    -- needed for computation of roots
    g := primitiveElement()$pF
    for ev in le repeat
        sp := skalar_product(ev, inv, nlcl)
        k1 := discreteLog(sp)
        odd?(k1) => error "sp always is a square"
        a1 := g^(-(k1 quo 2))
        n := ev(1)*a1
        -- We choose root so that value at e is positive, that is less than p/2.  Since values are much
        -- smaller than that we can use 700 in test below.
        if (n::Integer) > 700 then a1 := -a1
        ev1 := ev*a1
        res := cons(vector([ev1(k) for k in il])$Vector(pF), res)
    reverse!(res)

Here we get list of characters

)set output tex off
 

)set output algebra on

lch := normalize_vectors(le, inv, nlcl);

Compiling function skalar_product with type (Vector(PrimeField(1459)
      ), Vector(Integer), List(NonNegativeInteger)) -> PrimeField(1459)

Compiling function normalize_vectors with type (List(Vector(
      PrimeField(1459))), Vector(Integer), List(NonNegativeInteger))
       -> List(Vector(PrimeField(1459)))

lch

   (31)
   [[3, 0, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 0, 439, 0, 1017, 3],
    [1, 339, 339, 1, 1119, 1, 1119, 1119, 1119, 339, 1, 339, 339, 1, 1119, 1, 1]
     ,
    [1, 1119, 1, 1119, 1, 1, 1119, 1, 339, 1, 339, 1, 339, 1, 1, 1, 1],
    [3, 0, 679, 0, 780, 1017, 0, 341, 0, 1118, 0, 1121, 0, 0, 338, 0, 439],
    [1, 1, 1119, 339, 339, 1, 1119, 339, 1, 1119, 1119, 1119, 339, 1, 339, 1, 1]
     ,
    [1, 1, 339, 1119, 1119, 1, 339, 1119, 1, 339, 339, 339, 1119, 1, 1119, 1, 1]
     ,
    [1, 339, 1119, 1119, 339, 1, 1, 339, 1119, 1119, 339, 1119, 1, 1, 339, 1, 1]
     ,
    [1, 339, 1, 339, 1, 1, 339, 1, 1119, 1, 1119, 1, 1119, 1, 1, 1, 1],
    [3, 0, 1118, 0, 338, 1017, 0, 780, 0, 1121, 0, 679, 0, 0, 341, 0, 439],
    [1, 1119, 1119, 1, 339, 1, 339, 339, 339, 1119, 1, 1119, 1119, 1, 339, 1, 1]
     ,
    [1, 1119, 339, 339, 1119, 1, 1, 1119, 339, 339, 1119, 339, 1, 1, 1119, 1, 1]
     ,
    [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1],
    [3, 0, 780, 0, 679, 439, 0, 1121, 0, 338, 0, 341, 0, 0, 1118, 0, 1017],
    [3, 0, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 0, 1017, 0, 439, 3],
    [3, 0, 1121, 0, 341, 1017, 0, 338, 0, 679, 0, 1118, 0, 0, 780, 0, 439],
    [3, 0, 341, 0, 1121, 439, 0, 1118, 0, 780, 0, 338, 0, 0, 679, 0, 1017],
    [3, 0, 338, 0, 1118, 439, 0, 679, 0, 341, 0, 780, 0, 0, 1121, 0, 1017]]

-- Check that squares of dimensions sum to correct value
reduce(_+, [ch(1)^2 for ch in lch])

   (32)  81

Comment: Using characters over finite field we could also compute values of characters over complex numbers, but we stop here.