# 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> 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 ] ] )```

GAP 3.4.4
April 1997