Spracherkennung für: .gd vermutete Sprache: Unknown {[0] [0] [0]} [Methode: Schwerpunktbildung, einfache Gewichte, sechs Dimensionen]
#############################################################################
##
#W ncordmachine.gd
## NMO: Machinery for installing NM orderings Randall Cone
##
##
#Y (C) 2010 Mathematics Dept., Virginia Polytechnic Institute, USA
##
#############################################################################
#############################################################################
##
## <#GAPDoc Label="IsNoncommutativeMonomialOrdering">
## <ManSection>
## <Filt Name="IsNoncommutativeMonomialOrdering"
## Arg="<obj>"
## Type="Category"/>
##
## <Description>
## A noncommutative monomial ordering is an object representing a monomial ordering
## on a noncommutative (associative) algebra. All <Package>NMO</Package>
## orderings are of this category.
## <P/>
## </Description>
## </ManSection>
## <#/GAPDoc>
##
DeclareCategory("IsNoncommutativeMonomialOrdering",IsObject);
#############################################################################
##
## <#GAPDoc Label="LtFunctionListRep">
## <ManSection>
## <Attr Name="LtFunctionListRep"
## Arg="<NoncommutativeMonomialOrdering>"/>
##
## <Description>
## Returns the low-level comparison function used by the given
## ordering.
## The function returned is a comparison
## function on the external representations (lists) for monomials in the
## algebra.
## <P/>
## </Description>
## </ManSection>
## <#/GAPDoc>
##
DeclareAttribute("LtFunctionListRep", IsNoncommutativeMonomialOrdering);
#############################################################################
##
## <#GAPDoc Label="NextOrdering">
## <ManSection>
## <Attr Name="NextOrdering"
## Arg="<NoncommutativeMonomialOrdering>"/>
##
## <Description>
## Returns the next noncommutative monomial ordering chained to the given ordering, if one
## exists. It is usually called after a <C>true</C> determination
## has been made with a <C>HasNextOrdering</C> call.
## <P/>
## </Description>
## </ManSection>
## <#/GAPDoc>
##
DeclareAttribute("NextOrdering",IsNoncommutativeMonomialOrdering);
#############################################################################
##
## <#GAPDoc Label="ParentAlgebra">
## <ManSection>
## <Attr Name="ParentAlgebra"
## Arg="<NoncommutativeMonomialOrdering>"/>
##
## <Description>
## Returns the parent algebra used in the creation of the given
## ordering.
## <P/>
## </Description>
## </ManSection>
## <#/GAPDoc>
##
DeclareAttribute("ParentAlgebra", IsNoncommutativeMonomialOrdering );
#############################################################################
##
## <#GAPDoc Label="LexicographicTable">
## <ManSection>
## <Attr Name="LexicographicTable"
## Arg="<NoncommutativeMonomialOrdering>"/>
##
## <Description>
## Returns the ordering of the generators of the <C>ParentAlgebra</C>,
## as specified in the creation of the given ordering.
## <P/>
## </Description>
## </ManSection>
## <#/GAPDoc>
##
DeclareAttribute("LexicographicTable", IsNoncommutativeMonomialOrdering);
#############################################################################
##
## <#GAPDoc Label="LexicographicIndexTable">
## <ManSection>
## <Attr Name="LexicographicIndexTable"
## Arg="<NoncommutativeMonomialOrdering>"/>
##
## <Description>
## Returns the ordering of the generators of the <C>ParentAlgebra</C>,
## as specified in the creation of the given ordering.
## <P/>
## An example here would be useful. We create
## a length left-lexicographic ordering on an algebra <C>A</C>
## with an order
## on the generators of <M>b < a < d < c</M>. Then in accessing the attributes
## via the attributes above we see how the list given by <C>LexicographicIndexTable</C>
## indexes the ordered generators:
## <Example>
## gap> A := FreeAssociativeAlgebraWithOne(Rationals,"a","b","c","d");
## <algebra-with-one over Rationals, with 4 generators>
## gap> ml := NCMonomialLeftLengthLexOrdering(A,2,4,1,3);
## NCMonomialLeftLengthLexicographicOrdering([ (1)*b, (1)*d, (1)*a, (1)*c ])
## gap> LexicographicTable(ml);
## [ (1)*b, (1)*d, (1)*a, (1)*c ]
## gap> LexicographicIndexTable(ml);
## [ 3, 1, 4, 2 ]
## </Example>
##
## The index table shows that the generator <M>a</M> is the third in the generator
## ordering, <M>b</M> is the least generator in the ordering, <M>c</M> is the greatest
## and <M>d</M> the second least in order.
## <P/>
## </Description>
## </ManSection>
## <#/GAPDoc>
##
DeclareAttribute("LexicographicIndexTable", IsNoncommutativeMonomialOrdering);
#############################################################################
##
## <#GAPDoc Label="LexicographicPermutation">
## <ManSection>
## <Attr Name="LexicographicPermutation"
## Arg="<NoncommutativeMonomialOrdering>"/>
##
## <Description>
## Experimental permutation based on the information in <C>LexicographicTable</C>,
## could possibly be used to make indexed versions of
## comparison functions more efficient. Currently only used
## by the <Package>NMO</Package> built-in ordering <C>NCMonomialLLLTestOrdering</C>.
## <P/>
## </Description>
## </ManSection>
## <#/GAPDoc>
##
DeclareAttribute("LexicographicPermutation", IsNoncommutativeMonomialOrdering);
#############################################################################
##
## <#GAPDoc Label="AuxilliaryTable">
## <ManSection>
## <Attr Name="AuxilliaryTable"
## Arg="<NoncommutativeMonomialOrdering>"/>
##
## <Description>
## An extra table carried by the given ordering which can be used
## for such things as weight vectors, etc.
## <P/>
## </Description>
## </ManSection>
## <#/GAPDoc>
##
DeclareAttribute("AuxilliaryTable", IsNoncommutativeMonomialOrdering);
#############################################################################
##
#R IsNoncommutativeMonomialOrderingDefaultRep
##
## The following two lines create the representation and family for
## our noncommutative monomial ordering objects.
##
DeclareRepresentation("IsNoncommutativeMonomialOrderingDefaultRep",
IsAttributeStoringRep and IsPositionalObjectRep
and IsNoncommutativeMonomialOrdering,[]);
BindGlobal("NoncommutativeMonomialOrderingsFamily",
NewFamily("NoncommutativeMonomialOrderingsFamily",
IsNoncommutativeMonomialOrdering, IsNoncommutativeMonomialOrdering) );
#############################################################################
##
## <#GAPDoc Label="InstallNoncommutativeMonomialOrdering">
## <ManSection>
## <Func Name="InstallNoncommutativeMonomialOrdering"
## Arg="<string>, <function>, <function2>"/>
##
## <Description>
## Given a name <C><string></C>, a direct comparison function <C><function></C>, and an
## indexed comparison function <C><function2></C>, <C>InstallNoncommutativeMonomialOrdering</C>
## will install a monomial ordering function to allow the creation of
## a monomial ordering based on the provided functions.
## <P/>
##
## For example, we create a length ordering by setting up the two comparison
## functions, choosing a name for the ordering type
## and then calling <C>InstallNoncommutativeMonomialOrdering</C>.
##
## <Example>
## gap> f1 := function(a,b,aux)
## > return Length(a) < Length(b);
## > end;
## function( a, b, aux ) ... end
## gap> f2 := function(a,b,aux,idx)
## > return Length(a) < Length(b);
## > end;
## function( a, b, aux, idx ) ... end
##
## DeclareGlobalFunction("lenOrdering");
## InstallNoncommutativeMonomialOrdering("lenOrdering",f1,f2);
## </Example>
##
## Now we create an ordering based on this new function, and make
## some simple comparisons. (Note: we are passing in an empty
## <C>aux</C> table since it is not being used. Also, the comparison
## function is the non-indexed version since we determined
## no lex order on the generators):
## <Example>
## gap> A := FreeAssociativeAlgebraWithOne(Rationals,"a","b","c");
## <algebra-with-one over Rationals, with 3 generators>
## gap> ml := lenOrdering(A);
## lenOrdering([ (1)*a, (1)*b, (1)*c ])
## gap>
## gap> LtFunctionListRep(ml)([1,2],[1,1,1],[]);
## true
## gap> LtFunctionListRep(ml)([1,1],[],[]);
## false
## </Example>
## <P/>
##
## </Description>
## </ManSection>
## <#/GAPDoc>
##
DeclareGlobalFunction("InstallNoncommutativeMonomialOrdering");
#############################################################################
##
## <#GAPDoc Label="OrderingLtGtFunctions">
## <ManSection>
## <Oper Name="OrderingLtFunctionListRep"
## Arg="<NoncommutativeMonomialOrdering>"/>
##
## <Description>
## </Description>
##
## <Oper Name="OrderingGtFunctionListRep"
## Arg="<NoncommutativeMonomialOrdering>"/>
##
## <Description>
## Given a noncommutative monomial ordering, <C>OrderingLtFunctionListRep</C>
## and <C>OrderingLtFunctionListRep</C>
## return functions which compare the `list' representations
## (NP representations) of two
## monomials from the ordering's associated parent algebra.
## These functions are not typically accessed by the user.
## <P/>
## </Description>
## </ManSection>
## <#/GAPDoc>
##
DeclareOperation("OrderingLtFunctionListRep",
[ IsNoncommutativeMonomialOrdering ]
);
DeclareOperation("OrderingGtFunctionListRep",
[ IsNoncommutativeMonomialOrdering ]
);
#############################################################################
##
#O OrderGenerators( <algebra>, <list> )
##
## Given an algebra and an ordered list (partial or full) of generators for
## the algebra, `OrderGenerators' will return a full list of generators
## based on the given ordering, and will complete the list if necessary.
##
DeclareOperation("OrderGenerators",
[ IsAlgebra, IsList]
);
#############################################################################
##
#O IndexGenerators( <list> )
##
## Given an ordered list of generators for an algebra, `IndexGenerators'
## transforms the list to one with which sorting comparisons may be made.
##
DeclareOperation("IndexGenerators", [ IsList ]);
##
#E
