> < ^ From:

< ^ Subject:

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

german).

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

alread?

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.

--

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]