enumerate-balanced-ideals/weyl.c

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

#include <stdio.h>
#include <memory.h>
#include <stdlib.h>

#define BIT(n) ((uint64_t)1 << (n))

typedef struct {
  weylid_t id;
  int position;
} weylid_lookup_t;

static int search(const void *key, const void *base, size_t nmem, size_t size, int (*compar) (const void *, const void *, void *), void *arg);
static int compare_root_vectors(int rank, const int *x, const int *y);
static int compare_root_vectors_qsort(const void *x, const void *y, void *arg);
static int compare_weylid_lookup(const void *x, const void *y);
static int lookup_id(weylid_t id, weylid_lookup_t *list, int len);
static weylid_t multiply_generator(int s, weylid_t w, const int *simple, const int *mapping, int rank, int positive);
static void reflect_root_vector(const int *cartan, int rank, int i, int *old, int *new);

/***************** simple helper functions **********************************/

// glibc search function, but with user pointer and returning index (or -1 if not found)
static int search (const void *key, const void *base, size_t nmemb, size_t size, int (*compar) (const void *, const void *, void *), void *arg)
{
  size_t l, u, idx;
  const void *p;
  int comparison;

  l = 0;
  u = nmemb;
  while (l < u) {
    idx = (l + u) / 2;
    p = (void *) (((const char *) base) + (idx * size));
    comparison = (*compar) (key, p, arg);
    if (comparison < 0)
      u = idx;
    else if (comparison > 0)
      l = idx + 1;
    else
      return idx;
  }

  return -1;
}

// maybe we want a different ordering here?
static int compare_root_vectors(int rank, const int *x, const int *y)
{
  for(int i = 0; i < rank; i++)
    if(x[i] != y[i])
      return x[i] - y[i];

  return 0;
}

static int compare_root_vectors_qsort(const void *x, const void *y, void *arg)
{
  return compare_root_vectors(*((int*)arg), x, y);
}

static int compare_weylid(const void *x, const void *y)
{
  weylid_t u = *((weylid_t*)x);
  weylid_t v = *((weylid_t*)y);

  return u > v ? 1 : u < v ? -1 : 0;
}

static int compare_weylid_lookup(const void *x, const void *y)
{
  weylid_t u = ((weylid_lookup_t*)x)->id;
  weylid_t v = ((weylid_lookup_t*)y)->id;

  return u > v ? 1 : u < v ? -1 : 0;
}

static int lookup_id(weylid_t id, weylid_lookup_t *list, int len)
{
  weylid_lookup_t key;
  key.id = id;
  weylid_lookup_t *p = (weylid_lookup_t*)bsearch(&key, list, len, sizeof(weylid_lookup_t), compare_weylid_lookup);
  return p->position;
}

static weylid_t multiply_generator(int s, weylid_t w, const int* simple, const int* mapping, int rank, int positive)
{
  weylid_t sw = 0;

  for(int i = 0; i < positive; i++) {
    if(w & BIT(i))
      if(mapping[i*rank+s] != -1)
	sw |= BIT(mapping[i*rank+s]);
  }

  if(w & BIT(simple[s]))
    return sw;
  else
    return sw | BIT(simple[s]);
}

static void reflect_root_vector(const int *cartan, int rank, int i, int *old, int *new)
{
  memcpy(new, old, rank*sizeof(int));
  for(int j = 0; j < rank; j++)
    new[i] -= cartan[i*rank + j]*old[j];
}

/************* Weyl group infos ************************/

int weyl_rank(semisimple_type_t type)
{
  int rank = 0;
  for(int i = 0; i < type.n; i++)
    rank += type.factors[i].rank;
  return rank;
}

int weyl_order(semisimple_type_t type)
{
  int order = 1;
  for(int i = 0; i < type.n; i++) {
    switch(type.factors[i].series) {

    case 'A':
      for(int j = 1; j <= type.factors[i].rank + 1; j++)
	order *= j;
      break;

    case 'B': case 'C':
      for(int j = 1; j <= type.factors[i].rank; j++)
	order *= 2*j;
      break;

    case 'D':
      for(int j = 2; j <= type.factors[i].rank; j++)
	order *= 2*j;
      break;

    case 'E':
      if(type.factors[i].rank == 6)
	order *= 51840;
      else if(type.factors[i].rank == 7)
	order *= 2903040;
      else if(type.factors[i].rank == 8)
	order *= 696729600;
      else
	ERROR(1, "A Weyl group of type %c%d does not exist or is not implemented!\n", type.factors[i].series, type.factors[i].rank);
      break;

    case 'F':
      ERROR(type.factors[i].rank != 4, "A Weyl group of type %c%d does not exist or is not implemented!\n", type.factors[i].series, type.factors[i].rank);
      order *= 1152;
      break;

    case 'G':
      ERROR(type.factors[i].rank != 2, "A Weyl group of type %c%d does not exist or is not implemented!\n", type.factors[i].series, type.factors[i].rank);
      order *= 12;
      break;

    default:
      ERROR(1, "A Weyl group of type %c%d does not exist or is not implemented!\n", type.factors[i].series, type.factors[i].rank);
    }
  }

  return order;
}

int weyl_hyperplanes(semisimple_type_t type)
{
  int hyperplanes = 0;

  for(int i = 0; i < type.n; i++) {
    switch(type.factors[i].series) {
    case 'A':
      hyperplanes += (type.factors[i].rank * (type.factors[i].rank + 1)) / 2;
      break;

    case 'B': case 'C':
      hyperplanes += type.factors[i].rank * type.factors[i].rank;
      break;

    case 'D':
      hyperplanes += type.factors[i].rank * (type.factors[i].rank - 1);
      break;

    case 'E':
      if(type.factors[i].rank == 6)
	hyperplanes += 36;
      else if(type.factors[i].rank == 7)
	hyperplanes += 63;
      else if(type.factors[i].rank == 8)
	hyperplanes += 120;
      else
	ERROR(1, "A Weyl group of type %c%d does not exist or is not implemented!\n", type.factors[i].series, type.factors[i].rank);
      break;

    case 'F':
      ERROR(type.factors[i].rank != 4, "A Weyl group of type %c%d does not exist or is not implemented!\n", type.factors[i].series, type.factors[i].rank);
      hyperplanes += 24;
      break;

    case 'G':
      ERROR(type.factors[i].rank != 2, "A Weyl group of type %c%d does not exist or is not implemented!\n", type.factors[i].series, type.factors[i].rank);
      hyperplanes += 6;
      break;

    default:
      ERROR(1, "A Weyl group of type %c%d does not exist or is not implemented!\n", type.factors[i].series, type.factors[i].rank);
    }
  }

  return hyperplanes;
}

int weyl_opposition(semisimple_type_t type, int simple_root)
{
  int offset = 0;
  int factor = 0;
  int r, iota_r;

  for(factor = 0; factor < type.n; factor++)
    if(simple_root < offset + type.factors[factor].rank)
      break;
    else
      offset += type.factors[factor].rank;
  r = simple_root - offset;

  switch(type.factors[factor].series) {
  case 'A':
    iota_r = type.factors[factor].rank - 1 - r;
    break;

  case 'B': case 'C':
    iota_r = r;
    break;

  case 'D':
    ERROR(1, "A Weyl group of type %c%d does not exist or is not implemented!\n", type.factors[factor].series, type.factors[factor].rank);
    break;

  case 'E':
    ERROR(1, "A Weyl group of type %c%d does not exist or is not implemented!\n", type.factors[factor].series, type.factors[factor].rank);
    break;

  case 'F':
    ERROR(1, "A Weyl group of type %c%d does not exist or is not implemented!\n", type.factors[factor].series, type.factors[factor].rank);
    break;

  case 'G':
    ERROR(1, "A Weyl group of type %c%d does not exist or is not implemented!\n", type.factors[factor].series, type.factors[factor].rank);
    break;

  default:
    ERROR(1, "A Weyl group of type %c%d does not exist or is not implemented!\n", type.factors[factor].series, type.factors[factor].rank);
  }

  return iota_r + offset;
}

void weyl_cartan_matrix(semisimple_type_t type, int *m)
{
  int offset = 0;
  int rank = weyl_rank(type);

  int **A = (int**)malloc(rank*sizeof(int*));

  memset(m, 0, rank*rank*sizeof(int));
  for(int i = 0; i < rank; i++)
    m[i*rank+i] = 2;

  for(int k = 0; k < type.n; k++) {
    for(int i = 0; i < type.factors[k].rank; i++)  // A is the submatrix corresponding to the current simple factor
      A[i] = &m[(i+offset)*rank + offset];

    switch(type.factors[k].series) {
    case 'A':
      for(int i = 1; i < type.factors[k].rank; i++) {
	A[i][i-1] = -1;
	A[i-1][i] = -1;
      }
      break;

    case 'B':        // not sure at all about the order of B and C
      if(type.factors[k].rank >= 2) {
	A[0][1] = -2;
	A[1][0] = -1;
      }
      for(int i = 2; i < type.factors[k].rank; i++) {
	A[i][i-1] = -1;
	A[i-1][i] = -1;
      }
      break;

    case 'C':
      if(type.factors[k].rank >= 2) {
	A[0][1] = -1;
	A[1][0] = -2;
      }
      for(int i = 2; i < type.factors[k].rank; i++) {
	A[i][i-1] = -1;
	A[i-1][i] = -1;
      }
      break;

    case 'D':
      ERROR(1, "A Weyl group of type %c%d does not exist or is not implemented!\n", type.factors[k].series, type.factors[k].rank);
      break;

    case 'E':
      ERROR(1, "A Weyl group of type %c%d does not exist or is not implemented!\n", type.factors[k].series, type.factors[k].rank);
      break;

    case 'F':
      ERROR(1, "A Weyl group of type %c%d does not exist or is not implemented!\n", type.factors[k].series, type.factors[k].rank);
      break;

    case 'G':
      ERROR(1, "A Weyl group of type %c%d does not exist or is not implemented!\n", type.factors[k].series, type.factors[k].rank);
      break;

    default:
      ERROR(1, "A Weyl group of type %c%d does not exist or is not implemented!\n", type.factors[k].series, type.factors[k].rank);
    }

    offset += type.factors[k].rank;
  }

  free(A);
}

/************ memory allocation ********************/

weylgroup_element_t *weyl_alloc(semisimple_type_t type)
{
  int rank = weyl_rank(type);
  int order = weyl_order(type);

  int *left = (int*)malloc(rank*order*sizeof(int));
  int *right = (int*)malloc(rank*order*sizeof(int));
  weylgroup_element_t *group = (weylgroup_element_t*)malloc(order*sizeof(weylgroup_element_t));

  for(int i = 0; i < order; i++) {
    group[i].left = &left[i*rank];
    group[i].right = &right[i*rank];
  }

  return group;
}

void weyl_free(weylgroup_element_t *x)
{
  free(x[0].left);
  free(x[0].right);
  free(x);
}

void weyl_generate(semisimple_type_t type, weylgroup_element_t *group)
{
  int rank, order, positive;
  queue_t queue;
  int current;
  int roots_known, elements, length_elements, nextids_count;
  int *cartan_matrix;
  int *root_vectors;
  int *vector;
  int *simple_roots;
  int *root_mapping;
  weylid_t *ids, *edges, *nextids;
  weylid_lookup_t *lookup;

  rank = weyl_rank(type);
  order = weyl_order(type);
  positive = weyl_hyperplanes(type);

  ERROR(positive > 64, "We can't handle root systems with more than 64 positive roots!\n");

  cartan_matrix =      (int*)malloc(rank*rank      *sizeof(int));
  root_vectors =       (int*)malloc(2*positive*rank*sizeof(int));
  vector =             (int*)malloc(rank           *sizeof(int));
  root_mapping =       (int*)malloc(positive*rank  *sizeof(int));
  simple_roots =       (int*)malloc(rank           *sizeof(int));
  ids =           (weylid_t*)malloc(order          *sizeof(weylid_t));
  edges =         (weylid_t*)malloc(rank*order     *sizeof(weylid_t));
  nextids =       (weylid_t*)malloc(rank*order     *sizeof(weylid_t));
  lookup = (weylid_lookup_t*)malloc(order          *sizeof(weylid_lookup_t));

  weyl_cartan_matrix(type, cartan_matrix);

  // enumerate roots
  memset(root_vectors, 0, 2*positive*rank*sizeof(int));

  // first the simple roots
  queue_init(&queue);
  for(int i = 0; i < rank; i++) {
    root_vectors[rank*i + i] = 1;
    queue_put(&queue, i);
  }

  // and then we get all others by reflecting
  roots_known = rank;
  while((current = queue_get(&queue)) != -1) {
    for(int i = 0; i < rank; i++) {
      reflect_root_vector(cartan_matrix, rank, i, &root_vectors[rank*current], vector);
      int j;
      for(j = 0; j < roots_known; j++)
	if(compare_root_vectors(rank, &root_vectors[rank*j], vector) == 0)
	  break;
      if(j == roots_known) {
	memcpy(&root_vectors[rank*roots_known], vector, rank*sizeof(int));
	queue_put(&queue, roots_known);
	roots_known++;
      }
    }
  }

  ERROR(roots_known != 2*positive, "Number of roots does not match!\n")

  // sort roots and restrict to positives
  qsort_r(root_vectors, 2*positive, rank*sizeof(int), compare_root_vectors_qsort, &rank);
  memcpy(root_vectors, &root_vectors[positive*rank], positive*rank*sizeof(int));

  for(int i = 0; i < positive; i++) {
    for(int j = 0; j < rank; j++) {
      reflect_root_vector(cartan_matrix, rank, j, &root_vectors[rank*i], vector);
      root_mapping[i*rank+j] =
	search(vector, root_vectors, positive, rank*sizeof(int), compare_root_vectors_qsort, &rank);
    }
  }

  // where in the list are the simple roots?
  for(int i = 0; i < rank; i++) {
    memset(vector, 0, rank*sizeof(int));
    vector[i] = 1;
    simple_roots[i] = search(vector, root_vectors, positive, rank*sizeof(int), compare_root_vectors_qsort, &rank);
  }

  // enumerate weyl group elements using difference sets
  nextids[0] = 0;
  nextids_count = 1;
  elements = 0;
  for(int len = 0; len <= positive; len++) {
    length_elements = 0;

    // find unique ids in edges added in the last iteration
    qsort(nextids, nextids_count, sizeof(weylid_t), compare_weylid);
    for(int i = 0; i < nextids_count; i++)
      if(i == 0 || nextids[i] != nextids[i-1])
	ids[elements + length_elements++] = nextids[i];

    // add new edges
    nextids_count = 0;
    for(int i = elements; i < elements + length_elements; i++)
      for(int j = 0; j < rank; j++) {
	edges[i*rank+j] = multiply_generator(j, ids[i], simple_roots, root_mapping, rank, positive);
	if(!(ids[i] & BIT(simple_roots[j]))) // the new element is longer then the old one
	  nextids[nextids_count++] = edges[i*rank+j];
      }

    elements += length_elements;
  }

  // translate the ids to list positions (i.e. local continuous ids)
  for(int i = 0; i < order; i++) {
    lookup[i].id = ids[i];
    lookup[i].position = i;
  }
  qsort(lookup, order, sizeof(weylid_lookup_t), compare_weylid_lookup);

  for(int i = 0; i < order; i++) {
    group[i].id = ids[i];
    for(int j = 0; j < rank; j++)
      group[i].left[j] = lookup_id(edges[i*rank+j], lookup, order);
  }

  free(cartan_matrix);
  free(root_vectors);
  free(vector);
  free(root_mapping);
  free(simple_roots);
  free(ids);
  free(edges);
  free(nextids);
  free(lookup);
}