Quelle algrep.gi Sprache: unbekannt

#############################################################################
##
## This file is part of GAP, a system for computational discrete algebra.
## This file's authors include 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 the methods for general modules over algebras.
##

#############################################################################
##
#M PrintObj( <obj> ) . . . . . . . . . . . . . . . . for an algebra module
#M ViewObj( <obj> ) . . . . . . . . . . . . . . . . for an algebra module
##
InstallMethod( PrintObj,
 "for algebra module",
 true, [ IsVectorSpace and IsAlgebraModule ], 0,
 function( V )

 if HasDimension( V ) then
 Print("<", Dimension(V), "-dimensional " );
 else
 Print( "<" );
 fi;
 if IsLeftAlgebraModuleElementCollection( V ) then
 if IsRightAlgebraModuleElementCollection( V ) then
 Print("bi-module over ");
 Print( LeftActingAlgebra( V ) );
 Print( " (left) and " );
 Print( RightActingAlgebra( V ) );
 Print( " (right)>" );
 else
 Print("left-module over ");
 Print( LeftActingAlgebra( V ) );
 Print(">");
 fi;
 else
 Print("right-module over ");
 Print( RightActingAlgebra( V ) );
 Print(">");
 fi;

 end );

 InstallMethod( ViewObj,
 "for algebra module",
 true, [ IsVectorSpace and IsAlgebraModule ], 0,
 function( V )

 if HasDimension( V ) then
 Print("<", Dimension(V), "-dimensional " );
 else
 Print( "<" );
 fi;
 if IsLeftAlgebraModuleElementCollection( V ) then
 if IsRightAlgebraModuleElementCollection( V ) then
 Print("bi-module over ");
 View( LeftActingAlgebra( V ) );
 Print( " (left) and " );
 View( RightActingAlgebra( V ) );
 Print( " (right)>" );
 else
 Print("left-module over ");
 View( LeftActingAlgebra( V ) );
 Print(">");
 fi;
 else
 Print("right-module over ");
 View( RightActingAlgebra( V ) );
 Print(">");
 fi;

end );

############################################################################
##
#M ExtRepOfObj( <elm> ) . . . . . . . . . . . . for algebra module elements
##
InstallMethod( ExtRepOfObj,
 "for algebra module element in packed element rep",
 true,
 [ IsAlgebraModuleElement and IsPackedElementDefaultRep ], 0,
 elm -> elm![1] );

#############################################################################
##
#M ObjByExtRep( <Fam>, <descr> ) . . . . . . . . for algebra module elements
##
##
InstallMethod( ObjByExtRep,
 "for algebra module elements family, object",
 true,
 [ IsAlgebraModuleElementFamily, IsObject ], 0,
 function( Fam, vec )

 if Fam!.underlyingModuleEltsFam <> FamilyObj( vec ) then
 TryNextMethod();
 fi;
 return Objectify( Fam!.packedType, [ vec ] );
 end );

#############################################################################
##
#F BasisOfAlgebraModule( <V>, <vecs> ) for space of algebra module elements
## and a list of elements thereof
##
## Note that the work is delegated to a basis of the module
## generated by the <v>![1] vectors, for <v> in <vecs>. This basis
## is stored in the basis of the algebra module as !.delegateBasis.
##
BindGlobal( "BasisOfAlgebraModule",
 function( V, vectors )
 local B, delmod, vecs;

 B:= Objectify( NewType( FamilyObj( V ),
 IsFiniteBasisDefault and
 IsBasisOfAlgebraModuleElementSpace and
 IsAttributeStoringRep ),
 rec() );
 SetUnderlyingLeftModule( B, V );
 SetBasisVectors( B, vectors );
 if IsEmpty( vectors ) then
 delmod:= VectorSpace( LeftActingDomain(V), [ ],
 ExtRepOfObj( Zero(V) ) );
 B!.delegateBasis:= Basis( delmod );
 else
 vecs:= List( vectors, ExtRepOfObj );
 delmod:= VectorSpace( LeftActingDomain(V), vecs, "basis" );
 B!.delegateBasis:= Basis( delmod, vecs );
 fi;
 return B;
 end );

#############################################################################
##
#M CanonicalBasis( <V> ) . . . . . . for a space of algebra module elements
##
InstallMethod( CanonicalBasis,
 "for algebra module",
 [ IsVectorSpace and IsAlgebraModuleElementCollection ],
 function( V )
 local B, fam, vecs;

 B:= CanonicalBasis( VectorSpace( LeftActingDomain( V ),
 List( GeneratorsOfLeftModule( V ), ExtRepOfObj ) ) );
 fam:= ElementsFamily( FamilyObj( V ) );
 vecs:= List( BasisVectors( B ), x -> ObjByExtRep( fam, x ) );
 return BasisOfAlgebraModule( V, vecs );
 end );

#############################################################################
##
#M LeftAlgebraModuleByGenerators( <A>, <op>, <gens> )
#M LeftAlgebraModuleByGenerators( <A>, <op>, <gens>, "basis" )
##
## The elements of an algebra module lie in the representation
## `IsPackedElementDefaultRep': if <v> is an element of an algebra
## module, then v![1] is an element of a vector space on which there
## is an action of the algebra defined.
##
InstallMethod( LeftAlgebraModuleByGenerators,
 "for algebra, function of 2 args, module generators",
 true, [ IsAlgebra, IS_FUNCTION, IsHomogeneousList], 0,
 function( A, op, gens )

 local F,V;

 F:= LeftActingDomain( A );
 V:= VectorSpace( F, gens );
 return LeftAlgebraModule( A, op, V );

 end );

InstallOtherMethod( LeftAlgebraModuleByGenerators,
 "for algebra, function of 2 args, generators, string",
 true, [ IsAlgebra, IS_FUNCTION, IsHomogeneousList, IsString], 0,
 function( A, op, gens, str )

 local F,V;

 if str<>"basis" then
 Error( "Usage: LeftAlgebraModuleByGenerators( <A>, <op>, <gens>, <str>) where the last argument is the string \"basis\"" );
 fi;

 F:= LeftActingDomain( A );
 V:= VectorSpace( F, gens, str );
 return LeftAlgebraModule( A, op, V );

end );

#############################################################################
##
#M RightAlgebraModuleByGenerators( <A>, <op>, <gens> )
#M RightAlgebraModuleByGenerators( <A>, <op>, <gens>, "basis" )
##
## The elements of an algebra module lie in the representation
## `IsPackedElementDefaultRep': if <v> is an element of an algebra
## module, then v![1] is an element of a vector space on which there
## is an action of the algebra defined.
##
InstallMethod( RightAlgebraModuleByGenerators,
 "for algebra, function of 2 args, module generators",
 true, [ IsAlgebra, IS_FUNCTION, IsHomogeneousList], 0,
 function( A, op, gens )

 local F,V;

 F:= LeftActingDomain( A );
 V:= VectorSpace( F, gens );
 return RightAlgebraModule( A, op, V );

end );

InstallOtherMethod( RightAlgebraModuleByGenerators,
 "for algebra, function of 2 args, generators, string",
 true, [ IsAlgebra, IS_FUNCTION, IsHomogeneousList, IsString], 0,
 function( A, op, gens, str )

 local F,V;

 if str<>"basis" then
 Error( "Usage: RightAlgebraModuleByGenerators( <A>, <op>, <gens>, <str>) where the last argument is the string \"basis\"" );
 fi;

 F:= LeftActingDomain( A );
 V:= VectorSpace( F, gens, str );
 return RightAlgebraModule( A, op, V );

 end );

#############################################################################
##
#M BiAlgebraModuleByGenerators( <A>, , <opl>, <opr>, <gens> )
#M BiAlgebraModuleByGenerators( <A>, , <opl>, <opr>, <gens>, "basis" )
##
## The elements of an algebra module lie in the representation
## `IsPackedElementDefaultRep': if <v> is an element of an algebra
## module, then v![1] is an element of a vector space on which there
## is an action of the algebra defined.
##
InstallMethod( BiAlgebraModuleByGenerators,
"for 2 algebras, function of 2 args, function of 2 args, module generators",
 true,
 [ IsAlgebra, IsAlgebra, IS_FUNCTION, IS_FUNCTION, IsHomogeneousList], 0,
 function( A, B, opl, opr, gens )

 local F,V;

 F:= LeftActingDomain( A );
 V:= VectorSpace( F, gens );
 return BiAlgebraModule( A, B, opl, opr, V );

 end );

InstallOtherMethod( BiAlgebraModuleByGenerators,
"for 2 algebras, function of 2 args, function of 2 args, generators, string",
true,
[ IsAlgebra, IsAlgebra, IS_FUNCTION, IS_FUNCTION, IsHomogeneousList, IsString],
 0,
 function( A, B, opl, opr, gens, str )

 local F,V;

 if str<>"basis" then
 Error( "Usage: BiAlgebraModuleByGenerators( <A>, , <opl>, <opr>, <gens>, <str>) where the last argument is the string \"basis\"" );
 fi;

 F:= LeftActingDomain( A );
 V:= VectorSpace( F, gens, str );
 return BiAlgebraModule( A, B, opl, opr, V );

end );

#############################################################################
##
#M LeftAlgebraModule( <A>, <op>, <V> )
##
## The elements of an algebra module lie in the representation
## `IsPackedElementDefaultRep': if <v> is an element of an algebra
## module, then v![1] is an element of a vector space on which there
## is an action of the algebra defined.
##
InstallMethod( LeftAlgebraModule,
 "for algebra, function of 2 args, underlying space",
 true, [ IsAlgebra, IS_FUNCTION, IsVectorSpace ], 0,
 function( A, op, V )

 local F,type,g,W,gens,B;

 F:= LeftActingDomain( A );
 type:= NewType( NewFamily( "AlgModElementsFam",
 IsLeftAlgebraModuleElement ),
 IsPackedElementDefaultRep );
 gens:= GeneratorsOfLeftModule( V );
 if gens <> [] then
 g:= List( GeneratorsOfLeftModule( V ),
 x -> Objectify( type, [ x ] ) );
 else
 g:= [ Objectify( type, [ Zero(V) ] ) ];
 fi;

 W:= Objectify( NewType( FamilyObj( g ),
 IsLeftModule and IsAttributeStoringRep ),
 rec() );
 SetLeftActingDomain( W, F );
 SetGeneratorsOfAlgebraModule( W, g );
 ElementsFamily( FamilyObj( W ) )!.left_operation:= op;
 ElementsFamily( FamilyObj( W ) )!.packedType:= type;
 ElementsFamily( FamilyObj( W ) )!.underlyingModuleEltsFam:=
 FamilyObj( Zero(V) );
 SetZero( ElementsFamily( FamilyObj( W ) ), Zero( g[1] ) );
 FamilyObj( W )!.leftAlgebraElementsFam:= ElementsFamily( FamilyObj(A) );
 SetIsAlgebraModule( W, true );
 SetLeftActingAlgebra( W, A );
 SetUnderlyingLeftModule( W, V );

 if HasBasis( V ) then
 B:= Objectify( NewType( FamilyObj( W ),
 IsFiniteBasisDefault and
 IsBasisOfAlgebraModuleElementSpace and
 IsAttributeStoringRep ),
 rec() );
 SetUnderlyingLeftModule( B, W );
 SetBasisVectors( B, List( Basis(V), x -> Objectify( type, [ x ] ) ));
 B!.delegateBasis:= Basis( V );
 SetDimension( W, Dimension(V) );
 SetBasis( W, B );
 fi;

 return W;

end );

#############################################################################
##
#M RightAlgebraModule( <A>, <op>, <V> )
##
## The elements of an algebra module lie in the representation
## `IsPackedElementDefaultRep': if <v> is an element of an algebra
## module, then v![1] is an element of a vector space on which there
## is an action of the algebra defined.
##
InstallMethod( RightAlgebraModule,
 "for algebra, function of 2 args, underlying space",
 true, [ IsAlgebra, IS_FUNCTION, IsVectorSpace ], 0,
 function( A, op, V )

 local F,type,g,W,gens,B;

 F:= LeftActingDomain( A );
 type:= NewType( NewFamily( "AlgModElementsFam",
 IsRightAlgebraModuleElement ),
 IsPackedElementDefaultRep );
 gens:= GeneratorsOfLeftModule( V );
 if gens <> [] then
 g:= List( GeneratorsOfLeftModule( V ),
 x -> Objectify( type, [ x ] ) );
 else
 g:= [ Objectify( type, [ Zero(V) ] ) ];
 fi;

 W:= Objectify( NewType( FamilyObj( g ),
 IsLeftModule and IsAttributeStoringRep ),
 rec() );
 SetLeftActingDomain( W, F );
 SetGeneratorsOfAlgebraModule( W, g );
 ElementsFamily( FamilyObj( W ) )!.right_operation:= op;
 ElementsFamily( FamilyObj( W ) )!.packedType:= type;
 ElementsFamily( FamilyObj( W ) )!.underlyingModuleEltsFam:=
 FamilyObj( Zero(V) );
 SetZero( ElementsFamily( FamilyObj( W ) ), Zero( g[1] ) );
 FamilyObj( W )!.rightAlgebraElementsFam:= ElementsFamily( FamilyObj(A) );
 SetIsAlgebraModule( W, true );
 SetRightActingAlgebra( W, A );
 SetUnderlyingLeftModule( W, V );

 if HasBasis( V ) then
 B:= Objectify( NewType( FamilyObj( W ),
 IsFiniteBasisDefault and
 IsBasisOfAlgebraModuleElementSpace and
 IsAttributeStoringRep ),
 rec() );
 SetUnderlyingLeftModule( B, W );
 SetBasisVectors( B, List( Basis(V), x -> Objectify( type, [ x ] ) ));
 B!.delegateBasis:= Basis( V );
 SetDimension( W, Dimension(V) );
 SetBasis( W, B );
 fi;

 return W;

end );

#############################################################################
##
#M BiAlgebraModule( <A>, , <opl>, <opr>, <V> )
##
## The elements of an algebra module lie in the representation
## `IsPackedElementDefaultRep': if <v> is an element of an algebra
## module, then v![1] is an element of a vector space on which there
## is an action of the algebra defined.
##
InstallMethod( BiAlgebraModule,
 "for 2 algebras, function of 2 args, function of 2 args, module generators",
 true,
 [ IsAlgebra, IsAlgebra, IS_FUNCTION, IS_FUNCTION, IsVectorSpace], 0,
 function( A, B, opl, opr, V )

 local F, type, g, W, Ba, gens;

 F:= LeftActingDomain( A );
 type:= NewType( NewFamily( "AlgModElementsFam",
 IsLeftAlgebraModuleElement and
 IsRightAlgebraModuleElement ),
 IsPackedElementDefaultRep );
 gens:= GeneratorsOfLeftModule( V );
 if gens <> [] then
 g:= List( GeneratorsOfLeftModule( V ),
 x -> Objectify( type, [ x ] ) );
 else
 g:= [ Objectify( type, [ Zero(V) ] ) ];
 fi;

 W:= Objectify( NewType( FamilyObj( g ),
 IsLeftModule and IsAttributeStoringRep ),
 rec() );
 SetLeftActingDomain( W, F );
 SetGeneratorsOfAlgebraModule( W, g );
 ElementsFamily( FamilyObj( W ) )!.left_operation:= opl;
 ElementsFamily( FamilyObj( W ) )!.right_operation:= opr;
 ElementsFamily( FamilyObj( W ) )!.packedType:= type;
 ElementsFamily( FamilyObj( W ) )!.underlyingModuleEltsFam:=
 FamilyObj( Zero(V) );
 FamilyObj( W )!.leftAlgebraElementsFam:= ElementsFamily( FamilyObj(A) );
 FamilyObj( W )!.rightAlgebraElementsFam:= ElementsFamily( FamilyObj(B) );
 SetIsAlgebraModule( W, true );
 SetLeftActingAlgebra( W, A );
 SetRightActingAlgebra( W, B );
 SetZero( ElementsFamily( FamilyObj( W ) ), Zero( g[1] ) );
 SetUnderlyingLeftModule( W, V );

 if HasBasis( V ) then
 Ba:= Objectify( NewType( FamilyObj( W ),
 IsFiniteBasisDefault and
 IsBasisOfAlgebraModuleElementSpace and
 IsAttributeStoringRep ),
 rec() );
 SetUnderlyingLeftModule( Ba, W );
 SetBasisVectors( Ba, List( Basis(V), x -> Objectify( type, [ x ])));
 Ba!.delegateBasis:= Basis( V );
 SetDimension( W, Dimension(V) );
 SetBasis( W, Ba );
 fi;

 return W;

end );

############################################################################
##
#R IsMutableBasisViaUnderlyingMutableBasisRep( )
##
DeclareRepresentation( "IsMutableBasisViaUnderlyingMutableBasisRep",
 IsComponentObjectRep,
 [ "moduleElementsFam", "underlyingMutableBasis" ] );

############################################################################
##
#M MutableBasis( <R>, <vectors> )
#M MutableBasis( <R>, <vectors>, <zero> )
##
## Mutable bases of algebra modules delegate the work to corresponding
## mutable bases of the underlying vector spaces.
##
InstallMethod( MutableBasis,
 "for ring and vectors",
 true,
 [ IsRing, IsAlgebraModuleElementCollection ], 0,
 function( R, vectors )
 local B;

 if ForAll( vectors, IsZero ) then
 return MutableBasis( R, [], vectors[1] );
 fi;

 B:= rec(
 moduleElementsFamily:= FamilyObj( vectors[1] ),
 underlyingMutableBasis:= MutableBasis( R,
 List( vectors, ExtRepOfObj ) )
 );

 return Objectify( NewType( FamilyObj( vectors ),
 IsMutableBasis
 and IsMutable
 and IsMutableBasisViaUnderlyingMutableBasisRep ),
 B );
end );

InstallOtherMethod( MutableBasis,
 "for ring, list and zero",
 true,
 [ IsRing, IsList, IsAlgebraModuleElement ], 0,
 function( R, vectors, zero )
 local B;

 B:= rec(
 moduleElementsFamily:= FamilyObj( zero ),
 underlyingMutableBasis:= MutableBasis( R,
 List( vectors, ExtRepOfObj ),
 ExtRepOfObj( zero ) )
 );

 return Objectify( NewType( CollectionsFamily( FamilyObj( zero ) ),
 IsMutableBasis
 and IsMutable
 and IsMutableBasisViaUnderlyingMutableBasisRep ),
 B );
end );

#############################################################################
##
#M PrintObj( <MB> ) . . . . . . . . . . . . . . . . . . view a mutable basis
##
InstallMethod( PrintObj,
 "for mutable basis with underlying mutable basis",
 true,
 [ IsMutableBasis and IsMutableBasisViaUnderlyingMutableBasisRep ], 0,
 function( MB )
 Print( "<mutable basis with " );
 Print( NrBasisVectors( MB ), " vectors>" );
 end );

############################################################################
##
#M BasisVectors( <MB> )
#M CloseMutableBasis( <MB>, <v> )
#M IsContainedInSpan( <MB>, <v> )
##
InstallOtherMethod( BasisVectors,
 "for mutable basis with underlying mutable basis",
 true,
 [ IsMutableBasis and IsMutableBasisViaUnderlyingMutableBasisRep ], 0,
 function( MB )
 # return the basis vectors of the underlying mutable basis, wrapped up.
 return List( BasisVectors( MB!.underlyingMutableBasis ), x ->
 ObjByExtRep( MB!.moduleElementsFamily, x ));
end );

InstallMethod( CloseMutableBasis,
 "for mutable basis with underlying mutable basis, and vector",
 IsCollsElms,
 [ IsMutableBasis and IsMutable and
 IsMutableBasisViaUnderlyingMutableBasisRep, IsVector ], 0,
 function( MB, v )
 return CloseMutableBasis( MB!.underlyingMutableBasis, ExtRepOfObj( v ) );

end );

InstallMethod( IsContainedInSpan,
 "for mutable basis with underlying mutable basis, and vector",
 IsCollsElms,
 [ IsMutableBasis and IsMutable and
 IsMutableBasisViaUnderlyingMutableBasisRep, IsVector ], 0,
 function( MB, v )

 return IsContainedInSpan( MB!.underlyingMutableBasis,
 ExtRepOfObj( v ) );
end );

#############################################################################
##
#M ActingAlgebra( <V> ) . . . . . . . . . . . . for an algebra module
##
InstallMethod( ActingAlgebra,
 "for an algebra module",
 true, [ IsAlgebraModule ], 0,
 function( V )

 if IsLeftAlgebraModuleElementCollection( V ) then
 if IsRightAlgebraModuleElementCollection( V ) then
 Error("ActingAlgebra is not defined for bi-modules");
 else
 return LeftActingAlgebra( V );
 fi;
 else
 return RightActingAlgebra( V );
 fi;
end );

#############################################################################
##
#M PrintObj( <obj> ) . . . . . . . . . . . . . . . for algebra module element
##
InstallMethod( PrintObj,
 "for algebra module element in packed representation",
 true, [ IsAlgebraModuleElement and IsPackedElementDefaultRep], 0,
 function( v ) Print( v![1] ); end );

#############################################################################
##
#M \=( , <v> ) . . . . . . . . . . . . . . . for algebra module elements
#M \<( , <v> ) . . . . . . . . . . . . . . . for algebra module elements
#M \+( , <v> ) . . . . . . . . . . . . . . . for algebra module elements
#M AdditiveInverseOp( ) . .. . . . . . . . . . . . . . . for an algebra module element
#M \*( , <scal> ) . . . . . . for an algebra module element and a scalar
#M \*( <scal>, ) . . . . . . for a scalar and an algebra module element
#M ZeroOp( ) . . . . . . . . . . . . . . . .for an algebra module element
##
##

InstallMethod(\=,
 "for two algebra module elements in packed representation",
 IsIdenticalObj, [ IsAlgebraModuleElement and IsPackedElementDefaultRep,
 IsAlgebraModuleElement and IsPackedElementDefaultRep ], 0,
 function( u, v ) return u![1] = v![1]; end );

InstallMethod(\<,
 "for two algebra module elements in packed representation",
 IsIdenticalObj, [ IsAlgebraModuleElement and IsPackedElementDefaultRep,
 IsAlgebraModuleElement and IsPackedElementDefaultRep ], 0,
 function( u, v ) return u![1] < v![1]; end );

InstallMethod(\+,
 "for two algebra module elements in packed representation",
 IsIdenticalObj, [ IsAlgebraModuleElement and IsPackedElementDefaultRep,
 IsAlgebraModuleElement and IsPackedElementDefaultRep ], 0,
 function( u, v ) return ObjByExtRep( FamilyObj( u ), u![1]+v![1] ); end );

InstallMethod(\+,
 "for an algebra module element in packed representation and a vector",
 true, [ IsAlgebraModuleElement and IsPackedElementDefaultRep,
 IsVector ], 0,
 function( u, v ) return ObjByExtRep( FamilyObj( u ), u![1]+v ); end );

InstallMethod(\+,
 "for a vector and an algebra module element in packed representation",
 true, [ IsVector,
 IsAlgebraModuleElement and IsPackedElementDefaultRep ], 0,
 function( u, v ) return ObjByExtRep( FamilyObj( v ), u+v![1] ); end );

InstallMethod( AdditiveInverseOp,
 "for an algebra module element in packed representation",
 true, [ IsAlgebraModuleElement and IsPackedElementDefaultRep ], 0,
 function( u ) return ObjByExtRep( FamilyObj(u), -u![1] ); end );

InstallMethod( \*,
 "for an algebra module element in packed representation and a scalar",
 true, [ IsAlgebraModuleElement and IsPackedElementDefaultRep,
 IsScalar ], 0,
 function( u, scal ) return ObjByExtRep( FamilyObj(u), scal*u![1] );
 end );

InstallMethod( \*,
 "for a scalar and an algebra module element in packed representation",
 true, [ IsScalar, IsAlgebraModuleElement and IsPackedElementDefaultRep],0,
 function( scal, u ) return ObjByExtRep( FamilyObj(u), scal*u![1] );
 end );

InstallMethod( ZeroOp,
 "for an algebra module element in packed representation",
 true, [ IsAlgebraModuleElement and IsPackedElementDefaultRep ], 0,
 function( u ) return ObjByExtRep( FamilyObj(u), 0*u![1] ); end );

#############################################################################
##
#M \*( <obj>, <vec> ) . . . . . . . . . . . for a Lie object and a row vector
#M \*( <vec>, <obj> ) . . . . . . . . . . . for a row vector and a Lie object
##
##
InstallMethod( \*,
 "for Lie object and row vector",
 true, [ IsLieObject and IsPackedElementDefaultRep, IsRowVector ], 0,
 function( m, v )
 return m![1]*v;
 end );

InstallMethod( \*,
 "for row vector and Lie object",
 true, [ IsRowVector, IsLieObject and IsPackedElementDefaultRep ], 0,
 function( v, m )
 return v*m![1];
 end );

#############################################################################
##
#M \^( <a>, <v> ) . . . . . . . . . . . . for algebra elt, and elt of module
##
## The action of an algebra element <a> on an element <v> of a left module
## is denoted by <a>^<v>.
##
InstallOtherMethod( \^,
 "for an algebra element and an element of an algebra module",
 function( F1, F2 )
 return CollectionsFamily( F2 )!.leftAlgebraElementsFam = F1;
 end,
 [ IsRingElement,
 IsLeftAlgebraModuleElement and IsPackedElementDefaultRep ], 0,
 function( x, u )
 return ObjByExtRep( FamilyObj( u ),
 FamilyObj( u )!.left_operation(x,u![1]));
end );

#############################################################################
##
#M \^( <a>, <v> ) . . . . . . . . . . . . for algebra elt, and elt of module
##
## The action of an algebra element <a> on an element <v> of a right module
## is denoted by <v>^<a>.
##
InstallOtherMethod( \^,
 "for an algebra element and an element of an algebra module",
 function( F1, F2 )
 return CollectionsFamily( F1 )!.rightAlgebraElementsFam = F2;
 end,
 [ IsRightAlgebraModuleElement and IsPackedElementDefaultRep,
 IsRingElement ], 0,
 function( u, x )
 return ObjByExtRep( FamilyObj( u ),
 FamilyObj( u )!.right_operation(u![1],x));
end );

#############################################################################
##
#M Basis( <V> ) . . . . . . . . . . . . . . . . . . . for an algebra module
#M Basis( <V> ) . . . . . . . . . . for a space of algebra module elements
##
InstallMethod( Basis,
 "for an algebra module",
 true, [ IsFreeLeftModule and IsAlgebraModule ], 0,
 function( V )

 local A, gens, F, fam, B, vecs, from, op, ready;

 gens:= GeneratorsOfAlgebraModule( V );
 F:= LeftActingDomain( V );
 fam:= ElementsFamily( FamilyObj( V ) );
 if IsLeftAlgebraModuleElementCollection( V ) then
 if IsRightAlgebraModuleElementCollection( V ) then

 # We let the algebra act alternatingly from the left
 # and the right.
 vecs:= List( gens, ExtRepOfObj );
 from:= "left";
 op:= fam!.left_operation;
 ready:= false;
 A:= LeftActingAlgebra( V );

 while not ready do
 B:= MutableBasisOfClosureUnderAction( F,
 GeneratorsOfAlgebra( A ),
 from,
 vecs,
 op,
 ExtRepOfObj( Zero(V) ), "infinity" );
 if Length( BasisVectors( B ) ) = Length( vecs ) and
 from = "right" then
 # from = "right", means that we acted both from the
 # left and the right, and we did not find anything new.
 # So we have a set of vectors closed under both the
 # left and the right action.
 ready:= true;
 else
 vecs:= BasisVectors( B );
 if from = "left" then
 from:= "right";
 op:= fam!.right_operation;
 A:= RightActingAlgebra( V );
 else
 from:= "left";
 op:= fam!.left_operation;
 A:= LeftActingAlgebra( V );
 fi;
 fi;

 od;

 vecs:= List( vecs, x -> ObjByExtRep( fam, x ) );
 SetDimension( V, Length( vecs ) );
 return BasisOfAlgebraModule( V, vecs );

 else
 from:= "left";
 op:= fam!.left_operation;
 A:= LeftActingAlgebra( V );
 fi;
 else
 from:= "right";
 op:= fam!.right_operation;
 A:= RightActingAlgebra( V );
 fi;
 B:= MutableBasisOfClosureUnderAction( F,
 GeneratorsOfAlgebra( A ),
 from,
 List( gens, ExtRepOfObj ),
 op,
 ExtRepOfObj( Zero(V) ), "infinity" );
 vecs:= List( BasisVectors(B), x -> ObjByExtRep( fam, x ) );
 SetDimension( V, Length( vecs ) );
 return BasisOfAlgebraModule( V, vecs );
end );

InstallMethod( Basis,
 "for a space of algebra module elements",
 true, [ IsFreeLeftModule and IsAlgebraModuleElementCollection ], 0,
 function( V )

 local g, fam, B, vecs;

 if HasIsAlgebraModule( V ) and IsAlgebraModule( V ) then
 TryNextMethod();
 fi;

 # In this case `V' is just a vector space of algebra module
 # elements, so there is no need to apply the action of an
 # algebra to get the basis.

 g:= List( GeneratorsOfLeftModule( V ), ExtRepOfObj );
 fam:= ElementsFamily( FamilyObj( V ) );
 B:= Basis( VectorSpace( LeftActingDomain( V ), g ) );
 vecs:= List( BasisVectors(B), x -> ObjByExtRep( fam, x ) );
 return BasisOfAlgebraModule( V, vecs );
end );

##############################################################################
##
#M Coefficients( , <v> ). . . . . . for basis of a space of algebra
## module elements and vector
##
InstallMethod( Coefficients,
 "for basis of a space of algebra module elements, and algebra module element",
 true, [ IsBasisOfAlgebraModuleElementSpace,
 IsAlgebraModuleElement and IsPackedElementDefaultRep ], 0,
 function( B, v )

 return Coefficients( B!.delegateBasis, v![1] );
end );

##############################################################################
##
#M Basis( <V>, <vecs> )
#M BasisNC( <V>, <vecs> )
##
## The basis of the space of algebra module elements <V> consisting of the
## vectors in <vecs>.
## In the NC version it is not checked whether the elements of <vecs> are
## linearly independent.
##
InstallMethod( Basis,
 "for a space of algebra module elements and a collection of algebra module elements",
 IsIdenticalObj,
 [ IsFreeLeftModule and IsAlgebraModuleElementCollection,
 IsAlgebraModuleElementCollection and IsList ], 0,
 function( V, vectors )

 local W;

 if not ForAll( vectors, x -> x in V ) then return fail; fi;

 W:= VectorSpace( LeftActingDomain(V), List( vectors, ExtRepOfObj ) );
 if Dimension( W ) <> Length( vectors ) then return fail; fi;
 return BasisOfAlgebraModule( V, vectors );
end );

InstallMethod( BasisNC,
 "for a space of algebra module elements and a collection of algebra module elements",
 IsIdenticalObj,
 [ IsFreeLeftModule and IsAlgebraModuleElementCollection,
 IsAlgebraModuleElementCollection and IsList ], 0,
 function( V, vectors )

 return BasisOfAlgebraModule( V, vectors );
end );

##########################################################################
##
#M IsFiniteDimensional( <V> ) . . . . . . . . for a space of algebra module
## elements
##
InstallMethod( IsFiniteDimensional,
 "for a space of algebra module elements",
 true, [ IsFreeLeftModule and IsAlgebraModuleElementCollection ], 0,
 function( V )

 return Length( Basis( V ) ) < infinity;
end );

##########################################################################
##
#M GeneratorsOfLeftModule( <V> ) . . . . . . . . for a space of algebra
## module elements
##
InstallMethod( GeneratorsOfLeftModule,
 "for a space of algebra module elements",
 true, [ IsFreeLeftModule and IsAlgebraModuleElementCollection ], 0,
 function( V )

 return BasisVectors( Basis( V ) );
end );

############################################################################
##
#M SubAlgebraModule( <V>, <gens> [,<"basis">] )
##
## Is the submodule of <V> generated by <gens>.
##
BindGlobal("_SubAlgebraModuleHelper", function( V, gens, args... )
 local sub, isBasis;

 if Length(args)>0 and args[1]<>"basis" then
 Error( "Usage: SubAlgebraModule( <V>, <gens>, <str>) where the last argument is string \"basis\"" );
 fi;
 isBasis := Length(gens) = 0 or (Length(args)>0 and args[1]="basis");

 sub:= Objectify( NewType( FamilyObj( V ),
 IsLeftModule and IsAttributeStoringRep ), rec() );
 SetIsAlgebraModule( sub, true );
 SetLeftActingDomain( sub, LeftActingDomain( V ) );
 SetGeneratorsOfAlgebraModule( sub, gens );

 if HasIsFiniteDimensional( V ) and IsFiniteDimensional( V ) then
 SetIsFiniteDimensional( sub, true );
 fi;

 if IsLeftAlgebraModuleElementCollection( V ) then
 SetLeftActingAlgebra( sub, LeftActingAlgebra( V ) );
 fi;

 if IsRightAlgebraModuleElementCollection( V ) then
 SetRightActingAlgebra( sub, RightActingAlgebra( V ) );
 fi;

 if isBasis then
 SetGeneratorsOfLeftModule( sub, gens );
 SetBasis( sub, BasisOfAlgebraModule( sub, gens ) );
 SetDimension( sub, Length( gens ) );
 fi;

 return sub;
end );

InstallMethod( SubAlgebraModule,
 "for algebra module, and a list of submodule generators",
 IsIdenticalObj,
 [ IsFreeLeftModule and IsAlgebraModule,
 IsAlgebraModuleElementCollection and IsList ],
 _SubAlgebraModuleHelper );

InstallOtherMethod( SubAlgebraModule,
 "for algebra module, and an empty list of submodule generators",
 [ IsFreeLeftModule and IsAlgebraModule,
 IsEmpty and IsList ],
 _SubAlgebraModuleHelper );

InstallOtherMethod( SubAlgebraModule,
 "for algebra module, and a list of submodule generators, and string",
 IsFamFamX,
 [ IsFreeLeftModule and IsAlgebraModule,
 IsAlgebraModuleElementCollection and IsList,
 IsString ],
 _SubAlgebraModuleHelper );

InstallOtherMethod( SubAlgebraModule,
 "for algebra module, and an empty list of submodule generators, and string",
 [ IsFreeLeftModule and IsAlgebraModule,
 IsEmpty and IsList,
 IsString ],
 _SubAlgebraModuleHelper );

##############################################################################
##
#M LeftModuleByHomomorphismToMatAlg( <A>, <f> ) . . for algebra and hom to
## matrix algebra
##
InstallMethod( LeftModuleByHomomorphismToMatAlg,
 "for an algebra and a homomorphism to a matrix algebra",
 true, [ IsAlgebra, IsAlgebraHomomorphism ], 0,
 function( A, f )

 local zero,bas;

 if not A = Source(f) then
 Error( "<A> must be the source of the homomorphism <f>" );
 fi;

 zero:= Zero( Range( f ) );
 if not IsMatrix( zero ) then
 Error( "the range of <f> must be a matrix algebra" );
 fi;

 bas:= IdentityMat( Length(zero), LeftActingDomain(A) );
 return LeftAlgebraModuleByGenerators( A,
 function( x, v ) return Image( f, x )*v; end,
 bas, "basis");

 end );

##############################################################################
##
#M RightModuleByHomomorphismToMatAlg( <A>, <f> ) . . for algebra and hom to
## matrix algebra
##
InstallMethod( RightModuleByHomomorphismToMatAlg,
 "for an algebra and a homomorphism to a matrix algebra",
 true, [ IsAlgebra, IsAlgebraHomomorphism ], 0,
 function( A, f )

 local zero,bas;

 if not A = Source(f) then
 Error( "<A> must be the source of the homomorphism <f>" );
 fi;

 zero:= Zero( Range( f ) );
 if not IsMatrix( zero ) then
 Error( "the range of <f> must be a matrix algebra" );
 fi;

 bas:= IdentityMat( Length(zero), LeftActingDomain(A) );
 return RightAlgebraModuleByGenerators( A,
 function( v, x ) return v*Image( f, x ); end,
 bas, "basis");

 end );

##############################################################################
##
#M AdjointModule( <A> ) . . . . . . . . . . . . . . . . . . . for an algebra
##
##
InstallMethod( AdjointModule,
 "for an algebra",
 true, [ IsAlgebra ], 0,
 function( A )

 return LeftAlgebraModule( A, function( a, b ) return a*b; end, A);

end );

#############################################################################
##
#M FaithfulModule( <A> ) . . . . . . . . . . . . for an associative algebra
##
##
InstallMethod( FaithfulModule,
 "for an algebra",
 true, [ IsAlgebra ], 0,
 function( A )

 local bb, n, BA, F, bv, i, M, j, col, B;

 if One( A ) <> fail then
 # the adjoint module is faithful.
 return AdjointModule( A );
 fi;

 # construct the adjoint representation of A on the algebra
 # gotten from A by adding a one (Dorroh extension).

 bb:= [];
 n:= Dimension( A );
 BA:= Basis( A );
 F:= LeftActingDomain( A );
 bv:= BasisVectors( BA );

 for i in [1..n] do
 M:=[];
 for j in [1..n] do
 col:= ShallowCopy( Coefficients( BA, bv[i] * bv[j] ) );
 col[n+1]:= Zero( F );
 Add( M, col );
 od;
 col:= [ 1 .. n+1 ] * Zero( F );
 col[i]:= One( F );
 Add( M, col );
 Add( bb, TransposedMat( M ) );
 od;

 B:= Algebra( Rationals, bb, "basis" );

 return LeftModuleByHomomorphismToMatAlg( A,
 AlgebraHomomorphismByImages( A, B, bv, bb ) );

end );

#############################################################################
##
#M ModuleByRestriction( <V>, ) . . .for an alg module and a subalgebra
#M ModuleByRestriction( <V>, , ) for a bi-alg module and
## two subalgebras
##
InstallMethod( ModuleByRestriction,
 "for an algebra module and a subalgebra",
 true, [ IsAlgebraModule, IsAlgebra ], 0,
 function( V, sub )

 local op, M;

 if IsLeftAlgebraModuleElementCollection( V ) then
 if IsRightAlgebraModuleElementCollection( V ) then
 return ModuleByRestriction( V, sub, sub );
 fi;
 op:= ElementsFamily( FamilyObj( V ) )!.left_operation;
 M:= UnderlyingLeftModule( V );
 if HasBasis( V ) and not HasBasis( M ) then
 if IsBound( Basis(V)!.delegateBasis ) then
 SetBasis( M, Basis(V)!.delegateBasis );
 fi;
 fi;
 return LeftAlgebraModule( sub, op, UnderlyingLeftModule( V ) );
 else
 op:= ElementsFamily( FamilyObj( V ) )!.right_operation;
 M:= UnderlyingLeftModule( V );
 if HasBasis( V ) and not HasBasis( M ) then
 if IsBound( Basis(V)!.delegateBasis ) then
 SetBasis( M, Basis(V)!.delegateBasis );
 fi;
 fi;
 return RightAlgebraModule( sub, op, M );
 fi;

end );

InstallOtherMethod( ModuleByRestriction,
 "for a bi-algebra module and a subalgebra and a subalgebra",
 true, [ IsAlgebraModule, IsAlgebra, IsAlgebra ], 0,
 function( V, subl, subr )

 local basis, gens, M;

 if IsLeftAlgebraModuleElementCollection( V ) then
 if IsRightAlgebraModuleElementCollection( V ) then
 M:= UnderlyingLeftModule( V );
 if HasBasis( V ) and not HasBasis( M ) then
 if IsBound( Basis(V)!.delegateBasis ) then
 SetBasis( M, Basis(V)!.delegateBasis );
 fi;
 fi;
 return BiAlgebraModule( subl, subr,
 ElementsFamily( FamilyObj( V ) )!.left_operation,
 ElementsFamily( FamilyObj( V ) )!.right_operation,
 M );
 else
 Error( "<V> must be a bi-module");
 fi;
 else
 Error( "<V> must be a bi-module");
 fi;

end );

########################################################################
##
#M NaturalHomomorphismBySubAlgebraModule( <V>, <W> )
##
##
InstallMethod( NaturalHomomorphismBySubAlgebraModule,
 "for algebra module and a submodule",
 IsIdenticalObj, [ IsAlgebraModule, IsAlgebraModule ], 0,
 function( V, W )

 local f, quot, left_op, right_op, bb, qmod, imgs, nathom;

 f:= NaturalHomomorphismBySubspace( V, W );
 quot:= ImagesSource( f );

 if IsTrivial(quot) then
 quot := SubAlgebraModule( V, [], "basis" );
 nathom := ZeroMapping( V, quot );
 SetIsSurjective( nathom, true );
 SetImagesSource(nathom, quot);
 SetKernelOfAdditiveGeneralMapping( nathom, W );
 return nathom;
 fi;

 imgs:= List( Basis( V ), x -> Coefficients( Basis( quot ),
 ImagesRepresentative(f,x)));

 # We make V/W into an algebra module and produce new linear map from
 # V into this module, doing exactly the same as f does.

 if IsLeftAlgebraModuleElementCollection( V ) then
 if IsRightAlgebraModuleElementCollection( V ) then
 left_op:= function( x, v )
 return ImagesRepresentative( f, x^PreImagesRepresentative( f, v ) );
 end;
 right_op:= function( v, x )
 return ImagesRepresentative( f, PreImagesRepresentative( f, v )^x );
 end;
 qmod:= BiAlgebraModule( LeftActingAlgebra( V ),
 RightActingAlgebra( V ),
 left_op, right_op, quot );
 else
 left_op:= function( x, v )
 return ImagesRepresentative( f, x^PreImagesRepresentative( f, v ) );
 end;
 qmod:= LeftAlgebraModule( LeftActingAlgebra( V ),
 left_op, quot);
 fi;
 else
 right_op:= function( v, x )
 return ImagesRepresentative( f, PreImagesRepresentative( f, v )^x );
 end;
 qmod:= RightAlgebraModule( RightActingAlgebra( V ),
 right_op, quot );
 fi;

 nathom:= LeftModuleHomomorphismByMatrix( Basis( V ), imgs, Basis( qmod ) );
 SetIsSurjective( nathom, true );

 # Enter the preimages info.
 nathom!.basisimage:= Basis( qmod );
 if IsBound(f!.preimagesbasisimage) then
 nathom!.preimagesbasisimage:= f!.preimagesbasisimage;
 fi;
 SetKernelOfAdditiveGeneralMapping( nathom, W );

 # Run the implications for the factor.
 UseFactorRelation( V, W, qmod );

 return nathom;

end );

#############################################################################
##
#M \/( <V>, <W> ) . . . . . . . factor of an algebra module by a submodule
#M \/( <V>, <vectors> ) . . . . factor of an algebra module by a submodule
##
InstallOtherMethod( \/,
 "for an algebra module and collection",
 IsIdenticalObj,
 [ IsVectorSpace and IsAlgebraModule, IsCollection ], 0,
 function( V, vectors )
 if IsAlgebraModule( vectors ) then
 TryNextMethod();
 else
 return V / SubAlgebraModule( V, vectors );
 fi;
end );

InstallOtherMethod( \/,
 "for two algebra modules",
 IsIdenticalObj,
 [ IsVectorSpace and IsAlgebraModule, IsAlgebraModule ], 0,
 function( V, W )
 return ImagesSource( NaturalHomomorphismBySubAlgebraModule( V, W ) );
end );

##############################################################################
##
#M MatrixOfAction( , <x> )
#M MatrixOfAction( , <x>, <side> )
##
InstallMethod( MatrixOfAction,
 "for a basis of an algebra module and an algebra element",
 true, [ IsBasisOfAlgebraModuleElementSpace, IsObject ], 0,
 function( B, x )

 if IsRightAlgebraModuleElementCollection( B ) then
 if IsLeftAlgebraModuleElementCollection( B ) then
 Error( "usage MatrixOfAction( , <x>, <side> )" );
 fi;

 return List( B, b -> Coefficients( B, b^x ) );
 else
 return TransposedMatDestructive(
 List( B, b -> ShallowCopy( Coefficients( B, x^b ) ) ) );
 fi;

end );

InstallOtherMethod( MatrixOfAction,
 "for a basis of an algebra module, an algebra element and a side",
 true, [ IsBasisOfAlgebraModuleElementSpace, IsObject, IsObject ], 0,
 function( B, x, side )

 if side = "right" then
 return List( B, b -> Coefficients( B, b^x ) );
 else
 return TransposedMatDestructive(
 List( B, b -> ShallowCopy( Coefficients( B, x^b ) ) ) );
 fi;

end );

##############################################################################
##
#R IsMonomialElementRep( <obj> )
##
## A monomial element is a list of two components: the first component
## is a list of the form [ t1, c1, t2, c2...] where the ci are coefficients,
## and the ti are monomials (where the meaning of the word `monomial'
## may differ according to the context).
## The second component is `true' or `false',
## `true' if the monomial element is in normal form, `false' otherwise.
##
DeclareRepresentation( "IsMonomialElementRep", IsPositionalObjectRep, [1,2] );

############################################################################
##
#M ObjByExtRep( <fam>, <list> ) . . . for a MonomialElementFamily and a list
#M ExtRepOfObj( <t> ) . . . . . . . for a monomial element in monomial rep.
##
InstallMethod( ObjByExtRep,
 "for a family of monomial elements and a list",
 true, [ IsMonomialElementFamily, IsList] , 0,
 function( fam, list )
 return Objectify( fam!.monomialElementDefaultType,
 [ Immutable( list ), false ] );
end );

InstallMethod( ExtRepOfObj,
 "for a monomial element",
 true, [ IsMonomialElement and IsMonomialElementRep ] , 0,
 function( t ) return t![1];
end );

##############################################################################
##
#M ZeroOp( <m> ) . . . . . . . . . . . . . . for a monomial element
#M \+( <m1>, <m2> ) . . . . . . . . . . . . for two monomial elements
#M AdditiveInverseOp( <m> ) . . . . . . . . . . . . . . . for a monomial element
#M \*( <m>, <scal> ) . . . . . . . . . . for a monomial element and a scalar
#M \*( <scal>, <m> ) . . . . . . . . . . for scalar and a monomial element
#M \<( <m1>, <m2> ) . . . . . . . . . . . . for two monomial elements
#M \=( <m1>, <m2> ) . . . . . . . . . . . . for two monomial elements
##
InstallMethod( ZeroOp,
 "for monomial elements",
 true, [ IsMonomialElement and IsMonomialElementRep ], 0,
 function( u )
 local res;
 res:= ObjByExtRep( FamilyObj( u ),
 [ [], FamilyObj(u)!.zeroCoefficient ] );
 res![2]:= true;
 return res;
end );

InstallMethod(\+,
 "for monomial elements",
 IsIdenticalObj,
 [ IsMonomialElement and IsMonomialElementRep,
 IsMonomialElement and IsMonomialElementRep], 0,
 function( u, v )

 local lu,lv,zero, sum, res;

 # We assume that the monomials in the monomial elements are sorted
 # according to \<.

 lu:= u![1];
 lv:= v![1];
 zero:= FamilyObj( u )!.zeroCoefficient;
 sum:= ZippedSum( lu, lv, zero, [\<,\+] );
 if Length( sum ) >= 2 then
 if sum[1] = [] and sum[2] = zero then
 Remove( sum, 1 );
 Remove( sum, 1 );
 fi;
 fi;
 if sum = [ ] then sum:= [ [], zero ]; fi;
 res:= ObjByExtRep( FamilyObj( u ), sum );
 if u![2] and v![2] then res![2]:= true; fi;
 return res;

end );

InstallMethod( AdditiveInverseOp,
 "for a monomial element",
 true,
 [ IsMonomialElement and IsMonomialElementRep ], 0,
 function( u )

 local lu,k,res;

 lu:= ShallowCopy( u![1] );
 for k in [2,4..Length(lu)] do
 lu[k]:= -lu[k];
 od;
 res:= ObjByExtRep( FamilyObj( u ), lu );
 if u![2] then res![2]:= true; fi;
 return res;

end );

InstallMethod(\*,
 "for a monomial element and a scalar",
 true,
 [ IsMonomialElement and IsMonomialElementRep, IsRingElement ], 0,
 function( u, scal )
 local lu,k,res;

 if IsZero(scal) then return Zero(u); fi;
 lu:= ShallowCopy( u![1] );
 for k in [2,4..Length(lu)] do
 lu[k]:= scal*lu[k];
 od;
 res:= ObjByExtRep( FamilyObj( u ), lu );
 if u![2] then res![2]:= true; fi;
 return res;

end );

InstallMethod(\*,
 "for a scalar and a monomial element",
 true,
 [ IsRingElement, IsMonomialElement and IsMonomialElementRep ], 0,
 function( scal, u )
 local lu,k,res;

 if IsZero(scal) then return Zero(u); fi;
 lu:= ShallowCopy( u![1] );
 for k in [2,4..Length(lu)] do
 lu[k]:= scal*lu[k];
 od;
 res:= ObjByExtRep( FamilyObj( u ), lu );
 if u![2] then res![2]:= true; fi;
 return res;

end );

InstallMethod(\<,
 "for monomial elements",
 IsIdenticalObj,
 [ IsMonomialElement and IsMonomialElementRep,
 IsMonomialElement and IsMonomialElementRep], 0,
 function( u, v )
 local u1, v1;

 u1:= ConvertToNormalFormMonomialElement( u );
 v1:= ConvertToNormalFormMonomialElement( v );
 return u1![1] < v1![1];
end );

InstallMethod(\=,
 "for monomial elements",
 IsIdenticalObj,
 [ IsMonomialElement and IsMonomialElementRep,
 IsMonomialElement and IsMonomialElementRep], 0,
 function( u, v )

 local u1, v1;

 u1:= ConvertToNormalFormMonomialElement( u );
 v1:= ConvertToNormalFormMonomialElement( v );
 return u1![1] = v1![1];
end );

############################################################################
##
#F TriangulizeMonomialElementList( <tt>, <zero>, <LM>, <LC> )
##
## Here <tt> is a list of monomial elements, <zero> is the zero
## of the ground field, <LM> is a function that calculates the
## leading monomial of a monomial element (with respect to the ordering
## \<), and <LC> is a function calculating the coefficient of the
## leading monomial of a monomial element.
##
## This function triangulizes the list <tt>, and returns a record with
## the following components:
##
## echelonbas: a list of basis vectors of the space spanned by <tt>,
## in echelon form (with leading coefficients 1).
##
## heads: a list of leading monomials of the elements of `echelonbas'.
##
## basechange: a list of the same length as `ecelonbas' describing
## the elements of `echlonbas' as linear combinations of the original
## elements of `tt'. The elements of `basechange' are lists of the form
## `[ l1, l2,...,lk ]', where the `li' are lists of the form `[ ind, cf ]';
## the i-th element of `echelonbas' is the sum of `cf*tt[ind]'
## when we loop over the entire list `basechange[i]'.
##
## All of this is used to produce a basis of the space spaned by
## `tt'.
##
BindGlobal( "TriangulizeMonomialElementList", function( tt, zero, LM, LC )

 local basechange, heads, k, cf, i, head, b, b1, pos;

 # Initially `basechange' is just the identity.
 # We sort `tt' to get the smallest leading monomials first.

 basechange:= List( [1..Length(tt)], x -> [ [ x, One( zero ) ] ] );
 SortParallel( tt, basechange,
 function( u, v ) return LM(u) < LM(v); end );

 heads:= [ ];
 k:= 1;

 # We perform a Gaussian elimination...

 while k <= Length( tt ) do

 if IsZero( tt[k] ) then

 # Get rid of it.
 Remove( tt, k );
 Remove( basechange, k );
 else

 # Eliminate all instances of `LM( tt[k] )' that occur `below'
 # `tt[k]'.
 cf:= LC( tt[k] );
 tt[k]:= (1/cf)*tt[k];
 for i in [1..Length(basechange[k])] do
 basechange[k][i][2]:= basechange[k][i][2]/cf;
 od;

 head:= LM( tt[k] );
 Add( heads, head );
 i:= k+1;
 while i <= Length(tt) do
 if LM( tt[i] ) = head then
 cf:= LC( tt[i] );
 tt[i]:= tt[i] - cf*tt[k];
 if IsZero( tt[i] ) then

 # Get rid of it.
 Remove( tt, i );
 Remove( basechange, i );
 else

 # Adjust the i-th entry in basechange, we basically
 # subtract `cf' times the k-th entry of basechange.
 for b in basechange[k] do
 b1:= [ b[1], -cf*b[2] ];
 pos := PositionSorted( basechange[i], [b[1]]);
 if pos > Length( basechange[i] ) or
 basechange[i][pos][1] <> b1[1] then
 Add(basechange[i],b1,pos);
 else
 basechange[i][pos][2]:= basechange[i][pos][2]+
 b1[2];
 fi;

 od;
 i:= i+1;
 fi;
 else
 i:= i+1;
 fi;
 od;
 k:= k+1;
 fi;
 # sort the lists again...
 SortParallel( tt, basechange,
 function( u, v ) return LM(u) < LM(v); end );
 od;

 return rec( echelonbas:= tt, heads:= heads, basechange:= basechange );

end );

#############################################################################
##
#R IsBasisOfMonomialSpaceRep( )
##
## A basis of a monomial space knows the output of
## `TriangulizeMonomialElementList' with its basis vectors as input.
## It also knows the zero of the ground field.
##
DeclareRepresentation( "IsBasisOfMonomialSpaceRep", IsComponentObjectRep,
 [ "echelonBasis", "heads", "baseChange", "zeroCoefficient" ] );

#############################################################################
##
#F BasisOfMonomialSpace( <V>, <vecs> ) for space of monomial elements
## and a list of elements thereof
##
BindGlobal( "BasisOfMonomialSpace",
 function( V, vectors )
 local B;

 B:= Objectify( NewType( FamilyObj( V ),
 IsFiniteBasisDefault and
 IsBasisOfMonomialSpaceRep and
 IsAttributeStoringRep ),
 rec() );
 SetUnderlyingLeftModule( B, V );
 SetBasisVectors( B, vectors );

 return B;

end );

##############################################################################
##
#M Basis( <V>, <vecs> )
#M BasisNC( <V>, <vecs> )
##
## The basis of the space of monomial elements <V> consisting of the
## vectors in <vecs>.
## In the NC version it is not checked whether the elements of <vecs> lie
## in <V>.
##
## In both cases the list of vectors <vecs> is triangulized, and the data
## produced by this is stored in the basis.
##
InstallMethod( Basis,
 "for a space of monomial elements and a list of tensor elements",
 IsIdenticalObj,
 [ IsFreeLeftModule and IsMonomialElementCollection,
 IsMonomialElementCollection and IsList ], SUM_FLAGS,
 function( V, vectors )

 local B, info;

 if not ForAll( vectors, x -> x in V ) then return fail; fi;

 # A call to `ConvertToNormalFormMonomialElement' makes sure
 # that all monomial elements
 # are in normal form, and that they are all sorted. So the leading
 # element is just the first element in the list etc.

 vectors:= List( vectors, x -> ConvertToNormalFormMonomialElement( x ) );
 info:= TriangulizeMonomialElementList( ShallowCopy( vectors ),
 ElementsFamily(FamilyObj(V))!.zeroCoefficient,
 x -> ExtRepOfObj(x)[1],
 x -> ExtRepOfObj(x)[2] );
 if Length( info.echelonbas ) <> Length( vectors ) then return fail; fi;
 B:= BasisOfMonomialSpace( V, vectors );
 B!.echelonBasis:= info.echelonbas;
 B!.heads:= info.heads;
 B!.baseChange:= info.basechange;
 B!.zeroCoefficient:= ElementsFamily(FamilyObj(V))!.zeroCoefficient;
 return B;
end );

InstallMethod( BasisNC,
 "for a space of monomial elements and a list of monomial elements",
 IsIdenticalObj,
 [ IsFreeLeftModule and IsMonomialElementCollection,
 IsMonomialElementCollection and IsList ], SUM_FLAGS,
 function( V, vectors )

 local B, info;

 # A call to `ConvertToNormalFormMonomialElement' makes sure that
 # all monomial elements
 # are in normal form, and that they are all sorted. So the leading
 # element is just the first element in the list etc.

 vectors:= List( vectors, x -> ConvertToNormalFormMonomialElement( x ) );
 info:= TriangulizeMonomialElementList( ShallowCopy( vectors ),
 ElementsFamily(FamilyObj(V))!.zeroCoefficient,
 x -> ExtRepOfObj(x)[1],
 x -> ExtRepOfObj(x)[2] );
 if Length( info.echelonbas ) <> Length( vectors ) then return fail; fi;
 B:= BasisOfMonomialSpace( V, vectors );
 B!.echelonBasis:= info.echelonbas;
 B!.heads:= info.heads;
 B!.baseChange:= info.basechange;
 B!.zeroCoefficient:= ElementsFamily(FamilyObj(V))!.zeroCoefficient;
 return B;
end );

#############################################################################
##
#M Basis( <V> ) . . . . . . . . . . . . . . for a space of monomial elements
##
InstallMethod( Basis,
 "for a space of monomial elements",
 true, [ IsFreeLeftModule and IsMonomialElementCollection ], SUM_FLAGS,
 function( V )

 local B, vectors, info;

 vectors:= List( GeneratorsOfLeftModule(V), x ->
 ConvertToNormalFormMonomialElement( x ) );
 info:= TriangulizeMonomialElementList( vectors,
 ElementsFamily(FamilyObj(V))!.zeroCoefficient,
 x -> ExtRepOfObj(x)[1],
 x -> ExtRepOfObj(x)[2] );
 B:= BasisOfMonomialSpace( V, info.echelonbas );
 B!.echelonBasis:= info.echelonbas;
 B!.heads:= info.heads;
 B!.baseChange:= List( [1..Length(info.echelonbas)], x -> [[ x, 1 ]] );
 B!.zeroCoefficient:= ElementsFamily(FamilyObj(V))!.zeroCoefficient;
 return B;

end );

##############################################################################
##
#M Coefficients( , <v> ). . . . . . for basis of a monomial space
## and vector
##
InstallMethod( Coefficients,
 "for basis of a monomial space, and a vector",
 IsCollsElms, [ IsBasis and IsBasisOfMonomialSpaceRep,
 IsMonomialElement and IsMonomialElementRep], SUM_FLAGS,
 function( B, v )

 local w, cf, i, b, c;

 # We use the echelon basis that comes with .

 w:= ConvertToNormalFormMonomialElement( v );
 cf:= List( BasisVectors( B ), x -> B!.zeroCoefficient );
 for i in [1..Length(B!.heads)] do

 if IsZero( w ) then return cf; fi;

 if w![1][1] < B!.heads[i] then
 return fail;
 elif w![1][1] = B!.heads[i] then
 c:= w![1][2];
 w:= w - c*B!.echelonBasis[i];
 for b in B!.baseChange[i] do
 cf[b[1]]:= cf[b[1]] + b[2]*c;
 od;
 fi;
 od;

 if not IsZero( w ) then return fail; fi;
 return cf;

end );

##############################################################################
##
#M PrintObj( <te> ) . . . . . . . . . . . . . for tensor elements
##
## The zero tenso is represented by `[ [], 0 ]'.
##
InstallMethod( PrintObj,
 "for tensor elements",
 true, [ IsTensorElement and IsMonomialElementRep ], 0,
 function( u )

 local eu, k, i;

 eu:= u![1];

 if eu[1] = [] then
 Print("<0-tensor>");
 else

 for k in [1,3..Length(eu)-1] do
 Print( eu[k+1], "*(" );
 for i in [1..Length(eu[k])-1] do
 Print(eu[k][i],"<x>");
 od;
 Print( Last(eu[k]), ")" );
 if k+1 <> Length( eu ) then
 if not ( IsRat( eu[k+3] ) and eu[k+3] < 0 ) then
 Print("+");
 fi;
 fi;
 od;

 fi;

end );

##############################################################################
##
#M ConvertToNormalFormMonomialElement( <te> ) . . for a tensor element
##
InstallMethod( ConvertToNormalFormMonomialElement,
 "for a tensor element",
 true, [ IsTensorElement ], 0,
 function( u )

 local eu, fam, bases, rank, tensors, cfts, i, le, k,
 tt, cf, c, is_replaced, j, tt1, res, len;

 # We expand every component of every tensor in `u' wrt the bases
 # of the constituents of the tensor product. We assume those bases
 # are stored in the FamilyObj of the tensor element.

 if u![2] then return u; fi;

 eu:= ExtRepOfObj( u );
 fam:= FamilyObj( u );
 bases:= fam!.constituentBases;
 rank:= Length( bases );

 # `tensors' will be a list of tensors, i.e., a list of lists
 # of algebra module elements. `cfts' will be the list of their
 # coefficients.

 tensors:= [ ];
 cfts:= [ ];
 for i in [1,3..Length(eu)-1] do
 if eu[i] <> [ ] then #i.e., if it is not the zero tensor
 Add( tensors, eu[i] );
 Add( cfts, eu[i+1] );
 fi;
 od;
 if tensors = [ ] then
 # the thing is zero...
 res:= ObjByExtRep( fam, [ [], fam!.zeroCoefficient ] );
 res![2]:= true;
 return res;
 fi;

 for i in [1..rank] do

 # in all tensors expand the i-th component

 le:= Length( tensors );
 for k in [1..le] do
 tt:= ShallowCopy( tensors[k] );
 cf:= Coefficients( bases[i], tensors[k][i] );
 c:= cfts[k];

 # we replace the tensor on position `k', and add the rest
 # to the and of the list.

 is_replaced:= false;
 for j in [1..Length(cf)] do
 if cf[j] <> 0*cf[j] then
 if not is_replaced then
 tt1:= ShallowCopy( tt );
 tt1[i]:= bases[i][j];
 tensors[k]:= tt1;
 cfts[k]:= c*cf[j];
 is_replaced:= true;
 else
 tt1:= ShallowCopy( tt );
 tt1[i]:= bases[i][j];
 Add( tensors, tt1 );
 Add( cfts, c*cf[j] );
 fi;
 fi;
 od;
 if not is_replaced then
 # i.e., the tensor is zero, erase it
 Unbind( tensors[k] );
 Unbind( cfts[k] );
 fi;

 od;
 tensors:= Compacted( tensors );
 cfts:= Compacted( cfts );
 od;

 # Merge tensors and coefficients, take equal tensors together.
 SortParallel( tensors, cfts );
 res:= [ ];
 len:= 0;
 for i in [1..Length(tensors)] do
 if len > 0 and tensors[i] = res[len-1] then
 res[len]:= res[len]+cfts[i];
 if res[len] = 0*res[len] then
 Unbind( res[len-1] );
 Unbind( res[len] );
 len:= len-2;
 fi;
 else
 Add( res, tensors[i] );
 Add( res, cfts[i] );
 len:= len+2;
 fi;
 od;
 if res = [] then res:= [ [], fam!.zeroCoefficient ]; fi;

 res:= ObjByExtRep( fam, res );
 res![2]:= true;
 return res;

end );

##############################################################################
##
#M TensorProductOp( <list> ) . . . . for a list of vectorspaces.
##
InstallMethod( TensorProductOp,
 "for a list of finite dimensional vector spaces, and a space (for method selection)",
 true, [ IsDenseList, IsVectorSpace ], 0,
 function( list, list1 )

 local F, fam, type, gens, i, gV, gens1, ten, v, ten1,
 VT, BT;

 # We first make the family of the tensor elements, and construct
 # a basis of the tensor space. Note that if the arguments do not
 # know how to compute bases, then the rewriting of tensors to normal
 # forms will fail. Hence we can assume that every module has a basis,
 # and therefore we have a basis of the tensor space as well.

 F:= LeftActingDomain( list1 );

 if not ForAll( list, x -> LeftActingDomain(x) = F ) then
 Error("all vector spaces must be defined over the same field.");
 fi;

 fam:= NewFamily( "TensorElementsFam", IsTensorElement );
 type:= NewType( fam, IsMonomialElementRep );
 fam!.monomialElementDefaultType:= type;
 fam!.zeroCoefficient:= Zero( F );
 fam!.constituentBases:= List( list, Basis );

 if Length(list)=0 then
 gens := [One(F)];
 else
 gens:= List( Basis( list[1] ), x -> [ x ] );
 fi;
 for i in [2..Length(list)] do
 gV:= Basis( list[i] );
 gens1:= [ ];
--> --------------------

--> maximum size reached

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

Quelle algrep.gi Sprache: unbekannt

[ Dauer der Verarbeitung: 0.18 Sekunden (vorverarbeitet) ]