symmetricAlgebra -- the symmetric algebra of a module

Synopsis

Optional inputs:
- Constants (missing documentation) => ..., default value false,
- DegreeGroup (missing documentation) => ..., default value null,
- DegreeLift => ..., default value null
- DegreeMap => ..., default value null
- DegreeRank => ..., default value null
- Degrees => ..., default value null
- Global => ..., default value true
- Heft => ..., default value null
- Inverses => ..., default value false
- Join => ..., default value null
- Local => ..., default value false
- MonomialOrder => ..., default value {GRevLex, Position => Up}
- MonomialSize => ..., default value 32
- SkewCommutative => ..., default value {}
- VariableBaseName => ..., default value "p"
- Variables => ..., default value null
- Weights => ..., default value {}
- WeylAlgebra => ..., default value {}

Description

Synopsis

Usage:

symmetricAlgebra M
Inputs:
- M, a module
Outputs:
- a ring, the symmetric algebra of M

i1 : R = QQ[a..d];

i2 : M = image matrix{{a,b,c}}

o2 = image | a b c |

                             1
o2 : R-module, submodule of R

i3 : symmetricAlgebra M

                       R[p ..p ]
                          0   2
o3 = ---------------------------------------------
     (- b*p  + a*p , - c*p  + b*p , - c*p  + a*p )
           0      1       1      2       0      2

o3 : QuotientRing

i4 : symmetricAlgebra(R^{1,2,3})

o4 = R[p ..p ]
        0   2

o4 : PolynomialRing

Most of the optional arguments for monoids (see Ring Array or monoid) are available here as well, as in the following example. They apply to the variables that correspond to the generators of the module.

i5 : A = symmetricAlgebra(M, Variables=>{x,y,z})

o5 = A

o5 : QuotientRing

i6 : describe A

                     R[x..z]
o6 = ---------------------------------------
     (- b*x + a*y, - c*y + b*z, - c*x + a*z)

i7 : B = symmetricAlgebra(M, VariableBaseName=>G, MonomialSize=>16)

o7 = B

o7 : QuotientRing

i8 : describe B

                       R[G ..G ]
                          0   2
o8 = ---------------------------------------------
     (- b*G  + a*G , - c*G  + b*G , - c*G  + a*G )
           0      1       1      2       0      2

i9 : symmetricAlgebra(M, Degrees=> {3:1})

                       R[p ..p ]
                          0   2
o9 = ---------------------------------------------
     (- b*p  + a*p , - c*p  + b*p , - c*p  + a*p )
           0      1       1      2       0      2

o9 : QuotientRing

Synopsis

Usage:

symmetricAlgebra f
Inputs:
- f, a matrix
Outputs:
- a ring map, the map between symmetric algebras induced by f

i10 : symmetricAlgebra vars R

o10 = map (R[p ], R[p ..p ], {a*p , b*p , c*p , d*p , a, b, c, d})
              0      0   3       0     0     0     0

o10 : RingMap R[p ] <-- R[p ..p ]
                 0         0   3

Synopsis

Usage:

symmetricAlgebra(A,B,f)
Inputs:
- A, a ring, the symmetric algebra of the target of f, previously computed. Optional.
- B, a ring, the symmetric algebra of the source of f, previously computed. Optional.
- f, a matrix
Outputs:
- a ring map, the map between the specified symmetric algebras induced by f

This form of functoriality is needed, because various options are available when computing symmetric algebras.

For a linear map that is an isomorphism, and is known to be so, e.g., by having had its inverse computed, the inverse of the corresponding map between symmetric algebras is precomputed and made available.

i11 : symmetricAlgebra vars R

o11 = map (R[p ], R[p ..p ], {a*p , b*p , c*p , d*p , a, b, c, d})
              0      0   3       0     0     0     0

o11 : RingMap R[p ] <-- R[p ..p ]
                 0         0   3

i12 : p = symmetricAlgebra(A,B,id_M)

o12 = map (A, B, {x, y, z, a, b, c, d})

o12 : RingMap A <-- B

i13 : p^-1

o13 = map (B, A, {G , G , G , a, b, c, d})
                   0   1   2

o13 : RingMap B <-- A

i14 : p * p^-1 === id_A

o14 = true

i15 : p^-1 * p === id_B

o15 = true

Ways to use symmetricAlgebra :

symmetricAlgebra(Matrix)
symmetricAlgebra(Module)
symmetricAlgebra(Nothing,Nothing,Matrix)
symmetricAlgebra(Nothing,Ring,Matrix)
symmetricAlgebra(Ring,Nothing,Matrix)
symmetricAlgebra(Ring,Ring,Matrix)

For the programmer

The object symmetricAlgebra is a method function with options.