enumerate-balanced-ideals/generate.c

#include "thickenings.h"
#include "weyl.h"
#include "queue.h"

#include <strings.h>
#include <stdio.h>

void balanced_thickening_callback(const bitvec_t *pos, int size, void *data)
{
  static long totcount = 0;

  if((++totcount) % 100000000 == 0) {
    fprintf(stderr, "Found balanced ideal: ");
    bv_print(stderr, pos, size/2);
    fprintf(stderr, "\n");
  }
}

int main(int argc, const char *argv[])
{
  semisimple_type_t type;
  unsigned long right_invariance, left_invariance;
  int rank, order, hyperplanes, cosets;
  int fixpoints;

  node_t *graph;

  char string_buffer1[1000];
  const char *alphabet = "abcdefghijklmnopqrstuvwxyz";

  // read arguments

  ERROR(argc < 2, "Too few arguments!\n");

  type.n = 0;
  for(int i = 0; i < argc - 1; i++) {
    if(argv[i+1][0] < 'A' || argv[i+1][0] > 'I')
      break;
    type.n++;
  }

  type.factors = (simple_type_t*)malloc(type.n*sizeof(simple_type_t));
  for(int i = 0; i < type.n; i++) {
    type.factors[i].series = argv[i+1][0];
    type.factors[i].rank = argv[i+1][1] - '0';
    ERROR(argv[i+1][0] < 'A' || argv[i+1][0] > 'I' || argv[i+1][1] < '1' || argv[i+1][1] > '9', "Arguments must be Xn with X out of A-I and n out of 0-9\n");
  }

  left_invariance = right_invariance = 0;

  if(argc - type.n >= 3) {
    if(strcmp(argv[type.n + 1], "-") != 0)
      for(int i = 0; i < strlen(argv[type.n + 1]); i++)
	left_invariance |= (1 << (argv[type.n + 1][i] - 'a'));
    if(strcmp(argv[type.n + 2], "-") != 0)
      for(int i = 0; i < strlen(argv[type.n + 2]); i++)
	right_invariance |= (1 << (argv[type.n + 2][i] - 'a'));
  }

  ERROR(strlen(alphabet) < rank, "The alphabet has too few letters\n");

  // generate graph

  graph = graph_alloc(type);
  cosets = prepare_simplified_graph(type, left_invariance, right_invariance, graph);

  ERROR(cosets < 0, "The left invariance is not preserved by the opposition involution!\n");

  // print stuff

  rank = weyl_rank(type);                // number of simple roots
  order = weyl_order(type);              // number of Weyl group elements
  hyperplanes = weyl_hyperplanes(type);  // number of positive roots

  fprintf(stderr, "Rank: %d\tOrder: %d\tPositive Roots: %d\tCosets: %d\n", rank, order, hyperplanes, cosets);
  fprintf(stderr, "\n");

  /*
  fprintf(stderr, "Shortest coset representatives: \n");
  for(int i = 0, wl = 0; i < cosets; i++) {
    if(i == 0) {
      fprintf(stderr, "1");
    } else if(graph[i].wordlength > wl) {
      fprintf(stderr, "\n%s ", alphabetize(graph[i].word, graph[i].wordlength, alphabet, string_buffer1));
      wl = graph[i].wordlength;
    } else
      fprintf(stderr, "%s ", alphabetize(graph[i].word, graph[i].wordlength, alphabet, string_buffer1));
  }
  fprintf(stderr, "\n\n");
  */

  fixpoints = 0;
  for(int i = 0; i < cosets; i++)
    if(graph[i].opposite == i) {
      if(fixpoints == 0)
	fprintf(stderr, "No thickenings since the longest element fixes the following cosets: %s", alphabetize(graph[i].word, graph[i].wordlength, alphabet, string_buffer1));
      else
	fprintf(stderr, " %s", alphabetize(graph[i].word, graph[i].wordlength, alphabet, string_buffer1));
      fixpoints++;
    }

  if(fixpoints > 0) {
    fprintf(stderr, "\n\n");
  } else {
    fwrite(&type.n, sizeof(int), 1, stdout);
    fwrite(type.factors, sizeof(simple_type_t), type.n, stdout);
    fwrite(&left_invariance, sizeof(unsigned long), type.n, stdout);
    fwrite(&right_invariance, sizeof(unsigned long), type.n, stdout);

    long count = enumerate_balanced_thickenings(graph, cosets, balanced_thickening_callback, (void*)0);

    fprintf(stderr, "Found %ld balanced thickenings\n\n", count);
  }

  graph_free(type, graph);
  free(type.factors);

  return 0;
}