undocumented {(net,NCGroebnerBasis), (net,NCIdeal), (net,NCLeftIdeal), (net,NCRightIdeal), (net,NCRing), (net,NCRingElement), (net,NCMatrix), (net,NCRingMap), (net,NCChainComplex), (expression, NCMatrix), (net,NCQuotientRing), functionHash, (NewFromMethod,NCPolynomialRing,List), (NewFromMethod,NCQuotientRing,List), (symbol ?, NCMatrix, NCMatrix), (symbol ?, NCRingMap, NCRingMap), CacheBergmanGB, MakeMonic, Derivation, NumModuleVars, InstallGB, ReturnIdeal, NumberOfBins, Basis} beginDocumentation() ------------------------- ----- Types ------------------------- doc /// Key NCAlgebra Description Text This package is used to define and manipulate noncommutative algebras. Many of the commands contain calls to the existing noncommutative algebra package Bergman. Subnodes "Basic operations on noncommutative algebras" "General setup information" "Using the Bergman interface" /// doc /// Key NCRing Headline Type of a noncommutative ring Description Text All noncommutative rings have this as an ancestor type. It is the parent of the types @ TO NCPolynomialRing @ and @ TO NCQuotientRing @. Text In addition to defining a ring as a quotient of a @ TO NCPolynomialRing @, some common ways to create NCRings include @ TO skewPolynomialRing @, @ TO endomorphismRing @, and @ TO oreExtension @. Let's consider a three dimensional Sklyanin algebra. We first define the tensor algebra: Example A = QQ{x,y,z} Text Then input the defining relations, and put them in an ideal: Example f = y*z + z*y - x^2 g = x*z + z*x - y^2 h = z^2 - x*y - y*x I=ncIdeal{f,g,h} Text Next, define the quotient ring (as well as try a few functions on this new ring). Note that when the quotient ring is defined, a call is made to Bergman to compute the Groebner basis of I (out to a certain degree, should the Groebner basis be infinite). Example B=A/I generators B numgens B isCommutative B coefficientRing B Text As we can see, x is an element of B. Example x Text If we define a new ring containing x, x is now part of that new ring Example C = skewPolynomialRing(QQ,(-1)_QQ,{x,y,z,w}) x Text We can 'go back' to B using the command @ TO (use, NCRing) @. Example use B x use C Text We can also create an Ore extension. First define a @ TO NCRingMap @ with @ TO ncMap @. Example sigma = ncMap(C,C,{y,z,w,x}) Text Then call the command @ TO oreExtension @. Example D = oreExtension(C,sigma,a) generators D numgens D SeeAlso "Basic operations on noncommutative algebras" /// doc /// Key (generators, NCRing) Headline The list of algebra generators of an NCRing Usage gensA = generators A Inputs A : NCRing Outputs gensA : List Description Text This function returns the generators of an NCRing as a list. As usual, gens is a synonym for generators. Example A = QQ{x,y,z} generators A gens A /// doc /// Key (numgens, NCRing) Headline The number of algebra generators of an NCRing Usage numgensA = numgens A Inputs A : NCRing Outputs numgensA : ZZ Description Text This function returns the number of generators of an NCRing. Example A = QQ{x,y,z} numgens A /// doc /// Key (isCommutative, NCRing) isExterior (isExterior, NCRing) (isExterior, Ring) Headline Returns whether an NCRing is commutative Usage isCommutative A or isExterior A Inputs A : NCRing Outputs : Boolean Description Text This function returns whether an NCRing is commutative or a quotient of the exterior algebra Example A = QQ{x,y,z} isCommutative A B = skewPolynomialRing(QQ,(-1)_QQ,{x,y,z}) isCommutative B C = skewPolynomialRing(QQ,1_QQ,{x,y,z}) isCommutative C D = toNCRing(QQ[x,y,SkewCommutative=>true]) isExterior D /// doc /// Key (coefficientRing, NCRing) Headline Returns the base ring of an NCRing Usage k = coefficientRing NCRing Inputs A : NCRing Outputs k : Ring Description Text This function returns the base ring of an NCRing Example A = QQ{x,y,z} coefficientRing A R = ZZ/101[a,b,c,d]/(ideal(a^2-b^2)) B = R{x,y,z} coefficientRing B /// doc /// Key (use, NCRing) Headline Brings the variables of a particular NCRing in scope Usage use A Inputs A : NCRing Description Text This function brings the variables of a particular NCRing in scope. For an illustration: Example A = QQ{x,y,z} coefficientRing A B = skewPolynomialRing(QQ,(-1)_QQ,{x,y,z}) x Text As you can see, at this point the interpreter treats x,y and z as elements of B. To go back to A, we run the command use A: Example use A x /// doc /// Key NCPolynomialRing Headline Type of a noncommutative polynomial ring Usage A = QQ{x,y} Description Text This is the type of a noncommutative polynomial ring over a commutative ring R (i.e. a tensor algebra over R). It has parent type @ TO NCRing @. Example A = QQ{x,y} /// doc /// Key (ideal, NCPolynomialRing) Headline The defining ideal of an NCPolynomialRing Usage I = ideal A Inputs A : NCPolynomialRing Outputs I : NCIdeal Description Text This returns the defining ideal of an NCPolynomialRing, which will be the zero ideal in the noncommutative polynomial ring. Example A = QQ{x,y} ideal A /// doc /// Key NCQuotientRing Headline Type of a noncommutative ring Description Text This is the type of a quotient of a tensor algebra by a two-sided ideal. At this point, one cannot define quotients of quotients. /// doc /// Key (symbol /, NCPolynomialRing, NCIdeal) Headline Construct a NCQuotientRing Usage B = A/I Inputs A : NCPolynomialRing I : NCIdeal Outputs B : NCQuotientRing Description Text This is one way to create a quotient of the tensor algebra modulo some relations. At this point, one cannot define quotients of quotients. If the base ring is QQ or a finite field of order p, then Bergman is called to compute a Groebner basis. If not, then one has a couple of options. The first is to take the defining ideal of the algebra, and provide a Groebner Basis by calling @ TO ncGroebnerBasis @ with the InstallGB flag set to true. Of course, if this generating set is not a Groebner basis, then you will get incorrect results upon calls to functions like @ TO (basis, ZZ, NCRing) @. The alternative is to use the built in commands @ TO skewPolynomialRing @ and @ TO oreExtension @ which has the same effect as above occuring behind the scenes. Just be careful using these commands to create your ring if your base ring is not a field Bergman can work with, as the generating sets created may not be a Groebner basis for the defining ideal (this is more often a problem for @ TO oreExtension @ than @ TO skewPolynomialRing @). Example A = QQ{x,y,z} f = y*z + z*y - x^2 g = x*z + z*x - y^2 h = z^2 - x*y - y*x I=ncIdeal{f,g,h} B = A/I z^2 R = toField(QQ[a]/ideal(a^4+a^3+a^2+a+1)) C = skewPolynomialRing(R,a,{x,y,z}) y*x /// doc /// Key (ambient, NCQuotientRing) Headline Ambient ring of an NCQuotientRing Usage A = ambient B Inputs B : NCQuotientRing Outputs A : NCPolynomialRing Description Text Returns the ambient ring of an @ TO NCQuotientRing @. As quotients of NCQuotientRings are added, this will return the top-level ambient ring. Example B = skewPolynomialRing(QQ,(-1)_QQ,{x,y,z}) A = ambient B /// doc /// Key (ideal, NCQuotientRing) Headline Defining ideal of an NCQuotientRing in its ambient ring Usage I = ideal B Inputs B : NCQuotientRing Outputs I : NCIdeal Description Text This returns the defining ideal of an NCQuotientRing in its ambient ring. As of now, this is always an ideal in an NCPolynomialRing, but when quotients of @ TO NCQuotientRing @s are added, this will no longer be the case. Example B = skewPolynomialRing(QQ,(-1)_QQ,{x,y,z}) A = ambient B I = ideal B ring I === A /// doc /// Key NCMatrix Headline Type of a matrix over a noncommutative ring Description Text This is the type of a matrix over a noncommutative ring. These represent homomorphisms between two free modules in chosen bases (whether you think of it as a map of left or right modules is up you). Modules themselves are not implemented yet in the @ TO NCAlgebra @ package, but are slated for a later release. Text Common ways to make (and use) a matrix include Code UL {TO (ncMatrix, List), TO (basis, ZZ, NCRing), TO (rightKernel, NCMatrix, ZZ), TO (rightKernelBergman, NCMatrix)} Text Common ways to get information about matrices Code UL {TO (ring, NCMatrix), TO (entries, NCMatrix)} Text Common operations on matrices: Code UL {TO (symbol +, NCMatrix,NCMatrix), TO (symbol -, NCMatrix,NCMatrix), TO (symbol %, NCMatrix,NCGroebnerBasis), TO (symbol *, NCMatrix,NCMatrix), TO (symbol *, NCMatrix,NCRingElement), TO (symbol *, NCMatrix,RingElement), TO (symbol //, NCMatrix,NCMatrix), TO (symbol _, NCMatrix,List), TO (symbol ==, NCMatrix, NCMatrix), TO (symbol |, NCMatrix,NCMatrix), TO (symbol ||, NCMatrix,NCMatrix), TO (symbol ^, NCMatrix,List), TO (symbol ^, NCMatrix,ZZ), } Text This is the type of a matrix with entries in an NCRing. Many of the basic operations one can perform on a @ TO Matrix @ are also allowed with an @ TO NCMatrix @, and the behavior of the functions should be similar to the corresponding 'usual' command. Some examples of creating and using NCMatrices are given below. Example A = QQ{a,b,c,d} M = ncMatrix {{a,b,c,d}} N = ncMatrix {{M,2*M,3*M},{4*M,5*M,6*M}} B = QQ{x,y,z} f = y*z + z*y - x^2 g = x*z + z*x - y^2 h = z^2 - x*y - y*x I = ncIdeal {f,g,h} Igb = ncGroebnerBasis I M = ncMatrix {{x, y, z}} sigma = ncMap(B,B,{y,z,x}) N = ncMatrix {{M},{sigma M}, {sigma sigma M}} Nred = N^3 % Igb C = B/I phi = ncMap(C,B,gens C) NC = phi N N3C = NC^3 X = NC + 3*NC Y = NC | 2*NC Z = X || NC /// doc /// Key ncMatrix (ncMatrix,List) (ncMatrix,NCRing,List,List) Headline Create an NCMatrix Usage M = ncMatrix entriesList Inputs entriesList : List Outputs M : NCMatrix Description Text This command creates an NCMatrix. As with the @ TO matrix @ command, the user may provide this matrix as a doubly nested list of NCRingElements, or as a doubly nested list of NCMatrices. The ncMatrix(NCRing,List,List) constructor is used only when creating maps to and from the zero free module. Example A = QQ{a,b,c,d} M = ncMatrix {{a,b,c,d}} N = ncMatrix {{M,2*M,3*M},{4*M,5*M,6*M}} /// doc /// Key (symbol -, NCMatrix, NCMatrix) Headline Subtract NCMatrices Usage L = M - N Inputs M : NCMatrix N : NCMatrix Outputs L : NCMatrix Description Text This subtracts NCMatrices. Example A = QQ{x,y,z} M = ncMatrix {{x, y, z}} sigma = ncMap(A,A,{y,z,x}) N = ncMatrix {{M},{sigma M}, {sigma sigma M}} N' = ncMatrix {{sigma sigma M}, {sigma M}, {M}} N - N' /// doc /// Key (symbol -, NCMatrix) Headline Negates NCMatrices Usage L = -M Inputs M : NCMatrix Outputs L : NCMatrix Description Text This negates NCMatrices. Example A = QQ{x,y,z} M = ncMatrix {{x, y, z}} sigma = ncMap(A,A,{y,z,x}) N = ncMatrix {{M},{sigma M}, {sigma sigma M}} -N /// doc /// Key (symbol +, NCMatrix, NCMatrix) Headline Add NCMatrices Usage L = M + N Inputs M : NCMatrix N : NCMatrix Outputs L : NCMatrix Description Text This adds NCMatrices. Example A = QQ{x,y,z} M = ncMatrix {{x, y, z}} sigma = ncMap(A,A,{y,z,x}) N = ncMatrix {{M},{sigma M}, {sigma sigma M}} N' = ncMatrix {{sigma sigma M}, {sigma M}, {M}} N + N' /// doc /// Key (symbol %, NCMatrix, NCGroebnerBasis) Headline Reduces the entries of an NCMatrix with respect to an NCGroebnerBasis Usage L = M % Igb Inputs M : NCMatrix Igb : NCGroebnerBasis Outputs L : NCMatrix Description Text This command reduces the entries of an NCMatrix with respect to an NCGroebnerBasis. Example A = QQ{x,y,z} f = y*z + z*y - x^2 g = x*z + z*x - y^2 h = z^2 - x*y - y*x I = ncIdeal {f,g,h} Igb = ncGroebnerBasis I M = ncMatrix {{x, y, z}} sigma = ncMap(A,A,{y,z,x}) N = ncMatrix {{M},{sigma M}, {sigma sigma M}} N3 = N^3 N3red = N3 % Igb /// doc /// Key (symbol *, NCMatrix, NCMatrix) Headline Product of NCMatrices Usage L = M*N Inputs M : NCMatrix N : NCMatrix Outputs L : NCMatrix Description Text This command allows for the product of composable NCMatrices (or ordinary matrices over the base). Example B = threeDimSklyanin(QQ,{1,1,-1},{x,y,z}) M = ncMatrix {{x, y, z}} sigma = ncMap(B,B,{y,z,x}) N = ncMatrix {{M},{sigma M}, {sigma sigma M}} N' = ncMatrix {{sigma sigma M}, {sigma M}, {M}} N*N' N'*N /// doc /// Key (symbol *, NCMatrix, Matrix) Headline Product of NCMatrices Usage L = M*N Inputs M : NCMatrix N : Matrix Outputs L : NCMatrix Description Text This command allows for the product of composable NCMatrices (or ordinary matrices over the base). Example B = threeDimSklyanin(QQ,{1,1,-1},{x,y,z}) M = ncMatrix {{x, y, z}} sigma = ncMap(B,B,{y,z,x}) N = ncMatrix {{M},{sigma M}, {sigma sigma M}} L = map(QQ^3,QQ^3,{{2,0,0},{1,2,0},{1,2,3}}) N*L /// doc /// Key (symbol *, NCMatrix, NCRingElement) Headline Product of NCMatrices Usage L = M*f Inputs M : NCMatrix f : NCRingElement Outputs L : NCMatrix Description Text This command allows for the scalar multiplication of an NCMatrix by an NCRingElement on the right. Example B = threeDimSklyanin(QQ,{1,1,-1},{x,y,z}) M = ncMatrix {{x, y, z}} sigma = ncMap(B,B,{y,z,x}) N = ncMatrix {{M},{sigma M}, {sigma sigma M}} N*x^2 /// doc /// Key (symbol *, NCMatrix, RingElement) Headline Product of NCMatrices Usage L = M*f Inputs M : NCMatrix N : RingElement Outputs L : NCMatrix Description Text This command allows for the scaling of an NCMatrix by an element in the base ring. Example R = frac(QQ[a]) B = skewPolynomialRing(R,a,{x,y,z}) M = ncMatrix {{x, y, z}} sigma = ncMap(B,B,{y,z,x}) N = ncMatrix {{M},{sigma M}, {sigma sigma M}} N*a /// doc /// Key (symbol *, NCMatrix, QQ) Headline Product of NCMatrices Usage L = M*a Inputs M : NCMatrix a : QQ Outputs L : NCMatrix Description Text This command allows for the scaling of an @ TO NCMatrix @ by an element in @ TO QQ @. Example B = threeDimSklyanin(QQ,{1,1,-1},{x,y,z}) M = ncMatrix {{x, y, z}} sigma = ncMap(B,B,{y,z,x}) N = ncMatrix {{M},{sigma M}, {sigma sigma M}} N*(1/2) /// doc /// Key (symbol *, NCMatrix, ZZ) Headline Product of NCMatrices Usage L = M*a Inputs M : NCMatrix a : ZZ Outputs L : NCMatrix Description Text This command allows for the scaling of an @ TO NCMatrix @ by an element in @ TO ZZ @. Example B = threeDimSklyanin(QQ,{1,1,-1},{x,y,z}) M = ncMatrix {{x, y, z}} sigma = ncMap(B,B,{y,z,x}) N = ncMatrix {{M},{sigma M}, {sigma sigma M}} N*3 /// doc /// Key (symbol *, Matrix, NCMatrix) Headline Product of NCMatrices Usage L = N*M Inputs N : Matrix M : NCMatrix Outputs L : NCMatrix Description Text This command allows for the product of composable NCMatrices (or ordinary matrices over the base). Example B = threeDimSklyanin(QQ,{1,1,-1},{x,y,z}) M = ncMatrix {{x, y, z}} sigma = ncMap(B,B,{y,z,x}) N = ncMatrix {{M},{sigma M}, {sigma sigma M}} L = map(QQ^3,QQ^3,{{2,0,0},{1,2,0},{1,2,3}}) L*N /// doc /// Key (symbol *, NCRingElement, NCMatrix) Headline Product of NCMatrices Usage L = f*M Inputs f : NCRingElement M : NCMatrix Outputs L : NCMatrix Description Text This command allows for the scalar multiplication of an NCMatrix by an NCRingElement on the left. Example B = threeDimSklyanin(QQ,{1,1,-1},{x,y,z}) M = ncMatrix {{x, y, z}} sigma = ncMap(B,B,{y,z,x}) N = ncMatrix {{M},{sigma M}, {sigma sigma M}} x^2*N /// doc /// Key (symbol *, RingElement, NCMatrix) Headline Product of NCMatrices Usage L = f*M Inputs f : RingElement M : NCMatrix Outputs L : NCMatrix Description Text This command allows for the scaling of an NCMatrix by an element in the base ring. Example R = frac(QQ[a]) B = skewPolynomialRing(R,a,{x,y,z}) M = ncMatrix {{x, y, z}} sigma = ncMap(B,B,{y,z,x}) N = ncMatrix {{M},{sigma M}, {sigma sigma M}} a*N /// doc /// Key (symbol *, QQ, NCMatrix) Headline Product of NCMatrices Usage L = a*M Inputs a : QQ M : NCMatrix Outputs L : NCMatrix Description Text This command allows for the scaling of an @ TO NCMatrix @ by an element in @ TO QQ @. Example B = threeDimSklyanin(QQ,{1,1,-1},{x,y,z}) M = ncMatrix {{x, y, z}} sigma = ncMap(B,B,{y,z,x}) N = ncMatrix {{M},{sigma M}, {sigma sigma M}} (1/2)*N /// doc /// Key (symbol *, ZZ, NCMatrix) Headline Product of NCMatrices Usage L = a*M Inputs a : ZZ M : NCMatrix Outputs L : NCMatrix Description Text This command allows for the scaling of an @ TO NCMatrix @ by an element in @ TO ZZ @. Example B = threeDimSklyanin(QQ,{1,1,-1},{x,y,z}) M = ncMatrix {{x, y, z}} sigma = ncMap(B,B,{y,z,x}) N = ncMatrix {{M},{sigma M}, {sigma sigma M}} 3*N /// doc /// Key (symbol ==, NCMatrix, NCMatrix) (symbol ==, NCMatrix, ZZ) (symbol ==, ZZ, NCMatrix) Headline Test equality of matrices Usage isEqual = M == N Inputs M : NCMatrix or an integer N : NCMatrix or an integer Outputs isEqual : Boolean Description Text This command tests equality for matrices. If one of the inputs is an integer, then the test only will work if the integer is zero. Below, we test the well-definedness of the exponentiation operation using Groebner bases. Example A = QQ{x,y,z} f = y*z + z*y - x^2 g = x*z + z*x - y^2 h = z^2 - x*y - y*x I = ncIdeal {f,g,h} Igb = ncGroebnerBasis I M = ncMatrix {{x, y, z}} sigma = ncMap(A,A,{y,z,x}) N = ncMatrix {{M},{sigma M}, {sigma sigma M}} Nred = N^3 % Igb B = A/I phi = ncMap(B,A,gens B) NB = phi N N3B = NB^3 (phi Nred) == N3B /// doc /// Key (symbol |, NCMatrix, NCMatrix) Headline Join NCMatrices horizontally Usage L = M | N Inputs M : NCMatrix N : NCMatrix Outputs L : NCMatrix Description Text This command joins NCMatrices horizontally. Example A = QQ{a,b,c,d} M = ncMatrix {{a,b,c,d},{b,c,d,a}} N = M | 2*M | -3*M /// doc /// Key (symbol ||, NCMatrix, NCMatrix) Headline Join NCMatrices vertically Usage L = M || N Inputs M : NCMatrix N : NCMatrix Outputs L : NCMatrix Description Text This command joins NCMatrices vertically. Example A = QQ{a,b,c,d} M = ncMatrix {{a,b,c,d},{b,c,d,a}} N = M || 2*M || -3*M /// doc /// Key (symbol ^, NCMatrix, List) Headline Select some rows of an NCMatrix Usage L = M^rows Inputs M : NCMatrix rows : List Outputs L : NCMatrix Description Text This command selects some rows of an NCMatrix. Example A = QQ{a,b,c,d} M = ncMatrix {{a,b,c,d},{b,c,d,a}} N = M || 2*M || -3*M N^{0,3,4} /// doc /// Key (symbol _, NCMatrix, List) Headline Select some columns of an NCMatrix Usage L = M_cols Inputs M : NCMatrix cols : List Outputs L : NCMatrix Description Text This command selects some columns of an NCMatrix. Example A = QQ{a,b,c,d} M = ncMatrix {{a,b,c,d},{b,c,d,a}} N = M || 2*M || -3*M N_{0,2} /// doc /// Key (symbol ^, NCMatrix, ZZ) Headline Exponentiate an NCMatrix Usage L = M^n Inputs M : NCMatrix n : ZZ Outputs L : NCMatrix Description Text This exponentiates an NCMatrix. It should be remarked that the matrix is reduced with the GB of the ring it is over on each iteration of the product. If your algebra is significantly smaller than the tensor algebra, this is a large savings. The input is assumed to be a nonnegative integer at this time. Example A = QQ{x,y,z} M = ncMatrix {{x, y, z}} sigma = ncMap(A,A,{y,z,x}) N = ncMatrix {{M},{sigma M}, {sigma sigma M}} N^3 B = A/ncIdeal{y*z + z*y - x^2, x*z + z*x - y^2, z^2 - x*y - y*x} NB = promote(N,B) NB^3 /// doc /// Key (symbol //, NCMatrix, NCMatrix) Headline Factor one map through another Usage L = M // N Inputs M : NCMatrix N : NCMatrix Outputs L : NCMatrix Description Text This command factors one map through another. One nice application of this is to compute twisted matrix factorizations. If the maps input are homogeneous, then the degrees must match up for the command to work. If M does not factor through N, then the return value L is such that M - N*L is the reduction of M modulo a Groebner basis for the image of N. Here is an example of doing so over a PI Sklyanin algebra. Note that since quotients of quotients are (unfortunately) not yet implemented, we have to do a bit of acrobatics to define the quotient of the Sklyanin we want. Example B = threeDimSklyanin(QQ,{1,1,-1},{x,y,z}) A = ambient B Text The element g below is central in B (the two is just for convenience). Example g = 2*(-y^3-x*y*z+y*x*z+x^3) J = (ideal B) + ncIdeal {g} B' = A/J -- Factor of sklyanin k = ncMatrix {{x,y,z}} BprimeToB = ncMap(B,B',gens B) -- way to lift back from B' to B M = BprimeToB rightKernelBergman rightKernelBergman k -- second syzygy of k over B Text At this point, M is maximal Cohen-Macaulay B'-module, and hence the projective dimension of M as a B-module is 1. Since M is a B' module, multiplication by g on the complex that gives the resolution over B is null homotopic. This means we may factor the map f through f times the identity. We do so below. Example gId = g*(ncMatrix applyTable(entries id_(ZZ^4), i -> promote(i,B))) assignDegrees(gId,{2,2,2,3},{5,5,5,6}); -- now factor through g*id M' = gId // M M*M' == gId /// doc /// Key (transpose, NCMatrix) Headline Transposes an NCMatrix Usage L = transpose M Inputs M : NCMatrix Outputs L : NCMatrix Description Text This command transposes an NCMatrix Example A = QQ{a,b,c,d} M = ncMatrix {{a,b,c,d},{b,c,d,a}} N = M || 2*M || -3*M transpose N /// doc /// Key (ring, NCMatrix) Headline Gives the ring of the NCMatrix Usage L = ring M Inputs M : NCMatrix Outputs L : NCRing Description Text This command returns the ring over which the NCMatrix is defined. Example A = QQ{a,b,c,d} M = ncMatrix {{a,b,c,d},{b,c,d,a}} ring M /// doc /// Key (entries, NCMatrix) Headline Returns the entries of the NCMatrix Usage L = entries M Inputs M : NCMatrix Outputs L : List Description Text Returns the entries of the NCMatrix as a doubly nested list. Example A = QQ{a,b,c,d} M = ncMatrix {{a,b,c,d},{b,c,d,a}} N = M || 2*M || -3*M entries N /// doc /// Key (lift, NCMatrix) Headline Lifts an NCMatrix Usage L = lift M Inputs M : NCMatrix Outputs L : NCMatrix Description Text This command lifts an NCMatrix to a matrix over its @ TO ambient @ NCRing. Example A = QQ{x,y,z,w} B = A/ncIdeal{y*z + z*y - x^2, x*z + z*x - y^2, z^2 - x*y - y*x} M = ncMatrix {{x,y,z,w},{y,z,w,x}} N = M || 2*M || -3*M ring N ring lift N /// doc /// Key NCRingElement Headline Type of an element in a noncommutative ring Description Text This is the type of an element in a noncommutative graded ring. One can deal with these elements in much the same way as in the commutative case. See @ TO RingElement @ for details. /// doc /// Key (degree, NCRingElement) Headline Returns the degree of an NCRingElement Usage d = degree f Inputs f : NCRingElement Outputs d : ZZ Description Text Returns the degree of an NCRingElement. At the moment, multigraded NCRings are not supported. Example A = QQ{x,y,z,w} f = x^2+y^2+z^3 degree f isHomogeneous f setWeights(A,{3,3,2,1}) degree f isHomogeneous f /// doc /// Key (ring, NCRingElement) Headline Returns the NCRing of an NCRingElement Usage A = ring f Inputs f : NCRingElement Outputs A : NCRing Description Text Returns the ring of an NCRingElement Example A = QQ{x,y,z,w} f = x^2+y^2+z^3 ring f /// doc /// Key (terms, NCRingElement) Headline Returns the terms of an NCRingElement Usage t = terms f Inputs f : NCRingElement Outputs t : List Description Text Returns the list of terms that make up the NCRingElement. It is a list of NCRingElements. Example A = QQ{x,y,z,w} f = 2*x^2+y^2+z^3 t = terms f first t /// doc /// Key (size, NCRingElement) Headline Returns the number of terms of an NCRingElement Usage n = size f Inputs f : NCRingElement Outputs n : ZZ Description Text Returns the number of terms of an NCRingElement. Example A = QQ{x,y,z,w} f = x^2+y^2+z^3 size f /// doc /// Key (support, NCRingElement) Headline Returns the variables appearing in the NCRingElement Usage sup = support f Inputs f : NCRingElement Outputs sup : List Description Text Returns the variables appearing in f (as elements of the ring of f). Example A = QQ{x,y,z,w} f = x^2+y^2+z^3 sup = support f first sup /// doc /// Key (monomials, NCRingElement) Headline Returns the monomials appearing in the NCRingElement Usage mons = support f Inputs f : NCRingElement Outputs mons : NCMatrix Description Text Returns the monomials appearing in NCRingElement as an NCMatrix. Example A = QQ{x,y,z,w} f = x^2+y^2+z^3 mons = monomials f /// doc /// Key (leadMonomial, NCRingElement) Headline Returns the lead monomial of an NCRingElement Usage mon = leadMonomial f Inputs f : NCRingElement Outputs mon : NCRingElement Description Text Returns the lead monomial of an NCRingElement (as an NCRingElement). Example A = QQ{x,y,z,w} f = x^2+y^2+z^3 mon = leadMonomial f /// doc /// Key (leadCoefficient, NCRingElement) Headline Returns the lead monomial of an NCRingElement Usage coeff = leadCoefficient f Inputs f : NCRingElement Outputs coeff : RingElement Description Text Returns the lead coefficient of an NCRingElement (as an element of the base). Example A = QQ{x,y,z,w} f = x^2+y^2+z^3 coeff = leadCoefficient f /// doc /// Key (leadTerm, NCRingElement) Headline Returns the lead term of an NCRingElement Usage coeff = leadTerm f Inputs f : NCRingElement Outputs coeff : NCRingElement Description Text Returns the lead term of an NCRingElement (as an NCRingElement). Example A = QQ{x,y,z,w} f = x^2+y^2+2*z^3 coeff = leadTerm f /// doc /// Key (isConstant, NCRingElement) Headline Returns whether the NCRingElement is constant Usage t = isConstant f Inputs f : NCRingElement Outputs t : Boolean Description Text Returns whether the NCRingElement is constant. Example A = QQ{x,y,z,w} f = x^2+y^2+2*z^3 isConstant f g = promote(1,A) isConstant g /// doc /// Key (baseName, NCRingElement) Headline Returns the base name of a generator of an NCRing Usage name = baseName f Inputs f : NCRingElement Description Text Returns the base name of a generator of an NCRing. This could be something of type @ TO IndexedVariable @ or a @ TO Symbol @. Example A = QQ{x,y,z,w} baseName x B = QQ{p_1..p_6} baseName p_1 /// doc /// Key (toString, NCRingElement) Headline Converts an NCRingElement to a string Usage str = toString f Inputs f : NCRingElement Outputs str : String Description Text Converts an NCRingElement to a string. This should be readable by both Macaulay2 as well as Bergman. Example A = QQ{x,y,z,w} f = x^2+y^2+z^3 toString f /// doc /// Key (symbol *, List, NCRingElement) Headline Scales a list by an NCRingElement on the right Usage xsf = xs*f Inputs xs : List f : NCRingElement Outputs xsf : List Description Text Scales a list by an NCRingElement on the right. Example A = QQ{x,y} f = x^2+y^2 bas = flatten entries basis(3,A) bas*f /// doc /// Key (symbol *, NCRingElement, List) Headline Scales a list by an NCRingElement on the left Usage fxs = f*xs Inputs f : NCRingElement xs : List Outputs xsf : List Description Text Scales a list by an NCRingElement on the right. Example A = QQ{x,y} f = x^2+y^2 bas = flatten entries basis(3,A) f*bas /// doc /// Key NCGroebnerBasis Headline Type of a Groebner basis for an NCIdeal in an NCRing. Description Text This is the type for a Groebner basis of an ideal in the tensor algebra. One can provide one using the @ TO [ncGroebnerBasis,InstallGB] @ option of @ TO ncGroebnerBasis @ if you happen to know it. One also can have Macaulay2 call Bergman and have it computed via the function @ TO twoSidedNCGroebnerBasisBergman @. This command is automatically called when defining a quotient ring, if the defining ideal does not yet have a cached Groebner basis. You can also install one from a Bergman output file if you have that handy; see @ TO gbFromOutputFile @. Below are a couple of examples. Example R = QQ[a,b,c,d]/ideal{a*b+c*d} A = R {x,y,z} I = ncIdeal {a*x*y,b*z^2} Igb = ncGroebnerBasis(I, InstallGB=>true) Text Note that after the InstallGB flag is set, no checking is done to ensure that the input is in fact a Groebner basis. Example c*z^2 % Igb b*z^2 % Igb A = QQ{x,y,z} p = y*z + z*y - x^2 q = x*z + z*x - y^2 r = z^2 - x*y - y*x I = ncIdeal {p,q,r} Igb = ncGroebnerBasis I normalFormBergman(z^17,Igb) Text stuff /// doc /// Key ncGroebnerBasis (ncGroebnerBasis,List) (ncGroebnerBasis,NCIdeal) [ncGroebnerBasis,InstallGB] Headline Compute a noncommutative Groebner basis. Usage Igb = ncGroebnerBasis I Inputs I : NCIdeal or a @ TO List @ of NCRingElements DegreeLimit => ZZ the maximum degree for the calculation of a Groebner basis InstallGB => Boolean set this to true to install a NCGroebnerBasis without verifying that it is one Outputs Igb : NCGroebnerBasis Description Example R = QQ[a,b,c,d]/ideal{a*b+c*d} A = R {x,y,z} I = ncIdeal {a*x*y,b*z^2} Igb = ncGroebnerBasis(I, InstallGB=>true) c*z^2 % Igb b*z^2 % Igb Text Note that after the InstallGB flag is set, no checking is done to ensure that the input is in fact a Groebner basis. Example A = QQ{x,y,z} p = y*z + z*y - x^2 q = x*z + z*x - y^2 r = z^2 - x*y - y*x I = ncIdeal {p,q,r} Igb = ncGroebnerBasis I Text If the InstallGB flag is not set, then a call to Bergman is made, if the base ring is @ TO QQ @ or a finite field of characteristic p. Otherwise, an error is raised. Now we can do things with an ncgb, like compute normal forms (using the Bergman interface). Example normalFormBergman(z^17,Igb) Text Or using the built in reduction code: Example z^17 % Igb Text Calls to Bergman are usually faster, except for when the polynomial is small. See the documentation for @ TO (symbol %, NCRingElement, NCGroebnerBasis) @ for details on controlling when Bergman is called. /// {* -- This block of doc nodes is in case we decide to have stubs for the name of the option -- in addition to the description of how to use the option in the function call. doc /// Key CacheBergmanGB Headline Whether or not to cache the gb from Bergman to a file for later use SeeAlso gbFromOutputFile twoSidedNCGroebnerBasisBergman /// doc /// Key MakeMonic Headline An option that specifies Bergman output should be made monic SeeAlso gbFromOutputFile twoSidedNCGroebnerBasisBergman /// doc /// Key ReturnIdeal Headline An option that specifies certain NCAlgebra functions should return an ideal rather than a Groebner basis. SeeAlso gbFromOutputFile /// doc /// Key Derivation Headline An option that specifies that an NCRingMap be considered a derivation. SeeAlso ncMap /// doc /// Key NumModuleVars Headline An option specifying the number of module variables in the ring of the Groebner basis. /// doc /// Key InstallGB Headline Install a NCGroebnerBasis (without verifying that it is one). SeeAlso ncGroebnerBasis /// *} doc /// Key gbFromOutputFile (gbFromOutputFile,NCPolynomialRing,String) [gbFromOutputFile,CacheBergmanGB] [gbFromOutputFile,ReturnIdeal] [gbFromOutputFile,MakeMonic] Headline Read in a NCGroebnerBasis from a Bergman output file. Usage Igb = gbFromOutputFile(A,fileName) Inputs A : NCPolynomialRing fileName : String CacheBergmanGB => Boolean specifies whether or not to cache the Groebner basis for later use MakeMonic => Boolean specifies whether the Bergman output should be made monic ReturnIdeal => Boolean specifies whether to return an NCIdeal or the NCGroebnerBasis Outputs Igb : NCGroebnerBasis or an @ TO NCIdeal @ Description Text This command reads in a Groebner basis from a Bergman output file. It can be useful if you have performed a lengthy computation before, and wish to load in a previously computed result to do some computations. The Groebner basis we are reading in for this example is located in the NCAlgebra auxiliary files directory. We are currently unable to compile this documentation node in a way that enables M2 to read the file. We give a text version of the session until the issue is resolved. Example A=QQ{x56,x46,x36,x26,x16,x45,x35,x25,x15,x34,x24,x14,x23,x13,x12} Text I = gbFromOutputFile(A,"NCAlgebra/FK.bo", ReturnIdeal=>true) Text B=A/I -- The gb in the file is up to degree 6 Text hilbertSeries(B,Order=>4) Text In "Quadratic algebras, Dunkl elements, and Schubert calculus," Fomin and Kirillov introduce a family of noncommutative algebras E_n which may be thought of as the quadratic closure of the ring of "Bruhat operators" acting on a vector space whose basis is the symmetric group. In that paper, they provide Hilbert series for the algebras E_1, ..., E_5. The file loaded above is a Groebner basis of E_6 to degree 6. Thus B is isomorphic to E_6 in low degrees. /// doc /// Key (generators, NCGroebnerBasis) Headline The list of algebra generators of an NCGroebnerBasis Usage gensIgb = generators Igb Inputs Igb : NCGroebnerBasis Outputs gensIgb : List Description Text This function returns the generators of an NCGroebnerBasis as a list. As usual, gens is a synonym for generators. Example A = QQ{x,y,z} p = y*z + z*y - x^2 q = x*z + z*x - y^2 r = z^2 - x*y - y*x I = ncIdeal {p,q,r} Igb = ncGroebnerBasis I gens Igb /// doc /// Key (symbol %, NCRingElement, NCGroebnerBasis) (symbol %, QQ, NCGroebnerBasis) (symbol %, ZZ, NCGroebnerBasis) Headline Reduces a NCRingElement by a NCGroebnerBasis Usage fred = f % Igb Inputs f : NCRingElement or an integer, or a rational number Igb : NCGroebnerBasis Outputs fred : NCRingElement Description Text This command reduces the input modulo a noncommutative Groebner basis. It will either reduce it using top-level Macaulay code, or via a call to Bergman, depending on the size and degree of the input element. Example A = QQ{x,y,z} p = y*z + z*y - x^2 q = x*z + z*x - y^2 r = z^2 - x*y - y*x I = ncIdeal {p,q,r} Igb = ncGroebnerBasis I z^6 % Igb /// doc /// Key twoSidedNCGroebnerBasisBergman (twoSidedNCGroebnerBasisBergman,List) (twoSidedNCGroebnerBasisBergman,NCIdeal) [twoSidedNCGroebnerBasisBergman,DegreeLimit] [twoSidedNCGroebnerBasisBergman,NumModuleVars] [twoSidedNCGroebnerBasisBergman,CacheBergmanGB] [twoSidedNCGroebnerBasisBergman,MakeMonic] Headline Calls Bergman to compute a two sided noncommutative Groebner Basis. Usage twoSidedNCGroebnerBasisBergman I Inputs I : NCIdeal or a @ TO List @ of NCRingElements DegreeLimit => ZZ specifies the maximum degree for the Groebner basis calculation NumModuleVars => ZZ specifies the number of module variables in the ring of the Groebner basis MakeMonic => Boolean specifies whether the Bergman output should be made monic CacheBergmanGB => Boolean specifies whether or not to cache the Groebner basis for later use Outputs : NCGroebnerBasis Description Text This command calls the computer algebra system Bergman to compute a noncommutative Groebner basis. Since Groebner bases in the tensor algebra need not be finitely generated, one should specify a degree limit on the computation unless one has a reason to believe the Groebner basis is finite. Example A = QQ{x,y,z} p = y*z + z*y - x^2 q = x*z + z*x - y^2 r = z^2 - x*y - y*x I = ncIdeal {p,q,r} Igb = twoSidedNCGroebnerBasisBergman I /// doc /// Key NCLeftIdeal Headline Type of a left ideal in a noncommutative ring Description Text This defines a left ideal in a noncommutative ring. Not much can be done with these objects at this point (as one can tell by the dearth of operations that take an NCLeftIdeal as input), , but eventually it will be a 'fully featured' object. /// doc /// Key ncLeftIdeal (ncLeftIdeal, List) (ncLeftIdeal, NCRingElement) Headline Define a left ideal in a noncommutative ring Usage I = ncLeftIdeal fs Inputs fs : NCRingElement or a @ TO List @ of NCRingElements Outputs I : NCLeftIdeal Description Text This defines a left ideal in a noncommutative ring. Not much can be done with these objects at this point (as one can tell by the dearth of operations that take an NCLeftIdeal as input), but eventually it will be a 'fully featured' object. Example A = QQ{x,y,z} p = y*z + z*y - x^2 q = x*z + z*x - y^2 r = z^2 - x*y - y*x I = ncLeftIdeal{p,q,r} /// doc /// Key (generators, NCLeftIdeal) Headline Returns the generators of an NCLeftIdeal Usage gensI = generators I Inputs I : NCLeftIdeal Outputs gensI : List Description Text Returns the generators of an NCLeftIdeal. Example A = QQ{x,y,z} p = y*z + z*y - x^2 q = x*z + z*x - y^2 r = z^2 - x*y - y*x I = ncLeftIdeal{p,q,r} gens I /// doc /// Key (ring, NCLeftIdeal) Headline Returns the ring of an NCLeftIdeal Usage A = ring I Inputs I : NCLeftIdeal Outputs A : NCRing Description Text Returns the ring of an NCLeftIdeal. Example A = QQ{x,y,z} p = y*z + z*y - x^2 q = x*z + z*x - y^2 r = z^2 - x*y - y*x I = ncLeftIdeal{p,q,r} ring I /// doc /// Key (symbol +, NCLeftIdeal, NCLeftIdeal) Headline Sum of NCLeftIdeals Usage K = I + J Inputs I : NCLeftIdeal J : NCLeftIdeal Outputs K : NCLeftIdeal Description Text This command sums two NCLeftIdeals. Example A = QQ{x,y,z} p = y*z + z*y - x^2 q = x*z + z*x - y^2 r = z^2 - x*y - y*x I = ncLeftIdeal{p,q} J = ncLeftIdeal r I + J /// doc /// Key NCRightIdeal Headline Type of a right ideal in a noncommutative ring Description Text This defines a right ideal in a noncommutative ring. Not much can be done with these objects at this point (as one can tell by the dearth of operations that take an NCRightIdeal as input), , but eventually it will be a 'fully featured' object. /// doc /// Key ncRightIdeal (ncRightIdeal, List) (ncRightIdeal, NCRingElement) Headline Define a right ideal in a noncommutative ring Usage I = ncRightIdeal fs Inputs fs : NCRingElement or a @ TO List @ of NCRingElements Outputs I : NCRightIdeal Description Text This defines a right ideal in a noncommutative ring. Not much can be done with these objects at this point (as one can tell by the dearth of operations that take an NCRightIdeal as input), but eventually it will be a 'fully featured' object. Example A = QQ{x,y,z} p = y*z + z*y - x^2 q = x*z + z*x - y^2 r = z^2 - x*y - y*x I = ncRightIdeal{p,q,r} /// doc /// Key (generators, NCRightIdeal) Headline Returns the generators of an NCRightIdeal Usage gensI = generators I Inputs I : NCRightIdeal Outputs gensI : List Description Text Returns the generators of an NCRightIdeal. Example A = QQ{x,y,z} p = y*z + z*y - x^2 q = x*z + z*x - y^2 r = z^2 - x*y - y*x I = ncRightIdeal{p,q,r} gens I /// doc /// Key (ring, NCRightIdeal) Headline Returns the ring of an NCRightIdeal Usage A = ring I Inputs I : NCRightIdeal Outputs A : NCRing Description Text Returns the ring of an NCRightIdeal. Example A = QQ{x,y,z} p = y*z + z*y - x^2 q = x*z + z*x - y^2 r = z^2 - x*y - y*x I = ncRightIdeal{p,q,r} ring I /// doc /// Key (symbol +, NCRightIdeal, NCRightIdeal) Headline Sum of NCRightIdeals Usage K = I + J Inputs I : NCRightIdeal J : NCRightIdeal Outputs K : NCRightIdeal Description Text This command sums two NCRightIdeals. Example A = QQ{x,y,z} p = y*z + z*y - x^2 q = x*z + z*x - y^2 r = z^2 - x*y - y*x I = ncRightIdeal{p,q} J = ncRightIdeal r I + J /// doc /// Key NCIdeal Headline Type of a two-sided ideal in a noncommutative ring Description Text This defines a right ideal in a noncommutative ring. /// doc /// Key ncIdeal (ncIdeal, List) (ncIdeal, NCRingElement) Headline Define a two-sided ideal in a noncommutative ring Usage I = ncIdeal fs Inputs fs : NCRingElement or a @ TO List @ of NCRingElements Outputs I : NCIdeal Description Text This defines a two-sided ideal in a noncommutative ring. Example A = QQ{x,y,z} p = y*z + z*y - x^2 q = x*z + z*x - y^2 r = z^2 - x*y - y*x I = ncIdeal{p,q,r} /// doc /// Key (generators, NCIdeal) Headline Returns the generators of an NCIdeal Usage gensI = generators I Inputs I : NCIdeal Outputs gensI : List Description Text Returns the generators of an NCIdeal. Example A = QQ{x,y,z} p = y*z + z*y - x^2 q = x*z + z*x - y^2 r = z^2 - x*y - y*x I = ncIdeal{p,q,r} gens I /// doc /// Key (ring, NCIdeal) (ring, NCGroebnerBasis) Headline Returns the ring of an NCIdeal or NCGroebnerBasis Usage A = ring I Inputs I : NCIdeal Outputs A : NCRing Description Text Returns the ring of an NCIdeal. Example A = QQ{x,y,z} p = y*z + z*y - x^2 q = x*z + z*x - y^2 r = z^2 - x*y - y*x I = ncIdeal{p,q,r} ring I /// doc /// Key (symbol +, NCIdeal, NCIdeal) Headline Sum of NCIdeals Usage K = I + J Inputs I : NCIdeal J : NCIdeal Outputs K : NCIdeal Description Text This command sums two NCIdeals. Example A = QQ{x,y,z} p = y*z + z*y - x^2 q = x*z + z*x - y^2 r = z^2 - x*y - y*x I = ncIdeal{p,q} J = ncIdeal r I + J /// doc /// Key (basis, ZZ, NCIdeal) Headline Returns a basis of an NCIdeal in a particular degree. Usage bas = basis(n,I) Inputs n : ZZ I : NCIdeal Outputs bas : NCMatrix Description Text This command returns a basis (or minimal generating set, if the ground ring is not a field), of a homogeneous two-sided ideal in a noncommutative ring. Example A = QQ{x,y,z} p = y*z + z*y - x^2 q = x*z + z*x - y^2 r = z^2 - x*y - y*x I = ncIdeal{p,q,r} bas = basis(3,I) /// doc /// Key (basis, ZZ, NCLeftIdeal) Headline Returns a basis of an NCLeftIdeal in a particular degree. Usage bas = basis(n,I) Inputs n : ZZ I : NCLeftIdeal Outputs bas : NCMatrix Description Text This command returns a basis (or minimal generating set, if the ground ring is not a field), of a homogeneous left ideal in a noncommutative ring. Example A = QQ{x,y,z} p = y*z + z*y - x^2 q = x*z + z*x - y^2 r = z^2 - x*y - y*x I = ncLeftIdeal{p,q,r} bas = basis(3,I) /// doc /// Key (basis, ZZ, NCRightIdeal) Headline Returns a basis of an NCRightIdeal in a particular degree. Usage bas = basis(n,I) Inputs n : ZZ I : NCRightIdeal Outputs bas : NCMatrix Description Text This command returns a basis (or minimal generating set, if the ground ring is not a field), of a homogeneous right ideal in a noncommutative ring. Example A = QQ{x,y,z} p = y*z + z*y - x^2 q = x*z + z*x - y^2 r = z^2 - x*y - y*x I = ncRightIdeal{p,q,r} bas = basis(3,I) /// doc /// Key (basis, ZZ, NCRing) Headline Returns a basis of an NCRing in a particular degree. Usage bas = basis(n,B) Inputs n : ZZ I : NCRing Outputs bas : NCMatrix Description Text This command returns a basis (or minimal generating set, if the ground ring is not a field), of a graded noncommutative ring. Example A = QQ{x,y,z} p = y*z + z*y - x^2 q = x*z + z*x - y^2 r = z^2 - x*y - y*x I = ncIdeal{p,q,r} B = A/I bas = basis(4,B) /// doc /// Key setWeights (setWeights,NCRing,List) Headline Set a nonstandard grading for a NCRing. Usage setWeights(A,degList) Inputs A : NCRing degList : List a list of integer weights to be assigned to the generators of A Outputs : NCRing Description Text This method enables the user to work with rings which are not naturally graded (the generators are not all degree 1). The user should be aware that methods which call Bergman may not work with nonstandard gradings. Perhaps the most important example is hilbertBergman, which throws an error. Instead, use @ TO hilbertSeries @. Example A=QQ{x,y,z} w=x^3-y^2 isHomogeneous w setWeights(A, {2,3,1}) isHomogeneous w C = QQ{a,b,c} g = ncMap(C,A,{a^3,b^2,a+b,a-b}) isHomogeneous g setWeights(A,{3,2,1,1}) isHomogeneous g SeeAlso isHomogeneous /// doc /// Key (isHomogeneous, NCIdeal) (isHomogeneous, NCRightIdeal) (isHomogeneous, NCLeftIdeal) (isHomogeneous, NCRing) (isHomogeneous, NCMatrix) (isHomogeneous, NCRingElement) Headline Determines whether the input defines a homogeneous object Usage isHomogeneous x Inputs x : NCIdeal or an @ TO NCLeftIdeal @ an @ TO NCRightIdeal @ an @ TO NCRing @ an @ TO NCMatrix @ or an @ TO NCRingElement @ Outputs : Boolean Description Text Many methods in the NCAlgebra package require inputs to be homogeneous. The meaning of "homogeneous" depens on the type of object. Text If x is an @ TO NCRingElement @, the method returns true if all terms of x have the same degree. If x is an @ TO NCIdeal @, @ TO NCLeftIdeal @, or @ TO NCRightIdeal @, the method returns true if all generators of the ideal are homogeneous (not necessarily of the same degree). If x is an @ TO NCPolynomialRing @, the method returns true. If x is any other @ TO NCRing@, the method returns true if and only if the defining ideal of x is homogeneous. If x is an @ TO NCMatrix @, the method returns true if integer weights were assigned to the source and target of the associated map of free right modules such that the map is graded (degree 0). See @ TO assignDegrees @. Example A=QQ{x,y,z} w=x^3-y^2 isHomogeneous w setWeights(A, {2,3,1}) isHomogeneous w I = ncIdeal{w,x+z^2} isHomogeneous I Example B = threeDimSklyanin(QQ,{1,1,-1},{x,y,z}) M = ncMatrix {{x,y,z,0}, {-y*z-2*x^2,-y*x,z*x-x*z,x},{x*y-2*y*x,x*z,-x^2,y}, {-y^2-z*x,x^2,-x*y,z}} isHomogeneous M assignDegrees(M,{1,0,0,0},{2,2,2,1}) isHomogeneous M N = ncMatrix {gens B} isHomogeneous N SeeAlso (isHomogeneous, NCRingMap) setWeights assignDegrees /// doc /// Key assignDegrees (assignDegrees,NCMatrix) (assignDegrees,NCMatrix,List,List) Headline Weights entries of a matrix to make associated map of free modules graded Usage assignDegrees(M) or assignDegrees(M,targetDegs,sourceDegs) Inputs M : NCMatrix targetDegs : List a list of integer weights for the target basis vectors sourceDegs : List a list of integer weights for the source basis vectors Outputs : NCMatrix the same matrix M with source and target keys specified and isHomogeneous flag true Description Text A matrix M with homogeneous entries in an NCRing can determine a homomorphism of graded free modules if the entries satisfy certain consistency conditions. Finding a set of degrees for source and target basis vectors such that M determines a graded module map is an integer programming problem. This method does not solve the problem in general. Text With only one input, this method checks to see if the entries in each column all have the same homogeneous degree. If so, the method assigns source and target degrees in the natural way and the @ TO isHomogeneous @ flag is set for M. If not, all degrees are set to 0 and the flag is not set. This method is called any time a matrix is created. Text With three inputs, the user may specify the desired degree shifts on inputs and outputs such that the associated module map is graded. Example B = threeDimSklyanin(QQ,{1,1,-1},{x,y,z}) M = ncMatrix {{x,y,z,0}, {-y*z-2*x^2,-y*x,z*x-x*z,x},{x*y-2*y*x,x*z,-x^2,y}, {-y^2-z*x,x^2,-x*y,z}} isHomogeneous M assignDegrees(M,{1,0,0,0},{2,2,2,1}) isHomogeneous M N = ncMatrix {gens B} isHomogeneous N SeeAlso isHomogeneous rightKernelBergman /// doc /// Key rightKernelBergman rightKernelDegreeLimit (rightKernelBergman,NCMatrix) [rightKernelBergman,DegreeLimit] Headline Methods for computing kernels of matrices over noncommutative rings using Bergman Usage rightKernelBergman(M,DegreeLimit=>n) Inputs M : NCMatrix a homogeneous matrix interpreted as a map of free right modules DegreeLimit => ZZ the maximum degree in which to compute the kernel Outputs : NCMatrix the kernel of the matrix (considered as a right module map) to degree n Description Text Let M be a matrix with homogeneous entries in an NCRing. If the degrees of the entries of M satisfy certain consistency conditions, one can define a graded homomorphism of free right modules via left multiplication by M. If isHomogeneous(M) returns true, these conditions have been verified for M and M is a valid input for rightKernelBergman. Otherwise, an error is returned stating that M is not homogeneous. To set the isHomogeneous flag to true, use @ TO assignDegrees @. Text For valid inputs, this method computes the first n homogeneous components of the (right) kernel of the homomorphism determined by M. If n is not specified by the user, the default maximum degree is 10. The method returns a minimal set of generators for the kernel in these degrees. The results of this command are cached in the input matrix M in M.cache#rightKernel, and the maximum degree used in this computation is in M.cache#rightKernelDegreeLimit. Example B = threeDimSklyanin(QQ,{1,1,-1},{x,y,z}) A = ambient B g = -y^3-x*y*z+y*x*z+x^3 C = A/(ideal B + ncIdeal g) M3 = ncMatrix {{x,y,z,0}, {-y*z-2*x^2,-y*x,z*x-x*z,x},{x*y-2*y*x,x*z,-x^2,y}, {-y^2-z*x,x^2,-x*y,z}} assignDegrees(M3,{1,0,0,0},{2,2,2,1}) ker1M3 = rightKernelBergman(M3) M3*ker1M3 == 0 ker2M3 = rightKernelBergman(ker1M3) ker1M3*ker2M3 == 0 ker3M3 = rightKernelBergman(ker2M3) ker2M3*ker3M3 == 0 SeeAlso isHomogeneous assignDegrees rightKernel /// doc /// Key isLeftRegular (isLeftRegular,NCRingElement,ZZ) isRightRegular (isRightRegular,NCRingElement,ZZ) Headline Determines if a given (homogeneous) element is regular in a given degree Usage isLeftRegular(x,n) or isRightRegular(x,n) Inputs x : NCRingElement n : ZZ the degree in which regularity is checked. Outputs : Boolean Description Text Given an element x in an NCRing, isLeftRegular returns true if a*x=0 implies a=0 for all a in the specified homogeneous degree n. Likewise isRightRegular returns true if x*a=0 implies a=0 for all elements a of degree n. The method calls @ TO leftMultiplicationMap @ or @ TO rightMultiplicationMap @ as appropriate and checks the kernel in the specified degree. Example B = threeDimSklyanin(QQ,{1,1,-1},{x,y,z}) g = -y^3-x*y*z+y*x*z+x^3 isLeftRegular(g,6) C = QQ{x,y} D = C/ncIdeal{x^2+x*y,y^2} isLeftRegular(x,1) isRightRegular(x,1) SeeAlso leftMultiplicationMap rightMultiplicationMap /// doc /// Key isCentral (isCentral,NCRingElement) (isCentral,NCRingElement,NCGroebnerBasis) Headline Determines if an element is central Usage isCentral x or isCentral(x,ncgb) Inputs x : NCRingElement ncgb : NCGroebnerBasis a Groebner basis for the NCRing to which x belongs. Outputs : Boolean Description Text This method checks to see if a given NCRing element is central. Example B = threeDimSklyanin(QQ,{1,1,-1},{x,y,z}) g = -y^3-x*y*z+y*x*z+x^3 h = x^2 + y^2 + z^2 isCentral h isCentral g SeeAlso centralElements /// doc /// Key centralElements (centralElements, NCRing, ZZ) Headline Finds central elements in a given degree Usage centralElements(A,n) Inputs A : NCRing n : ZZ the homogeneous degree in which to compute central elements Outputs : NCMatrix Description Text If the given NCRing has central elements of the specified degree, this method returns a basis for the space of central elements in that degree. Example B = threeDimSklyanin(QQ,{1,1,-1},{x,y,z}) centralElements(B,2) centralElements(B,3) /// doc /// Key normalElements (normalElements, NCQuotientRing, ZZ, Symbol, Symbol) Headline Finds normal elements Usage normalElements(A,n,x,y) Inputs A : NCQuotientRing n : ZZ x : Symbol y : Symbol Outputs : List Description Text Let b_1,...,b_n be a monomial basis for an NCRing A in degree d. We assume A is generated by elements a_1,...,a_k of degree 1. A homogeneous element r in A is normal if a_i*r is in the span of the r*a_j for all i. Text Using the input symbols x and y, we define the "normal variety" to be the set of common solutions to the equations x_j*a_i*b_j = y_j1*b_j*a_1+...+y_jk*b_j*a_k for all i and j. Saturating the ideal at each x_i we extract polynomial equations the x_i must satisfy for the element x_1*b_1+...+x_n*b_n to be normal in A. Text Before computing the normal variety, this method checks for normal monomials in degree n. These are returned first to reduce the complexity of the problem. Then the method computes the variety and returns its components. The equations the method returns are given in terms of the indexed variable x. The indices are basis monomials in degree n. Text The following example is a 3-dimensional Sklyanin algebra. Example B = threeDimSklyanin(QQ,{1,1,-1},{x,y,z}) basis(2,B) normalElements(B,2,r,s) Text The normal elements in degree 2 are x^2, y^2 and z^2. The basis calculation shows x^2 and y^2 are normal forms in B. The normalElements method first checks all basis monomials using @ TO isNormal @. In this case it finds x^2 and y^2 are normal and returns this information. However, z^2 is not a normal form expression. The normal form of z^2 is x*y+y*x. In the second phase of the calculation, the method returns generators of the ideal describing the normal elements (excluding the normal monomials). We see the coefficients of basis monomials y*z and x*z must be 0 and the coefficients of x*y and y*x must be equal. The last equation identifies z^2 = x*y+y*x as a normal element of degree 2. Example normalElements(B,3,t,u) g = -y^3-x*y*z+y*x*z+x^3 isCentral g Text In degree 3, there are no normal monomials. The function returns several equations which determine the only normal element of degree 3 (up to scaling) is the central element g. /// doc /// Key (normalElements, NCRingMap, ZZ) Headline Finds elements normalized by a ring map Usage normalElements(f,n) Inputs f : NCRingMap n : ZZ a homogeneous degree in which to search for normal elements Outputs : List Description Text A normal element x in an NCRing R determines an automorphism f of R by a*x=x*f(a). Conversely, given a ring endomorphism, we may ask if any x satisfy the above equation for all a. Text Given an NCRingMap f and a degree n, this method returns solutions to the equations a*x=x*f(a) for all generators a of R. Example B = skewPolynomialRing(QQ,(-1)_QQ,{x,y,z,w}) sigma = ncMap(B,B,{y,z,w,x}) C = oreExtension(B,sigma,a) sigmaC = ncMap(C,C,{y,z,w,x,a}) normalElements(sigmaC,1) normalElements(sigmaC,2) normalElements(sigmaC @@ sigmaC,2) /// doc /// Key (isNormal, NCRingElement) Headline Determines if a given NCRingElement is normal Usage isNormal x Inputs x : NCRingElement Outputs : Boolean Description Text Given an element x in an NCRing R, this method returns true if Rx=xR. Example A = QQ{a,b,c} I = ncIdeal {a*b+b*a,a*c+c*a,b*c+c*b} B = A/I sigma = ncMap(B,B,{b,c,a}) isWellDefined sigma C = oreExtension(B,sigma,w) isCentral w isNormal w SeeAlso isCentral normalElements /// doc /// Key normalAutomorphism (normalAutomorphism,NCRingElement) Headline Computes the automorphism determined by a normal homogeneous element Usage normalAutomorphism x Inputs x : NCRingElement a homogeneous normal element Outputs : NCRingMap Description Text Let x be a homogeneous element in an NCRing R. If x is normal then x determines a graded ring automorphism f of R by x*a = f(x)*a. This method returns this automorphism as an NCRingMap. Example A = QQ{a,b,c} I = ncIdeal {a*b+b*a,a*c+c*a,b*c+c*b} B = A/I sigma = ncMap(B,B,{b,c,a}) isWellDefined sigma C = oreExtension(B,sigma,w) isNormal w^2 phi = normalAutomorphism w^2 matrix phi (matrix sigma @@ sigma) SeeAlso normalElements /// doc /// Key leftMultiplicationMap (leftMultiplicationMap,NCRingElement,ZZ) (leftMultiplicationMap,NCRingElement,ZZ,ZZ) (leftMultiplicationMap,NCRingElement,List,List) rightMultiplicationMap (rightMultiplicationMap,NCRingElement,ZZ) (rightMultiplicationMap,NCRingElement,ZZ,ZZ) (rightMultiplicationMap,NCRingElement,List,List) Headline Computes a matrix for left or right multiplication by a homogeneous element Usage leftMultiplicationMap(r,n) or leftMultiplicationMap(r,n,m) or leftMultiplicationMap(r,fromBasis,toBasis) Inputs r : NCRingElement n : ZZ the homogeneous degree for the source of the map m : ZZ the homogeneous degree for the target of the map fromBasis : List a list of monomials of the same homogeneous degree toBasis : List a list of monomials of homogeneous degree deg(r) larger than the degree of the toBasis Outputs : Matrix Description Text These methods return a matrix over the coefficient ring of the NCRing to which r belongs. The matrix represents left or right multiplication by r. Most commonly, the user will enter the ring element (required to be homogeneous) and a degree n. The result is the matrix of the map A_n -> A_n+d where d is the degree of r. The matrix is computed relative to the monomial basis obtain using @ TO (basis, ZZ, NCRing) @. Alternatively, the user can enter sets of independent monomials to serve as a basis for the domain and co-domain of the maps. The method left or right multiplies r by the fromBasis and converts to coordinates via @ TO sparseCoeffs @ and the toBasis. Example B = threeDimSklyanin(QQ,{1,1,-1},{x,y,z}) leftMultiplicationMap(x,2) kernel oo isRightRegular(x,2) Text If the element is not regular, you can use these methods to compute the annihilators in particular degrees. Example C = QQ{x,y} D = C/ncIdeal{x^2+x*y,y^2} isRightRegular(x,1) leftMultiplicationMap(x,1) M=matrix gens kernel oo basis(1,D)*M SeeAlso sparseCoeffs /// doc /// Key rightKernel (rightKernel,NCMatrix,ZZ) [rightKernel,NumberOfBins] [rightKernel,Verbosity] Headline Method for computing kernels of matrices over noncommutative rings in a given degree without using Bergman Usage rightKernel(M,n) Inputs M : NCMatrix n : ZZ the degree in which to compute the kernel NumberOfBins => ZZ an integer dividing the number of rows of M Verbosity => ZZ Outputs : NCMatrix Description Text The method @ TO rightKernelBergman @ is a very effective tool for computing kernels of homogeneous matrices with entries in rings over QQ or ZZ/p. This method provides an alternative that can be used for NCMatrices over any ground ring. The method is also useful when one knows additional homological information - for example if the cokernel of M has a linear free resolution. Text Given an NCMatrix M and an integer n, this method returns a basis for the kernel of the matrix (viewed as a linear map of free right modules) in homogeneous degree n. The method successively computes annihilators of columns of M and intersects them. For large matrices or large values of n, it may save memory to break the calculation into smaller pieces. Use the option NumberOfBins to reduce the memory (but increase the time) the program uses. Set Verbosity to 1 to see progress updates. Text To avoid accidental calls to Bergman for normal form calculations, set the MAXSIZE environment variable fairly high, say 1000. Example B = threeDimSklyanin(QQ,{1,1,-1},{x,y,z}) sigma = ncMap(B,B,{y,z,x}) C = oreExtension(B,sigma,w) D = (ambient C)/(ideal C + ncIdeal{promote(w^2,ambient C)}) Text This algebra is an Ore extension of a 3-dimensional Sklyanin algebra, factored by the normal regular element w^2. This algebra is Koszul, hence it has a linear free resolution. The rightKernel method is significantly faster than rightKernelBergman in this case. Also note the two methods return different generating sets for the kernel. Example M1 = ncMatrix {{x,y,z,w}} M2 = rightKernel(M1,1) M3 = rightKernel(M2,1) rightKernelBergman(M2) M4 = rightKernel(M3,1) rightKernelBergman(M3) SeeAlso rightKernelBergman /// doc /// Key quadraticClosure (quadraticClosure,NCIdeal) (quadraticClosure,NCQuotientRing) Headline Creates the subideal generated by quadratic elements of a given ideal Usage quadraticClosure I Inputs I : NCIdeal Outputs : NCIdeal the quadratic closure of I Description Text The quadratic closure of an NCIdeal in an NCPolynomialRing is the NCIdeal generated by the elements of degree at most 2. Commonly used with Link to homogDual in the case where the ideal generators are homogeneous of degree greater than 1. If the input is an NCQuotientRing, the method is applied to the defining ideal of the quotient ring and the corresponding quotient ring is returned. At the moment, quotients of quotients is not implemented, and the ambient ring of the input NCQuotientRing is assumed to be an NCPolynomialRing. This method is commonly used in conjunction with @ TO homogDual @. Example A = QQ{x,y,z} I = ncIdeal{x*z-z*x, y*z, x*y^2-y^2*x, x^3*y-y*x^3} J = quadraticClosure I SeeAlso homogDual /// doc /// Key homogDual (homogDual,Ring) (homogDual,NCIdeal) (homogDual,NCQuotientRing) Headline Computes the dual of a pure homogeneous ideal Usage homogDual I Inputs I : NCIdeal or an @ TO NCQuotientRing @ or a @ TO Ring @. Outputs : NCIdeal or an @ TO NCQuotientRing @ Description Text The homogeneous dual of a pure ideal I in an NCPolynomialRing A is generated by the orthogonal complement to the generators of I under the natural pairing on the generating subspace of A and its linear dual. Though technically the dual ideal belongs to the tensor algebra on the dual space of generators, this method returns the dual ideal in the same NCPolynomialRing. If the input is an NCQuotient ring, the method is applied to the defining ideal of the quotient and the corresponding quotient ring is returned. Commonly used in conjunction with @ TO quadraticClosure @. Example A = QQ{x,y,z} I = ncIdeal{x*z-z*x, y*z, x*y^2-y^2*x, x^3*y-y*x^3} J = quadraticClosure I J' = homogDual J SeeAlso quadraticClosure /// doc /// Key coordinates (coordinates, NCRingElement) (coordinates, List) [coordinates,Basis] Headline Computes coordinates relative to a given basis Usage coordinates L Inputs L : NCRingElement or a @ TO List @ of NCRingElements Basis => List a list of homogeneous elements to use as a basis for computing coordinate vectors Outputs : Matrix Description Text Generally, linear algebra in graded rings is performed using the monomial basis obtained from a Groebner basis calculation. In some cases, it is desirable to work relative to a different basis. This method calls @ TO sparseCoeffs @ to compute the coordinate vector(s) of a ring element (or a list of ring elements) relative to a user-specified basis. If no basis is specified, the method simple calls @ TO sparseCoeffs @ with no options. Example R = QQ[w]/ideal(w^2+w+1) A = skewPolynomialRing(R,promote(-1,R),{x,y,z}) Text One motivating example comes from invariant theory. In this example, we take a skew polynomial ring in three variables and act by the cyclic subgroup of graded automorphisms of A generated by permuting the variables. A basis for the fixed ring is given by "orbit sums" of basis monomials. Here we work in homogeneous degree 3. Example g = ncMap(A,A,{y,z,x}) gList = {g, g^2, g^3} a = sum apply(3,i-> (gList#i)(x^3)) b = sum apply(3,i-> (gList#i)(x^2*y)) c = sum apply(3,i-> (gList#i)(x*y^2)) d = sum apply(3,i-> (gList#i)(x*y*z)) Text It is clear that these are linearly independent. Next, we take a homogeneous polynomial of degree 3, make it invariant, and compute its coordinate vector. Example p = w^2*z^2*y+x^2*z+(1-w)*y^3 g(p)==p p' = sum apply(3,i-> (gList#i)(p)) g(p')==p' coordinates(p',Basis=>{a,b,c,d}) SeeAlso sparseCoeffs /// doc /// Key sparseCoeffs (sparseCoeffs,List) (sparseCoeffs,NCRingElement) [sparseCoeffs,Monomials] Headline Converts ring elements into vectors over the coefficient ring Usage sparseCoeffs L Inputs L : NCRingElement or a @ TO List @ of NCRingElements Monomials => List a list of monomials to use as a basis for computing coordinate vectors Outputs : Matrix Description Text This method converts a list of ring elements to coordinate vectors - returned as a matrix - relative to a list of monomilas. If the user does not supply a monomial list, the list is taken to be the monomials occuring in the elements of the list (with repetition). Example A=QQ{a, b, c, d, e, f, g, h} F = a^2+b^2+c^2+d^2+e^2+f^2+g^2+h^2; sparseCoeffs(F) bas = flatten entries basis(2,A); #bas sparseCoeffs(F,Monomials=>bas) sparseCoeffs(toList (10:F),Monomials=>bas) /// doc /// Key NCRingMap Headline Type of a map to or from a noncommutative ring. Description Text As in the commutative case, a map F:R->S where R or S is an NCRing is specified by giving the images in S of the variables of R. The target map is given first. Text Common ways to make (and use) an NCRingMap include Code UL {TO (ncMap,Ring,NCRing,List), TO (ncMap,NCRing,Ring,List), TO (ncMap,NCRing,NCRing,List), TO (normalElements, NCRingMap, ZZ), TO (oreExtension,NCRing,NCRingMap,NCRingMap,NCRingElement), TO (oreExtension,NCRing,NCRingMap,NCRingMap,Symbol), TO (oreExtension,NCRing,NCRingMap,NCRingElement), TO (oreExtension,NCRing,NCRingMap,Symbol), TO (oreIdeal,NCRing,NCRingMap,NCRingMap,NCRingElement), TO (oreIdeal,NCRing,NCRingMap,NCRingMap,Symbol), TO (oreIdeal,NCRing,NCRingMap,NCRingElement), TO (oreIdeal,NCRing,NCRingMap,Symbol) } Text Common ways to get information about NCRingMaps Code UL {TO (source,NCRingMap), TO (target,NCRingMap), TO (matrix,NCRingMap), TO (isWellDefined,NCRingMap), TO (isHomogeneous,NCRingMap), TO (symbol _, NCRingMap, ZZ)} Text Common operations involving NCRingMaps Code UL {TO (ambient,NCRingMap), TO (symbol /,List,NCRingMap), TO (symbol SPACE, NCRingMap, NCRingElement), TO (symbol SPACE, NCRingMap, RingElement), TO (symbol SPACE, NCRingMap, NCMatrix), } Example A = skewPolynomialRing(QQ,(-1)_QQ,{w,x,y,z}) B = QQ{a,b,c} f = ncMap(B,A,{a^3,b^2,a+b,a-b}) target f source f matrix f Text Note that NCRingMaps need not be well-defined or homogeneous. Apply a function to an element or a matrix using the usual function notation. NCRingMaps are linear and multiplicative by definition. Example f(w*x+2*y) isWellDefined f isHomogeneous f Text The user has the option to define an NCRingMap to be a derivation. Of course, such a map must have the same source and target. Example g = ncMap(B,B,{a*b,b^2,c*a*c},Derivation=>true) g(a*b)==g(a)*b+a*g(b) g(promote(1,B)) g(c*a+2*b) /// doc /// Key ncMap (ncMap,NCRing,NCRing,List) (ncMap,Ring,NCRing,List) (ncMap,NCRing,Ring,List) [ncMap,Derivation] Headline Make a map to or from an NCRing Usage f = ncMap(B,A,m) Inputs A : NCRing or a @ TO Ring @ B : NCRing or a @ TO Ring @ m : List the images of the generators of A. Derivation => Boolean Outputs f : NCRingMap Description Text NCRingMaps are linear and multiplicative by definition, but need not be well-defined or homogeneous. The user has the option to define an NCRingMap to be a derivation. Such a map must have the same source and target. Example A = skewPolynomialRing(QQ,(-1)_QQ,{w,x,y,z}) B = QQ{a,b,c} f = ncMap(B,A,{a^3,b^2,a+b,a-b}) f(w*x+2*y) g = ncMap(B,B,{a*b,b^2,c*a*c},Derivation=>true) g(a*b)==g(a)*b+a*g(b) g(promote(1,B)) g(c*a+2*b) SeeAlso NCRingMap /// doc /// Key (ambient, NCRingMap) Headline Extends an NCRingMap to the ambient ring of the source. Usage g = ambient f Inputs f : NCRingMap Outputs g : NCRingMap Description Text If f:R->S is a ring map and R=A/I is a quotient ring, this method returns the NCRingMap g:A->S obtained by composing f with the natural map. This method is called by @ TO (isWellDefined, NCRingMap) @ and can be used to determine what ideal to mod out of the target so the map becomes well-defined. Example A = skewPolynomialRing(QQ,(-1)_QQ,{w,x,y,z}) B = QQ{w,x,y,z}/ncIdeal{w*x+x*w,w*y+y*w,x*y+y*x} f = ncMap(B,A,gens B) isWellDefined f g = ambient f (gens ideal A)/g /// doc /// Key (isHomogeneous, NCRingMap) Headline Determines if an NCRingMap preserves the natural grading Usage isHomogeneous f Inputs f : NCRingMap Outputs : Boolean Description Text This method returns true if the map f is degree 0; that is, if the generators of the source of f are mapped to elements of the same degree in the target. Example A = skewPolynomialRing(QQ,(-1)_QQ,{w,x,y,z}) B = QQ{w,x,y,z}/ncIdeal{w*x+x*w,w*y+y*w,x*y+y*x} f = ncMap(B,A,gens B) isHomogeneous f C = QQ{a,b,c} g = ncMap(C,A,{a^3,b^2,a+b,a-b}) isHomogeneous g setWeights(A,{3,2,1,1}) isHomogeneous g SeeAlso (isHomogeneous, NCIdeal) /// doc /// Key (isWellDefined, NCRingMap) Headline Determines if an NCRingMap is well-defined. Usage isWellDefined f Inputs f : NCRingMap Outputs : Boolean Description Text Returns true if the given NCRingMap evaluates as 0 on the defining relations of the source. Example A = skewPolynomialRing(QQ,(-1)_QQ,{w,x,y,z}) B = QQ{w,x,y,z}/ncIdeal{w*x+x*w,w*y+y*w,x*y+y*x} f = ncMap(B,A,gens B) isWellDefined f C = QQ{a,b,c} g = ncMap(C,A,{a^3,b^2,a+b,a-b}) isWellDefined g /// doc /// Key (symbol /, List, NCRingMap) Headline Applies an NCRingMap to each element of a list Usage L/f Inputs L : List f : NCRingMap Outputs : List Description Text This operation is the same thing as apply(L,x->f(x)). Note that the operation is left associative. Example A = QQ{x,y} f = ncMap(A,A,{x^2,y^2}) g = ncMap(A,A,{x+y,y}) gens A/f/g gens A/g/f /// doc /// Key (matrix, NCRingMap) Headline An NCMatrix associated to an NCRingMap. Usage matrix f Inputs f : NCRingMap Outputs : NCMatrix Description Text This function returns a matrix whose entries are the images of the source generators in the target ring of f. The type of matrix depends on the type of the target ring. Example A = skewPolynomialRing(QQ,(-1)_QQ,{w,x,y,z}) B = QQ[a,b,c,SkewCommutative=>true] f = ncMap(B,A,{a^3,b^2,a+b,a-b}) matrix f g = ncMap(A,A,{x,y,z,w}) matrix g /// doc /// Key (symbol @@, NCRingMap, NCRingMap) Headline Compose two NCRingMaps Usage f @@ g Inputs f : NCRingMap g : NCRingMap Outputs : NCRingMap Description Example A = QQ{x,y} f = ncMap(A,A,{x^2,y^2}) g = ncMap(A,A,{x+y,y}) gens A/f @@ g gens A/g @@ f /// doc /// Key (symbol SPACE, NCRingMap, NCRingElement) (symbol SPACE, NCRingMap, RingElement) (symbol SPACE, NCRingMap, NCMatrix) Headline Apply an NCRingMap to an element or matrix Usage f x Inputs f : NCRingMap x : NCRingElement or a @ TO RingElement @ or an @ TO NCMatrix @ Outputs : NCRingElement Description Example A = skewPolynomialRing(QQ,(-1)_QQ,{w,x,y,z}) B = QQ{a,b,c} f = ncMap(B,A,{a^3,b^2,a+b,a-b}) f(w*x+2*y) f basis(2,A) /// doc /// Key (symbol _, NCRingMap, ZZ) Headline Matrix of one homogeneous component of an NCRingMap Usage f_n Inputs f : NCRingMap n : ZZ Outputs : Matrix Description Text This method returns the homogeneous degree n component of the ring map f. The output is the matrix (over the coefficient ring of the target) of the component map relative to the monomial bases for the source and target. Example A = skewPolynomialRing(QQ,(-1)_QQ,{w,x,y,z}) setWeights(A,{1,1,2,2}) f = ncMap(A,A,{x,w,z,y}) basis(1,A) f_1 basis(2,A) f_2 /// doc /// Key (source, NCRingMap) Headline Source of a map Description Text Gives the source of an @ TO NCRingMap @. SeeAlso (target,NCRingMap) /// doc /// Key (target, NCRingMap) Headline Target of a map Description Text Gives the target of an @ TO NCRingMap @. SeeAlso (source,NCRingMap) /// doc /// Key oreExtension (oreExtension,NCRing,NCRingMap,NCRingMap,NCRingElement) (oreExtension,NCRing,NCRingMap,NCRingMap,Symbol) (oreExtension,NCRing,NCRingMap,NCRingElement) (oreExtension,NCRing,NCRingMap,Symbol) Headline Creates an Ore extension of a noncommutative ring Usage oreExtension(A,sigma,delta,x) or oreExtension(A,sigma,x) Inputs A : NCRing sigma : NCRingMap delta : NCRingMap x : NCRingElement or a @ TO Symbol @ Outputs : NCQuotientRing Description Text This method calls @ TO oreIdeal @ and returns the associated Ore extension as an NCQuotientRing. Example B = skewPolynomialRing(QQ,(-1)_QQ,{x,y,z,w}) sigma = ncMap(B,B,{y,z,w,x}) C = oreExtension(B,sigma,a) SeeAlso oreIdeal /// doc /// Key oreIdeal (oreIdeal,NCRing,NCRingMap,NCRingMap,NCRingElement) (oreIdeal,NCRing,NCRingMap,NCRingMap,Symbol) (oreIdeal,NCRing,NCRingMap,NCRingElement) (oreIdeal,NCRing,NCRingMap,Symbol) Headline Creates the defining ideal of an Ore extension of a noncommutative ring Usage oreIdeal(A,sigma,delta,x) or oreIdeal(A,sigma,x) Inputs A : NCRing sigma : NCRingMap delta : NCRingMap x : NCRingElement or a @ TO Symbol @ Outputs : NCIdeal Description Text Given a ring A, an Ore extension of A by x is the quotient of the free extension A by the relations x*a - sigma(a)*x-delta(a) where sigma is an automorphism of A and delta is a sigma-derivation. This method returns the defining ideal (in the appropriate tensor algebra) of an Ore extension of A by x. The current version assumes the sigma-derivation delta is 0. Example B = skewPolynomialRing(QQ,(-1)_QQ,{x,y,z,w}) sigma = ncMap(B,B,{y,z,w,x}) C = oreIdeal(B,sigma,a) SeeAlso oreExtension /// doc /// Key endomorphismRing (endomorphismRing,Module,Symbol) endomorphismRingGens Headline Methods for creating endomorphism rings of modules over a commutative ring Usage E = endomorphismRing(M,X) Inputs M : Module X : Symbol the base name for the indexed variables serving as generators for the output ring Outputs E : NCQuotientRing Description Text This method computes a presentation for the endomorphism ring of a module over a commutative ring R. The presentation is given as a quotient of an NCPolynomialRing with coefficients in R generated by indexed variables. The second argument specifies the symbol to use for the indexed variables. The presentation this method returns is unlikely to be minimal. Simplifications to the presentation may be made with Link to minimizeRelations. Example Q = QQ[a,b,c] R = Q/ideal{a*b-c^2} kRes = res(coker vars R, LengthLimit=>7) M = coker kRes.dd_5 B = endomorphismRing(M,X) gensI = gens ideal B gensIMin = minimizeRelations(gensI) Text The endomorphisms are cached in the endomorphism ring and can be accessed via the key endomorphismRingGens. We verify that X_3 is redundant: Example maps = B.cache.endomorphismRingGens maps_3 == maps_0*maps_2 /// doc /// Key minimizeRelations (minimizeRelations,List) [minimizeRelations,Verbosity] Headline Minimizes a list of NCRingElements Usage mgens = minimizeRelations(gens) Inputs gens : List Outputs mgens : List Description Text Given a list of NCRingElements, this method produces a generating set for the NCIdeal generated by the list which (possibly) uses fewer generators and/or fewer NCRing generators. Commonly used with Link to endomorphismRing. Example Q = QQ[a,b,c,d] R = Q/ideal{a*b+c*d} kRes = res(coker vars R, LengthLimit=>7) M = coker kRes.dd_5 B = endomorphismRing(M,Y) gensI = gens ideal B gensIMin = minimizeRelations(gensI) /// doc /// Key skewPolynomialRing (skewPolynomialRing,Ring,Matrix,List) Headline Defines a skew polynomial ring via a skewing matrix Usage B = skewPolynomialRing(R,M,L) Inputs R : Ring M : Matrix L : List Outputs B : NCRing Description Text This method constructs a skew polynomial ring with coefficients in the ring R and generators from the list L. A valid input matrix is a square matrix over R with at least #L rows such that M_{ij} = M_{ji}^{(-1)} and M_{ii}=1. The relations of the resulting ring have the form g_i*g_j - M_{ij}*g_j*g_i. If R is a Bergman coefficient ring, an NCGroebnerBasis is computed for B. Example R = QQ[q]/ideal{q^4+q^3+q^2+q+1} M = matrix{{1,q,q},{q^4,1,1},{q^4,1,1}} B = skewPolynomialRing(R,M,{x,y,z}) x*y == q^4*y*x N = matrix{{1,1,1,1},{1,1,1,1},{1,1,1,1},{1,1,1,1}} C = skewPolynomialRing(QQ,promote(N,QQ), {a,b,c,d}) isCommutative C isCommutative B Bop = oppositeRing B y*x == q^4*x*y SeeAlso oppositeRing /// doc /// Key (skewPolynomialRing,Ring,RingElement,List) (skewPolynomialRing,Ring,QQ,List) (skewPolynomialRing,Ring,ZZ,List) Headline Defines a skew polynomial ring via a scaling factor Usage skewPolynomialRing(R,f,L) Inputs R : Ring f : RingElement or an integer or a rational number L : List Outputs : NCRing Description Text This method constructs a skew polynomial ring with coefficient ring R and generators elements of L. The relations all have the form a*b - f*b*a where a and b are in L. If R is a Bergman coefficient ring, an NCGroebnerBasis is computed for B. Example R = QQ[q]/ideal{q^4+q^3+q^2+q+1} A = skewPolynomialRing(R,promote(2,R),{x,y,z,w}) x*y == 2*y*x B = skewPolynomialRing(R,q,{x,y,z,w}) x*y == q*y*x Bop = oppositeRing B y*x == q*x*y C = skewPolynomialRing(QQ,2_QQ, {x,y,z,w}) x*y == 2*y*x D = skewPolynomialRing(QQ,1_QQ, {x,y,z,w}) isCommutative C isCommutative D Cop = oppositeRing C y*x == 2*x*y SeeAlso oppositeRing skewPolynomialRing /// doc /// Key threeDimSklyanin (threeDimSklyanin,Ring,List) (threeDimSklyanin,Ring,List,List) Headline Defines a three-dimensional Sklyanin with given parameters Usage threeDimSklyanin(R,params,varList) Inputs R : Ring params : List varList : List DegreeLimit => ZZ Outputs : NCRing Description Text This method constructs a three dimensional Sklyanin algebra with parameters from the params list, and variables from varList (see @ HREF{"http:////arxiv.org//abs//1107.2953","here"} @). If either list is not length three, then an error is thrown. The generic such algebra does not have a finite Groebner basis, so the optional parameter DegreeLimit has been defaulted to 5. If only one list is provided, it is used for the variable names, and a random choice for each parameter is chosen. The following example is a PI algebra, and has a finite Groebner basis. Example B = threeDimSklyanin(QQ,{1,1,-1},{x,y,z}) ncGroebnerBasis ideal B Text This is not generically true, however: Example C = threeDimSklyanin(QQ,{a,b,c}) ncGroebnerBasis ideal C Text In all cases, there is a degree three central regular element (a formula for which is given in the paper referenced above). Example centralElements(B,3) centralElements(C,3) Text These algebras also all AS-regular and as such have the same Hilbert series as a commutative polynomial algebra in three variables, as we can see here: Example hilbertBergman B hilbertBergman(C,DegreeLimit=>5) /// doc /// Key fourDimSklyanin (fourDimSklyanin,Ring,List) (fourDimSklyanin,Ring,List,List) Headline Defines a four-dimensional Sklyanin with given parameters Usage fourDimSklyanin(R,params,varList) Inputs R : Ring params : List varList : List DegreeLimit => ZZ Outputs : NCRing Description Text This method constructs a three dimensional Sklyanin algebra with parameters from the params list, and variables from varList (see @ HREF{"https://www.math.washington.edu/~smith/Research/Skly-survey.pdf","here"} @). If either list is not the appropriate length, then an error is thrown. The generic such algebra has a fairly complicated Groebner basis, so the optional parameter DegreeLimit has been defaulted to 5. If only one list is provided, it is used for the variable names, and a random choice for each parameter is chosen. In order to not get a degenerate example, one should ensure that the parameters provided satisfy \alpha + \beta + \gamma + \alpha\beta\gamma = 0. This method does not check this condition, since the degenerate examples are of interest as well. If no parameters are provided, however a generic choice of \alpha,\beta and \gamma satisfying the equation above are selected. Example C = fourDimSklyanin(QQ,{a,b,c,d}) ncGroebnerBasis ideal C Text In all nondegenerate cases, there is are two central elements of degree two which form a regular sequence on the four dimensional Sklyanin (this was proven by Paul Smith and Toby Stafford in a paper in Compositio. Example centralElements(C,2) Text These algebras also all AS-regular and as such have the same Hilbert series as a commutative polynomial algebra in four variables, as we can see here: Example hilbertBergman(C, DegreeLimit => 6) /// doc /// Key toM2Ring (toM2Ring,NCRing) [toM2Ring,SkewCommutative] Headline Compute the abelianization of an NCRing and returns a Ring. Usage S = toM2Ring R Inputs R : NCRing SkewCommutative => Boolean Outputs S : Ring Description Text This method takes an NCRing and returns the quotient of a commutative polynomial ring (or an exterior algebra, if SkewCommutative=>true) on the same generators by the defining relations of the input ring. Example A = skewPolynomialRing(QQ,(-1)_QQ,{w,x,y,z}) x*y-y*x w^2 B = toM2Ring(A) x*y-y*x w^2 C = toM2Ring(A,SkewCommutative=>true) x*y-y*x w^2 SeeAlso toNCRing /// doc /// Key toNCRing (toNCRing,Ring) Headline Converts a Ring to an NCRing Usage S = toNCRing R Inputs R : Ring Outputs S : NCRing Description Text This function converts commutative rings and quotients of exterior algebras created by Macaulay2 to the type of an NCRing. An error is returned if the input ring has some commutative and some skew-commutative generators. Example R = QQ[a,b,c,d] I = ideal(a*d-b*c) S = R/I S' = toNCRing(S) ideal S' SeeAlso toM2Ring /// doc /// Key oppositeRing (oppositeRing,NCRing) Headline Creates the opposite ring of a noncommutative ring Usage Aop = oppositeRing A Inputs A : NCRing Outputs Aop : NCRing Description Text Given an NCRing A, this creates an NCRing whose defining NCIdeal is generated by the "opposites" - elements whose noncommutative monomial terms have been reversed - of the generators of the defining NCIdeal of A. If the coefficient ring of A is a Bergman ring, an NCGroebnerBasis is computed for Aop. Example R = QQ[q]/ideal{q^4+q^3+q^2+q+1} A = skewPolynomialRing(R,q,{x,y,z,w}) x*y == q*y*x Aop = oppositeRing A y*x == q*x*y SeeAlso skewPolynomialRing /// doc /// Key normalFormBergman (normalFormBergman,List,NCGroebnerBasis) (normalFormBergman,NCRingElement,NCGroebnerBasis) Headline Calls Bergman for a normal form calculation Usage nfList = normalFormBergman(L,Igb) Inputs L : NCRingElement or a @ TO List @ of NCRingElements Igb : NCGroebnerBasis Outputs nfList : List Description Text This method takes a list of NCRingElements and calls Bergman to reduce each element to normal form relative to the given NCGroebnerBasis for the NCIdeal defining the NCRing to which the list elements belong. Example A = QQ{x,y,z} f = y*z + z*y - x^2 g = x*z + z*x - y^2 h = z^2 - x*y - y*x I = ncIdeal {f,g,h} Igb = ncGroebnerBasis I normalFormBergman(z^17,Igb) /// {* doc /// Key isReduced Headline Determines if a given element is in normal form with respect to a Groebner basis Usage b = w.isReduced Inputs w : NCRingElement Outputs b : Boolean Description Text This flag is set ot true if a given element of an NCRing (considered as an element of an appropriate NCPolynomialRing) is in normal form relative to a Groebner basis. Example A = QQ{x,y} I = ncIdeal{y^2-x^2} Igb = ncGroebnerBasis(I) w = y^3+x*y^2 w.isReduced w'=w % Igb w'.isReduced /// *} doc /// Key hilbertBergman (hilbertBergman, NCQuotientRing) [hilbertBergman,DegreeLimit] Headline Calls Bergman to compute the Hilbert series of an NCQuotientRing Usage hseries = hilbertBergman(A) Inputs A : NCQuotientRing DegreeLimit => ZZ Outputs hseries : RingElement Description Text This method calls the Bergman function ncpbhgroebner to compute the Hilbert series of an NCQuotientRing. The input ring must be a ring over QQ or ZZ/p. At this time, the output is correct only for NCRings with a standard grading - all generators have degree 1. The output is returned as a polynomial in ZZ[T]. Example B = threeDimSklyanin(QQ,{1,1,-1},{x,y,z}) hilbertBergman(B,DegreeLimit=>12) /// doc /// Key (hilbertSeries, NCRing) Headline Computes the Hilbert series of an NCRing Usage hseries = hilbertSeries(A) Inputs A : NCRing Order => ZZ Outputs hseries : RingElement Description Text This method computes the Hilbert series of a graded NCRing. If the ring is defined ober QQ or ZZ/p, and standard graded, it calls @ TO hilbertBergman @. Otherwise, if the ring is defined over a field (and potentially not standard graded), then a basis is computed and the generating function of the degrees of that basis is returned. The degree to which one computes the Hilbert series is controlled with the Order option. The output is returned as a polynomial in ZZ[T]. Example A = QQ{x,y,z} hilbertSeries(A,Order=>12) B = threeDimSklyanin(QQ,{1,1,-1},{x,y,z}) hilbertSeries(B,Order=>12) setWeights(B,{1,2,3}) hilbertSeries(B,Order=>12) /// doc /// Key "Basic operations on noncommutative algebras" Description Text The NCAlgebra package contains a number of methods for studying noncommutative rings - primarily graded rings. The following three extended examples highlight the capabilites of the package. For a detailed account of the Groebner basis calculations underlying nearly all of these methods, see @ TO "Using the Bergman interface" @. Text Our first example concerns a three-dimensional Sklyanin algebra. This example is a PI-ring. We define the ring as a quotient of the tensor algebra on three generators by the two-sided ideal generated by the three elements listed. Example A = QQ{x,y,z} Text Users familiar with Macaulay2 will recognize the notation for a ring of noncommutative polynomials is identical to that for local rings, see @ TO (symbol SPACE, Ring, List) @. Thus the previous line does not generate an error if you forget to load the NCAlgebra package. Example f = y*z + z*y - x^2 g = x*z + z*x - y^2 h = z^2 - x*y - y*x B = A/ncIdeal{f,g,h} Text It is known that this algebra has a unique (up to rescaling) central element of degree 3. We can verify this claim computationally using @ TO centralElements @ and check that the element is regular to a given degree. See @ TO isLeftRegular @. Example centralElements(B,3) j = y^3+x*y*z-y*x*z-x^3 isCentral j apply(5,i->isLeftRegular(j,i+1)) Text In fact, we can see that j is (up to scaling) the only normal element of degree 3. See the discussion above for interpreting the output of @ TO normalElements @. Example normalElements(B,3,n,o) basis(3,B) Text Recently, we studied noncommutative matrix factorizations over noncommutative hypersurfaces. Here is a simple example. The hypersurface is B/(j). However, iterated quotients are not yet implemented, so we define this ring as a quotient of the tensor algebra. Note the use of "promote" to ensure j is thought of as an element of the tensor algebra. Example use A I = B.ideal J = ncIdeal promote(j,A) B' = A/(I+J) Text As in the commutative case, any minimal free resolution of a finitely generated module over a noncommutative hypersurface is eventually given by a matrix factorization. We resolve the trivial module for B' by expressing it as the cokernel of a homogeneous matrix. Example k = ncMatrix {gens B'} M = rightKernelBergman rightKernelBergman k N = rightKernelBergman M Text As discussed in @ TO "Using the Bergman interface" @, the method @ TO rightKernelBergman @ only computes the kernel of a module map to a certain homogeneous degree. Applying a theorem of Cassidy and Shelton, we can be sure the matrices in any minimal graded free resolution of the trivial module of B' will have entries of homogeneous degree at most 3. Thus we conclude M is the third syzygy module and N is the fourth. If we lift these matrices we see that M and N are nearly a factorization of the central element j. Example BprimeToB = ncMap(B,B',gens B) liftM = BprimeToB M liftN = BprimeToB N liftM*liftN Text It appears that a change of basis will produce a matrix factorization. In general, Bergman returns a generating set for the kernel, but it need not have any nice properties. Here the NCAlgebra package can help by factoring a map. We would like M*M' = M'*M = j*I where I is the identity matrix. Example jId = promote(j,B)*(ncMatrix applyTable(entries id_(ZZ^4), i -> promote(i,B))) assignDegrees(jId,{2,2,2,3},{5,5,5,6}); Text The matrix jId is diagonal, and we have assigned degrees to make it compatible with M. Now we factor the lift of M through jId. Example M' = jId // liftM N Text We see that M' and N describe the same submodule and we check that the factorization worked: Example liftM*M' M'*liftM Text The user can create noncommutative rings in ways other than specifying a presentation. For our second example, consider a skew polynomial ring on four generators, where generators skew-commute (but are not nilpotent). See @ TO skewPolynomialRing @ for more details. Example C = skewPolynomialRing(QQ,(-1)_QQ,{x,y,z,w}) Text Let us briefly note that the user can also define a skew polynomial ring with coefficients in a commutative ring. Example R = QQ[q]/ideal{q^4+q^3+q^2+q+1} B = skewPolynomialRing(R,q,{x,y,z,w}) x*y == q*y*x Text Returning to the main example, we can define a graded Ore extension of C by specifying an automorphism. The function @ TO ncMap @ is used to define a ring map. Note that ring maps are linear and multiplicative by definition but are not assumed to be well-defined. Example use C sigma = ncMap(C,C,{y,z,w,x}) isWellDefined sigma Text We form the Ore extension of C by sigma. See @ TO oreExtension @. Example D = oreExtension(C,sigma,a) Text The new generator a is normal and regular in D. Regularity (on the left or right) can be checked one homogeneous degree at a time. See @ TO isLeftRegular @. Thus a determines a graded automorphism f:D->D via a*r=f(r)*a. Example isNormal a apply(5,i-> isLeftRegular(a,i+1)) sigmaD = normalAutomorphism a Text Given an automorphism, one can check to see which elements it normalizes in any given degree. Example normalElements(sigmaD,1) normalElements(sigmaD,2) Text One can check for the presence of normal elements more generally. In our example, since a is normal, a^2 will also be normal. It is the only normal monomial of degree 2. A complete description of the normal elements in a given degree is given by @ TO normalElements @. Example normalElements(D,2,P,Q) Text Each component of the "normal variety" is a set of polynomial equations which must be satisfied by the coefficients of the monomial basis for an element expressed in that basis to be normal. In this case, the basis of D in degree 2 is Example basis(2,D) Text The output of normalElements tells us that in order for a degree 2 element of D to be normal, it must be an expresison in powers of the generators. The coefficients of these powers must satisfy the six equations listed. Example isNormal (x^2+z^2-y^2-w^2) Text In Macaulay2, the user can define a polynomial ring to be commutative or skew-commutative (the exterior algebra). The user can convert these rings (and their quotients) to a type compatible with the NCAlgebra package using @ TO toNCRing @. Example E' = QQ[x,y,z,w,SkewCommutative=>true] E = toNCRing E' f = ncMap(E,C,gens E) f x^2 use C x^2 == 0 Text Conversely, the user can convert an NCRing to a (quotient of a) polynomial ring in the usual sense of Macaulay2 using @ TO toM2Ring @. This method works on any NCRing - the result is the abelianization or "exterior-ization" of the given ring. For example, if we abelianize the skew polynomial ring C, we get a ring in which only powers of the generators are nonzero. On the other hand, if we "exterior-ize" C, we get the exterior algebra. Example C' = toM2Ring C x*y x*x C'' = toM2Ring(C,SkewCommutative=>true) y*x y*y Text Finally, we can construct the opposite ring. The opposite ring of D will be the Ore extension by the inverse of sigma. See @ TO oppositeRing @. Example Dop = oppositeRing D a*x == w*a use D a*w == x*a Text Our last extended example illustrates how to obtain a presentation for the endomorphism ring of a module over a commutative ring. First we define a hypersurface ring and a high syzygy module. Example Q = QQ[a,b,c] R = Q/ideal{a*b-c^2} kRes = res(coker vars R, LengthLimit=>7); M = coker kRes.dd_5 Text The endomorphism ring is computed using @ TO endomorphismRing @. This method computes a presentation, but the presentation is typically not minimal. We see from the following calcuation that X_3 = X_0X_2. Example B = endomorphismRing(M,X); gensI = gens ideal B Text To eliminate redundant generators and relations, use @ TO minimizeRelations @. This method makes several passes through the presentation, and stops if no minimization occurs. Example gensIMin = minimizeRelations(gensI, Verbosity=>1) Text We see a substantial reduction in the number of relations and that X_1 and X_3 are redundant generators. The endomorphisms themselves are cached, and can be accessed via @ TO endomorphismRingGens @. As an example, we explicitly verify that X_3 is redundant. Example maps = B.cache.endomorphismRingGens maps#3 == maps#0*maps#2 /// doc /// Key "Using the Bergman interface" Description Text Bergman is a software package for computing Groebner bases for ideals in both commutative and noncommutative polynomial rings with coefficients in Q or Z/p. Bergman was created by J. Backelin (U. of Stockholm) and its capabilites were extended by V. Ufnarovski, S. Cojacaru, and A. Podoplelov. Text Though Bergman is limited in terms of the coefficients it can handle and the choice of orderings it offers, it is a very efficient (especially in terms of memory usage) open source program for computing noncommutative Groebner bases. (In the future we may add support for other Groebner basis software.) Rather than re-inventing this wheel, the NCAlgebra package makes extensive use of Bergman calls for noncommutative Groebner basis calculations. The following examples illustrate some common calculations which involve a call to Bergman. Our goal is to provide a more intuitive user experience with minimal compromises to efficiency. Text Typically, the user begins by defining a noncommutative polynomial ring. By default, the ring is graded with generators in degree 1. Other gradings can be defined, see @ TO setWeights @. Example A = QQ{x,y,z} Text Implicit in this definition is a choice of ordering for Groebner basis calculations: the ordering is degree-lexicographic with the generator symbols listed in order from smallest to largest. Ring elements are displayed with the high term listed first. Example p = y*z + z*y - x^2 Text One can try to compute Groebner bases for both homogeneous and inhomogeneous ideals. We cannot ensure Bergman computes any other than the homogeneous case correctly. We consider only homogeneous examples, the inhomogeneous case being similar. Example q = x*z + z*x - y^2 r = z^2 - x*y - y*x I = ncIdeal {p,q,r} Text NCAlgebra has three methods pertaining to noncommutative Groebner bases. One is @ TO twoSidedNCGroebnerBasisBergman @. This command runs Bergman to compute a noncommutative Groebner basis to a certain degree. The user will recall that unlike the commutative case, noncommutative Groebner bases need not be finite, and may grow rapidly. For unfamiliar examples, we recommend initially setting a relatively low degree threshhold (say, n=5). In our example, we know from experience the Groebner basis is finite so we do not specify a degree limit. Example Igb = twoSidedNCGroebnerBasisBergman I Text One an NCGroebner basis has been calculated, it is cached for later use. This option can be disabled. See @ TO twoSidedNCGroebnerBasisBergman @ for more on options. We note that twoSidedNCGroebnerBasisBergman is called automatically any time the user attempts to create an @ TO NCQuotientRing @. Text Another method related to Groebner bases is @ TO ncGroebnerBasis @. This method creates the @ TO NCGroebnerBasis @ object. By default, this method also calls Bergman for a noncommutative Groebner basis calculation. However, by setting the option InstallGB to true, the user instructs Macaulay2 to bypass the Bergman call and accept the input list as a Groebner basis without checking it is one. This can be useful when the coefficient ring is not @ TO QQ @ or a finite prime field. Example Igb2 = ncGroebnerBasis(I,InstallGB=>true) Text As mentioned above, noncommutative Groebner bases can grow rapidly both in the number and size of the terms. In some cases, it takes days to calcuate a Groebner basis to the desired degree. So as not to repeat this calculation more than once, users might have a Groebner basis saved in a file. The method @ TO gbFromOutputFile @ enables the user to load the Groebner basis from a file. The file should contain nothing besides a list of noncommutative polynomials in Macaulay2 readable form. (One exception: Bergman output files contain lines beginning with the "%" symbol. gbFromOutputFile ignores lines beginning with a "%".) Bergman users: you need not alter the output file from ncpbhgroebner in any way prior to calling gbFromOutputFile. See @ TO gbFromOutputFile @ for an example. Text Once a Groebner basis is computed, many methods become available. The most basic calculation is to return the normal form of a given element relative to the known Groebner basis. The NCAlgebra package also provides multiple options for this calculation. Text Generally speaking, Bergman is the most efficient way to reduce a ring element to normal form. Behind the scenes, the NCAlgebra package creates a Bergman-readable input file, runs a Bergman session, and interprets the output, which it displays to the user. This takes time, especially when the Groebner basis is large. The NCAlgebra package has its own normal form reduction algorithm. It is considerably slower than Bergman, but it can be faster than the time required to execute the Bergman call. Text The file NCAlgebra.m2 contains two environment variables: MAXDEG and MAXSIZE. If the element to be reduced has degree less than MAXDEG and fewer than MAXSIZE terms (or if the coefficient ring is not Q or Z/p), the NCAlgebra package calls its own normal form reduction method. Otherwise, it calls @ TO normalFormBergman @. The user can force a Bergman call using this method. Example z^17 % Igb normalFormBergman(z^17,Igb) Text Normal form calculations are performed automatically in an @ TO NCQuotientRing @. Example B = A/I z^17 Text We also use Bergman to compute Hilbert series of an @ TO NCQuotientRing @ using the @ TO hilbertBergman @ command. By default, the Hilbert series is given to degree 10. As mentioned above, we suggest reducing the degree limit for rings whose growth is not well understood beforehand. Example hilbertBergman B Text Perhaps a major achievement of the NCAlgebra package is the method @ TO rightKernelBergman @. The functionality described above involves only the most basic Bergman calls, and long time Bergman users may find little reason to prefer NCAlgebra on those grounds. On the other hand, computing kernel generators for a matrix with entries in a noncommutative ring is anything but straightforward, and we reduce the call to a single command. Example B = threeDimSklyanin(QQ,{1,1,-1},{x,y,z}) A = ambient B g = -y^3-x*y*z+y*x*z+x^3 C = A/(ideal B + ncIdeal g) M = ncMatrix {{x,y,z,0}, {-y*z-2*x^2,-y*x,z*x-x*z,x},{x*y-2*y*x,x*z,-x^2,y}, {-y^2-z*x,x^2,-x*y,z}} Text For details about matrices over noncommutative rings, see @ TO NCMatrix @. Provided the entries of M are homogeneous and their degrees are compatible, M can be viewed as a graded (degree 0) homomorphism of graded free B-modules. For more on this degree-compatibility, see @ TO assignDegrees @. Example assignDegrees(M,{1,0,0,0},{2,2,2,1}) Text Now, we can compute the kernel of M. It is always assumed that M determines a map of graded right modules. As always in the noncommutative case, computing generators of the kernel of a map is generally an infinite linear algebra problem. The @ TO rightKernelBergman @ method returns a set of minimal kernel generators to degree 10, or to the degree specified by the user. Example ker1M = rightKernelBergman(M) M*ker1M == 0 Text In principle, this method can be used to compute the minimal free resolution of a finitely generated B-module with known presentation up to a specified degree. Example ker2M = rightKernelBergman(ker1M) ker3M = rightKernelBergman(ker2M) SeeAlso "General setup information" /// doc /// Key "General setup information" Description Text We recommend using the NCAlgebra package with the most recent version of Macaulay2. Text Many of the methods in the NCAlgebra package rely on J. Backelin's noncommutative Groebner basis program Bergman. In the future, we may add support for other programs which compute Groebner bases, but for now, users must have Bergman installed. Text Bergman is free, open-source software available at http://servus.math.su.se/bergman/. We suggest users download the "current" version. You will find that Bergman can be compiled in several ways. We have found that as of March of 2015, Bergman does not run on the version of Common Lisp that installs via homebrew on Mac OS X versions 10.9 or newer. We give detailed instructions for installing Bergman and having it work with the NCAlgebra package below in the case of an Ubuntu installation. Text First, install Common Lisp using the command CannedExample sudo apt-get install clisp Text Next, download the bergman source and un-tar it. You'll need M2 to see the source even after it is built so remember where you left it. Next, change to the directory /scripts/clisp/unix. In this directory is a file called mkbergman that is basically the makefile for the common lisp build. From within that directory, execute the command CannedExample ./mkbergman -auto Text The -auto parameter can be left off in place of -i (for interactive) if you would like to specify non-default answers to some of the build parameters. When this command has been completed, the location of the bergman executable will be reported to you. Text Next, add bergman to your path. This can be achieved, for example, by symlinking the bergman executable to a directory on your path using the command: CannedExample ln -s /usr/bin/bergman Text Next, you need to set it up so that the environment variable BERGMANPATH is set upon entering a terminal by editing, for example, your .bashrc file. It should contain the location of the root of the bergman source code. This can be achieved with adding the following line to your .bashrc file (or course, assuming your source code is located at "~/bergman"): CannedExample export BERGMANPATH="~/bergman" Text There are also two global variables present (MAXDEG and MAXSIZE) in NCAlgebra.m2 which are tolerance values beyond which Bergman is called for normal form reductions. See @ TO "Using the Bergman interface" @ for more information. SeeAlso "Using the Bergman interface" /// doc /// Key kernelComponent (kernelComponent, ZZ, NCRingMap) Headline Computes a basis of the kernel of a ring map in a specified degree. Usage kern = kernelComponent(n,phi) Inputs n : ZZ phi : NCRingMap Outputs kern : NCMatrix Description Text This function returns a basis of the kernel of a ring map in a specified degree. Example A = QQ{x,y,z} B = skewPolynomialRing(QQ,(-1)_QQ, {a,b,c}) phi = ncMap(B,A,{a,b,c}) kernelComponent(2,phi) /// doc /// Key gddKernel (gddKernel, ZZ, NCRingMap) Headline Computes a homogeneous generating set of the kernel of a ring map. Usage kern = gddKernel(n,phi) Inputs n : ZZ phi : NCRingMap Outputs kern : List Description Text This function returns a generating set of the kernel of a ring map up to a specified degree. Example A = QQ{x,y,z} B = skewPolynomialRing(QQ,(-1)_QQ, {a,b,c}) phi = ncMap(B,A,{a,b,c}) gddKernel(4,phi) /// doc /// Key envelopingAlgebra (envelopingAlgebra, NCRing, Symbol) Headline Create the enveloping algebra Usage Ae = envelopingAlgebra(A,x) Inputs A : NCRing x : Symbol Outputs Ae : NCRing Description Text This function returns the enveloping algebra A ** Aop. The symbol argument is used to define the variables in Aop. Example B = skewPolynomialRing(QQ,(-1)_QQ, {a,b,c}) envelopingAlgebra(B,v) /// doc /// Key freeProduct (freeProduct, NCRing, NCRing) Headline Define the free product of two algebras Usage C = freeProduct(A,B) Inputs A : NCRing B : NCRing Outputs C : NCRing Description Text This function returns the free product of the algebras A and B. Example A = QQ{x,y,z} B = skewPolynomialRing(QQ,(-1)_QQ, {a,b,c}) C = freeProduct(A,B) /// doc /// Key qTensorProduct (qTensorProduct,NCRing,NCRing,ZZ) (qTensorProduct,NCRing,NCRing,QQ) (qTensorProduct,NCRing,NCRing,RingElement) (symbol **, NCRing, NCRing) Headline Define the (q-)commuting tensor product Usage C = qTensorProduct(A,B,q) Inputs A : NCRing B : NCRing q : RingElement Outputs C : NCRing Description Text This function returns the algebra that contains A and B as a subalgebra, with the commutation law on the images of A and B given by a*b = q*b*a for all a in A and b in B. In the case of A ** B, q = 1. Example A = QQ{x,y} B = skewPolynomialRing(QQ,(-1)_QQ, {a,b}) C = qTensorProduct(A,B,-1_QQ) ideal C D = A ** B ideal D /// doc /// Key (Hom,ZZ,NCMatrix,NCMatrix) Headline Compute a graded component of Hom(M,N) Usage homs = Hom(n,M,N) Inputs n : ZZ M : NCMatrix N : NCMatrix Outputs homs : List Description Text This function computes a generating set of the degree n component of Hom(M,N) as a module over the coefficient ring of A = ring M. /// doc /// Key (symbol _, NCMatrix, ZZ) Headline Induced map in homogeneous degree n Usage m = M_n Inputs M : NCMatrix n : ZZ Outputs m : Matrix Description Text If we regard M as defining a map of graded right free modules, then M_n returns the induced map of underlying R-modules in degree n, where R is the coefficient ring of ring M. /// doc /// Key (symbol SPACE, NCMatrix, Array) Headline Graded shift of an NCMatrix. Usage N = M x Inputs M : NCMatrix x : Array Outputs N : NCMatrix Description Text Shifts the source and target in degrees by n if x = [n]. /// doc /// Key (symbol +, NCRingMap, NCRingMap) (symbol *, ZZ, NCRingMap) (symbol *, QQ, NCRingMap) (symbol *, RingElement, NCRingMap) (symbol ^, NCRingMap, ZZ) Headline Basic operations with NCRingMaps Usage h = f + g or r*f Inputs f : NCRingMap g : NCRingMap Outputs h : NCRingMap Description Text Defines the sum of NCRingMaps. Though a linear combination of ring maps is not a ring map in general, this routine is useful in constructing ring maps programmatically. The sum is defined only on generators of the common source of f and g, while for higher degree monomials m, one no longer has f(m) + g(m) = h(m) (so it is only the sum on words of length 1). Example A = QQ{x,y} f = ncMap(A,A,{x,y}) g = ncMap(A,A,{y,x}) h = 3*f + 4*g matrix h k = h^3 matrix k /// doc /// Key (symbol SPACE, NCRingMap, NCIdeal) (symbol SPACE, NCRingMap, NCGroebnerBasis) Headline Apply a ring map to the generators of an ideal Usage J = f I Inputs f : NCRingMap I : NCIdeal or @ TO NCGroebnerBasis @ Outputs J : NCIdeal or @ TO NCGroebnerBasis @ Description Text This function applies the ring map f to the generators of the ideal or noncommutative Groebner basis that is passed in. Example A = QQ{x,y} g = ncMap(A,A,{y,x}) I = ncIdeal {x^2*y+y*x^2} g I /// doc /// Key (resolution, NCMatrix) NCChainComplex (betti,NCChainComplex) Headline Compute the resolution of coker M as a map of free right modules Usage res M Inputs M : NCMatrix LengthLimit => ZZ The length of the resolution. This defaults to the number of variables of ring M. Outputs : NCChainComplex Description Text This function computes a minimal graded free resolution of the cokernel of M, considered as a map of graded right free modules. M must be homogeneous for this command to work. As of this version, NCChainComplex (the return type) is still quite simple, though @ TO betti @ still works on them. Example A = skewPolynomialRing(QQ,(-1)_QQ,{x,y,z}) M = ncMatrix {{x,y,z}} Mres = res M Mres#0 Mres#1 Mres#2 betti Mres SeeAlso resolution /// --warning: tag has no documentation: NCAlgebra :: resolution(NCMatrix), key (resolution,NCMatrix) --warning: tag has no documentation: NCAlgebra :: ring(NCGroebnerBasis), key (ring,NCGroebnerBasis)