SSL algebra.gi Sprache: unbekannt

#############################################################################
##
## This file is part of GAP, a system for computational discrete algebra.
## This file's authors include Thomas Breuer, and Willem de Graaf.
##
## Copyright of GAP belongs to its developers, whose names are too numerous
## to list here. Please refer to the COPYRIGHT file for details.
##
## SPDX-License-Identifier: GPL-2.0-or-later
##
## This file contains generic methods for algebras and algebras-with-one.
##

#############################################################################
##
#M Representative( <A> ) . . . . . . . . one element of a left operator ring
##
InstallMethod( Representative,
 "for left operator ring with known generators",
 [ IsLeftOperatorRing and HasGeneratorsOfLeftOperatorRing ],
 RepresentativeFromGenerators( GeneratorsOfLeftOperatorRing ) );

#############################################################################
##
#M Representative( <A> ) . . . one element of a left operator ring-with-one
##
InstallMethod( Representative,
 "for left operator ring-with-one with known generators",
 [ IsLeftOperatorRingWithOne and HasGeneratorsOfLeftOperatorRingWithOne ],
 RepresentativeFromGenerators( GeneratorsOfLeftOperatorRingWithOne ) );

#############################################################################
##
#M FLMLORByGenerators( <R>, <gens> ) . . . . <R>-FLMLOR generated by <gens>
#M FLMLORByGenerators( <R>, <gens>, <zero> )
##
InstallMethod( FLMLORByGenerators,
 "for ring and collection",
 [ IsRing, IsCollection ],
 function( R, gens )
 local A;
 A:= Objectify( NewType( FamilyObj( gens ),
 IsFLMLOR and IsAttributeStoringRep ),
 rec() );
 SetLeftActingDomain( A, R );
 SetGeneratorsOfLeftOperatorRing( A, AsList( gens ) );

 CheckForHandlingByNiceBasis( R, gens, A, false );
 return A;
 end );

InstallOtherMethod( FLMLORByGenerators,
 "for ring, homogeneous list, and ring element",
 [ IsRing, IsHomogeneousList, IsRingElement ],
 function( R, gens, zero )
 local A;
 A:= Objectify( NewType( CollectionsFamily( FamilyObj( zero ) ),
 IsFLMLOR and IsAttributeStoringRep ),
 rec() );
 SetLeftActingDomain( A, R );
 SetGeneratorsOfLeftOperatorRing( A, gens );
 SetZero( A, zero );

 if IsEmpty( gens ) then
 SetDimension( A, 0 );
 SetGeneratorsOfLeftModule( A, gens );
 fi;

 CheckForHandlingByNiceBasis( R, gens, A, zero );
 return A;
 end );

#############################################################################
##
#M FLMLORWithOneByGenerators( <R>, <gens> ) unit. <R>-FLMLOR gen. by <gens>
#M FLMLORWithOneByGenerators( <R>, <gens>, <zero> )
##
InstallMethod( FLMLORWithOneByGenerators,
 "for ring and collection",
 [ IsRing, IsCollection ],
 function( R, gens )
 local A;
 A:= Objectify( NewType( FamilyObj( gens ),
 IsFLMLORWithOne and IsAttributeStoringRep ),
 rec() );
 SetLeftActingDomain( A, R );
 SetGeneratorsOfLeftOperatorRingWithOne( A, AsList( gens ) );

 CheckForHandlingByNiceBasis( R, gens, A, false );
 return A;
 end );

InstallOtherMethod( FLMLORWithOneByGenerators,
 "for ring, homogeneous list, and ring element",
 [ IsRing, IsHomogeneousList, IsRingElement ],
 function( R, gens, zero )
 local A;
 A:= Objectify( NewType( CollectionsFamily( FamilyObj( zero ) ),
 IsFLMLORWithOne and IsAttributeStoringRep ),
 rec() );
 SetLeftActingDomain( A, R );
 SetGeneratorsOfLeftOperatorRingWithOne( A, AsList( gens ) );
 SetZero( A, zero );

 CheckForHandlingByNiceBasis( R, gens, A, zero );
 return A;
 end );

#############################################################################
##
#F Algebra( <F>, <gens> )
#F Algebra( <F>, <gens>, <zero> )
#F Algebra( <F>, <gens>, "basis" )
#F Algebra( <F>, <gens>, <zero>, "basis" )
##
InstallGlobalFunction( FLMLOR, function( arg )
 local A;

 # ring and list of generators
 if Length( arg ) = 2 and IsRing( arg[1] )
 and IsList( arg[2] ) and 0 < Length( arg[2] ) then
 A:= FLMLORByGenerators( arg[1], arg[2] );

 # ring, list of generators plus zero
 elif Length( arg ) = 3 and IsRing( arg[1] )
 and IsList( arg[2] ) then
 if arg[3] = "basis" then
 A:= FLMLORByGenerators( arg[1], arg[2] );
 UseBasis( A, arg[2] );
 else
 A:= FLMLORByGenerators( arg[1], arg[2], arg[3] );
 fi;

 # ring, list of generators plus zero
 elif Length( arg ) = 4 and IsRing( arg[1] )
 and IsList( arg[2] )
 and arg[4] = "basis" then
 A:= FLMLORByGenerators( arg[1], arg[2], arg[3] );
 UseBasis( A, arg[2] );

 # no argument given, error
 else
 Error( "usage: FLMLOR( <F>, <gens> ), ",
 "FLMLOR( <F>, <gens>, <zero> )" );
 fi;

 # Return the result.
 return A;
end );

#############################################################################
##
#F Subalgebra( <A>, <gens> ) . . . . . subalgebra of <A> generated by <gens>
#F Subalgebra( <A>, <gens>, "basis" )
##
InstallGlobalFunction( SubFLMLOR, function( arg )
 local S;
 if Length( arg ) <= 1
 or not IsFLMLOR( arg[1] )
 or not IsHomogeneousList( arg[2] ) then
 Error( "first argument must be a FLMLOR,\n",
 "second argument must be a list of generators" );

 elif IsEmpty( arg[2] ) then

 return SubFLMLORNC( arg[1], arg[2] );

 elif IsIdenticalObj( FamilyObj( arg[1] ),
 FamilyObj( arg[2] ) )
 and ForAll( arg[2], v -> v in arg[1] ) then

 S:= FLMLORByGenerators( LeftActingDomain( arg[1] ), arg[2] );
 SetParent( S, arg[1] );
 if Length( arg ) = 3 and arg[3] = "basis" then
 UseBasis( S, arg[2] );
 fi;
 return S;

 fi;
 Error( "usage: SubFLMLOR( <V>, <gens> [, \"basis\"] )" );
end );

#############################################################################
##
#F SubalgebraNC( <A>, <gens>, "basis" )
#F SubalgebraNC( <A>, <gens> )
##
InstallGlobalFunction( SubFLMLORNC, function( arg )
 local S;
 if IsEmpty( arg[2] ) then
 S:= Objectify( NewType( FamilyObj( arg[1] ),
 IsFLMLOR
 and IsTrivial
 and IsTwoSidedIdealInParent
 and IsAttributeStoringRep ),
 rec() );
 SetDimension(S, 0);
 SetLeftActingDomain( S, LeftActingDomain( arg[1] ) );
 SetGeneratorsOfLeftModule( S, AsList( arg[2] ) );
 else
 S:= FLMLORByGenerators( LeftActingDomain( arg[1] ), arg[2] );
 fi;
 if Length( arg ) = 3 and arg[3] = "basis" then
 UseBasis( S, arg[2] );
 fi;
 SetParent( S, arg[1] );
 return S;
end );

#############################################################################
##
#F AlgebraWithOne( <F>, <gens> )
#F AlgebraWithOne( <F>, <gens>, <zero> )
#F AlgebraWithOne( <F>, <gens>, "basis" )
#F AlgebraWithOne( <F>, <gens>, <zero>, "basis" )
##
InstallGlobalFunction( FLMLORWithOne, function( arg )
 local A;

 # ring and list of generators
 if Length( arg ) = 2 and IsRing( arg[1] )
 and IsList( arg[2] ) and 0 < Length( arg[2] ) then
 A:= FLMLORWithOneByGenerators( arg[1], arg[2] );

 # ring, list of generators plus zero
 elif Length( arg ) = 3 and IsRing( arg[1] )
 and IsList( arg[2] ) then
 if arg[3] = "basis" then
 A:= FLMLORWithOneByGenerators( arg[1], arg[2] );
 UseBasis( A, arg[2] );
 else
 A:= FLMLORWithOneByGenerators( arg[1], arg[2], arg[3] );
 fi;

 # ring, list of generators plus zero
 elif Length( arg ) = 4 and IsRing( arg[1] )
 and IsList( arg[2] )
 and arg[4] = "basis" then
 A:= FLMLORWithOneByGenerators( arg[1], arg[2], arg[3] );
 UseBasis( A, arg[2] );

 # no argument given, error
 else
 Error( "usage: FLMLORWithOne( <F>, <gens> ), ",
 "FLMLORWithOne( <F>, <gens>, <zero> )" );
 fi;

 # Return the result.
 return A;
end );

#############################################################################
##
#F SubalgebraWithOne( <A>, <gens> ) subalg.-with-one of <A> gen. by <gens>
##
InstallGlobalFunction( SubFLMLORWithOne, function( arg )
 local S;
 if Length( arg ) <= 1 or not IsFLMLOR( arg[1] )
 or not IsHomogeneousList( arg[2] ) then

 Error( "first argument must be a FLMLOR,\n",
 "second argument must be a list of generators" );

 elif IsEmpty( arg[2] ) then

 return SubFLMLORWithOneNC( arg[2], arg[2] );

 elif IsIdenticalObj( FamilyObj( arg[1] ),
 FamilyObj( arg[2] ) )
 and ForAll( arg[2], v -> v in arg[1] )
 and ( IsFLMLORWithOne( arg[1] ) or One( arg[1] ) <> fail ) then
 S:= FLMLORWithOneByGenerators( LeftActingDomain( arg[1] ), arg[2] );
 SetParent( S, arg[1] );
 if Length( arg ) = 3 and arg[3] = "basis" then
 UseBasis( S, arg[2] );
 fi;
 return S;
 fi;
 Error( "usage: SubFLMLORWithOne( <V>, <gens> [, \"basis\"] )" );
end );

#############################################################################
##
#F SubalgebraWithOneNC( <A>, <gens> )
##
InstallGlobalFunction( SubFLMLORWithOneNC, function( arg )
 local S, gens;
 if IsEmpty( arg[2] ) then

 # Note that `S' is in general not trivial,
 # and if we call `Objectify' here then `S' does not get a special
 # representation (e.g., as a matrix algebra).
 # So the argument that special methods would catch this case
 # does not hold!
 gens:= [ One( arg[1] ) ];
 S:= FLMLORWithOneByGenerators( LeftActingDomain( arg[1] ), gens );
 UseBasis( S, gens );

 else

 S:= FLMLORWithOneByGenerators( LeftActingDomain( arg[1] ), arg[2] );
 if Length( arg ) = 3 and arg[3] = "basis" then
 UseBasis( S, arg[2] );
 fi;

 fi;

 SetParent( S, arg[1] );
 return S;
end );

#############################################################################
##
#M LieAlgebraByDomain( <A> )
##
## The Lie algebra of the associative algebra <A>
##
InstallMethod( LieAlgebraByDomain,
 "for an algebra",
 [ IsAlgebra ],
 function( A )
 local T, n, zero, nullvec, S, i, j, k, m, cfs, cij, cji;

 if not IsAssociative( A ) then TryNextMethod(); fi;

# We construct a structure constants table for the Lie algebra
# corresponding to <A>. If the structure constants of <A> are given by
# d_{ij}^k, then the structure constants of the Lie algebra will be given
# by d_{ij}^k - d_{ji}^k.

 T:= StructureConstantsTable( Basis( A ) );
 n:= Dimension( A );
 zero:= Zero( LeftActingDomain( A ) );
 nullvec:= List( [1..n], x -> zero );
 S:= EmptySCTable( n, zero, "antisymmetric" );
 for i in [1..n] do
 for j in [i+1..n] do
 cfs:= ShallowCopy( nullvec );
 cij:= T[i][j]; cji:= T[j][i];
 for m in [1..Length(cij[1])] do
 k:= cij[1][m];
 cfs[k]:= cfs[k] + cij[2][m];
 od;
 for m in [1..Length(cji[1])] do
 k:= cji[1][m];
 cfs[k]:= cfs[k] - cji[2][m];
 od;

 cij:= [ ];

 for m in [1..n] do
 if cfs[m] <> zero then
 Add( cij, cfs[m] );
 Add( cij, m );
 fi;
 od;
 SetEntrySCTable( S, i, j, cij );
 od;
 od;

 return LieAlgebraByStructureConstants( LeftActingDomain( A ), S );
 end );

#############################################################################
##
#F LieAlgebra( <A> )
#F LieAlgebra( <F>, <gens> )
#F LieAlgebra( <F>, <gens>, <zero> )
#F LieAlgebra( <F>, <gens>, "basis" )
#F LieAlgebra( <F>, <gens>, <zero>, "basis" )
##
InstallGlobalFunction( LieAlgebra, function( arg )
#T check that the families have the same characteristic?
#T `CharacteristicFamily' ?
 local A,gens;

 # In the case of one domain argument,
 # construct the isomorphic Lie algebra.
 if Length( arg ) = 1 and IsDomain( arg[1] ) then
 A:= LieAlgebraByDomain( arg[1] );

 # division ring and list of generators
 elif Length( arg ) >= 2 and IsList( arg[2] ) then

 gens:= List( arg[2], x -> LieObject( x ) );

 if Length( arg ) = 2 and IsDivisionRing( arg[1] )
 and 0 < Length( arg[2] ) then
 A:= AlgebraByGenerators( arg[1], gens );

 # division ring, list of generators plus zero
 elif Length( arg ) = 3 and IsDivisionRing( arg[1] ) then
 if arg[3] = "basis" then
 A:= AlgebraByGenerators( arg[1], gens );
 UseBasis( A, gens );
 else
 A:= AlgebraByGenerators( arg[1], gens, arg[3] );
 fi;

 # division ring, list of generators plus zero
 elif Length( arg ) = 4 and IsDivisionRing( arg[1] )
 and arg[4] = "basis" then
 A:= AlgebraByGenerators( arg[1], gens, arg[3] );
 UseBasis( A, gens );

 else
 Error( "usage: LieAlgebra( <F>, <gens> ), ",
 "LieAlgebra( <F>, <gens>, <zero> ), LieAlgebra( <D> )");

 fi;
 # no argument given, error
 else
 Error( "usage: LieAlgebra( <F>, <gens> ), ",
 "LieAlgebra( <F>, <gens>, <zero> ), LieAlgebra( <D> )");
 fi;

 # Return the result.
 return A;
end );

#############################################################################
##
#F EmptySCTable( <dim>, <zero> )
#F EmptySCTable( <dim>, <zero>, \"symmetric\" )
#F EmptySCTable( <dim>, <zero>, \"antisymmetric\" )
##
InstallGlobalFunction( EmptySCTable, function( arg )
 local dim, T, entry, i;

 if 2 <= Length( arg )
 and IsInt( arg[1] ) and IsZero( arg[2] )
 and ( Length( arg ) = 2 or IsString( arg[3] ) ) then

 dim:= arg[1];
 T:= [];
 entry:= Immutable( [ [], [] ] );
 for i in [ 1 .. dim ] do
 T[i]:= List( [ 1 .. dim ], x -> entry );
 od;

 # Store the symmetry flag.
 if Length( arg ) = 3 then
 if arg[3] = "symmetric" then
 Add( T, 1 );
 elif arg[3] = "antisymmetric" then
 Add( T, -1 );
 else
 Error("third argument must be \"symmetric\" or \"antisymmetric\"");
 fi;
 else
 Add( T, 0 );
 fi;

 # Store the zero coefficient.
 Add( T, arg[2] );

 else
 Error( "usage: EmptySCTable( <dim>, <zero> [,\"symmetric\"] )" );
 fi;

 return T;
end );

#############################################################################
##
#F SetEntrySCTable( <T>, , <j>, <list> )
##
InstallGlobalFunction( SetEntrySCTable, function( T, i, j, list )
 local range, zero, Fam, entry, k, val, pos;

 # Check that `i' and `j' are admissible.
 range:= [ 1 .. Length( T ) - 2 ];
 if not i in range then
 Error( " must lie in ", range );
 elif not j in range then
 Error( "<j> must lie in ", range );
 fi;

 # Check `list', and construct the table entry.
 zero:= Last(T);
 Fam:= FamilyObj( zero );
 entry:= [ [], [] ];
 for k in [ 1, 3 .. Length( list ) -1 ] do

 val:= list[k];
 pos:= list[k+1];

 # Check that `pos' is inside the table,
 # and that its entry is assigned only once.
 if not pos in range then
 Error( "list entry ", list[k+1], " must lie in ", range );
 elif pos in entry[1] then
 Error( "position ", pos, " must occur at most once in <list>" );
 fi;

 # Check that the coefficients either fit to the zero element
 # or are rationals (with suitable denominators).
 if FamilyObj( val ) = Fam then
 if val <> zero then
 Add( entry[1], pos );
 Add( entry[2], val );
 fi;
 elif IsRat( val ) then
 if val <> 0 then
 Add( entry[1], pos );
 Add( entry[2], val * One( zero ) );
 fi;
 else
 Error( "list entry ", list[k], " does not fit to zero element" );
 fi;

 od;

 # Set the table entry.
 SortParallel( entry[1], entry[2] );
 T[i][j]:= Immutable( entry );

 # Add the value `T[j][i]' in the case of (anti-)symmetric tables.
 if T[ Length(T) - 1 ] = 1 then
 T[j][i]:= T[i][j];
 elif T[ Length(T) - 1 ] = -1 then
 T[j][i]:= Immutable( [ entry[1], -entry[2] ] );
 fi;
end );

#############################################################################
##
#F ReducedSCTable( <T>, <one> )
##
InstallGlobalFunction( ReducedSCTable, function( T, one )
 local new, n, i, j, entry;

 new:= [];
 n:= Length( T ) - 2;

 # Reduce the entries.
 for i in [ 1 .. n ] do
 new[i]:= [];
 for j in [ 1 .. n ] do
 entry:= T[i][j];
 entry:= [ Immutable( entry[1] ), entry[2] * one ];
 MakeImmutable( entry );
 new[i][j]:= entry;
 od;
 od;

 # Store zero coefficient and symmetry flag.
 new[ n+1 ]:= T[ n+1 ];
 new[ n+2 ]:= T[ n+2 ] * one;

 # Return the immutable new table.
 MakeImmutable( new );
 return new;
end );

#############################################################################
##
#F GapInputSCTable( <T>, <varnam> )
##
InstallGlobalFunction( GapInputSCTable, function( T, varnam )
 local dim, str, lower, i, j, entry, k;

 # Initialize, and set the ranges for the loops.
 dim:= Length( T ) - 2;
 str:= Concatenation( varnam, ":= EmptySCTable( ",
 String( dim ), ", ", String( Last(T) ) );
 lower:= [ 1 .. dim ];
 if T[ dim+1 ] = 1 then
 Append( str, ", \"symmetric\"" );
 elif T[ dim+1 ] = -1 then
 Append( str, ", \"antisymmetric\"" );
 else
 lower:= ListWithIdenticalEntries( dim, 1 );
 fi;
 Append( str, " );\n" );

 # Fill up the table.
 for i in [ 1 .. dim ] do
 for j in [ lower[i] .. dim ] do
 entry:= T[i][j];
 if not IsEmpty( entry[1] ) then
 Append( str, "SetEntrySCTable( " );
 Append( str, varnam );
 Append( str, ", " );
 Append( str, String(i) );
 Append( str, ", " );
 Append( str, String(j) );
 Append( str, ", [" );
 for k in [ 1 .. Length( entry[1] )-1 ] do
 Append( str, String( entry[2][k] ) );
 Add( str, ',' );
 Append( str, String( entry[1][k] ) );
 Add( str, ',' );
 od;
 k:= Length( entry[1] );
 Append( str, String( entry[2][k] ) );
 Add( str, ',' );
 Append( str, String( entry[1][k] ) );
 Append( str, "] );\n" );
 fi;
 od;
 od;

 ConvertToStringRep( str );
 return str;
end );

#############################################################################
##
#F IdentityFromSCTable( <T> )
##
InstallGlobalFunction( IdentityFromSCTable, function( T )
 local n, # dimension of the underlying algebra
 equ, # equation system to solve
 zero, # zero of the field
 zerovec, # zero vector
 vec, # right hand side of the equation system
 one, # identity of the field
 i, j, k, # loop over rows of `equ'
 row, # one row of the equation system
 Tpos, #
 Tval, #
 p, #
 sol,
 sum;

 n:= Length( T ) - 2;
 zero:= T[ n+2 ];

 # If the table belongs to a trivial algebra,
 # the identity is equal to the zero.
 if n = 0 then
 return EmptyRowVector( FamilyObj( zero ) );
 fi;

 # Set up the equation system,
 # in row $i$ and column $(k-1)*n + j$ we have $c_{ijk}$.
 equ:= [];
 zerovec:= ListWithIdenticalEntries( n^2, zero );
 vec:= ShallowCopy( zerovec );
 one:= One( zero );

 for i in [ 1 .. n ] do
 row:= ShallowCopy( zerovec );
 for j in [ 1 .. n ] do
 Tpos:= T[i][j][1];
 Tval:= T[i][j][2];
 p:= (j-1)*n;
 for k in [ 1 .. Length( Tpos ) ] do
 row[ p + Tpos[k] ]:= Tval[k];
 od;
 od;
 Add( equ, row );
 vec[ (i-1)*n + i ]:= one;
 od;

 sol:= SolutionMat( equ, vec );

 # If we have a candidate and if the algebra is not known
 # to be commutative then check whether the candidate
 # acts trivially also from the right.
 if sol <> fail and T[ n+1 ] <> 1 then

 for j in [ 1 .. n ] do
 for k in [ 1 .. n ] do
 sum:= zero;
 for i in [ 1 .. n ] do
 Tpos:= T[j][i];
 p:= Position( Tpos[1], k );
#T cheaper !!!
 if p <> fail then
 sum:= sum + sol[i] * Tpos[2][p];
 fi;
 od;
 if ( j = k and sum <> one ) or ( j <> k and sum <> zero ) then
 return fail;
 fi;
 od;
 od;

 fi;

 # Return the result.
 return sol;
end );

#############################################################################
##
#F QuotientFromSCTable( <T>, <num>, <den> )
##
## We solve the equation system $<num> = x <den>$.
## If no solution exists, `fail' is returned.
##
## In terms of the basis $B$ with vectors $b_1, \ldots, b_n$ this means
## for $<num> = \sum_{i=1}^n a_i b_i$,
## $<den> = \sum_{i=1}^n c_i b_i$,
## $x = \sum_{i=1}^n x_i b_i$ that
## $a_k = \sum_{i,j} c_i x_j c_{ijk}$ for all $k$.
## Here $c_{ijk}$ denotes the structure constants w.r.t. $B$.
## This means $a = x M$ with $M_{ik} = \sum_{j=1}^n c_{ijk} c_j$.
##
InstallGlobalFunction( QuotientFromSCTable, function( T, x, c )
 local M, # matrix of the equation system
 n, # dimension of the algebra
 zero, # zero vector
 i, j, # loop variables
 row, # one row of `M'
 entry, #
 val; #

 M:= [];
 n:= Length( c );

 # If the algebra is zero dimensional,
 # the zero is also the identity and thus also its inverse.
 if n = 0 then
 return c;
 fi;

 zero:= ListWithIdenticalEntries( n, Last(T) );
 for i in [ 1 .. n ] do
 row:= ShallowCopy( zero );
 for j in [ 1 .. n ] do
 entry:= T[i][j];
 val:= c[j];
 row{ entry[1] }:= row{ entry[1] } + val * entry[2];
#T better!
 od;
 Add( M, row );
 od;

 # Return the quotient, or `fail'.
 return SolutionMat( M, x );
end );

#############################################################################
##
#F TestJacobi( <T> )
##
## We check whether for all $1 \leq m \leq n$ the equality
## $\sum_{l=1}^n c_{jkl} c_{ilm} + c_{kil} c_{jlm} + c_{ijl} c_{klm} = 0$
## holds.
##
InstallGlobalFunction( TestJacobi, function( T )
 local zero, # the zero of the field
 n, # dimension of the algebra
 i, j, k, m, # loop variables
 cij, cki, cjk, # structure constant vectors
 sum,
 t;

 zero:= Last(T);
 n:= Length( T ) - 2;

 for i in [ 1 .. n ] do
 for j in [ i+1 .. n ] do
 cij:= T[i][j];
 for k in [ j+1 .. n ] do
 cki:= T[k][i];
 cjk:= T[j][k];
 for m in [ 1 .. n ] do
 sum:= zero;
 for t in [ 1 .. Length( cjk[1] ) ] do
 sum:= sum + cjk[2][t] * SCTableEntry( T, i, cjk[1][t], m );
 od;
 for t in [ 1 .. Length( cki[1] ) ] do
 sum:= sum + cki[2][t] * SCTableEntry( T, j, cki[1][t], m );
 od;
 for t in [ 1 .. Length( cij[1] ) ] do
 sum:= sum + cij[2][t] * SCTableEntry( T, k, cij[1][t], m );
 od;
 if sum <> zero then
 return [ i, j, k ];
 fi;
 od;
 od;
 od;
 od;

 return true;
end );

#############################################################################
##
#M MultiplicativeNeutralElement( <A> )
##
## is the multiplicative neutral element of <A> if this exists,
## otherwise is `fail'.
##
## Let $(b_1, b_2, \ldots, b_n)$ be a basis of $A$, and $e$ the result of
## `MultiplicativeNeutralElement( <A> )'.
## Then $e = \sum_{i=1}^n a_i b_i$, and for $1 \leq k \leq n$ we have
## $e \cdot b_j = b_j$, or equivalently
## $\sum_{i=1}^n a_i b_i \cdot b_j = b_j$.
## Define the structure constants by
## $b_i \cdot b_j = \sum_{k=1}^n c_{ijk} b_k$.
##
## Then $\sum_{i=1}^n a_i c_{ijk} = \delta_{jk}$ for $1 \leq k \leq n$.
##
## This yields $n^2$ linear equations for the $n$ indeterminates $a_i$,
## and a solution is a left identity.
## For this we have to test whether it is also a right identity.
##
InstallMethod( MultiplicativeNeutralElement,
 [ IsFLMLOR and IsFiniteDimensional ],
 function( A )
 local B, # basis of `A'
 one; # result

 B:= Basis( A );
 one:= IdentityFromSCTable( StructureConstantsTable( B ) );
 if one <> fail then
 one:= LinearCombination( B, one );
 fi;
 return one;
 end );

#############################################################################
##
#M IsAssociative( <A> )
##
## We check whether the vectors of a basis satisfy the associativity law.
## (Bilinearity of the multiplication is of course assumed.)
##
## If $b_i \cdot b_j = \sum_{l=1}^n c_{ijl} b_l$ then we have
## $b_i \cdot ( b_j \cdot b_k ) = ( b_i \cdot b_j ) \cdot b_k$
## if and only if
## $\sum_{l=1}^n c_{jkl} c_{ilm} = \sum_{l=1}^n c_{ijl} c_{lkm}$ for all
## $1 \leq m \leq n$.
##
## We check this equality for all $1 \leq i, j, k \leq n$.
##
InstallMethod( IsAssociative,
 "generic method for a (finite dimensional) FLMLOR",
 [ IsFLMLOR ],
 function( A )
 local T, # structure constants table w.r.t. a basis of `A'
 zero,
 range,
 i, j, k, l, m,
 Ti,
 Tj,
 cijpos,
 cijval,
 cjkpos,
 cjkval,
 sum,
 x,
 pos;

 if not IsFiniteDimensional( A ) then
 TryNextMethod();
 fi;

 T:= StructureConstantsTable( Basis( A ) );
 zero:= Zero( LeftActingDomain( A ) );
 range:= [ 1 .. Length( T[1] ) ];
 for i in range do
 Ti:= T[i];
 for j in range do
 cijpos:= Ti[j][1];
 cijval:= Ti[j][2];
 Tj:= T[j];
 for k in range do
 cjkpos:= Tj[k][1];
 cjkval:= Tj[k][2];
 for m in range do
 sum:= zero;
 for l in [ 1 .. Length( cjkpos ) ] do
 x:= Ti[ cjkpos[l] ];
 pos:= Position( x[1], m );
 if pos <> fail then
 sum:= sum + cjkval[l] * x[2][ pos ];
 fi;
 od;
 for l in [ 1 .. Length( cijpos ) ] do

 x:= T[ cijpos[l] ][k];
 pos:= Position( x[1], m );
 if pos <> fail then
 sum:= sum - cijval[l] * x[2][ pos ];
 fi;
 od;
 if sum <> zero then
 # $i, j, k$ fail
 Info( InfoAlgebra, 2,
 "IsAssociative fails for i = ", i, ", j = ", j,
 ", k = ", k );
 return false;
 fi;
 od;
 od;
 od;
 od;
 return true;
 end );

#############################################################################
##
#M IsAnticommutative( <A> ) . . . . . . . . . . . . .for a fin.-dim. FLMLOR
##
## is `true' if the multiplication in <A> is anticommutative,
## and `false' otherwise.
##
InstallMethod( IsAnticommutative,
 "generic method for a (finite dimensional) FLMLOR",
 [ IsFLMLOR ],
 function( A )
 local n, # dimension of `A'
 T, # table of structure constants for `A'
 i, j; # loop over rows and columns ot `T'

 if not IsFiniteDimensional( A ) then
 TryNextMethod();
 fi;

 n:= Dimension( A );
 T:= StructureConstantsTable( Basis( A ) );
 for i in [ 2 .. n ] do
 for j in [ 1 .. i-1 ] do
 if T[i][j][1] <> T[j][i][1]
 or ( not IsEmpty( T[i][j][1] )
 and PositionNonZero( T[i][j][2] + T[j][i][2] )
 <= Length( T[i][j][2] ) ) then
 return false;
 fi;
 od;
 od;

 if Characteristic( A ) <> 2 then

 # The values on the diagonal must be zero.
 for i in [ 1 .. n ] do
 if not IsEmpty( T[i][i][1] ) then
 return false;
 fi;
 od;

 fi;

 return true;
 end );

#############################################################################
##
#M IsCommutative( <A> ) . . . . . . . . . . . for finite dimensional FLMLOR
##
## Check whether every basis vector commutes with every basis vector.
##
InstallMethod( IsCommutative,
 "generic method for a finite dimensional FLMLOR",
 [ IsFLMLOR ],
 IsCommutativeFromGenerators( GeneratorsOfVectorSpace ) );
#T use structure constants!

#############################################################################
##
#M IsCommutative( <A> ) . . . . . . . . . . . . . for an associative FLMLOR
##
## If <A> is associative then we can restrict the check to a smaller
## equation system than that for arbitrary algebras, since we have to check
## $x a = a x$ only for algebra generators $a$ and $x$, not for all vectors
## of a basis.
##
InstallMethod( IsCommutative,
 "for an associative FLMLOR",
 [ IsFLMLOR and IsAssociative ],
 IsCommutativeFromGenerators( GeneratorsOfAlgebra ) );

InstallMethod( IsCommutative,
 "for an associative FLMLOR-with-one",
 [ IsFLMLORWithOne and IsAssociative ],
 IsCommutativeFromGenerators( GeneratorsOfAlgebraWithOne ) );

#############################################################################
##
#M IsZeroSquaredRing( <A> ) . . . . . . . . for a finite dimensional FLMLOR
##
InstallMethod( IsZeroSquaredRing,
 "for a finite dimensional FLMLOR",
 [ IsFLMLOR ],
 function( A )

 if not IsAnticommutative( A ) then

 # Every zero squared ring is anticommutative.
 return false;

 elif ForAny( BasisVectors( Basis( A ) ),
 x -> not IsZero( x*x ) ) then

 # If not all basis vectors are zero squared then we return `false'.
 return false;

 elif IsCommutative( LeftActingDomain( A ) ) then

 # If otherwise the left acting domain is commutative then we return
 # `true' because we know that <A> is anticommutative and the basis
 # vectors are zero squared.
 return true;

 else

 # Otherwise we give up.
 TryNextMethod();

 fi;
 end );

#############################################################################
##
#M IsJacobianRing( <A> )
##
InstallMethod( IsJacobianRing,
 "for a (finite dimensional) FLMLOR",
 [ IsFLMLOR ],
 function( A )
 local n, # dimension of `A'
 T, # table of structure constants for `A'
 i; # loop over the diagonal of `T'

 if not IsFiniteDimensional( A ) then
 TryNextMethod();
 fi;

 # In characteristic 2 we have to make sure that $a \* a = 0$.
#T really?
 T:= StructureConstantsTable( Basis( A ) );
 if Characteristic( A ) = 2 then
 n:= Dimension( A );
 for i in [ 1 .. n ] do
 if not IsEmpty( T[i][i][1] ) then
 return false;
 fi;
 od;
 fi;

 # Check the Jacobi identity $[a,[b,c]] + [b,[c,a]] + [c,[a,b]] = 0$.
 return TestJacobi( T ) = true;
 end );

#############################################################################
##
#M Intersection2( <A1>, <A2> ) . . . . . . . . . intersection of two FLMLORs
##
InstallMethod( Intersection2,
 "generic method for two FLMLORs",
 IsIdenticalObj,
 [ IsFLMLOR, IsFLMLOR ],
 Intersection2Spaces( AsFLMLOR, SubFLMLORNC, FLMLOR ) );

#############################################################################
##
#M Intersection2( <A1>, <A2> ) . . . . intersection of two FLMLORs-with-one
##
InstallMethod( Intersection2,
 "generic method for two FLMLORs-with-one",
 IsIdenticalObj,
 [ IsFLMLORWithOne, IsFLMLORWithOne ],
 Intersection2Spaces( AsFLMLORWithOne, SubFLMLORWithOneNC,
 FLMLORWithOne ) );

#############################################################################
##
#M \/( <A>, ) . . . . . . . . . . . . factor of an algebra by an ideal
#M \/( <A>, <relators> ) . . . . . . . . . factor of an algebra by an ideal
##
## is the factor algebra of the finite dimensional algebra <A> modulo
## the ideal or the ideal spanned by the collection <relators>.
##
InstallOtherMethod( \/,
 "for FLMLOR and collection",
 IsIdenticalObj,
 [ IsFLMLOR, IsCollection ],
 function( A, relators )
 if IsFLMLOR( relators ) then
 TryNextMethod();
 else
 return A / TwoSidedIdealByGenerators( A, relators );
 fi;
 end );

InstallOtherMethod( \/,
 "for FLMLOR and empty list",
 [ IsFLMLOR, IsList and IsEmpty ],
 function( A, empty )
 # `NaturalHomomorphismByIdeal( A, TrivialSubFLMLOR( A ) )' is the
 # identity mapping on `A', and `ImagesSource' of it yields `A'.
 return A;
 end );

InstallOtherMethod( \/,
 "generic method for two FLMLORs",
 IsIdenticalObj,
 [ IsFLMLOR, IsFLMLOR ],
 function( A, I )
 return ImagesSource( NaturalHomomorphismByIdeal( A, I ) );
 end );

#############################################################################
##
#M TrivialSubadditiveMagmaWithZero( <A> ) . . . . . . . . . . for a FLMLOR
##
InstallMethod( TrivialSubadditiveMagmaWithZero,
 "for a FLMLOR",
 [ IsFLMLOR ],
 A -> SubFLMLORNC( A, [] ) );

#############################################################################
##
#M AsFLMLOR( <R>, <D> ) . . view a collection as a FLMLOR over the ring <R>
##
InstallMethod( AsFLMLOR,
 "for a ring and a collection",
 [ IsRing, IsCollection ],
 function( F, D )
 local A, L;

 D:= AsSSortedList( D );
 L:= ShallowCopy( D );
 A:= TrivialSubFLMLOR( AsFLMLOR( F, D ) );
 SubtractSet( L, AsSSortedList( A ) );
 while 0 < Length(L) do
 A:= ClosureLeftOperatorRing( A, L[1] );
#T call explicit function that maintains an elements list?
 SubtractSet( L, AsSSortedList( A ) );
 od;
 if Length( AsList( A ) ) <> Length( D ) then
 return fail;
 fi;
 A:= FLMLOR( F, GeneratorsOfLeftOperatorRing( A ), Zero( D[1] ) );
 SetAsSSortedList( A, D );
 SetSize( A, Length( D ) );
 SetIsFinite( A, true );
#T ?

 # Return the FLMLOR.
 return A;
 end );

#############################################################################
##
#M AsFLMLOR( <F>, <V> ) . . view a left module as FLMLOR over the field <F>
##
## is an algebra over <F> that is equal (as set) to <V>.
## For that, perhaps the field of <A> has to be changed before
## getting the correct list of generators.
##
InstallMethod( AsFLMLOR,
 "for a division ring and a free left module",
 [ IsDivisionRing, IsFreeLeftModule ],
 function( F, V )
 local L, A;

 if LeftActingDomain( V ) = F then

 A:= FLMLOR( F, GeneratorsOfLeftModule( V ) );
 if A <> V then
 return fail;
 fi;
 if HasBasis( V ) then
 SetBasis( A, Basis( V ) );
 fi;

 elif IsTrivial( V ) then

 # We need the zero.
 A:= FLMLOR( F, [], Zero( V ) );

 elif IsSubset( LeftActingDomain( V ), F ) then

 # Make sure that the field change does not change the elements.
 L:= BasisVectors( Basis( AsField( F, LeftActingDomain(V) ) ) );
 L:= Concatenation( List( L, x -> List( GeneratorsOfLeftModule( V ),
 y -> x * y ) ) );
 A:= FLMLOR( F, L );
 if A <> V then
 return fail;
 fi;

 elif IsSubset( F, LeftActingDomain( V ) ) then

 # Make sure that the field change does not change the elements.
 L:= BasisVectors( Basis( AsField( LeftActingDomain(V), F ) ) );
 if ForAny( L, x -> ForAny( GeneratorsOfLeftModule( V ),
 y -> not x * y in V ) ) then
 return fail;
 fi;
 A:= FLMLOR( F, GeneratorsOfLeftModule( V ) );
 if A <> V then
 return fail;
 fi;

 else

 V:= AsFLMLOR( Intersection( F, LeftActingDomain( V ) ), V );
 return AsFLMLOR( F, V );

 fi;

 UseIsomorphismRelation( V, A );
 UseSubsetRelation( V, A );

 return A;
 end );

#############################################################################
##
#M AsFLMLOR( <F>, <A> ) . . . view an algebra as algebra over the field <F>
##
## is an algebra over <F> that is equal (as set) to <D>.
## For that, perhaps the field of <A> has to be changed before
## getting the correct list of generators.
##
InstallMethod( AsFLMLOR,
 "for a division ring and an algebra",
 [ IsDivisionRing, IsFLMLOR ],
 function( F, D )
 local L, A;

 if LeftActingDomain( D ) = F then

 return D;

 elif IsTrivial( D ) then

 # We need the zero.
 A:= FLMLOR( F, [], Zero( D ) );

 elif IsSubset( LeftActingDomain( D ), F ) then

 # Make sure that the field change does not change the elements.
 L:= BasisVectors( Basis( AsField( F, LeftActingDomain(D) ) ) );
 L:= Concatenation( List( L, x -> List( GeneratorsOfAlgebra( D ),
 y -> x * y ) ) );
 A:= FLMLOR( F, L );

 elif IsSubset( F, LeftActingDomain( D ) ) then

 # Make sure that the field change does not change the elements.
 L:= BasisVectors( Basis( AsField( LeftActingDomain(D), F ) ) );
 if ForAny( L, x -> ForAny( GeneratorsOfAlgebra( D ),
 y -> not x * y in D ) ) then
 return fail;
 fi;
 A:= FLMLOR( F, GeneratorsOfAlgebra( D ) );

 else

 D:= AsFLMLOR( Intersection( F, LeftActingDomain( D ) ), D );
 return AsFLMLOR( F, D );

 fi;

 UseIsomorphismRelation( D, A );
 UseSubsetRelation( D, A );
 return A;
 end );

#############################################################################
##
#M AsFLMLORWithOne( <R>, <D> ) . . . . . . view a coll. as a FLMLOR-with-one
##
InstallMethod( AsFLMLORWithOne,
 "for a ring and a collection",
 [ IsRing, IsCollection ],
 function( F, D )
 return AsFLMLORWithOne( AsFLMLOR( F, D ) );
 end );

#############################################################################
##
#M AsFLMLORWithOne( <F>, <V> ) . . view a left module as an algebra-with-one
##
InstallMethod( AsFLMLORWithOne,
 "for a division ring and a free left module",
 [ IsDivisionRing, IsFreeLeftModule ],
 function( F, V )
 local L, A;

 # Check that `V' contains the identity.
 if One( V ) = fail then

 return fail;

 elif LeftActingDomain( V ) = F then

 A:= FLMLORWithOne( F, GeneratorsOfLeftModule( V ) );
 if A <> V then
 return fail;
 fi;

 # Left module generators and basis are maintained.
 if HasGeneratorsOfLeftModule( V ) then
 SetGeneratorsOfLeftModule( A, GeneratorsOfLeftModule( V ) );
 fi;
 if HasBasis( V ) then
 SetBasis( A, Basis( V ) );
 fi;

 elif IsSubset( LeftActingDomain( V ), F ) then

 # Make sure that the field change does not change the elements.
 L:= BasisVectors( Basis( AsField( F, LeftActingDomain(V) ) ) );
 L:= Concatenation( List( L, x -> List( GeneratorsOfLeftModule( V ),
 y -> x * y ) ) );
 A:= FLMLORWithOne( F, L );
 if A <> V then
 return fail;
 fi;

 elif IsSubset( F, LeftActingDomain( V ) ) then

 # Make sure that the field change does not change the elements.
 L:= BasisVectors( Basis( AsField( LeftActingDomain(V), F ) ) );
 if ForAny( L, x -> ForAny( GeneratorsOfLeftModule( V ),
 y -> not x * y in V ) ) then
 return fail;
 fi;
 A:= FLMLORWithOne( F, GeneratorsOfLeftModule( V ) );
 if A <> V then
 return fail;
 fi;

 else

 # Note that we need not use the isomorphism and subset relations
 # (see below) because this is the task of the calls to
 # `AsAlgebraWithOne'.
 A:= AsAlgebraWithOne( Intersection( F, LeftActingDomain( V ) ), V );
 return AsAlgebraWithOne( F, A );

 fi;

 UseIsomorphismRelation( V, A );
 UseSubsetRelation( V, A );
 return A;
 end );

#############################################################################
##
#M AsFLMLORWithOne( <F>, <D> ) . . . view an algebra as an algebra-with-one
##
InstallMethod( AsFLMLORWithOne,
 "for a division ring and an algebra",
 [ IsDivisionRing, IsFLMLOR ],
 function( F, D )
 local L, A;

 # Check that `D' contains the identity.
 if One( D ) = fail then

 return fail;

 elif LeftActingDomain( D ) = F then

 A:= FLMLORWithOne( F, GeneratorsOfLeftOperatorRing( D ) );

 # Left module generators and basis are maintained.
 if HasGeneratorsOfLeftModule( D ) then
 SetGeneratorsOfLeftModule( A, GeneratorsOfLeftModule( D ) );
 fi;
 if HasBasis( D ) then
 SetBasis( A, Basis( D ) );
 fi;

 elif IsSubset( LeftActingDomain( D ), F ) then

 # Make sure that the field change does not change the elements.
 L:= BasisVectors( Basis( AsField( F, LeftActingDomain(D) ) ) );
 L:= Concatenation( List( L, x -> List( GeneratorsOfAlgebra( D ),
 y -> x * y ) ) );
 A:= FLMLORWithOne( F, L );

 elif IsSubset( F, LeftActingDomain( D ) ) then

 # Make sure that the field change does not change the elements.
 L:= BasisVectors( Basis( AsField( LeftActingDomain(D), F ) ) );
 if ForAny( L, x -> ForAny( GeneratorsOfAlgebra( D ),
 y -> not x * y in D ) ) then
 return fail;
 fi;
 A:= FLMLORWithOne( F, GeneratorsOfLeftOperatorRing( D ) );

 else

 # Note that we need not use the isomorphism and subset relations
 # (see below) because this is the task of the calls to
 # `AsAlgebraWithOne'.
 D:= AsAlgebraWithOne( Intersection( F, LeftActingDomain( D ) ), D );
 return AsAlgebraWithOne( F, D );

 fi;

 UseIsomorphismRelation( D, A );
 UseSubsetRelation( D, A );
 return A;
 end );

#############################################################################
##
#M AsFLMLORWithOne( <F>, <D> ) . . view an alg.-with-one as an alg.-with-one
##
InstallMethod( AsFLMLORWithOne,
 "for a division ring and an algebra-with-one",
 [ IsDivisionRing, IsFLMLORWithOne ],
 function( F, D )
 local L, A;

 if LeftActingDomain( D ) = F then

 return D;

 elif IsSubset( LeftActingDomain( D ), F ) then

 # Make sure that the field change does not change the elements.
 L:= BasisVectors( Basis( AsField( F, LeftActingDomain(D) ) ) );
 L:= Concatenation( List( L, x -> List( GeneratorsOfAlgebra( D ),
 y -> x * y ) ) );
 A:= AlgebraWithOne( F, L );

 elif IsSubset( F, LeftActingDomain( D ) ) then

 # Make sure that the field change does not change the elements.
 L:= BasisVectors( Basis( AsField( LeftActingDomain(D), F ) ) );
 if ForAny( L, x -> ForAny( GeneratorsOfAlgebra( D ),
 y -> not x * y in D ) ) then
 return fail;
 fi;
 A:= AlgebraWithOne( F, GeneratorsOfAlgebra( D ) );

 else

 # Note that we need not use the isomorphism and subset relations
 # (see below) because this is the task of the calls to
 # `AsAlgebraWithOne'.
 D:= AsAlgebraWithOne( Intersection( F, LeftActingDomain( D ) ), D );
 return AsAlgebraWithOne( F, D );

 fi;

 UseIsomorphismRelation( D, A );
 UseSubsetRelation( D, A );
 return A;
 end );

#############################################################################
##
#M ClosureLeftOperatorRing( <A>, <a> ) . . . . . . . closure with an element
##
InstallMethod( ClosureLeftOperatorRing,
 "for a FLMLOR and a ring element",
#T why not a general function for any left operator ring?
#T (need `LeftOperatorRingByGenerators' ?)
 IsCollsElms,
 [ IsFLMLOR, IsRingElement ],
 function( A, a )

 # if possible test if the element lies in the ring already,
 if HasGeneratorsOfLeftOperatorRing( A )
 and a in GeneratorsOfLeftOperatorRing( A ) then
 return A;

 # otherwise make a new left operator ring
 else
 return FLMLOR( LeftActingDomain( A ),
 Concatenation( GeneratorsOfLeftOperatorRing( A ), [ a ] ) );
 fi;
 end );

InstallMethod( ClosureLeftOperatorRing,
 "for an FLMLOR with basis, and a ring element",
 IsCollsElms,
 [ IsFLMLOR and HasBasis, IsRingElement ],
 function( A, a )

 # test if the element lies in the FLMLOR already,
 if a in A then
 return A;

 # otherwise make a new FLMLOR
 else
 return FLMLOR( LeftActingDomain( A ),
#T FLMLORByGenerators?
 Concatenation( BasisVectors( Basis( A ) ), [ a ] ),
 "basis" );
 fi;
 end );

InstallMethod( ClosureLeftOperatorRing,
 "for a FLMLOR-with-one and a ring element",
 IsCollsElms,
 [ IsFLMLORWithOne, IsRingElement ],
 function( A, a )

 # if possible test if the element lies in the ring already,
 if a in GeneratorsOfLeftOperatorRingWithOne( A ) then
 return A;

 # otherwise make a new left operator ring-with-one
 else
 return FLMLORWithOne( LeftActingDomain( A ),
 Concatenation( GeneratorsOfLeftOperatorRingWithOne( A ),
 [ a ] ) );
 fi;
 end );

InstallMethod( ClosureLeftOperatorRing,
 "for a FLMLOR-with-one with basis, and a ring element",
 IsCollsElms,
 [ IsFLMLORWithOne and HasBasis, IsRingElement ],
 function( A, a )

 # test if the element lies in the FLMLOR already,
 if a in A then
 return A;

 # otherwise make a new FLMLOR-with-one
 else
 return FLMLORWithOne( LeftActingDomain( A ),
 Concatenation( BasisVectors( Basis( A ) ), [ a ] ),
 "basis" );
 fi;
 end );

InstallMethod( ClosureLeftOperatorRing,
 "for a FLMLOR containing the whole family, and a ring element",
 IsCollsElms,
 [ IsFLMLOR and IsWholeFamily, IsRingElement ],
 SUM_FLAGS, # this is better than everything else
 ReturnFirst);

#############################################################################
##
#M ClosureLeftOperatorRing( <A>, ) . closure of two left operator rings
##
InstallMethod( ClosureLeftOperatorRing,
 "for two left operator rings",
 IsIdenticalObj,
 [ IsLeftOperatorRing, IsLeftOperatorRing ],
 function( A, S )
 local g; # one generator

 for g in GeneratorsOfLeftOperatorRing( S ) do
 A := ClosureLeftOperatorRing( A, g );
 od;
 return A;
 end );

InstallMethod( ClosureLeftOperatorRing,
 "for two left operator rings-with-one",
 IsIdenticalObj,
 [ IsLeftOperatorRingWithOne, IsLeftOperatorRingWithOne ],
 function( A, S )
 local g; # one generator

 for g in GeneratorsOfLeftOperatorRingWithOne( S ) do
 A := ClosureLeftOperatorRing( A, g );
 od;
 return A;
 end );

InstallMethod( ClosureLeftOperatorRing,
 "for a left op. ring cont. the whole family, and a collection",
 IsIdenticalObj,
 [ IsLeftOperatorRing and IsWholeFamily, IsCollection ],
 SUM_FLAGS, # this is better than everything else
 ReturnFirst);

#############################################################################
##
#M ClosureLeftOperatorRing( <A>, <list> ) . . . . closure of left op. ring
##
InstallMethod( ClosureLeftOperatorRing,
 "for left operator ring and list of elements",
 IsIdenticalObj,
 [ IsLeftOperatorRing, IsCollection ],
 function( A, list )
 local g; # one generator
 for g in list do
 A:= ClosureLeftOperatorRing( A, g );
 od;
 return A;
 end );

#############################################################################
##
#F MutableBasisOfClosureUnderAction( <F>, <Agens>, <from>, <init>, <opr>,
#F <zero>, <maxdim> )
##
## This function is used to compute bases of finite dimensional ideals $I$
## in *associative* algebras that are given by ideal generators $J$ and
## (generators of) the acting algebra $A$.
## An important special case is that of the algebra $A$ itself, given by
## algebra generators.
##
## The algorithm assumes that it is possible to deal with mutable bases of
## vector spaces generated by elements of $A$.
## It proceeds as follows.
##
## Let $A$ be a finite dimensional algebra over the ring $F$,
## and $I$ a two-sided ideal in $A$ that is generated (as a two-sided ideal)
## by the set $J$.
## (For the cases of one-sided ideals, see below.)
##
## Let $S$ be a set of algebra generators of $A$.
## The identity of $A$, if exists, need not be contained in $S$.
##
## Each element $x$ in $I$ can be written as a linear combination of
## products $j a_1 a_2 \cdots a_n$, with $j \in J$ and $a_i \in S$ for
## $1 \leq i \leq n$.
## Let $l(x)$ denote the minimum of the largest $n$ for involved words
## $a_1 a_2 \cdots a_n$, taken over all possible expressions for $x$.
##
## Define $I_i = \{ x \in I \mid l(x) \leq i \}$.
## Then $I_i$ is an $F$-space, $A_0 = \langle J \rangle_F$,
## and $I_0 \< I_1 \< I_2 \< \cdots I_k \< I_{k+1} \< \ldots$
## is an ascending chain that eventually reaches $I$.
## For $i > 0$ we have
## $I_{i+1} = \langle I_i\cup\bigcup_{s\in S} ( I_i s\cup s I_i )\rangle_F$.
##
## (*Note* that the computation of the $I_i$ gives us the smallest value $k$
## such that every element is a linear combination of words in terms of the
## algebra generators, of maximal length $k$.)
##
InstallGlobalFunction( MutableBasisOfClosureUnderAction,
 function( F, Agens, from, init, opr, zero, maxdim )
 local MB, # mutable basis, result
 gen, # loop over generators
 v, #
 dim, # dimension of the actual left module
 right, # `true' if we have to multiply from the right
 left; # `true' if we have to multiply from the left

 # Get the side(s) from where to multiply.
 left := true;
 right := true;
 if from = "left" then
 right:= false;
 elif from = "right" then
 left:= false;
 fi;

 # $I_0$
 MB := MutableBasis( F, init, zero );
 dim := 0;

 while dim < NrBasisVectors( MB ) and dim < maxdim do

 # `MB' is a mutable basis of $I_i$.
 dim:= NrBasisVectors( MB );

 if right then

 # Compute $I^{\prime}_i = I_i + \sum_{s \in S} I_i s$.
 for gen in Agens do
 for v in BasisVectors( MB ) do
 CloseMutableBasis( MB, opr( v, gen ) );
 od;
 od;

 fi;
 if left then

 # Compute $I_i + \sum_{s \in S} s I_i$
 # resp. $I^{\prime}_i + \sum_{s \in S} s I_i$.
 for gen in Agens do
 for v in BasisVectors( MB ) do
 CloseMutableBasis( MB, opr( gen, v ) );
 od;
 od;

 fi;

 od;

 # Return the mutable basis.
 return MB;
end );

#############################################################################
##
#F MutableBasisOfNonassociativeAlgebra( <F>, <Agens>, <zero>, <maxdim> )
##
InstallGlobalFunction( MutableBasisOfNonassociativeAlgebra,
 function( F, Agens, zero, maxdim )
 local MB, # mutable basis, result
 dim, # dimension of the current left module
 bv, # current basis vectors
 v, w; # loop over basis vectors found already

 MB := MutableBasis( F, Agens, zero );
 dim := 0;

 while dim < NrBasisVectors( MB ) and dim < maxdim do

 dim := NrBasisVectors( MB );
 bv := BasisVectors( MB );

 for v in bv do
 for w in bv do
 CloseMutableBasis( MB, v * w );
 CloseMutableBasis( MB, w * v );
 od;
 od;

 od;

 # Return the mutable basis.
 return MB;
end );

#############################################################################
##
#F MutableBasisOfIdealInNonassociativeAlgebra( <F>, <Vgens>, <Igens>,
#F <zero>, <from>, <maxdim> )
##
InstallGlobalFunction( MutableBasisOfIdealInNonassociativeAlgebra,
 function( F, Vgens, Igens, zero, from, maxdim )
 local MB, # mutable basis, result
 dim, # dimension of the current left module
 bv, # current basis vectors
 right, # `true' if we have to multiply from the right
 left, # `true' if we have to multiply from the left
 v, gen; # loop over basis vectors found already

 # Get the side(s) from where to multiply.
 left := true;
 right := true;
 if from = "left" then
 right:= false;
 elif from = "right" then
 left:= false;
 fi;

 dim := 0;
 MB := MutableBasis( F, Igens, zero );

 while dim < NrBasisVectors( MB ) and dim < maxdim do

 dim := NrBasisVectors( MB );
 bv := BasisVectors( MB );

 for v in bv do
 for gen in Vgens do

 if left then
 CloseMutableBasis( MB, gen * v );
 fi;
 if right then
 CloseMutableBasis( MB, v * gen );
 fi;
 od;
 od;

 od;

 # Return the mutable basis.
 return MB;
end );

#############################################################################
##
#M IsSubset( <A>, ) . . . . . . . . . . . . test for subset of FLMLORs
##
## These methods are preferable to that for free left modules because they
## use algebra generators.
##
## We assume that generators of an extension of the left acting domains can
## be computed if they are fields; note that infinite field extensions do
## not (yet) occur in {\GAP} as `LeftActingDomain' values.
##
InstallMethod( IsSubset,
 "for two FLMLORs",
 IsIdenticalObj,
 [ IsFLMLOR, IsFLMLOR ],
 function( D1, D2 )
 local F1, F2;

 F1:= LeftActingDomain( D1 );
 F2:= LeftActingDomain( D2 );
 if not ( HasIsDivisionRing( F1 ) and IsDivisionRing( F1 ) and
 HasIsDivisionRing( F2 ) and IsDivisionRing( F2 ) ) then
 TryNextMethod();
 fi;

 # catch trivial case
 if IsSubset(GeneratorsOfLeftOperatorRing(D1),
 GeneratorsOfLeftOperatorRing(D2)) then
 return true;
 fi;
 return IsSubset( D1, GeneratorsOverIntersection( D2,
 GeneratorsOfLeftOperatorRing( D2 ),
 F2, F1 ) );
 end );

InstallMethod( IsSubset,
 "for two FLMLORs-with-one",
 IsIdenticalObj,
 [ IsFLMLORWithOne, IsFLMLORWithOne ],
 function( D1, D2 )
 local F1, F2;

 F1:= LeftActingDomain( D1 );
 F2:= LeftActingDomain( D2 );
 if not ( HasIsDivisionRing( F1 ) and IsDivisionRing( F1 ) and
 HasIsDivisionRing( F2 ) and IsDivisionRing( F2 ) ) then
 TryNextMethod();
 fi;
 return IsSubset( D1, GeneratorsOverIntersection( D2,
 GeneratorsOfLeftOperatorRingWithOne( D2 ),
 F2, F1 ) );
 end );

#############################################################################
##
#M ViewObj( <A> ) . . . . . . . . . . . . . . . . . . . . . . view a FLMLOR
##
## print left acting domain, if known also dimension or no. of generators
##
InstallMethod( ViewObj,
 "for a FLMLOR",
 [ IsFLMLOR ],
 function( A )
 Print( "<free left module over ", LeftActingDomain( A ), ", and ring>" );
 end );

InstallMethod( ViewObj,
 "for a FLMLOR with known dimension",
 [ IsFLMLOR and HasDimension ], 1, # override method requiring gens.
 function( A )
 Print( "<free left module of dimension ", Dimension( A ),
 " over ", LeftActingDomain( A ), ", and ring>" );
 end );

InstallMethod( ViewObj,
 "for a FLMLOR with known generators",
 [ IsFLMLOR and HasGeneratorsOfAlgebra ],
 function( A )
 Print( "<free left module over ", LeftActingDomain( A ),
 ", and ring, with ",
 Pluralize( Length( GeneratorsOfFLMLOR( A ) ), "generator" ), ">" );
 end );

#############################################################################
##
#M PrintObj( <A> ) . . . . . . . . . . . . . . . . . . . . . print a FLMLOR
##
InstallMethod( PrintObj,
 "for a FLMLOR",
 [ IsFLMLOR ],
 function( A )
 Print( "FLMLOR( ", LeftActingDomain( A ), ", ... )" );
 end );

InstallMethod( PrintObj,
 "for a FLMLOR with known generators",
 [ IsFLMLOR and HasGeneratorsOfFLMLOR ],
 function( A )
 if IsEmpty( GeneratorsOfFLMLOR( A ) ) then
 Print( "FLMLOR( ", LeftActingDomain( A ), ", [], ", Zero( A ), " )" );
 else
 Print( "FLMLOR( ", LeftActingDomain( A ), ", ",
 GeneratorsOfFLMLOR( A ), " )" );
 fi;
 end );

#############################################################################
##
#M ViewObj( <A> ) . . . . . . . . . . . . . . . . . view a FLMLOR-with-one
##
## print left acting domain, if known also dimension or no. of generators
##
InstallMethod( ViewObj,
 "for a FLMLOR-with-one",
 [ IsFLMLORWithOne ],
 function( A )
 Print( "<free left module over ", LeftActingDomain( A ),
 ", and ring-with-one>" );
 end );

InstallMethod( ViewObj,
 "for a FLMLOR-with-one with known dimension",
 [ IsFLMLORWithOne and HasDimension ], 1, # override method requ. gens.
 function( A )
 Print( "<free left module of dimension ", Dimension( A ),
 " over ", LeftActingDomain( A ), ", and ring-with-one>" );
 end );

InstallMethod( ViewObj,
 "for a FLMLOR-with-one with known generators",
 [ IsFLMLORWithOne and HasGeneratorsOfFLMLORWithOne ],
 function( A )
 Print( "<free left module over ", LeftActingDomain( A ),
 ", and ring-with-one, with ",
 Pluralize( Length( GeneratorsOfAlgebraWithOne( A ) ), "generator" ),
 ">" );
 end );

#############################################################################
##
#M PrintObj( <A> ) . . . . . . . . . . . . . . . . . print a FLMLOR-with-one
##
InstallMethod( PrintObj,
 "for a FLMLOR-with-one",
 [ IsFLMLORWithOne ],
 function( A )
 Print( "FLMLORWithOne( ", LeftActingDomain( A ), ", ... )" );
 end );

InstallMethod( PrintObj,
 "for a FLMLOR-with-one with known generators",
 [ IsFLMLORWithOne and HasGeneratorsOfFLMLOR ],
 function( A )
 if IsEmpty( GeneratorsOfFLMLORWithOne( A ) ) then
 Print( "FLMLORWithOne( ", LeftActingDomain( A ), ", [], ",
 Zero( A ), " )" );
 else
 Print( "FLMLORWithOne( ", LeftActingDomain( A ), ", ",
 GeneratorsOfFLMLORWithOne( A ), " )" );
 fi;
 end );

#############################################################################
##
#M ViewObj( <A> ) . . . . . . . . . . . . . . . . . . . . . view an algebra
##
## print left acting domain, if known also dimension or no. of generators
##
InstallMethod( ViewObj,
 "for an algebra",
 [ IsAlgebra ],
 function( A )
 Print( "<algebra over ", LeftActingDomain( A ), ">" );
 end );

InstallMethod( ViewObj,
 "for an algebra with known dimension",
 [ IsAlgebra and HasDimension ], 1, # override method requiring gens.
 function( A )
 Print( "<algebra of dimension ", Dimension( A ),
 " over ", LeftActingDomain( A ), ">" );
 end );

InstallMethod( ViewObj,
 "for an algebra with known generators",
 [ IsAlgebra and HasGeneratorsOfAlgebra ],
 function( A )
 Print( "<algebra over ", LeftActingDomain( A ), ", with ",
 Pluralize( Length( GeneratorsOfAlgebra( A ) ), "generator" ), ">" );
 end );

#############################################################################
##
#M PrintObj( <A> ) . . . . . . . . . . . . . . . . . . . . print an algebra
##
InstallMethod( PrintObj,
 "for an algebra",
 [ IsAlgebra ],
 function( A )
 Print( "Algebra( ", LeftActingDomain( A ), ", ... )" );
 end );

InstallMethod( PrintObj,
 "for an algebra with known generators",
 [ IsAlgebra and HasGeneratorsOfAlgebra ],
 function( A )
 if IsEmpty( GeneratorsOfAlgebra( A ) ) then
 Print( "Algebra( ", LeftActingDomain( A ), ", [], ", Zero( A ), " )" );
 else
 Print( "Algebra( ", LeftActingDomain( A ), ", ",
 GeneratorsOfAlgebra( A ), " )" );
 fi;
 end );

#############################################################################
##
#M ViewObj( <A> ) . . . . . . . . . . . . . . . . view an algebra-with-one
##
## print left acting domain, if known also dimension or no. of generators
##
InstallMethod( ViewObj, "for an algebra-with-one", [ IsAlgebraWithOne ],
function( A )
 if IsIdenticalObj(A,LeftActingDomain(A)) then
 Print( "<algebra-with-one over itself>" );
 else
 Print( "<algebra-with-one over ", LeftActingDomain( A ), ">" );
 fi;
end );

InstallMethod( ViewObj,
 "for an algebra-with-one with known dimension",
 [ IsAlgebraWithOne and HasDimension ], 1, # override method requ. gens.
 function( A )
 Print( "<algebra-with-one of dimension ", Dimension( A ),
 " over ", LeftActingDomain( A ), ">" );
 end );

InstallMethod( ViewObj,
 "for an algebra-with-one with known generators",
 [ IsAlgebraWithOne and HasGeneratorsOfAlgebraWithOne ],
 function( A )
 Print( "<algebra-with-one over ", LeftActingDomain( A ), ", with ",
 Pluralize( Length( GeneratorsOfAlgebraWithOne( A ) ), "generator" ),
 ">" );
 end );

#############################################################################
##
#M PrintObj( <A> ) . . . . . . . . . . . . . . . . print an algebra-with-one
##
InstallMethod( PrintObj,
 "for an algebra-with-one",
 [ IsAlgebraWithOne ],
 function( A )
 Print( "AlgebraWithOne( ", LeftActingDomain( A ), ", ... )" );
 end );

InstallMethod( PrintObj,
 "for an algebra-with-one with known generators",
 [ IsAlgebraWithOne and HasGeneratorsOfAlgebra ],
 function( A )
 if IsEmpty( GeneratorsOfAlgebraWithOne( A ) ) then
 Print( "AlgebraWithOne( ", LeftActingDomain( A ), ", [], ",
 Zero( A ), " )" );
 else
 Print( "AlgebraWithOne( ", LeftActingDomain( A ), ", ",
 GeneratorsOfAlgebraWithOne( A ), " )" );
 fi;
 end );

#############################################################################
##
#M ViewObj( <A> ) . . . . . . . . . . . . . . . . . . view a Lie algebra
##
## print left acting domain, if known also dimension or no. of generators
##
InstallMethod( ViewObj,
 "for a Lie algebra",
 [ IsLieAlgebra ],
 function( A )
 Print( "<Lie algebra over ", LeftActingDomain( A ), ">" );
 end );

InstallMethod( ViewObj,
 "for a Lie algebra with known dimension",
 [ IsLieAlgebra and HasDimension ], 1, # override method requ. gens.
 function( A )
 Print( "<Lie algebra of dimension ", Dimension( A ),
 " over ", LeftActingDomain( A ), ">" );
 end );

InstallMethod( ViewObj,
 "for a Lie algebra with known generators",
 [ IsLieAlgebra and HasGeneratorsOfAlgebra ],
 function( A )
 Print( "<Lie algebra over ", LeftActingDomain( A ), ", with ",
 Pluralize( Length( GeneratorsOfAlgebra( A ) ), "generator" ), ">" );
end );

#############################################################################
##
#M AsSubalgebra(<A>, ) . view an algebra as subalgebra of another algebra
##
InstallMethod( AsSubalgebra,
 "for two algebras",
 IsIdenticalObj,
 [ IsAlgebra, IsAlgebra ],
 function( A, U )
 local samecoeffs, S;
 if not IsSubset( A, U ) then
 return fail;
 fi;

 # Construct the generators list.
 samecoeffs:= LeftActingDomain( A ) = LeftActingDomain( U );
 if not samecoeffs then
 U:= AsAlgebra( LeftActingDomain( A ), U );
 fi;

 # Construct the subalgebra.
 S:= SubalgebraNC( A, GeneratorsOfAlgebra( U ) );

 # Maintain useful information.
 UseIsomorphismRelation( U, S );
 UseSubsetRelation( U, S );
 if samecoeffs and HasDimension( U ) then
 SetDimension( S, Dimension( U ) );
 fi;

 # Return the subalgebra.
 return S;
 end );

InstallMethod( AsSubalgebra,
 "for an algebra and an algebra-with-one",
 IsIdenticalObj,
 [ IsAlgebra, IsAlgebraWithOne ],
 function( A, U )
 local samecoeffs, S;
 if not IsSubset( A, U ) then
 return fail;
 fi;

 # Construct the generators list.
 samecoeffs:= LeftActingDomain( A ) = LeftActingDomain( U );
 if not samecoeffs then
 U:= AsAlgebraWithOne( LeftActingDomain( A ), U );
 fi;

 # Construct the subalgebra.
 S:= SubalgebraWithOneNC( A, GeneratorsOfAlgebraWithOne( U ) );

 # Maintain useful information.
 UseIsomorphismRelation( U, S );
 UseSubsetRelation( U, S );
 if samecoeffs and HasDimension( U ) then
 SetDimension( S, Dimension( U ) );
 fi;

 # Return the subalgebra.
 return S;
 end );

--> --------------------

--> maximum size reached

--> --------------------

SSL algebra.gi Sprache: unbekannt

[ Verzeichnis aufwärts0.54unsichere Verbindung Übersetzung europäischer Sprachen durch Browser ]