示例#1
0
 /**
  * Takes a word and translates it into the internally used form, an array of integers.
  *
  * @param word the input word.
  * @return the translated word.
  */
 private int[] translateWord(FreeWord word) {
   final int res[] = new int[word.size()];
   for (int i = 0; i < word.size(); ++i) {
     final FreeWord g = word.subword(i, i + 1);
     final Integer idx = (Integer) this.gen2idx.get(g);
     res[i] = idx.intValue();
   }
   return res;
 }
示例#2
0
 public Object apply(final Object x, final FreeWord w) {
   if (!(x instanceof Coset)) {
     return null;
   }
   final Coset coset = (Coset) x;
   if (coset.getAction() != this) {
     return null;
   }
   int current = coset.getIndex();
   if (current < 1 || current > size()) {
     return null;
   }
   for (int i = 0; i < w.length(); ++i) {
     final Integer j = (Integer) this.gen2idx.get(w.subword(i, i + 1));
     if (j == null) {
       return null;
     } else {
       final int row[] = (int[]) this.table.get(current);
       current = row[j.intValue()];
     }
   }
   return new Coset(current);
 }
示例#3
0
  /**
   * Constructs a CosetTable instance with a limit on the number of table rows that may be present
   * at any stage of the construction process. Note that this number may be much higher than the
   * actual number of cosets, because multiple rows may be found correspond to a single coset long
   * after their construction.
   *
   * @param group the group.
   * @param subgroupGenerators generators of the subgroup.
   * @param sizeLimit the limit on the number of coset rows.
   */
  public CosetAction(final FpGroup group, final List subgroupGenerators, final int sizeLimit) {

    // --- copy parameters to fields
    this.group = group;
    this.subgroupGenerators = Collections.unmodifiableList(subgroupGenerators);
    this.sizeLimit = sizeLimit;

    // --- extract generators and relators for group
    final List groupGenerators = group.getGenerators();
    final List groupRelators = group.getRelators();

    // --- set up translation tables
    this.ngens = 2 * groupGenerators.size();
    this.idx2gen = new FreeWord[this.ngens];
    this.gen2idx = new HashMap();
    this.idx2invidx = new int[this.ngens];

    int nu = 0;
    for (Iterator iter = groupGenerators.iterator(); iter.hasNext(); ) {
      final FreeWord g = (FreeWord) iter.next();
      this.idx2gen[nu] = g;
      this.gen2idx.put(g, new Integer(nu));
      this.idx2gen[nu + 1] = g.inverse();
      this.gen2idx.put(g.inverse(), new Integer(nu + 1));
      this.idx2invidx[nu] = nu + 1;
      this.idx2invidx[nu + 1] = nu;
      nu += 2;
    }

    // --- translate relators
    final List rels = new ArrayList();
    for (Iterator iter = groupRelators.iterator(); iter.hasNext(); ) {
      final FreeWord r = (FreeWord) iter.next();
      final int n = r.length();
      for (int i = 0; i < n; ++i) {
        final FreeWord w = r.subword(i, n).times(r.subword(0, i));
        rels.add(translateWord(w));
        rels.add(translateWord(w.inverse()));
      }
    }

    // --- translate subgroup generators
    final List subgens = new ArrayList();
    for (Iterator iter = subgroupGenerators.iterator(); iter.hasNext(); ) {
      final FreeWord generator = (FreeWord) iter.next();
      subgens.add(translateWord(generator));
      subgens.add(translateWord(generator.inverse()));
    }

    // --- set up a coset table with one dummy row and one row for the trivial coset
    this.table = new ArrayList();
    this.table.add(new int[this.ngens]);
    this.table.add(new int[this.ngens]);

    // --- holds classes of rows known to correspond to the same coset
    IntPartition equivalences = new IntPartition();

    // --- number of rows made invalid but not yet deleted
    int invalidRows = 0;

    // --- scan the table row by row, creating and deleting rows on the fly
    int i = 1;
    while (i < this.table.size()) {
      // --- proceed only if the current row is valid
      if (equivalences.find(i) != i) {
        ++i;
        continue;
      }

      // --- scan the current row
      final int row[] = (int[]) this.table.get(i);
      for (int j = 0; j < this.ngens; ++j) {
        // --- proceed only if the current column is empty
        if (row[j] != 0) {
          continue;
        }

        // --- log the result of this construction step
        if (LOGGING) {
          System.out.println("\ni = " + i + ", j = " + j);
        }
        // --- make a new row for the product with g
        final int newRow[] = new int[this.ngens];
        this.table.add(newRow);

        // --- set the correspondences
        final int n = this.table.size();
        row[j] = n - 1;
        newRow[this.idx2invidx[j]] = i;

        if (LOGGING) {
          System.out.println("after setting item:");
          dumpTable();
        }

        // --- scan relations to identify equivalent rows
        final LinkedList identify = new LinkedList();
        for (Iterator iter = rels.iterator(); iter.hasNext(); ) {
          final int rel[] = (int[]) iter.next();
          scanRelation(rel, n - 1, identify);
        }

        // --- scan subgroup generators
        final int one = equivalences.find(1);
        for (Iterator iter = subgens.iterator(); iter.hasNext(); ) {
          final int gen[] = (int[]) iter.next();
          scanRelation(gen, one, identify);
        }

        if (LOGGING) {
          System.out.println("after scanning:");
          dumpTable();
        }

        // --- perform pending identifications
        invalidRows += performIdentifications(identify, equivalences);

        if (LOGGING) {
          System.out.println("after identifying:");
          dumpTable();
        }

        // --- quit if the limit on the number of rows is reached
        if (this.sizeLimit > 0 && n - invalidRows > this.sizeLimit) {
          throw new RuntimeException("table limit reached");
        }

        // --- compress the table if necessary
        if (invalidRows > n / 2) {
          final int old2new[] = compressTable(equivalences);
          equivalences = new IntPartition();
          i = old2new[i];
          invalidRows = 0;
          if (LOGGING) {
            System.out.println("after compressing:");
            dumpTable();
          }
        }
      }

      // --- look at next row
      ++i;
    }

    // --- make a final cleanup
    compressTable(equivalences);
    if (LOGGING) {
      System.out.println("\nAfter final compression:");
      dumpTable();
    }

    // --- some finishing touches
    this.numberOfCosets = this.table.size() - 1;
    this.cosetRepresentatives = computeCosetRepresentatives();
  }