Quelle list_commutators.c Sprache: C

/****************************************************************************
**
*A  list_commutators.c          ANUPQ source                   Eamonn O'Brien
**
*Y  Copyright 1995-2001,  Lehrstuhl D fuer Mathematik,  RWTH Aachen,  Germany
*Y  Copyright 1995-2001,  School of Mathematical Sciences, ANU,     Australia
**
*/

#include "pq_defs.h"
#include "constants.h"
#include "pcp_vars.h"
#include "pq_functions.h"

/* evaluate the Engel (p - 1)-identity

          [a, (p - 1) b] = 1

   where each of a and b range over all of the generators of
   supplied weights; echelonise the results and add to the
   queue for possible closure under action of automorphisms  */

void list_commutators(int *queue, int *queue_length, struct pcp_vars *pcp)
{
   register int *y = y_address;

   register int lastg = pcp->lastg;
   register int cp, cp1, cp2, cp3, cp4, result;
   register int first, last;
   register int total;
   register int depth;
   register int i, gen;
   int weight, second_weight;
   register int start, end, second;
   register int p = pcp->p;

   total = 6 * lastg + 6;

   cp1 = pcp->submlg - lastg - 2;
   cp2 = cp1 - lastg;
   cp3 = cp2 - lastg;
   cp4 = cp3 - lastg;
   result = cp4 - lastg;

   /* fudge the value of submlg because of possible call to power */
   pcp->submlg -= total;

   read_value(
       TRUE, "Input weight of first component of commutator: ", &weight, 1);

   first = y[pcp->clend + weight - 1] + 1;
   last = y[pcp->clend + weight];

   read_value(TRUE,
              "Input weight of other components of commutator: ",
              &second_weight,
              1);

   start = y[pcp->clend + second_weight - 1] + 1;
   end = y[pcp->clend + second_weight];

   for (gen = first; gen <= last; ++gen) {
      for (second = start; second <= end; ++second) {

         if (is_space_exhausted(total, pcp))
            return;

         /* set up first component at cp2 and cp3 */
         for (i = 1; i <= lastg; ++i)
            y[cp2 + i] = y[cp3 + i] = 0;
         y[cp2 + gen] = y[cp3 + gen] = 1;

         depth = p;

         while (--depth > 0) {

            /* set up next component, b, at cp1 and cp4 -- b has value second */
            for (i = 1; i <= lastg; ++i)
               y[cp1 + i] = y[cp4 + i] = 0;
            y[cp1 + second] = y[cp4 + second] = 1;

            /* solve the equation (ba) * x = ab to obtain [a, b] */
            find_commutator(cp1, cp2, cp3, cp4, result, pcp);

            /* replace value of a by x */
            copy(result, lastg, cp2, pcp);
            copy(result, lastg, cp3, pcp);
         }

         cp = pcp->lused;

         /* print the commutator */
         if (pcp->diagn)
            setup_word_to_print("commutator", result, cp, pcp);

         /* now echelonise the result */
         copy(result, lastg, cp, pcp);
         setup_echelon(queue, queue_length, cp, pcp);

         if (pcp->redgen != 0 && pcp->diagn)
            printf("The commutator evaluated is [%d, %d]\n", gen, second);
      }
   }

   /* reset the value of submlg */
   pcp->submlg += total;
}

#if defined(DEBUG)

/* set up list of commutators of the form [a, 1, 1, 1, 1]
   where a ranges over a supplied weight, to close under
   action of automorphisms */

void List_Commutators(int *queue, int *queue_length, struct pcp_vars *pcp)
{
   register int *y = y_address;

   register int lastg = pcp->lastg;
   register int total;
   int cp1 = pcp->submlg - lastg - 2;
   int cp2 = cp1 - lastg;
   int cp3 = cp2 - lastg;
   int cp4 = cp3 - lastg;
   int result = cp4 - lastg;
   register int cp;
   register int first, last;
   register int depth;
   register int i, gen;
   int weight;

   read_value(
       TRUE, "Input weight of first component of commutator: ", &weight, 1);

   first = y[pcp->clend + weight - 1] + 1;
   last = y[pcp->clend + weight];

   total = 6 * lastg + 6;
   if (is_space_exhausted(total, pcp))
      return;

   /* fudge the value of submlg because of possible call to power */
   pcp->submlg -= total;

   for (gen = first; gen <= last; ++gen) {

      /* set up first component at cp2 and cp3 */
      for (i = 1; i <= lastg; ++i)
         y[cp2 + i] = y[cp3 + i] = 0;
      y[cp2 + gen] = y[cp3 + gen] = 1;

      depth = 5;

      while (--depth > 0) {

         /* set up next component, b, at cp1 and cp4 -- b is 1 in all cases */
         for (i = 1; i <= lastg; ++i)
            y[cp1 + i] = y[cp4 + i] = 0;
         y[cp1 + 1] = y[cp4 + 1] = 1;

         /* solve the equation (ba) * x = ab to obtain [a, b] */
         find_commutator(cp1, cp2, cp3, cp4, result, pcp);

         /* replace value of a by x */
         copy(result, lastg, cp2, pcp);
         copy(result, lastg, cp3, pcp);
      }

      /* now echelonise the result */
      cp = pcp->lused;
      copy(result, lastg, cp, pcp);
      for (i = 1; i <= lastg; ++i)
         y[cp + lastg + i] = 0;
      echelon(pcp);
      if (pcp->redgen != 0)
         queue[++*queue_length] = pcp->redgen;

      /* print the commutator */
      /*
        cp = pcp->lused;
        setup_word_to_print ("commutator", result, cp, pcp);
        */
   }

   /* reset the value of submlg */
   pcp->submlg += total;
}

#endif

quality87%

¤ Dauer der Verarbeitung: 0.16 Sekunden (vorverarbeitet) ¤

Wurzel

Suchen

Beweissystem der NASA

Beweissystem Isabelle

NIST Cobol Testsuite

Cephes Mathematical Library

Wiener Entwicklungsmethode

Haftungshinweis

Die Informationen auf dieser Webseite wurden nach bestem Wissen sorgfältig zusammengestellt. Es wird jedoch weder Vollständigkeit, noch Richtigkeit, noch Qualität der bereit gestellten Informationen zugesichert.

Bemerkung:

Die farbliche Syntaxdarstellung ist noch experimentell.