Welcome To Our Shell

Mister Spy & Souheyl Bypass Shell

  
  25 Integral matrices and lattices
  
  
  25.1 Linear equations over the integers and Integral Matrices
  
  25.1-1 NullspaceIntMat
  
  NullspaceIntMat( mat )  attribute
  
  If  mat  is  a matrix with integral entries, this function returns a list of
  vectors  that forms a basis of the integral nullspace of mat, i.e., of those
  vectors in the nullspace of mat that have integral entries.
  
    Example  
    gap> mat:=[[1,2,7],[4,5,6],[7,8,9],[10,11,19],[5,7,12]];;
    gap> NullspaceMat(mat);   
    [ [ -7/4, 9/2, -15/4, 1, 0 ], [ -3/4, -3/2, 1/4, 0, 1 ] ]
    gap> NullspaceIntMat(mat);                              
    [ [ 1, 18, -9, 2, -6 ], [ 0, 24, -13, 3, -7 ] ]
  
  
  25.1-2 SolutionIntMat
  
  SolutionIntMat( mat, vec )  operation
  
  If  mat  is  a  matrix  with integral entries and vec a vector with integral
  entries,  this  function  returns  a vector x with integer entries that is a
  solution  of  the  equation x * mat = vec. It returns fail if no such vector
  exists.
  
    Example  
    gap> mat:=[[1,2,7],[4,5,6],[7,8,9],[10,11,19],[5,7,12]];;
    gap> SolutionMat(mat,[95,115,182]);
    [ 47/4, -17/2, 67/4, 0, 0 ]
    gap> SolutionIntMat(mat,[95,115,182]);   
    [ 2285, -5854, 4888, -1299, 0 ]
  
  
  25.1-3 SolutionNullspaceIntMat
  
  SolutionNullspaceIntMat( mat, vec )  operation
  
  This function returns a list of length two, its first entry being the result
  of  a  call  to  SolutionIntMat (25.1-2) with same arguments, the second the
  result   of   NullspaceIntMat  (25.1-1)  applied  to  the  matrix  mat.  The
  calculation is performed faster than if two separate calls would be used.
  
    Example  
    gap> mat:=[[1,2,7],[4,5,6],[7,8,9],[10,11,19],[5,7,12]];;
    gap> SolutionNullspaceIntMat(mat,[95,115,182]);
    [ [ 2285, -5854, 4888, -1299, 0 ], 
      [ [ 1, 18, -9, 2, -6 ], [ 0, 24, -13, 3, -7 ] ] ]
  
  
  25.1-4 BaseIntMat
  
  BaseIntMat( mat )  attribute
  
  If  mat  is  a matrix with integral entries, this function returns a list of
  vectors that forms a basis of the integral row space of mat, i.e. of the set
  of integral linear combinations of the rows of mat.
  
    Example  
    gap> mat:=[[1,2,7],[4,5,6],[10,11,19]];;
    gap> BaseIntMat(mat);                  
    [ [ 1, 2, 7 ], [ 0, 3, 7 ], [ 0, 0, 15 ] ]
  
  
  25.1-5 BaseIntersectionIntMats
  
  BaseIntersectionIntMats( m, n )  operation
  
  If  m and n are matrices with integral entries, this function returns a list
  of vectors that forms a basis of the intersection of the integral row spaces
  of m and n.
  
    Example  
    gap> nat:=[[5,7,2],[4,2,5],[7,1,4]];;
    gap> BaseIntMat(nat);
    [ [ 1, 1, 15 ], [ 0, 2, 55 ], [ 0, 0, 64 ] ]
    gap> BaseIntersectionIntMats(mat,nat);
    [ [ 1, 5, 509 ], [ 0, 6, 869 ], [ 0, 0, 960 ] ]
  
  
  25.1-6 ComplementIntMat
  
  ComplementIntMat( full, sub )  operation
  
  Let  full  be  a list of integer vectors generating an integral row module M
  and  sub  a  list  of  vectors  defining  a  submodule S of M. This function
  computes a free basis for M that extends S. I.e., if the dimension of S is n
  it determines a basis B = { b_1, ..., b_m } for M, as well as n integers x_i
  such that the n vectors s_i:= x_i ⋅ b_i form a basis for S.
  
  It returns a record with the following components:
  
  complement
        the vectors b_{n+1} up to b_m (they generate a complement to S).
  
  sub
        the vectors s_i (a basis for S).
  
  moduli
        the factors x_i.
  
    Example  
    gap> m:=IdentityMat(3);;
    gap> n:=[[1,2,3],[4,5,6]];;
    gap> ComplementIntMat(m,n);
    rec( complement := [ [ 0, 0, 1 ] ], moduli := [ 1, 3 ], 
      sub := [ [ 1, 2, 3 ], [ 0, 3, 6 ] ] )
  
  
  
  25.2 Normal Forms over the Integers
  
  This  section describes the computation of the Hermite and Smith normal form
  of integer matrices.
  
  The  Hermite  Normal Form (HNF) H of an integer matrix A is a row equivalent
  upper  triangular form such that all off-diagonal entries are reduced modulo
  the  diagonal  entry  of  the  column  they  are  in.  There exists a unique
  unimodular matrix Q such that Q A = H.
  
  The  Smith  Normal  Form  S  of an integer matrix A is the unique equivalent
  diagonal  form  with  S_i  dividing  S_j  for  i < j. There exist unimodular
  integer matrices P, Q such that P A Q = S.
  
  All  routines  described  in  this  section  build  on the workhorse routine
  NormalFormIntMat (25.2-9).
  
  25.2-1 TriangulizedIntegerMat
  
  TriangulizedIntegerMat( mat )  operation
  
  Computes  an  upper  triangular  form  of  a matrix with integer entries. It
  returns a mutable matrix in upper triangular form.
  
  25.2-2 TriangulizedIntegerMatTransform
  
  TriangulizedIntegerMatTransform( mat )  operation
  
  Computes  an  upper  triangular  form  of  a matrix with integer entries. It
  returns  a  record  with  a  component  normal (an immutable matrix in upper
  triangular  form)  and  a  component rowtrans that gives the transformations
  done to the original matrix to bring it into upper triangular form.
  
  25.2-3 TriangulizeIntegerMat
  
  TriangulizeIntegerMat( mat )  operation
  
  Changes  mat to be in upper triangular form. (The result is the same as that
  of  TriangulizedIntegerMat  (25.2-1),  but  mat will be modified, thus using
  less memory.) If mat is immutable an error will be triggered.
  
    Example  
    gap> m:=[[1,15,28],[4,5,6],[7,8,9]];;
    gap> TriangulizedIntegerMat(m);
    [ [ 1, 15, 28 ], [ 0, 1, 1 ], [ 0, 0, 3 ] ]
    gap> n:=TriangulizedIntegerMatTransform(m);
    rec( normal := [ [ 1, 15, 28 ], [ 0, 1, 1 ], [ 0, 0, 3 ] ], 
      rank := 3, rowC := [ [ 1, 0, 0 ], [ 0, 1, 0 ], [ 0, 0, 1 ] ], 
      rowQ := [ [ 1, 0, 0 ], [ 1, -30, 17 ], [ -3, 97, -55 ] ], 
      rowtrans := [ [ 1, 0, 0 ], [ 1, -30, 17 ], [ -3, 97, -55 ] ], 
      signdet := 1 )
    gap> n.rowtrans*m=n.normal;
    true
    gap> TriangulizeIntegerMat(m); m;
    [ [ 1, 15, 28 ], [ 0, 1, 1 ], [ 0, 0, 3 ] ]
  
  
  25.2-4 HermiteNormalFormIntegerMat
  
  HermiteNormalFormIntegerMat( mat )  operation
  
  This operation computes the Hermite normal form of a matrix mat with integer
  entries. It returns a immutable matrix in HNF.
  
  25.2-5 HermiteNormalFormIntegerMatTransform
  
  HermiteNormalFormIntegerMatTransform( mat )  operation
  
  This operation computes the Hermite normal form of a matrix mat with integer
  entries.  It  returns  a  record  with  components  normal  (a matrix H) and
  rowtrans (a matrix Q) such that Q A = H.
  
    Example  
    gap> m:=[[1,15,28],[4,5,6],[7,8,9]];;
    gap> HermiteNormalFormIntegerMat(m);          
    [ [ 1, 0, 1 ], [ 0, 1, 1 ], [ 0, 0, 3 ] ]
    gap> n:=HermiteNormalFormIntegerMatTransform(m);
    rec( normal := [ [ 1, 0, 1 ], [ 0, 1, 1 ], [ 0, 0, 3 ] ], rank := 3, 
      rowC := [ [ 1, 0, 0 ], [ 0, 1, 0 ], [ 0, 0, 1 ] ], 
      rowQ := [ [ -2, 62, -35 ], [ 1, -30, 17 ], [ -3, 97, -55 ] ], 
      rowtrans := [ [ -2, 62, -35 ], [ 1, -30, 17 ], [ -3, 97, -55 ] ], 
      signdet := 1 )
    gap> n.rowtrans*m=n.normal;
    true
  
  
  25.2-6 SmithNormalFormIntegerMat
  
  SmithNormalFormIntegerMat( mat )  operation
  
  This  operation  computes the Smith normal form of a matrix mat with integer
  entries. It returns a new immutable matrix in the Smith normal form.
  
  25.2-7 SmithNormalFormIntegerMatTransforms
  
  SmithNormalFormIntegerMatTransforms( mat )  operation
  
  This  operation  computes the Smith normal form of a matrix mat with integer
  entries.  It  returns a record with components normal (a matrix S), rowtrans
  (a matrix P), and coltrans (a matrix Q) such that P A Q = S.
  
  25.2-8 DiagonalizeIntMat
  
  DiagonalizeIntMat( mat )  function
  
  This  function  changes  mat  to its SNF. (The result is the same as that of
  SmithNormalFormIntegerMat  (25.2-6),  but  mat  will be modified, thus using
  less memory.) If mat is immutable an error will be triggered.
  
    Example  
    gap> m:=[[1,15,28],[4,5,6],[7,8,9]];;
    gap> SmithNormalFormIntegerMat(m);          
    [ [ 1, 0, 0 ], [ 0, 1, 0 ], [ 0, 0, 3 ] ]
    gap> n:=SmithNormalFormIntegerMatTransforms(m);  
    rec( colC := [ [ 1, 0, 0 ], [ 0, 1, 0 ], [ 0, 0, 1 ] ], 
      colQ := [ [ 1, 0, -1 ], [ 0, 1, -1 ], [ 0, 0, 1 ] ], 
      coltrans := [ [ 1, 0, -1 ], [ 0, 1, -1 ], [ 0, 0, 1 ] ], 
      normal := [ [ 1, 0, 0 ], [ 0, 1, 0 ], [ 0, 0, 3 ] ], rank := 3, 
      rowC := [ [ 1, 0, 0 ], [ 0, 1, 0 ], [ 0, 0, 1 ] ], 
      rowQ := [ [ -2, 62, -35 ], [ 1, -30, 17 ], [ -3, 97, -55 ] ], 
      rowtrans := [ [ -2, 62, -35 ], [ 1, -30, 17 ], [ -3, 97, -55 ] ], 
      signdet := 1 )
    gap> n.rowtrans*m*n.coltrans=n.normal;
    true
    gap> DiagonalizeIntMat(m);m;
    [ [ 1, 0, 0 ], [ 0, 1, 0 ], [ 0, 0, 3 ] ]
  
  
  25.2-9 NormalFormIntMat
  
  NormalFormIntMat( mat, options )  function
  
  This  general  operation for computation of various Normal Forms is probably
  the most efficient.
  
  Options bit values:
  
  0/1
        Triangular Form / Smith Normal Form.
  
  2
        Reduce off diagonal entries.
  
  4
        Row Transformations.
  
  8
        Col Transformations.
  
  16
        Destructive (the original matrix may be destroyed)
  
  Compute  a  Triangular,  Hermite  or  Smith  form of the n × m integer input
  matrix  A.  Optionally,  compute  n  ×  n  and m × m unimodular transforming
  matrices Q, P which satisfy Q A = H or Q A P = S.
  
  Note  option  is a value ranging from 0 to 15 but not all options make sense
  (e.g.,  reducing  off diagonal entries with SNF option selected already). If
  an option makes no sense it is ignored.
  
  Returns  a  record with component normal containing the computed normal form
  and  optional  components rowtrans and/or coltrans which hold the respective
  transformation matrix. Also in the record are components holding the sign of
  the determinant, signdet, and the rank of the matrix, rank.
  
    Example  
    gap> m:=[[1,15,28],[4,5,6],[7,8,9]];;
    gap> NormalFormIntMat(m,0);  # Triangular, no transforms
    rec( normal := [ [ 1, 15, 28 ], [ 0, 1, 1 ], [ 0, 0, 3 ] ], 
      rank := 3, signdet := 1 )
    gap> NormalFormIntMat(m,6);  # Hermite Normal Form with row transforms
    rec( normal := [ [ 1, 0, 1 ], [ 0, 1, 1 ], [ 0, 0, 3 ] ], rank := 3, 
      rowC := [ [ 1, 0, 0 ], [ 0, 1, 0 ], [ 0, 0, 1 ] ], 
      rowQ := [ [ -2, 62, -35 ], [ 1, -30, 17 ], [ -3, 97, -55 ] ], 
      rowtrans := [ [ -2, 62, -35 ], [ 1, -30, 17 ], [ -3, 97, -55 ] ], 
      signdet := 1 )
    gap> NormalFormIntMat(m,13); # Smith Normal Form with both transforms
    rec( colC := [ [ 1, 0, 0 ], [ 0, 1, 0 ], [ 0, 0, 1 ] ], 
      colQ := [ [ 1, 0, -1 ], [ 0, 1, -1 ], [ 0, 0, 1 ] ], 
      coltrans := [ [ 1, 0, -1 ], [ 0, 1, -1 ], [ 0, 0, 1 ] ], 
      normal := [ [ 1, 0, 0 ], [ 0, 1, 0 ], [ 0, 0, 3 ] ], rank := 3, 
      rowC := [ [ 1, 0, 0 ], [ 0, 1, 0 ], [ 0, 0, 1 ] ], 
      rowQ := [ [ -2, 62, -35 ], [ 1, -30, 17 ], [ -3, 97, -55 ] ], 
      rowtrans := [ [ -2, 62, -35 ], [ 1, -30, 17 ], [ -3, 97, -55 ] ], 
      signdet := 1 )
    gap> last.rowtrans*m*last.coltrans;
    [ [ 1, 0, 0 ], [ 0, 1, 0 ], [ 0, 0, 3 ] ]
  
  
  25.2-10 AbelianInvariantsOfList
  
  AbelianInvariantsOfList( list )  attribute
  
  Given  a  list  of  nonnegative integers, this routine returns a sorted list
  containing  the  prime power factors of the positive entries in the original
  list, as well as all zeroes of the original list.
  
    Example  
    gap> AbelianInvariantsOfList([4,6,2,0,12]);
    [ 0, 2, 2, 3, 3, 4, 4 ]
  
  
  
  25.3 Determinant of an integer matrix
  
  25.3-1 DeterminantIntMat
  
  DeterminantIntMat( mat )  function
  
  Computes  the  determinant  of  an integer matrix using the same strategy as
  NormalFormIntMat  (25.2-9).  This  method  is faster in general for matrices
  greater  than  20  ×  20  but  quite  a  lot slower for smaller matrices. It
  therefore  passes  the  work to the more general DeterminantMat (24.4-4) for
  these smaller matrices.
  
  
  25.4 Decompositions
  
  For  computing  the decomposition of a vector of integers into the rows of a
  matrix   of  integers,  with  integral  coefficients,  one  can  use  p-adic
  approximations, as follows.
  
  Let  A  be  a square integral matrix, and p an odd prime. The reduction of A
  modulo  p  is  overlineA, its entries are chosen in the interval [ -(p-1)/2,
  (p-1)/2  ].  If  overlineA is regular over the field with p elements, we can
  form  A'  =  overlineA^{-1}.  Now  we  consider the integral linear equation
  system  x  A  = b, i.e., we look for an integral solution x. Define b_0 = b,
  and then iteratively compute
  
  
  x_i = (b_i A') mod p, b_{i+1} = (b_i - x_i A) / p, i = 0, 1, 2, ... .
  
  By induction, we get
  
  
  p^{i+1} b_{i+1} + ( ∑_{j = 0}^i p^j x_j ) A = b.
  
  If  there is an integral solution x then it is unique, and there is an index
  l such that b_{l+1} is zero and x = ∑_{j = 0}^l p^j x_j.
  
  There  are  two  useful  generalizations  of this idea. First, A need not be
  square; it is only necessary that there is a square regular matrix formed by
  a  subset  of  columns  of  A.  Second,  A does not need to be integral; the
  entries  may  be  cyclotomic  integers as well, in this case one can replace
  each  column  of  A  by  the  columns  formed  by the coefficients w.r.t. an
  integral  basis  (which  are integers). Note that this preprocessing must be
  performed compatibly for A and b.
  
  GAP    provides    the   following   functions   for   this   purpose   (see
  also InverseMatMod (24.15-1)).
  
  25.4-1 Decomposition
  
  Decomposition( A, B, depth )  operation
  
  For  a  m  ×  n matrix A of cyclotomics that has rank m ≤ n, and a list B of
  cyclotomic  vectors,  each of length n, Decomposition tries to find integral
  solutions  of  the  linear  equation  systems x * A = B[i], by computing the
  p-adic series of hypothetical solutions.
  
  Decomposition( A, B, depth ), where depth is a nonnegative integer, computes
  for  each vector B[i] the initial part ∑_{k = 0}^depth x_k p^k, with all x_k
  vectors of integers with entries bounded by ± (p-1)/2. The prime p is set to
  83  first;  if  the  reduction  of A modulo p is singular, the next prime is
  chosen automatically.
  
  A  list  X  is  returned. If the computed initial part for x * A = B[i] is a
  solution, we have X[i] = x, otherwise X[i] = fail.
  
  If  depth  is  not  an  integer  then  it  must be the string "nonnegative".
  Decomposition(  A,  B,  "nonnegative" ) assumes that the solutions have only
  nonnegative  entries,  and  that  the first column of A consists of positive
  integers.  This  is  satisfied,  e.g.,  for  the  decomposition  of ordinary
  characters  into  Brauer characters. In this case the necessary number depth
  of  iterations  can be computed; the i-th entry of the returned list is fail
  if there exists no nonnegative integral solution of the system x * A = B[i],
  and it is the solution otherwise.
  
  Note that the result is a list of fail if A has not full rank, even if there
  might be a unique integral solution for some equation system.
  
  25.4-2 LinearIndependentColumns
  
  LinearIndependentColumns( mat )  function
  
  Called with a matrix mat, LinearIndependentColumns returns a maximal list of
  column  positions  such that the restriction of mat to these columns has the
  same rank as mat.
  
  25.4-3 PadicCoefficients
  
  PadicCoefficients( A, Amodpinv, b, prime, depth )  function
  
  Let A be an integral matrix, prime a prime integer, Amodpinv an inverse of A
  modulo  prime,  b  an  integral  vector,  and  depth  a nonnegative integer.
  PadicCoefficients  returns  the  list  [  x_0,  x_1,  ...,  x_l,  b_{l+1}  ]
  describing the prime-adic approximation of b (see above), where l = depth or
  l is minimal with the property that b_{l+1} = 0.
  
  25.4-4 IntegralizedMat
  
  IntegralizedMat( A[, inforec] )  function
  
  IntegralizedMat returns, for a matrix A of cyclotomics, a record intmat with
  components  mat and inforec. Each family of algebraic conjugate columns of A
  is  encoded  in  a  set  of  columns  of  the  rational matrix intmat.mat by
  replacing  cyclotomics  in A by their coefficients w.r.t. an integral basis.
  intmat.inforec  is  a  record  containing  the information how to encode the
  columns.
  
  If  the  only  argument is A, the value of the component inforec is computed
  that  can  be  entered  as  second  argument  inforec  in  a  later  call of
  IntegralizedMat with a matrix B that shall be encoded compatibly with A.
  
  25.4-5 DecompositionInt
  
  DecompositionInt( A, B, depth )  function
  
  DecompositionInt  does the same as Decomposition (25.4-1), except that A and
  B must be integral matrices, and depth must be a nonnegative integer.
  
  
  25.5 Lattice Reduction
  
  25.5-1 LLLReducedBasis
  
  LLLReducedBasis( [L, ]vectors[, y][, "linearcomb"][, lllout] )  function
  
  provides  an  implementation  of  the  LLL algorithm by Lenstra, Lenstra and
  Lovász  (see [LLJL82],  [Poh87]). The implementation follows the description
  in [Coh93, p. 94f.].
  
  LLLReducedBasis  returns  a  record  whose  component basis is a list of LLL
  reduced  linearly  independent vectors spanning the same lattice as the list
  vectors.  L  must  be  a lattice, with scalar product of the vectors v and w
  given  by  ScalarProduct(  L,  v,  w  ). If no lattice is specified then the
  scalar product of vectors given by ScalarProduct( v, w ) is used.
  
  In  the case of the option "linearcomb", the result record contains also the
  components   relations  and  transformation,  with  the  following  meaning.
  relations  is  a  basis of the relation space of vectors, i.e., of vectors x
  such  that  x  * vectors is zero. transformation gives the expression of the
  new lattice basis in terms of the old, i.e., transformation * vectors equals
  the basis component of the result.
  
  Another optional argument is y, the sensitivity of the algorithm, a rational
  number between 1/4 and 1 (the default value is 3/4).
  
  The optional argument lllout is a record with the components mue and B, both
  lists of length k, with the meaning that if lllout is present then the first
  k vectors in vectors form an LLL reduced basis of the lattice they generate,
  and  lllout.mue  and  lllout.B  contain their scalar products and norms used
  internally  in  the  algorithm,  which  are  also  present  in the output of
  LLLReducedBasis.   So   lllout   can   be  used  for  incremental  calls  of
  LLLReducedBasis.
  
  The function LLLReducedGramMat (25.5-2) computes an LLL reduced Gram matrix.
  
    Example  
    gap> vectors:= [ [ 9, 1, 0, -1, -1 ], [ 15, -1, 0, 0, 0 ],
    >                [ 16, 0, 1, 1, 1 ], [ 20, 0, -1, 0, 0 ],
    >                [ 25, 1, 1, 0, 0 ] ];;
    gap> LLLReducedBasis( vectors, "linearcomb" );
    rec( B := [ 5, 36/5, 12, 50/3 ], 
      basis := [ [ 1, 1, 1, 1, 1 ], [ 1, 1, -2, 1, 1 ], 
          [ -1, 3, -1, -1, -1 ], [ -3, 1, 0, 2, 2 ] ], 
      mue := [ [  ], [ 2/5 ], [ -1/5, 1/3 ], [ 2/5, 1/6, 1/6 ] ], 
      relations := [ [ -1, 0, -1, 0, 1 ] ], 
      transformation := [ [ 0, -1, 1, 0, 0 ], [ -1, -2, 0, 2, 0 ], 
          [ 1, -2, 0, 1, 0 ], [ -1, -2, 1, 1, 0 ] ] )
  
  
  25.5-2 LLLReducedGramMat
  
  LLLReducedGramMat( G[, y] )  function
  
  LLLReducedGramMat  provides  an  implementation  of  the  LLL  algorithm  by
  Lenstra,  Lenstra  and  Lovász  (see [LLJL82], [Poh87]).  The implementation
  follows the description in [Coh93, p. 94f.].
  
  Let  G  the Gram matrix of the vectors (b_1, b_2, ..., b_n); this means G is
  either  a  square  symmetric  matrix  or  lower  triangular matrix (only the
  entries in the lower triangular half are used by the program).
  
  LLLReducedGramMat  returns  a  record  whose component remainder is the Gram
  matrix  of the LLL reduced basis corresponding to (b_1, b_2, ..., b_n). If G
  is a lower triangular matrix then also the remainder component of the result
  record is a lower triangular matrix.
  
  The result record contains also the components relations and transformation,
  which have the following meaning.
  
  relations  is a basis of the space of vectors (x_1, x_2, ..., x_n) such that
  ∑_{i  = 1}^n x_i b_i is zero, and transformation gives the expression of the
  new  lattice basis in terms of the old, i.e., transformation is the matrix T
  such that T ⋅ G ⋅ T^tr is the remainder component of the result.
  
  The optional argument y denotes the sensitivity of the algorithm, it must be
  a rational number between 1/4 and 1; the default value is y = 3/4.
  
  The function LLLReducedBasis (25.5-1) computes an LLL reduced basis.
  
    Example  
    gap> g:= [ [ 4, 6, 5, 2, 2 ], [ 6, 13, 7, 4, 4 ],
    >    [ 5, 7, 11, 2, 0 ], [ 2, 4, 2, 8, 4 ], [ 2, 4, 0, 4, 8 ] ];;
    gap> LLLReducedGramMat( g );
    rec( B := [ 4, 4, 75/16, 168/25, 32/7 ], 
      mue := [ [  ], [ 1/2 ], [ 1/4, -1/8 ], [ 1/2, 1/4, -2/25 ], 
          [ -1/4, 1/8, 37/75, 8/21 ] ], relations := [  ], 
      remainder := [ [ 4, 2, 1, 2, -1 ], [ 2, 5, 0, 2, 0 ], 
          [ 1, 0, 5, 0, 2 ], [ 2, 2, 0, 8, 2 ], [ -1, 0, 2, 2, 7 ] ], 
      transformation := [ [ 1, 0, 0, 0, 0 ], [ -1, 1, 0, 0, 0 ], 
          [ -1, 0, 1, 0, 0 ], [ 0, 0, 0, 1, 0 ], [ -2, 0, 1, 0, 1 ] ] )
  
  
  
  25.6 Orthogonal Embeddings
  
  25.6-1 OrthogonalEmbeddings
  
  OrthogonalEmbeddings( gram[, "positive"][, maxdim] )  function
  
  computes  all  possible orthogonal embeddings of a lattice given by its Gram
  matrix  gram, which must be a regular symmetric matrix of integers. In other
  words,  all  integral  solutions  X  of  the  equation  X^tr  ⋅  X =gram are
  calculated. The implementation follows the description in [Ple95].
  
  Usually  there are many solutions X but all their rows belong to a small set
  of  vectors,  so  OrthogonalEmbeddings  returns  the  solutions encoded by a
  record with the following components.
  
  vectors
        the  list  L = [ x_1, x_2, ..., x_n ] of vectors that may be rows of a
        solution,  up to sign; these are exactly the vectors with the property
        x_i ⋅gram^{-1} ⋅ x_i^tr ≤ 1, see ShortestVectors (25.6-2),
  
  norms
        the list of values x_i ⋅gram^{-1} ⋅ x_i^tr, and
  
  solutions
        a list S of index lists; the i-th solution matrix is L{ S[i] }, so the
        dimension  of  the  i-th  solution  is the length of S[i], and we have
        gram= ∑_{j ∈ S[i]} x_j^tr ⋅ x_j,
  
  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 gram is the matrix of scalar products of ordinary
  characters.
  
  When  OrthogonalEmbeddings  is  called  with the optional argument maxdim (a
  positive  integer), only solutions up to dimension maxdim are computed; this
  may accelerate the algorithm.
  
    Example  
    gap> b:= [ [ 3, -1, -1 ], [ -1, 3, -1 ], [ -1, -1, 3 ] ];;
    gap> c:=OrthogonalEmbeddings( b );
    rec( 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 ] ],
      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 ] ] )
    gap> c.vectors{ c.solutions[1] };
    [ [ -1, 1, 1 ], [ 1, -1, 1 ], [ -1, -1, 1 ] ]
  
  
  gram  may  be the matrix of scalar products of some virtual characters. From
  the  characters and the embedding given by the matrix X, Decreased (72.10-7)
  may be able to compute irreducibles.
  
  25.6-2 ShortestVectors
  
  ShortestVectors( G, m[, "positive"] )  function
  
  Let  G be a regular matrix of a symmetric bilinear form, and m a nonnegative
  integer.  ShortestVectors computes the vectors x that satisfy x ⋅ G ⋅ x^tr ≤
  m,  and returns a record describing these vectors. The result record has the
  components
  
  vectors
        list of the nonzero vectors x, but only one of each pair (x,-x),
  
  norms
        list of norms of the vectors according to the Gram matrix G.
  
  If  the  optional  argument "positive" is entered, only those vectors x with
  nonnegative entries are computed.
  
    Example  
    gap> g:= [ [ 2, 1, 1 ], [ 1, 2, 1 ], [ 1, 1, 2 ] ];;  
    gap> ShortestVectors(g,4);
    rec( norms := [ 4, 2, 2, 4, 2, 4, 2, 2, 2 ], 
      vectors := [ [ -1, 1, 1 ], [ 0, 0, 1 ], [ -1, 0, 1 ], [ 1, -1, 1 ], 
          [ 0, -1, 1 ], [ -1, -1, 1 ], [ 0, 1, 0 ], [ -1, 1, 0 ], 
          [ 1, 0, 0 ] ] )