> < ^ From:

> < ^ Subject:

Dear GAP-Forum,

Frank Quinn asked:

I have commutative rational algebras that are supposed to be semisimple

over some cyclotomic field. How can I find this structure? Extending

coefficients to "Cyclotomics" and using "CentralIdempotentsOfAlgebra" gives

a crash, apparently because GAP cannot factor polynomials over cyclotomics.

The algorithm to compute idempotents crucially needs to factorize a polynomial. (The problem is equivalent to a problem of polynomial factorization.)

Unfortunately at the moment GAP 4 does not contain code to factorize

polynomials over algebraic number fields.

For finite degree extensions this is not a fundamental problem: We had an

algorithm for this in GAP 3, but so far I did not find time to convert it to

GAP 4.

(If you need to solve this problem we could provide you with code that will

allow you to ``feed in'' a polynomial factorization obtained by another

program.)

In principle this should be sufficient for factorization over the

cyclotomics as well, though I don't see how to find the smallest subfield

that contains all the cyclotomic elements needed to factor a given

polynomial.

He continued:

> Is there some way to find where the implementation of a function is in the

> library? For instance material related to structure constant tables for

> algebras occurs in at least three different files. Reading the code can be

> very helpful, but I can't always find it.

I fear there is no general solution to this, but probably the following

remarks are of help:

There is a function `ApplicableMethod' that will return the function

used as a method for an operation. It is not yet documented in 4b5, but I

append the documentation as it will be in the next release.

gap> a:=Algebra(Rationals,[[[1,0],[-1,1]]]);

<algebra over Rationals, with 1 generators>

gap> meth:=ApplicableMethod(CentralIdempotentsOfAlgebra,[a],1);

#I Searching Method for CentralIdempotentsOfSemiring with 1 arguments:

#I Total: 3 entries

#I Method

2: ``CentralIdempotentsOfSemiring: for an associative algebra'', value: 36

function( A ) ... end

(Now `meth' is a function you can `Print'.)

To find the occurrence of functions and methods in the library, I tend to

use `grep'. To find a function, I search for the function name in the `gd'

files (as it is declared only once, only one file will show), it is very

likely the function will occur in the corresponding `gi' file.

To find a method I search for `Method(' (this catches `InstallMethod' and

`InstallOtherMethod' and the installation string (`ApplicableMethod' will

print it in the higher print levels) or the operation name.

(It would be nice to have better browsing tools, but I fear at the moment

this is beyond our capabilities.)

Finally, allow me to plug my talk at our Workshop in Linz about the library

which gives a little bit further information. Slides can be found at:

http://www-gap.dcs.st-and.ac.uk/~gap/Info/wlinz.html

I hope this is of some help,

Alexander Hulpke

% the manual section on `ApplicableMethod':

\>ApplicableMethod( <opr>, <args>[, <printlevel>] ) F

\>ApplicableMethod( <opr>, <args>, <printlevel>, <nr> ) F

\>ApplicableMethod( <opr>, <args>, <printlevel>, "all" ) F

In the first form, `ApplicableMethod' returns the method of highest rank

that is applicable for the operation <opr> with the arguments in the

list <args>.

The default <printlevel> is `0'.

If no method is applicable then `fail' is returned.

In the second form, if <nr> is a positive integer then

`ApplicableMethod' returns the <nr>-th applicable method for the

operation <opr> with the arguments in the list <args>, where the methods

are ordered according to descending rank. If less than <nr> methods are

applicable then `fail' is returned.

If the fourth argument is the string `"all"' then `ApplicableMethod'

returns a list of all applicable methods for <opr> with arguments

<args>, ordered according to descending rank.

Depending on the integer value <printlevel>, additional information is

printed. Admissible values and their meaning are as follows.

\beginlist

\item{0}

no information,

\item{1}

information about the applicable method,

\item{2}

also information about the not applicable methods of higher rank,

\item{3}

also for each not applicable method the first reason why it is not

applicable,

\item{4}

also for each not applicable method all reasons why it is not

applicable.

\item{6}

also the function body of the selected method(s)

\endlist

When a method returned by `ApplicableMethod' is called then it returns

either the desired result or the string `TRY_NEXT_METHOD', which

corresponds to a call to `TryNextMethod' in the method and means that

the method selection would call the next applicable method.

*Note:* The kernel provides special treatment for the infix operations

`\\+', `\\-', `\\*', `\\/', `\\^', `\\mod' and `\\in'. For some kernel

objects (notably cyclotomic numbers, finite field elements and vectors

thereof) it calls kernel methods circumventing the method selection

mechanism. Therefore for these operations `ApplicableMethod' may return

a method which is not the kernel method actually used.

% end

> < [top]