50.36 OrthogonalEmbeddings

OrthogonalEmbeddings( G [, "positive" ] [, maxdim ] )

computes all possible orthogonal embeddings of a lattice given by its Gram matrix G which must be a regular matrix (see LLLReducedGramMat). In other words, all solutions X of the problem

[ X^tr X = G ]

are calculated (see~Ple90). Usually there are many solutions X but all their rows are chosen from a small set of vectors, so OrthogonalEmbeddings returns the solutions in an encoded form, namely as a record with components

vectors:

the list [ x_1, x_2, ldots, x_n ] of vectors that may be rows of a solution; these are exactly those vectors that fulfill the condition x_i G^{-1} x_{i}^{tr} leq 1 (see ShortestVectors), and we have G = sum^n_{i=1} x_i^{tr} x_i,

norms:

the list of values x_i G^{-1}x_i^{tr}, and

solutions:

a list S of lists; the i--th solution matrix is Sublist( L, S[i] ), so the dimension of the i--th solution is the length of S[i].

The optional argument "positive" will cause OrthogonalEmbeddings to compute only vectors x_i with nonnegative entries. In the context of characters this is allowed (and useful) if G is the matrix of scalar products of ordinary characters.

When OrthogonalEmbeddings is called with the optional argument maxdim (a positive integer), it computes only solutions up to dimension maxdim; this will accelerate the algorithm in some cases.

G may be the matrix of scalar products of some virtual characters. From the characters and the embedding given by the matrix X, Decreased (see Decreased) may be able to compute irreducibles.

    gap> b := [ [  3, -1, -1 ], [ -1,  3, -1 ], [ -1, -1,  3 ] ];;
    gap> c:=OrthogonalEmbeddings(b);
    rec(
      vectors :=
       [ [ -1, 1, 1 ], [ 1, -1, 1 ], [ -1, -1, 1 ], [ -1, 1, 0 ],
          [ -1, 0, 1 ], [ 1, 0, 0 ], [ 0, -1, 1 ], [ 0, 1, 0 ],
          [ 0, 0, 1 ] ],
      norms := [ 1, 1, 1, 1/2, 1/2, 1/2, 1/2, 1/2, 1/2 ],
      solutions := [ [ 1, 2, 3 ], [ 1, 6, 6, 7, 7 ], [ 2, 5, 5, 8, 8 ],
          [ 3, 4, 4, 9, 9 ], [ 4, 5, 6, 7, 8, 9 ] ] )
    gap> Sublist( c.vectors, c.solutions[1] );
    [ [ -1, 1, 1 ], [ 1, -1, 1 ], [ -1, -1, 1 ] ]

OrthogonalEmbeddingsSpecialDimension ( tbl, reducibles, grammat [, "positive" ], dim )

This form can be used if you want to find irreducible characters of the table tbl, where reducibles is a list of virtual characters, grammat is the matrix of their scalar products, and dim is the maximal dimension of an embedding. First all solutions up to dim are compute, and then Decreased Decreased is called in order to find irreducible characters of tab.

If reducibles consists of ordinary characters only, you should enter the optional argument "positive"; this imposes some conditions on the possible embeddings (see the description of OrthogonalEmbeddings).

OrthogonalEmbeddingsSpecialDimension returns a record with components

irreducibles:

a list of found irreducibles, the intersection of all lists of irreducibles found by Decreased, for all possible embeddings, and

remainders:

a list of remaining reducible virtual characters

    gap> s6:= CharTable( "Symmetric", 6 );;
    gap> b:= InducedCyclic( s6, "all" );;
    gap> Add( b, [1,1,1,1,1,1,1,1,1,1,1] );
    gap> c:= LLL( s6, b ).remainders;;
    gap> g:= MatScalarProducts( s6, c, c );;
    gap> d:= OrthogonalEmbeddingsSpecialDimension( s6, c, g, 8 );
    rec(
      irreducibles :=
       [ [ 5, -3, 1, 1, 2, 0, -1, -1, -1, 0, 1 ], [ 5, 1, 1, -3, -1, 1,
              2, -1, -1, 0, 0 ], [ 10, -2, -2, 2, 1, 1, 1, 0, 0, 0, -1 ],
          [ 10, 2, -2, -2, 1, -1, 1, 0, 0, 0, 1 ] ],
      remainders :=
       [ [ 0, 4, 0, -4, 3, 1, -3, 0, 0, 0, -1 ], [ 4, 0, 0, 4, -2, 0, 1,
              -2, 2, -1, 1 ], [ 6, 2, 2, -2, 3, -1, 0, 0, 0, 1, -2 ],
          [ 14, 6, 2, 2, 2, 0, -1, 0, 0, -1, -1 ] ] )

Previous Up Top Next
Index