Macaulay2 » Documentation
Packages » MonomialOrbits :: normalForms
next | previous | forward | backward | up | index | toc

normalForms -- chooses orbit representatives from a list of monomial ideals, under a group of permutations

Synopsis

Description

To test a conjecture on monomial ideals of a certain type, one typically makes a computation on each one. If the computation is costly, and the result is invariant under a group G of permutations of the variables, it may be more efficient to choose orbit representatives first.

Applying the ring automorphisms and then comparing the ideals can be slow. In the routine orbitRepresentatives, the monomial ideals are first turned into lists of exponent vector, and the normalForms operations are done on these using "normalFormsLis" instead of on the original ideals. The conversions to and from monomialIdeals and lists of lists are done with toLis and fromLis.

i1 : R = ZZ/101[w,x,y,z]

o1 = R

o1 : PolynomialRing
 
i2 : monlist = flatten entries basis(4,R)

       4   3    3    3    2 2   2      2      2 2   2      2 2     3     2  
o2 = {w , w x, w y, w z, w x , w x*y, w x*z, w y , w y*z, w z , w*x , w*x y,
     ------------------------------------------------------------------------
        2        2                2     3     2        2     3   4   3    3  
     w*x z, w*x*y , w*x*y*z, w*x*z , w*y , w*y z, w*y*z , w*z , x , x y, x z,
     ------------------------------------------------------------------------
      2 2   2      2 2     3     2        2     3   4   3    2 2     3   4
     x y , x y*z, x z , x*y , x*y z, x*y*z , x*z , y , y z, y z , y*z , z }

o2 : List
 
i3 : idlist = subsets(monlist, 3)/monomialIdeal;
 
i4 : #oo

o4 = 6545

There are 6545 ideals in 4 variables generated by 3 monomials of degree 4

i5 : G0 = permutations numgens R

o5 = {{0, 1, 2, 3}, {0, 1, 3, 2}, {0, 2, 1, 3}, {0, 2, 3, 1}, {0, 3, 1, 2},
     ------------------------------------------------------------------------
     {0, 3, 2, 1}, {1, 0, 2, 3}, {1, 0, 3, 2}, {1, 2, 0, 3}, {1, 2, 3, 0},
     ------------------------------------------------------------------------
     {1, 3, 0, 2}, {1, 3, 2, 0}, {2, 0, 1, 3}, {2, 0, 3, 1}, {2, 1, 0, 3},
     ------------------------------------------------------------------------
     {2, 1, 3, 0}, {2, 3, 0, 1}, {2, 3, 1, 0}, {3, 0, 1, 2}, {3, 0, 2, 1},
     ------------------------------------------------------------------------
     {3, 1, 0, 2}, {3, 1, 2, 0}, {3, 2, 0, 1}, {3, 2, 1, 0}}

o5 : List
 
i6 : G = apply(G0, g -> map(R,R,(vars R)_g))

o6 = {map (R, R, {w, x, y, z}), map (R, R, {w, x, z, y}), map (R, R, {w, y,
     ------------------------------------------------------------------------
     x, z}), map (R, R, {w, y, z, x}), map (R, R, {w, z, x, y}), map (R, R,
     ------------------------------------------------------------------------
     {w, z, y, x}), map (R, R, {x, w, y, z}), map (R, R, {x, w, z, y}), map
     ------------------------------------------------------------------------
     (R, R, {x, y, w, z}), map (R, R, {x, y, z, w}), map (R, R, {x, z, w,
     ------------------------------------------------------------------------
     y}), map (R, R, {x, z, y, w}), map (R, R, {y, w, x, z}), map (R, R, {y,
     ------------------------------------------------------------------------
     w, z, x}), map (R, R, {y, x, w, z}), map (R, R, {y, x, z, w}), map (R,
     ------------------------------------------------------------------------
     R, {y, z, w, x}), map (R, R, {y, z, x, w}), map (R, R, {z, w, x, y}),
     ------------------------------------------------------------------------
     map (R, R, {z, w, y, x}), map (R, R, {z, x, w, y}), map (R, R, {z, x, y,
     ------------------------------------------------------------------------
     w}), map (R, R, {z, y, w, x}), map (R, R, {z, y, x, w})}

o6 : List
 
i7 : normalForms(idlist,G); --there are 244
---6545
 
i8 : #oo

o8 = 333

But only 333 orbits, a 19-fold reduction.

See also

Ways to use normalForms :

For the programmer

The object normalForms is a method function.