|
#############################################################################
##
## This file is part of GAP, a system for computational discrete algebra.
## This file's authors include Thomas Breuer.
##
## 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
##
## 1. general methods for Lie elements
## 2. methods for free left modules of Lie elements
## (there are special methods for Lie matrix spaces)
## 3. methods for FLMLORs (and ideals) of Lie elements
## (there are special methods for Lie matrix spaces)
##
#############################################################################
##
## 1. general methods for Lie elements
##
#############################################################################
##
#M LieFamily( <Fam> )
##
## We need to distinguish families of arbitrary ring elements and families
## that contain matrices,
## since in the latter case the Lie elements shall also be matrices.
## Note that matrices cannot be detected from their family,
## so we decide that the Lie family of a collections family will consist
## of Lie matrices.
##
InstallMethod( LieFamily,
"for family of ring elements",
true,
[ IsRingElementFamily ], 0,
function( Fam )
local F, filt;
if HasCharacteristic(Fam) and Characteristic(Fam)>0 then
filt := IsRestrictedLieObject;
else
filt := IsLieObject;
fi;
# Make the family of Lie elements.
F:= NewFamily( "LieFamily(...)", filt,CanEasilySortElements,
CanEasilySortElements);
SetUnderlyingFamily( F, Fam );
if HasCharacteristic( Fam ) then
SetCharacteristic( F, Characteristic( Fam ) );
fi;
#T maintain other req/imp properties as implied properties of `F'?
# Enter the type of objects in the image.
F!.packedType:= NewType( F, filt and IsPackedElementDefaultRep );
# Return the Lie family.
return F;
end );
InstallMethod( LieFamily,
"for a collections family (special case of Lie matrices)",
true,
[ IsCollectionFamily ], 0,
function( Fam )
local F, filt;
if HasCharacteristic(Fam) and Characteristic(Fam)>0 then
filt := IsRestrictedLieObject;
else
filt := IsLieObject;
fi;
# Make the family of Lie elements.
F:= NewFamily( "LieFamily(...)", filt and IsMatrix );
SetUnderlyingFamily( F, Fam );
if HasCharacteristic( Fam ) then
SetCharacteristic( F, Characteristic( Fam ) );
fi;
#T maintain other req/imp properties as implied properties of `F'?
# Enter the type of objects in the image.
F!.packedType:= NewType( F, filt
and IsPackedElementDefaultRep
and IsLieMatrix );
# Return the Lie family.
return F;
end );
#############################################################################
##
#M LieObject( <obj> ) . . . . . . . . . . . . . . . . . for a ring element
##
InstallMethod( LieObject,
"for a ring element",
true,
[ IsRingElement ], 0,
obj -> Objectify( LieFamily( FamilyObj( obj ) )!.packedType,
[ Immutable( obj ) ] ) );
#############################################################################
##
#M UnderlyingRingElement( <obj> ) . . . . . . . . . . . . for a Lie object
##
InstallMethod( UnderlyingRingElement,
"for a Lie object in default representation",
true,
[ IsLieObject and IsPackedElementDefaultRep], 0,
obj -> obj![1] );
#############################################################################
##
#M PrintObj( <obj> ) . . . . . . . . . . . . . . . . . . . for a Lie object
##
InstallMethod( PrintObj,
"for a Lie object in default representation",
true,
[ IsLieObject and IsPackedElementDefaultRep ], SUM_FLAGS,
function( obj )
Print( "LieObject( ", obj![1], " )" );
end );
#############################################################################
##
#M ViewObj( <obj> ) . . . . . . . . . . . . . . . . . . . for a Lie matrix
##
## For Lie matrices, we want to override the special `ViewObj' method for
## lists.
##
InstallMethod( ViewObj,
"for a Lie matrix in default representation",
true,
[ IsLieMatrix and IsPackedElementDefaultRep ], SUM_FLAGS,
function( obj )
Print( "LieObject( " ); View( obj![1] ); Print( " )" );
end );
#############################################################################
##
#M \=( <x>, <y> ) . . . . . . . . . . . . . . . . . . . for two Lie objects
#M \<( <x>, <y> ) . . . . . . . . . . . . . . . . . . . for two Lie objects
##
InstallMethod( \=,
"for two Lie objects in default representation",
IsIdenticalObj,
[ IsLieObject and IsPackedElementDefaultRep,
IsLieObject and IsPackedElementDefaultRep ], 0,
function( x, y ) return x![1] = y![1]; end );
InstallMethod( \<,
"for two Lie objects in default representation",
IsIdenticalObj,
[ IsLieObject and IsPackedElementDefaultRep,
IsLieObject and IsPackedElementDefaultRep ], 0,
function( x, y ) return x![1] < y![1]; end );
#############################################################################
##
#M \+( <x>, <y> ) . . . . . . . . . . . . . . . . . . . for two Lie objects
#M \-( <x>, <y> ) . . . . . . . . . . . . . . . . . . . for two Lie objects
#M \*( <x>, <y> ) . . . . . . . . . . . . . . . . . . . for two Lie objects
#M \^( <x>, <n> ) . . . . . . . . . . . . . . . . . . . for two Lie objects
##
## The addition, subtraction, and multiplication of Lie objects is obvious.
## If only one operand is a Lie object then we suspect that the operation
## for the unpacked object is defined, and that the Lie object shall behave
## as the unpacked object.
##
InstallMethod( \+,
"for two Lie objects in default representation",
IsIdenticalObj,
[ IsLieObject and IsPackedElementDefaultRep,
IsLieObject and IsPackedElementDefaultRep ], 0,
function( x, y ) return LieObject( x![1] + y![1] ); end );
InstallMethod( \+,
"for Lie object in default representation, and ring element",
true,
[ IsLieObject and IsPackedElementDefaultRep, IsRingElement ], 0,
function( x, y )
local z;
z:= x![1] + y;
if IsFamLieFam( FamilyObj( z ), FamilyObj( x ) ) then
return LieObject( z );
else
TryNextMethod();
fi;
end );
InstallMethod( \+,
"for ring element, and Lie object in default representation",
true,
[ IsRingElement, IsLieObject and IsPackedElementDefaultRep ], 0,
function( x, y )
local z;
z:= x + y![1];
if IsFamLieFam( FamilyObj( z ), FamilyObj( x ) ) then
return LieObject( z );
else
TryNextMethod();
fi;
end );
InstallMethod( \-,
"for two Lie objects in default representation",
IsIdenticalObj,
[ IsLieObject and IsPackedElementDefaultRep,
IsLieObject and IsPackedElementDefaultRep ], 0,
function( x, y ) return LieObject( x![1] - y![1] ); end );
InstallMethod( \-,
"for Lie object in default representation, and ring element",
true,
[ IsLieObject and IsPackedElementDefaultRep, IsRingElement ], 0,
function( x, y )
local z;
z:= x![1] - y;
if IsFamLieFam( FamilyObj( z ), FamilyObj( x ) ) then
return LieObject( z );
else
TryNextMethod();
fi;
end );
InstallMethod( \-,
"for ring element, and Lie object in default representation",
true,
[ IsRingElement, IsLieObject and IsPackedElementDefaultRep ], 0,
function( x, y )
local z;
z:= x - y![1];
if IsFamLieFam( FamilyObj( z ), FamilyObj( x ) ) then
return LieObject( z );
else
TryNextMethod();
fi;
end );
InstallMethod( \*,
"for two Lie objects in default representation",
IsIdenticalObj,
[ IsLieObject and IsPackedElementDefaultRep,
IsLieObject and IsPackedElementDefaultRep ], 0,
function( x, y ) return LieObject( LieBracket( x![1], y![1] ) ); end );
InstallMethod( \*,
"for Lie object in default representation, and ring element",
true,
[ IsLieObject and IsPackedElementDefaultRep, IsRingElement ], 0,
function( x, y )
local z;
z:= x![1] * y;
if IsFamLieFam( FamilyObj( z ), FamilyObj( x ) ) then
return LieObject( z );
else
TryNextMethod();
fi;
end );
InstallMethod( \*,
"for ring element, and Lie object in default representation",
true,
[ IsRingElement, IsLieObject and IsPackedElementDefaultRep ], 0,
function( x, y )
local z;
z:= x * y![1];
if IsFamLieFam( FamilyObj( z ), FamilyObj( y ) ) then
return LieObject( z );
else
TryNextMethod();
fi;
end );
InstallMethod( \^,
"for Lie object in default representation, and positive integer",
true,
[ IsLieObject and IsPackedElementDefaultRep, IsPosInt ], 0,
function( x, n )
if 1 < n then
return LieObject( Zero( x![1] ) );
else
return x;
fi;
end );
#############################################################################
##
#M PthPowerImage( <lie_obj> ) . . . . . . . . . for a restricted Lie object
##
InstallMethod(PthPowerImage, "for restricted Lie object",
[ IsRestrictedLieObject ],
function(x)
return LieObject(x![1]^Characteristic(FamilyObj(x)));
end);
InstallMethod(PthPowerImage, "for restricted Lie object and integer",
[ IsRestrictedLieObject, IsInt ],
function(x,n)
local y;
y := x![1];
while n>0 do
y := y^Characteristic(FamilyObj(x));
n := n-1;
od;
return LieObject(y);
end);
#############################################################################
##
#M ZeroOp( <lie_obj> ) . . . . . . . . . . . . . . . . . . for a Lie object
##
InstallMethod( ZeroOp,
"for Lie object in default representation",
true,
[ IsLieObject and IsPackedElementDefaultRep ], SUM_FLAGS,
x -> LieObject( Zero( x![1] ) ) );
#############################################################################
##
#M OneOp( <lie_obj> ) . . . . . . . . . . . . . . . . . . for a Lie object
##
InstallOtherMethod( OneOp,
"for Lie object",
true,
[ IsLieObject ], 0,
ReturnFail );
#############################################################################
##
#M InverseOp( <lie_obj> ) . . . . . . . . . . . . . . . . for a Lie object
##
InstallOtherMethod( InverseOp,
"for Lie object",
true,
[ IsLieObject ], 0,
ReturnFail );
#############################################################################
##
#M AdditiveInverseOp( <lie_obj> ) . . . . . . . . . . . . for a Lie object
##
InstallMethod( AdditiveInverseOp,
"for Lie object in default representation",
true,
[ IsLieObject and IsPackedElementDefaultRep ], 0,
x -> LieObject( - x![1] ) );
#############################################################################
##
#M \[\]( <mat>, <i> ) . . . . . . . . . . . . . . . . . . for a Lie matrix
#M Length( <mat> )
#M IsBound\[\]( <mat>, <i> )
#M Position( <mat>, <obj> )
##
InstallOtherMethod( \[\],
"for Lie matrix in default representation, and positive integer",
[ IsLieMatrix and IsPackedElementDefaultRep, IsPosInt ],
function( mat, i ) return mat![1][i]; end );
InstallOtherMethod( Length,
"for Lie matrix in default representation",
[ IsLieMatrix and IsPackedElementDefaultRep ],
mat -> NumberRows( mat![1] ) );
InstallMethod( IsBound\[\],
"for Lie matrix in default representation, and integer",
[ IsLieMatrix and IsPackedElementDefaultRep, IsPosInt ],
function( mat, i ) return IsBound( mat![1][i] ); end );
InstallMethod( Position,
"for Lie matrix in default representation, row vector, and integer",
[ IsLieMatrix and IsPackedElementDefaultRep, IsRowVector, IsInt ],
function( mat, v, pos ) return Position( mat![1], v, pos ); end );
#############################################################################
##
#R IsLieEmbeddingRep( <map> )
##
## representation of the embedding of a family into its Lie family
##
DeclareRepresentation( "IsLieEmbeddingRep", IsAttributeStoringRep,
[ "packedType" ] );
#############################################################################
##
#M Embedding( <Fam>, <LieFam> )
##
InstallOtherMethod( Embedding,
"for two families, the first with known Lie family",
true,
[ IsFamily and HasLieFamily, IsFamily ], 0,
function( Fam, LieFam )
local emb;
# Is this the right method?
if not IsFamLieFam( Fam, LieFam ) then
TryNextMethod();
fi;
# Make the mapping object.
emb := Objectify( TypeOfDefaultGeneralMapping( Fam, LieFam,
IsLieEmbeddingRep
and IsNonSPGeneralMapping
and IsMapping
and IsInjective
and IsSurjective ),
rec() );
# Enter preimage and image.
SetPreImagesRange( emb, Fam );
SetImagesSource( emb, LieFam );
# Return the embedding.
return emb;
end );
InstallMethod( ImagesElm,
"for Lie embedding and object",
FamSourceEqFamElm,
[ IsGeneralMapping and IsLieEmbeddingRep, IsObject ], 0,
function( emb, elm )
return [ LieObject( elm ) ];
end );
InstallMethod( PreImagesElm,
"for Lie embedding and Lie object in default representation",
FamRangeEqFamElm,
[ IsGeneralMapping and IsLieEmbeddingRep,
IsLieObject and IsPackedElementDefaultRep ], 0,
function( emb, elm )
return [ elm![1] ];
end );
#############################################################################
##
#M IsUnit( <lie_obj> )
##
InstallOtherMethod( IsUnit,
"for a Lie object (return `false')",
true,
[ IsLieObject ], 0,
ReturnFalse );
#############################################################################
##
## 2. methods for free left modules of Lie elements
##
## There are special methods for Lie matrix spaces, both Gaussian and
## non-Gaussian (see ...).
## Note that in principle the non-Gaussian Lie matrix spaces could be
## handled via the generic methods for spaces of Lie elements,
## but the special methods are more efficient; they avoid one indirection
## by assigning a row vector to each Lie matrix.
##
#############################################################################
##
#M MutableBasis( <R>, <lieelms> )
#M MutableBasis( <R>, <lieelms>, <zero> )
##
## In general, we choose a mutable basis that stores a mutable basis for a
## nice module.
##
## Note that the case of Lie matrices must *not* be treated by these methods
## since the space may be Gaussian and thus handled in a completely
## different way.
##
InstallMethod( MutableBasis,
"for ring and collection of Lie elements",
function( F1, F2 ) return not IsElmsCollLieColls( F1, F2 ); end,
[ IsRing, IsLieObjectCollection ], 0,
MutableBasisViaNiceMutableBasisMethod2 );
InstallOtherMethod( MutableBasis,
"for ring, (possibly empty) list, and Lie zero",
function( F1, F2, F3 ) return not IsElmsLieColls( F1, F3 ); end,
[ IsRing, IsList, IsLieObject ], 0,
MutableBasisViaNiceMutableBasisMethod3 );
#############################################################################
##
#M NiceFreeLeftModuleInfo( <liemodule> )
#M NiceVector( <M>, <lieelm> )
#M UglyVector( <M>, <vector> ) . for left module of Lie objects, and vector
##
InstallHandlingByNiceBasis( "IsLieObjectsModule", rec(
# Note that the case of Lie matrices must *not* be treated by these
# methods since the space may be Gaussian and thus handled in a
# completely different way.
detect := function( R, gens, V, zero )
if not IsLieObjectCollection( V ) then
return false;
elif zero = false then
return not IsElmsCollLieColls( FamilyObj( R ), FamilyObj( gens ) );
else
return not IsElmsLieColls( FamilyObj( R ), FamilyObj( zero ) );
fi;
end,
NiceFreeLeftModuleInfo := ReturnFalse,
NiceVector := function( M, lieelm )
if IsPackedElementDefaultRep( lieelm ) then
return lieelm![1];
else
TryNextMethod();
fi;
end,
UglyVector := function( M, vector )
return LieObject( vector );
end ) );
#############################################################################
##
#M TwoSidedIdealByGenerators( <L>, <elms> )
#M LeftIdealByGenerators( <L>, <elms> )
#M RightIdealByGenerators( <L>, <elms> )
##
## For Lie algebras <L>, we construct two-sided ideals in all three cases.
##
BindGlobal( "IdealByGeneratorsForLieAlgebra", function( L, elms )
local I, lad;
I:= Objectify( NewType( FamilyObj( L ),
IsFLMLOR
and IsAttributeStoringRep
and IsLieAlgebra ),
rec() );
lad:= LeftActingDomain( L );
SetLeftActingDomain( I, lad );
SetGeneratorsOfTwoSidedIdeal( I, elms );
SetGeneratorsOfLeftIdeal( I, elms );
SetGeneratorsOfRightIdeal( I, elms );
SetLeftActingRingOfIdeal( I, L );
SetRightActingRingOfIdeal( I, L );
if IsEmpty( elms ) then
SetIsTrivial( I, true );
SetDimension( I, 0 );
fi;
CheckForHandlingByNiceBasis( lad, elms, I, false );
return I;
end );
InstallMethod( TwoSidedIdealByGenerators,
"for Lie algebra and collection of Lie objects",
IsIdenticalObj,
[ IsLieAlgebra, IsLieObjectCollection and IsList ], 0,
IdealByGeneratorsForLieAlgebra );
InstallMethod( LeftIdealByGenerators,
"for Lie algebra and collection of Lie objects",
IsIdenticalObj,
[ IsLieAlgebra, IsLieObjectCollection and IsList ], 0,
IdealByGeneratorsForLieAlgebra );
InstallMethod( RightIdealByGenerators,
"for Lie algebra and collection of Lie objects",
IsIdenticalObj,
[ IsLieAlgebra, IsLieObjectCollection and IsList ], 0,
IdealByGeneratorsForLieAlgebra );
InstallMethod( TwoSidedIdealByGenerators,
"for Lie algebra and empty list",
true,
[ IsLieAlgebra, IsList and IsEmpty ], 0,
IdealByGeneratorsForLieAlgebra );
InstallMethod( LeftIdealByGenerators,
"for Lie algebra and empty list",
true,
[ IsLieAlgebra, IsList and IsEmpty ], 0,
IdealByGeneratorsForLieAlgebra );
InstallMethod( RightIdealByGenerators,
"for Lie algebra and empty list",
true,
[ IsLieAlgebra, IsList and IsEmpty ], 0,
IdealByGeneratorsForLieAlgebra );
[ Dauer der Verarbeitung: 0.15 Sekunden
(vorverarbeitet)
]
|
