> More precisely, before processing, I make the list of subgroups up to
> conjugation. Then I want to be able to sort the vectors depending on
> the conjugacy class of the stabilizer (I do not care about the class
> of the group).

There probably a lot of different strategy, I don't know the canonical
and efficient algorithm to build (or iddentify) the stabilizer. I
developed the integer vectors mod a permgroup for invariant theory. But,
it is not my goal to build strong support to group action. I just don't
know even if it exist in GAP (It is close for sure inside but I never
play with it).

So, if you want such feature, you should try dig this way. The only
thing `important` in the feature IntegerVectorsModPermGroup is the use
of categories and SearchForest (See sage/combinat/backtrack.py).
SearchForest allows the user to customize enumerated structure very
easily.

> A new question : is this the faster option ? Do we need to compute the
> orbit explicitely to get the answer to "is the stabilizer trivial ?" ?
> The typical input that i will give to the iterator corresponds to
> vectors of length around 20 and sum around 30... I need fast
> generation.

First thing, the current main cost of IntegerVectorsModPermGroup is due
to the GAP interface. Convert in Sage the Strong Generating System is
just horrible. see : 
sage: %time SymmetricGroup(20).strong_generating_system()
Wall time: 24.95 s
After, IntegerVectorsModPermGroup is optimized to call the function
`is_canonical` as least as possible. `is_canonical` return True if and
only if an integer vector is maximum for the lexicographic order in its
orbit under the action of a given permutation group. Let us imagine you
have another criteria `is_stabilizer_trivial` which have a very very
light cost. You should run it before testing if the integer vector is
canonical and thus, this engine of enumeration is no more optimized for
your case.

To the question : "Do we need to compute the orbit explicitely to get
the answer to "is the stabilizer trivial ?", I don't know. I guess not
but I really don't know the usual algorithm. It is probably in GAP
somewhere...

Anyway, you have SearchForest and you have an easy access to 
from sage.combinat.enumeration_mod_permgroup import is_canonical
which is a polymorph function : 
sage: G = PermutationGroup([[(1,2,3)]])
sage: sgs = G.strong_generating_system()
sage: is_canonical(sgs, [3,0,0])
True
sage: is_canonical(sgs, ['b','a','a'])
True
sage: is_canonical(sgs, ['a','b','a'])
False
sage: is_canonical(sgs, [5/2,3/2,1/2])
True
sage: is_canonical(sgs, [12.34, 6.12, 2.1])
True
With that, you can enumerate anything comparable up to the action of a
permutation group. WARNING : the action is on list on position!

If the memory of your computer can contains all, vectors of length
around 20 and sum around 30 can be possible. There are a lot of such
object especially for small group. For the cyclic group of order 20, the
order of highness is around 10^12 different integer vectors.

Cheers,
Nicolas.


-- 
You received this message because you are subscribed to the Google Groups 
"sage-combinat-devel" group.
To post to this group, send email to sage-combinat-devel@googlegroups.com.
To unsubscribe from this group, send email to 
sage-combinat-devel+unsubscr...@googlegroups.com.
For more options, visit this group at 
http://groups.google.com/group/sage-combinat-devel?hl=en.

Reply via email to