> < ^ Date: Wed, 20 May 1992 15:01:51 +0200
> < ^ From: Martin Schoenert <martin.schoenert@math.rwth-aachen.de >
< ^ Subject: Re: FreeGroup etc

Arnaldo Mandel writes in his e-mail of 15-May-92:

I really wished I could understand the current discussion on
FreeGroup, etc., but unfortunately I am very limited on languages.
Would anybody kindly summarize what is going on?

Well I will try, also adding a few comments on my own.

For the future I would like to ask everybody to use english in this
forum, because the majority of readers of this forum have english as
their native tongue (though I think quite a few of them also understand

Martin Wursthorn writes in his e-mail message of 12-May-92:

If one defines a group with abstract generators and relators
('FreeGroup'), some function such as 'ConjugacyClasses' cannot handle
such groups. Those functions use up all available memory and abort
when GAP fails to extend its workspace. Also the experiment to
convert such a group into an AG group fails. Are we doing anything
wrong (check the warning in section 21.3 in the manual)?

The functions that fail are generic functions that should work for any
group. However they do not work for finitely presented groups, because
one basic assumption does not hold for such groups. The assumption is
that '<g> = <h>' evaluates to 'true' if and only if the two elements <g>
and <h> are equal *in their group*. Now for finitely presented groups
'<g> = <h>' evaluates to 'true' if and only if <g> and <h> are equal as
words, i.e., are equal *in the free group*. But two different words may
denote the same element in a finitely presented group, e.g., in $< a |
a^2 = 1 >$, the words $a$ and $a^3$ denote the same element. The manual
states this problem in section 21.3 and 21.4, which say that you should
*not* use the functions not mentioned in this sections.

So you are doing something wrong in the sense that you are using
functions that you should not use. Currently there simply is no way to
compute the conjugacy classes of a finitely presented group. You could,
of course, compute a permutation representation of your finitely
presented group and then work with this.

If the group you are interested in is solvable, another possibilty would
be to convert the finitely presented group into an AG group, and then
work with this group. Apperently that is what Martin Wursthorn tried,
because he mentioned 'AgGroup' in his e-mail message. The catch is that
'AgGroup' is also a generic function, and you currently *cannot* use
'AgGroup' for finitely presented groups.

Frank Celler writes in his e-mail of 14-May-92:

'AgGroup' fails for the same reason as 'ConjugacyClasses' for
finitely presented groups (see M.Schoenert's letter [I never wrote
that letter, but see the above comments]). There is a special
function 'AgGroupFpGroup', which accepts a power/commutator or
power/conjugator presentation and returns the AG group. This
function does not perform any transformation of the presentation, so
the generators must be sorted w.r.t. to their depth.

The trouble with 'AgGroupFpGroup' is mentioned in the last sentence. It
does not perform any transformations of the presentation, thus you must
provide a presentation that already is in power/commutator or
power/conjugator form. This means that you cannot take a finitely
presented solvable group with an arbitrary presentation and convert it
into a AG group. So you cannot use the efficient methods for AG groups
unless you know a power/commutator or power/conjugator presentation for
your group.

Martin Wursthorn writes in his e-mail message of 14-May-92:

Yes, but usually one has an arbitrary presentation for a (solvable)
group. With larger groups it may be pretty difficult to transform
them by hand into a power/commutator or power/conjugator
presentation. Will there be functions for this taks.

Frank Celler replied in his e-mail message of 14-May-92:

There will be functions to convert a (solvable) permutation group
into an AG group. If one can find a (faithfull) permutation
representation for a finitely presented group with the TC, one can
use this function. There will be no other functions (except the PQ
for p-groups) for finitely presented groups.

Actually 'AgGroup' can already convert a solvable permutation group into
an AG group, but the new function will be much faster.

Joachim Neubueser also replied in his e-mail message of 14-May-92:

Frank Celler's message does not contain the whole story. There exist
suggestions for an SQ, which computes AG presentations for solvable
factor groups of increasing number of chief factors resp. increasing
solvable length for a finitely presented group. These methods will
eventually compute a AG presentation for a finitely presented
solvable group. One of these suggestions, which was made by W.
Plesken, was implemented by A. Wegner for an older version of GAP,
and is currently being ported to GAP 3.1. However, this method is
quite expensiv, and is certainly not suited for large groups.
Improvements of this method and implementation of the other
suggestions will remain on our agenda, but will not be available in
the near future.

One should also note that it is not always necessary to start with a
PAG presentation. One could start with a polycyclic presentation
with cyclic factors of composite size, convert this with
'AgGroupFpGroup' into a AG group, and then use 'RefinedSeries' to
convert this into a PAG presentation. This is sometimes easier than
to write down a PAG presentation immediatly.

Werner Nickel also mentioned the PQ in his e-mail message of 15-May-92:

There will be no other functions (except the PQ for p-groups) for
finitely presented groups.

I would not be so pessimistic. After all, Alex Wegner has an
implementation of Plesken's SQ , at least for GAP 2.4. As far as I
know, it is problematic to use this implementation for large groups.
Is Alex converting his functions for GAP 3.X, or has he done so

Martin Wursthorn writes about a related topic in his first e-mail:

If one already has a AG or PAG presentation, GAP works great. For
example we had no problems converting a group of order 2^24 into a PQ
presentation. Is it possible to obtain from such a PQ data structure
a group with abstract generators and relations corresponding to the
PQ presentation? Some of our programs need such a presentation.

Frank Celler answered:

Yes this is possible. 'AgGroup' should do this, but currently does
not. You can use 'AgGroupPcp'.


Martin Sch"onert, Martin.Schoenert@Math.RWTH-Aachen.DE, +49 241 804551
Lehrstuhl D f"ur Mathematik, Templergraben 64, RWTH, D 51 Aachen, Germany

> < [top]