There are kinds of free R-modules for which efficient computations are possible because the elements are ``nice'', for example subspaces of full row modules or of full matrix modules. In other cases, a ``nice'' canonical basis is known that allows one to do the necessary computations in the corresponding row module, for example algebras given by structure constants.
In many other situations, one knows at least an isomorphism from the given module V to a ``nicer'' free left module W, in the sense that for each vector in V, the image in W can easily be computed, and analogously for each vector in W, one can compute the preimage in V.
This allows one to delegate computations w.r.t. a basis B, say, of V
to the corresponding basis C, say, of W.
We call W the nice free left module of V, and C the nice basis
of B.
(Note that it may happen that also C delegates questions to a ``nicer''
basis.)
The basis B indicates the intended behaviour by the filter
IsBasisByNiceBasis (see IsBasisByNiceBasis),
and stores C as value of the attribute NiceBasis (see NiceBasis).
V indicates the intended behaviour by the filter IsHandledByNiceBasis
(see IsHandledByNiceBasis), and stores W as value of the attribute
NiceFreeLeftModule.
The bijection between V and W is implemented by the functions
NiceVector (see NiceVector) and UglyVector (see UglyVector);
additional data needed to compute images and preimages can be stored
as value of NiceFreeLeftModuleInfo (see NiceFreeLeftModuleInfo).
NiceFreeLeftModule( V ) A
For a free left module V that is handled via the mechanism of nice bases, this attribute stores the associated free left module to which the tasks are delegated.
NiceVector( V, v ) O
UglyVector( V, r ) O
NiceVector and UglyVector provide the linear bijection between the
free left module V and W:= NiceFreeLeftModule( V ).
If v lies in the elements family of the family of V then
NiceVector( v ) is either fail or an element in the elements family
of the family of W.
If r lies in the elements family of the family of W then
UglyVector( r ) is either fail or an element in the elements family
of the family of V.
If v lies in V (which usually cannot be checked without using W)
then UglyVector( V, NiceVector( V, v ) ) = v.
If r lies in W (which usually can be checked)
then NiceVector( V, UglyVector( V, r ) ) = r.
(This allows one to implement for example a membership test for V using the membership test in W.)
NiceFreeLeftModuleInfo( V ) A
For a free left module V that is handled via the mechanism of nice
bases, this operation has to provide the necessary information (if any)
for calls of NiceVector and UglyVector (see NiceVector).
NiceBasis( B ) A
Let B be a basis of a free left module V that is handled via
nice bases.
If B has no basis vectors stored at the time of the first call to
NiceBasis then NiceBasis( B ) is obtained as
Basis( NiceFreeLeftModule( V ) ).
If basis vectors are stored then NiceBasis( B ) is the result of the
call of Basis with arguments NiceFreeLeftModule( V )
and the NiceVector values of the basis vectors of B.
Note that the result is fail if and only if the ``basis vectors''
stored in B are in fact not basis vectors.
The attributes GeneratorsOfLeftModule of the underlying left modules
of B and the result of NiceBasis correspond via NiceVector and
UglyVector.
IsBasisByNiceBasis( B ) C
This filter indicates that the basis B delegates tasks such as the computation of coefficients (see Coefficients) to a basis of an isomorphisc ``nicer'' free left module.
IsHandledByNiceBasis( M ) C
For a free left module M in this category, essentially all operations are performed using a ``nicer'' free left module, which is usually a row module.
[Top] [Previous] [Up] [Next] [Index]
GAP 4 manual