Major rewrite
This commit is contained in:
parent
ab546946c8
commit
efd8e621ea
12
Makefile
12
Makefile
@ -6,20 +6,14 @@ SPECIAL_OPTIONS=-O3 -flto -funroll-loops -Winline
|
|||||||
|
|
||||||
OPTIONS=-m64 -march=native -std=gnu99 -D_GNU_SOURCE $(SPECIAL_OPTIONS)
|
OPTIONS=-m64 -march=native -std=gnu99 -D_GNU_SOURCE $(SPECIAL_OPTIONS)
|
||||||
|
|
||||||
all: generate process
|
all: enumerate
|
||||||
|
|
||||||
generate: generate.o weyl.o thickenings.o
|
enumerate: generate.o weyl.o thickenings.o
|
||||||
gcc $(OPTIONS) -o generate generate.o thickenings.o weyl.o
|
gcc $(OPTIONS) -o generate generate.o thickenings.o weyl.o
|
||||||
|
|
||||||
process: process.o weyl.o thickenings.o
|
|
||||||
gcc $(OPTIONS) -o process process.o thickenings.o weyl.o
|
|
||||||
|
|
||||||
generate.o: generate.c $(HEADERS)
|
generate.o: generate.c $(HEADERS)
|
||||||
gcc $(OPTIONS) -c generate.c
|
gcc $(OPTIONS) -c generate.c
|
||||||
|
|
||||||
process.o: process.c $(HEADERS)
|
|
||||||
gcc $(OPTIONS) -c process.c
|
|
||||||
|
|
||||||
thickenings.o: thickenings.c $(HEADERS)
|
thickenings.o: thickenings.c $(HEADERS)
|
||||||
gcc $(OPTIONS) -c thickenings.c
|
gcc $(OPTIONS) -c thickenings.c
|
||||||
|
|
||||||
@ -27,4 +21,4 @@ weyl.o: weyl.c $(HEADERS)
|
|||||||
gcc $(OPTIONS) -c weyl.c
|
gcc $(OPTIONS) -c weyl.c
|
||||||
|
|
||||||
clean:
|
clean:
|
||||||
rm -f generate process thickenings.o weyl.o generate.o process.o
|
rm -f generate thickenings.o weyl.o generate.o
|
||||||
|
143
generate.c
143
generate.c
@ -9,20 +9,27 @@ char stringbuffer[100];
|
|||||||
char stringbuffer2[100];
|
char stringbuffer2[100];
|
||||||
|
|
||||||
typedef struct {
|
typedef struct {
|
||||||
node_t *graph;
|
doublequotient_t *dq;
|
||||||
int cosets;
|
|
||||||
int rank;
|
int rank;
|
||||||
int order;
|
int order;
|
||||||
int hyperplanes;
|
int positive;
|
||||||
semisimple_type_t type;
|
|
||||||
unsigned long left_invariance;
|
|
||||||
unsigned long right_invariance;
|
|
||||||
const char *alphabet;
|
|
||||||
int *buffer;
|
int *buffer;
|
||||||
int level;
|
int level;
|
||||||
} info_t;
|
} info_t;
|
||||||
|
|
||||||
int shorten(int i, unsigned long left, unsigned long right, node_t *graph, int rank)
|
static char* alphabetize(weylgroup_element_t *e, char *str)
|
||||||
|
{
|
||||||
|
if(e->wordlength == 0)
|
||||||
|
sprintf(str, "1");
|
||||||
|
else
|
||||||
|
for(int j = 0; j < e->wordlength; j++)
|
||||||
|
sprintf(str, "%c", e->word[j] + 'a');
|
||||||
|
|
||||||
|
return str;
|
||||||
|
}
|
||||||
|
|
||||||
|
/*
|
||||||
|
int shorten(int i, unsigned long left, unsigned long right, doublequotient_t *dq, int rank)
|
||||||
{
|
{
|
||||||
int other, shorter = i;
|
int other, shorter = i;
|
||||||
do {
|
do {
|
||||||
@ -41,6 +48,7 @@ int shorten(int i, unsigned long left, unsigned long right, node_t *graph, int r
|
|||||||
|
|
||||||
return shorter;
|
return shorter;
|
||||||
}
|
}
|
||||||
|
*/
|
||||||
|
|
||||||
void balanced_thickening_callback(const bitvec_t *pos, int size, void *data)
|
void balanced_thickening_callback(const bitvec_t *pos, int size, void *data)
|
||||||
{
|
{
|
||||||
@ -57,8 +65,8 @@ void balanced_thickening_callback(const bitvec_t *pos, int size, void *data)
|
|||||||
for(int i = 0; i < size; i++) {
|
for(int i = 0; i < size; i++) {
|
||||||
bit1 = i < size/2 ? bv_get_bit(pos, i) : !bv_get_bit(pos, size - 1 - i);
|
bit1 = i < size/2 ? bv_get_bit(pos, i) : !bv_get_bit(pos, size - 1 - i);
|
||||||
for(int j = 0; j < info->rank; j++) {
|
for(int j = 0; j < info->rank; j++) {
|
||||||
left = info->graph[i].left[j];
|
left = info->dq->cosets[i].min->left[j]->coset - info->dq->cosets;
|
||||||
right = info->graph[i].right[j];
|
right = info->dq->cosets[i].min->right[j]->coset - info->dq->cosets;
|
||||||
bit2left = left < size/2 ? bv_get_bit(pos, left) : !bv_get_bit(pos, size - 1 - left);
|
bit2left = left < size/2 ? bv_get_bit(pos, left) : !bv_get_bit(pos, size - 1 - left);
|
||||||
bit2right = right < size/2 ? bv_get_bit(pos, right) : !bv_get_bit(pos, size - 1 - right);
|
bit2right = right < size/2 ? bv_get_bit(pos, right) : !bv_get_bit(pos, size - 1 - right);
|
||||||
if(bit1 != bit2left)
|
if(bit1 != bit2left)
|
||||||
@ -70,15 +78,16 @@ void balanced_thickening_callback(const bitvec_t *pos, int size, void *data)
|
|||||||
|
|
||||||
printf("%4d left: ", totcount++);
|
printf("%4d left: ", totcount++);
|
||||||
for(int j = 0; j < info->rank; j++)
|
for(int j = 0; j < info->rank; j++)
|
||||||
printf("%c", left_invariance & (1 << j) ? info->alphabet[j] : ' ');
|
printf("%c", left_invariance & (1 << j) ? j + 'a' : ' ');
|
||||||
printf(" right: ");
|
printf(" right: ");
|
||||||
for(int j = 0; j < info->rank; j++)
|
for(int j = 0; j < info->rank; j++)
|
||||||
printf("%c", right_invariance & (1 << j) ? info->alphabet[j] : ' ');
|
printf("%c", right_invariance & (1 << j) ? j + 'a' : ' ');
|
||||||
|
|
||||||
|
/*
|
||||||
if(info->buffer) {
|
if(info->buffer) {
|
||||||
printf(" generators:");
|
printf(" generators:");
|
||||||
queue_t queue;
|
queue_t queue;
|
||||||
int current, left, right, shortest;
|
int cur, left, right;
|
||||||
int *buffer = info->buffer;
|
int *buffer = info->buffer;
|
||||||
|
|
||||||
for(int i = 0; i < size/2; i++) {
|
for(int i = 0; i < size/2; i++) {
|
||||||
@ -87,32 +96,30 @@ void balanced_thickening_callback(const bitvec_t *pos, int size, void *data)
|
|||||||
}
|
}
|
||||||
for(int i = size-1; i >= 0; i--) {
|
for(int i = size-1; i >= 0; i--) {
|
||||||
if(buffer[i]) {
|
if(buffer[i]) {
|
||||||
int shortest = shorten(i, left_invariance, right_invariance, info->graph, info-> rank);
|
weylgroup_element_t *shortest = shorten(i, left_invariance, right_invariance, info->dq);
|
||||||
printf(" %s", alphabetize(info->graph[shortest].word,
|
printf(" %s", alphabetize(shortest, stringbuffer));
|
||||||
info->graph[shortest].wordlength,
|
|
||||||
info->alphabet,
|
|
||||||
stringbuffer));
|
|
||||||
buffer[i] = 0;
|
buffer[i] = 0;
|
||||||
queue_init(&queue);
|
queue_init(&queue);
|
||||||
queue_put(&queue, i);
|
queue_put(&queue, i);
|
||||||
while((current = queue_get(&queue)) != -1) {
|
while((cur = queue_get(&queue)) != -1) {
|
||||||
for(edgelist_t *edge = info->graph[current].bruhat_lower; edge != (edgelist_t*)0; edge = edge->next) {
|
for(doublecoset_list_t *current = info->dq->coset[cur].bruhat_lower; current; current = current->next) {
|
||||||
if(buffer[edge->to]) {
|
int idx = current->to - info->dq->cosets;
|
||||||
buffer[edge->to] = 0;
|
if(buffer[idx]) {
|
||||||
queue_put(&queue, edge->to);
|
buffer[idx] = 0;
|
||||||
|
queue_put(&queue, idx);
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
for(int j = 0; j < info->rank; j++) {
|
for(int j = 0; j < info->rank; j++) {
|
||||||
left = info->graph[current].left[j];
|
left = info->dq->coset[cur].min.left[j] - info->dq->cosets;
|
||||||
if(left_invariance & (1 << j) &&
|
if(left_invariance & (1 << j) &&
|
||||||
info->graph[left].wordlength < info->graph[current].wordlength &&
|
info->graph[left].wordlength < info->graph[cur].wordlength &&
|
||||||
buffer[left]) {
|
buffer[left]) {
|
||||||
buffer[left] = 0;
|
buffer[left] = 0;
|
||||||
queue_put(&queue, left);
|
queue_put(&queue, left);
|
||||||
}
|
}
|
||||||
right = info->graph[current].left[j];
|
right = info->graph[cur].left[j];
|
||||||
if(right_invariance & (1 << j) &&
|
if(right_invariance & (1 << j) &&
|
||||||
info->graph[right].wordlength < info->graph[current].wordlength &&
|
info->graph[right].wordlength < info->graph[cur].wordlength &&
|
||||||
buffer[right]) {
|
buffer[right]) {
|
||||||
buffer[right] = 0;
|
buffer[right] = 0;
|
||||||
queue_put(&queue, right);
|
queue_put(&queue, right);
|
||||||
@ -132,6 +139,7 @@ void balanced_thickening_callback(const bitvec_t *pos, int size, void *data)
|
|||||||
printf("]");
|
printf("]");
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
*/
|
||||||
|
|
||||||
printf("\n");
|
printf("\n");
|
||||||
}
|
}
|
||||||
@ -151,12 +159,11 @@ int main(int argc, const char *argv[])
|
|||||||
{
|
{
|
||||||
semisimple_type_t type;
|
semisimple_type_t type;
|
||||||
unsigned long right_invariance, left_invariance;
|
unsigned long right_invariance, left_invariance;
|
||||||
int rank, order, hyperplanes, cosets;
|
int rank, order, positive;
|
||||||
int fixpoints;
|
int fixpoints;
|
||||||
|
|
||||||
node_t *graph;
|
doublequotient_t *dq;
|
||||||
|
|
||||||
char string_buffer1[1000];
|
|
||||||
const char *alphabet = "abcdefghijklmnopqrstuvwxyz";
|
const char *alphabet = "abcdefghijklmnopqrstuvwxyz";
|
||||||
|
|
||||||
// read arguments
|
// read arguments
|
||||||
@ -190,10 +197,7 @@ int main(int argc, const char *argv[])
|
|||||||
|
|
||||||
// generate graph
|
// generate graph
|
||||||
|
|
||||||
graph = graph_alloc(type);
|
dq = weyl_generate_bruhat(type, left_invariance, right_invariance);
|
||||||
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
|
// print stuff
|
||||||
|
|
||||||
@ -203,7 +207,7 @@ int main(int argc, const char *argv[])
|
|||||||
|
|
||||||
rank = weyl_rank(type); // number of simple roots
|
rank = weyl_rank(type); // number of simple roots
|
||||||
order = weyl_order(type); // number of Weyl group elements
|
order = weyl_order(type); // number of Weyl group elements
|
||||||
hyperplanes = weyl_hyperplanes(type); // number of positive roots
|
positive = weyl_positive(type); // number of positive roots
|
||||||
|
|
||||||
if(output_level >= 1) {
|
if(output_level >= 1) {
|
||||||
if(left_invariance) {
|
if(left_invariance) {
|
||||||
@ -226,59 +230,48 @@ int main(int argc, const char *argv[])
|
|||||||
}
|
}
|
||||||
fprintf(stdout, "\n");
|
fprintf(stdout, "\n");
|
||||||
|
|
||||||
fprintf(stdout, "Rank: %d\tOrder: %d\tPositive Roots: %d\tCosets: %d\n\n", rank, order, hyperplanes, cosets);
|
fprintf(stdout, "Rank: %d\tOrder: %d\tPositive Roots: %d\tCosets: %d\n\n", rank, order, positive, dq->count);
|
||||||
}
|
}
|
||||||
|
|
||||||
if(output_level >= 3) {
|
if(output_level >= 3) {
|
||||||
fprintf(stdout, "Shortest coset representatives: \n");
|
fprintf(stdout, "Shortest coset representatives: \n");
|
||||||
for(int i = 0, wl = 0; i < cosets; i++) {
|
for(int i = 0, wl = 0; i < dq->count; i++) {
|
||||||
if(i == 0) {
|
if(dq->cosets[i].min->wordlength > wl) {
|
||||||
fprintf(stdout, "1");
|
printf("\n");
|
||||||
} else if(graph[i].wordlength > wl) {
|
wl = dq->cosets[i].min->wordlength;
|
||||||
fprintf(stdout, "\n%s ", alphabetize(graph[i].word, graph[i].wordlength, alphabet, string_buffer1));
|
}
|
||||||
wl = graph[i].wordlength;
|
fprintf(stdout, "\n%s ", alphabetize(dq->cosets[i].min, stringbuffer));
|
||||||
} else
|
|
||||||
fprintf(stdout, "%s ", alphabetize(graph[i].word, graph[i].wordlength, alphabet, string_buffer1));
|
|
||||||
}
|
}
|
||||||
fprintf(stdout, "\n\n");
|
fprintf(stdout, "\n\n");
|
||||||
}
|
}
|
||||||
|
|
||||||
if(output_level >= 4) {
|
if(output_level >= 4) {
|
||||||
edgelist_t *edge;
|
|
||||||
fprintf(stdout, "Bruhat order in graphviz format:\n");
|
fprintf(stdout, "Bruhat order in graphviz format:\n");
|
||||||
fprintf(stdout, "digraph test123 {\n");
|
fprintf(stdout, "digraph test123 {\n");
|
||||||
for(int i = 0; i < cosets; i++) {
|
for(int i = 0; i < dq->count; i++)
|
||||||
edge = graph[i].bruhat_lower;
|
for(doublecoset_list_t *current = dq->cosets[i].bruhat_lower; current; current = current->next)
|
||||||
while(edge) {
|
|
||||||
fprintf(stdout, "%s -> %s;\n",
|
fprintf(stdout, "%s -> %s;\n",
|
||||||
alphabetize(graph[i].word, graph[i].wordlength, alphabet, stringbuffer),
|
alphabetize(dq->cosets[i].min, stringbuffer),
|
||||||
alphabetize(graph[edge->to].word, graph[edge->to].wordlength, alphabet, stringbuffer2));
|
alphabetize(current->to->min, stringbuffer2));
|
||||||
|
|
||||||
edge = edge->next;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
fprintf(stdout, "}\n\n");
|
fprintf(stdout, "}\n\n");
|
||||||
}
|
}
|
||||||
|
|
||||||
if(output_level >= 4) {
|
if(output_level >= 4) {
|
||||||
fprintf(stdout, "Opposites:\n");
|
fprintf(stdout, "Opposites:\n");
|
||||||
for(int i = 0; i < cosets; i++) {
|
for(int i = 0; i < dq->count; i++)
|
||||||
fprintf(stdout, "%s <-> %s\n",
|
fprintf(stdout, "%s <-> %s\n",
|
||||||
alphabetize(graph[i].word, graph[i].wordlength, alphabet, stringbuffer),
|
alphabetize(dq->cosets[i].min, stringbuffer),
|
||||||
alphabetize(graph[graph[i].opposite].word, graph[graph[i].opposite].wordlength, alphabet, stringbuffer2));
|
alphabetize(dq->cosets[i].opposite->min, stringbuffer2));
|
||||||
|
|
||||||
}
|
|
||||||
fprintf(stdout, "\n");
|
fprintf(stdout, "\n");
|
||||||
}
|
}
|
||||||
|
|
||||||
fixpoints = 0;
|
fixpoints = 0;
|
||||||
for(int i = 0; i < cosets; i++)
|
for(int i = 0; i < dq->count; i++)
|
||||||
if(graph[i].opposite == i) {
|
if(dq->cosets[i].opposite == &dq->cosets[i]) {
|
||||||
if(output_level >= 1) {
|
if(output_level >= 1) {
|
||||||
if(fixpoints == 0)
|
if(fixpoints == 0)
|
||||||
fprintf(stdout, "No thickenings since the longest element fixes the following cosets: %s", alphabetize(graph[i].word, graph[i].wordlength, alphabet, string_buffer1));
|
fprintf(stdout, "No thickenings since the longest element fixes the following cosets:");
|
||||||
else
|
fprintf(stdout, " %s", alphabetize(dq->cosets[i].min, stringbuffer));
|
||||||
fprintf(stdout, " %s", alphabetize(graph[i].word, graph[i].wordlength, alphabet, string_buffer1));
|
|
||||||
}
|
}
|
||||||
fixpoints++;
|
fixpoints++;
|
||||||
}
|
}
|
||||||
@ -287,37 +280,31 @@ int main(int argc, const char *argv[])
|
|||||||
|
|
||||||
|
|
||||||
if(!fixpoints) {
|
if(!fixpoints) {
|
||||||
int *buffer = (int*)malloc(cosets*sizeof(int));
|
int *buffer = (int*)malloc(dq->count*sizeof(int));
|
||||||
|
|
||||||
info_t info;
|
info_t info;
|
||||||
info.graph = graph;
|
info.dq = dq;
|
||||||
info.cosets = cosets;
|
info.rank = weyl_rank(type);
|
||||||
info.rank = rank;
|
info.order = weyl_order(type);
|
||||||
info.order = order;
|
info.positive = weyl_positive(type);
|
||||||
info.hyperplanes = hyperplanes;
|
|
||||||
info.type = type;
|
|
||||||
info.left_invariance = left_invariance;
|
|
||||||
info.right_invariance = right_invariance;
|
|
||||||
info.alphabet = alphabet;
|
|
||||||
info.buffer = buffer;
|
info.buffer = buffer;
|
||||||
info.level = output_level;
|
info.level = output_level;
|
||||||
|
|
||||||
long count;
|
long count;
|
||||||
if(output_level >= 2) {
|
if(output_level >= 2) {
|
||||||
fprintf(stdout, "Balanced ideals:\n", count);
|
fprintf(stdout, "Balanced ideals:\n", count);
|
||||||
count = enumerate_balanced_thickenings(graph, cosets, balanced_thickening_callback, &info);
|
count = enumerate_balanced_thickenings(dq, balanced_thickening_callback, &info);
|
||||||
fprintf(stdout, "\n", count);
|
fprintf(stdout, "\n", count);
|
||||||
} else {
|
} else {
|
||||||
long outputcount = 0;
|
long outputcount = 0;
|
||||||
count = enumerate_balanced_thickenings(graph, cosets, balanced_thickening_simple_callback, &outputcount);
|
count = enumerate_balanced_thickenings(dq, balanced_thickening_simple_callback, &outputcount);
|
||||||
}
|
}
|
||||||
|
|
||||||
|
|
||||||
if(output_level >= 1)
|
if(output_level >= 1)
|
||||||
fprintf(stdout, "Found %ld balanced ideal%s\n", count, count == 1 ? "" : "s");
|
fprintf(stdout, "Found %ld balanced ideal%s\n", count, count == 1 ? "" : "s");
|
||||||
}
|
}
|
||||||
|
|
||||||
graph_free(type, graph);
|
weyl_destroy_bruhat(dq);
|
||||||
free(type.factors);
|
free(type.factors);
|
||||||
|
|
||||||
return 0;
|
return 0;
|
||||||
|
629
thickenings.c
629
thickenings.c
@ -8,606 +8,6 @@
|
|||||||
#include "weyl.h"
|
#include "weyl.h"
|
||||||
#include "queue.h"
|
#include "queue.h"
|
||||||
|
|
||||||
char *alphabetize(int *word, int len, const char *alphabet, char *buffer)
|
|
||||||
{
|
|
||||||
if(len == 0) {
|
|
||||||
buffer[0] = '1';
|
|
||||||
buffer[1] = 0;
|
|
||||||
return buffer;
|
|
||||||
}
|
|
||||||
|
|
||||||
int i = 0;
|
|
||||||
for(i = 0; i < len; i++)
|
|
||||||
buffer[i] = alphabet[word[i]];
|
|
||||||
buffer[i] = 0;
|
|
||||||
|
|
||||||
return buffer;
|
|
||||||
}
|
|
||||||
|
|
||||||
void print_thickening(int rank, int order, const signed char *thickening, int upto_level, const char *alphabet, FILE *f)
|
|
||||||
{
|
|
||||||
for(int i = 0; i < order; i++) {
|
|
||||||
if(thickening[i] == HEAD_MARKER)
|
|
||||||
fprintf(f, "\e[41;37mx\e[0m");
|
|
||||||
else if(thickening[i] < - upto_level || thickening[i] > upto_level)
|
|
||||||
fprintf(f, " ");
|
|
||||||
else if(thickening[i] < 0 && thickening[i] > -10)
|
|
||||||
fprintf(f, "\e[47;30m%d\e[0m", -thickening[i]);
|
|
||||||
else if(thickening[i] <= -10)
|
|
||||||
fprintf(f, "\e[47;30m+\e[0m");
|
|
||||||
else if(thickening[i] > 0 && thickening[i] < 10)
|
|
||||||
fprintf(f, "\e[40;37m%d\e[0m", thickening[i]);
|
|
||||||
else if(thickening[i] >= 10)
|
|
||||||
fprintf(f, "\e[40;37m+\e[0m");
|
|
||||||
else
|
|
||||||
fprintf(f, " ");
|
|
||||||
}
|
|
||||||
|
|
||||||
fprintf(f, "\e[K");
|
|
||||||
}
|
|
||||||
|
|
||||||
static int compare_wordlength(const void *a, const void *b, void *gr)
|
|
||||||
{
|
|
||||||
int i = *((int*)a);
|
|
||||||
int j = *((int*)b);
|
|
||||||
node_t *graph = (node_t*)gr;
|
|
||||||
|
|
||||||
return graph[i].wordlength - graph[j].wordlength;
|
|
||||||
}
|
|
||||||
|
|
||||||
void prepare_graph(semisimple_type_t type, node_t *graph)
|
|
||||||
{
|
|
||||||
queue_t queue;
|
|
||||||
|
|
||||||
edgelist_t *edgelists_lower, *edgelists_higher;
|
|
||||||
int rank, order, hyperplanes;
|
|
||||||
edgelist_t *edge, *previous;
|
|
||||||
int edgelist_count, hyperplane_count;
|
|
||||||
int current;
|
|
||||||
|
|
||||||
weylgroup_element_t *graph_data;
|
|
||||||
node_t *graph_unsorted;
|
|
||||||
int *ordering, *reverse_ordering, *seen;
|
|
||||||
|
|
||||||
// initialize
|
|
||||||
|
|
||||||
rank = weyl_rank(type);
|
|
||||||
order = weyl_order(type);
|
|
||||||
hyperplanes = weyl_hyperplanes(type);
|
|
||||||
|
|
||||||
edgelists_higher = graph[0].bruhat_higher;
|
|
||||||
edgelists_lower = &graph[0].bruhat_higher[order*hyperplanes/2];
|
|
||||||
|
|
||||||
graph_data = weyl_alloc(type);
|
|
||||||
graph_unsorted = (node_t*)malloc(order*sizeof(node_t));
|
|
||||||
ordering = (int*)malloc(order*sizeof(int));
|
|
||||||
reverse_ordering = (int*)malloc(order*sizeof(int));
|
|
||||||
seen = (int*)malloc(order*sizeof(int));
|
|
||||||
|
|
||||||
for(int i = 0; i < order; i++) {
|
|
||||||
graph_unsorted[i].wordlength = INT_MAX;
|
|
||||||
graph[i].bruhat_lower = 0;
|
|
||||||
graph[i].bruhat_higher = 0;
|
|
||||||
graph[i].is_hyperplane_reflection = 0;
|
|
||||||
}
|
|
||||||
|
|
||||||
LOG("Generate Weyl group.\n");
|
|
||||||
|
|
||||||
weyl_generate(type, graph_data);
|
|
||||||
|
|
||||||
for(int i = 0; i < order; i++)
|
|
||||||
for(int j = 0; j < rank; j++) {
|
|
||||||
graph_unsorted[i].left = graph_data[i].left;
|
|
||||||
graph_unsorted[i].id = graph_data[i].id;
|
|
||||||
}
|
|
||||||
|
|
||||||
// find wordlengths
|
|
||||||
|
|
||||||
LOG("Determine word lengths.\n");
|
|
||||||
|
|
||||||
graph_unsorted[0].wordlength = 0;
|
|
||||||
queue_init(&queue);
|
|
||||||
queue_put(&queue, 0);
|
|
||||||
while((current = queue_get(&queue)) != -1) {
|
|
||||||
for(int i = 0; i < rank; i++) {
|
|
||||||
int neighbor = graph_unsorted[current].left[i];
|
|
||||||
if(graph_unsorted[neighbor].wordlength > graph_unsorted[current].wordlength + 1) {
|
|
||||||
graph_unsorted[neighbor].wordlength = graph_unsorted[current].wordlength + 1;
|
|
||||||
queue_put(&queue, neighbor);
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
LOG("Sort by wordlength.\n");
|
|
||||||
|
|
||||||
for(int i = 0; i < order; i++)
|
|
||||||
ordering[i] = i;
|
|
||||||
qsort_r(ordering, order, sizeof(int), compare_wordlength, graph_unsorted); // so ordering is a map new index -> old index
|
|
||||||
for(int i = 0; i < order; i++)
|
|
||||||
reverse_ordering[ordering[i]] = i; // reverse_ordering is a map old index -> new index
|
|
||||||
for(int i = 0; i < order; i++) {
|
|
||||||
// we have only set left, wordlength and id so far, so just copy these
|
|
||||||
graph[i].wordlength = graph_unsorted[ordering[i]].wordlength;
|
|
||||||
graph[i].id = graph_unsorted[ordering[i]].id;
|
|
||||||
for(int j = 0; j < rank; j++)
|
|
||||||
graph[i].left[j] = reverse_ordering[graph_unsorted[ordering[i]].left[j]]; // rewrite references
|
|
||||||
}
|
|
||||||
|
|
||||||
LOG("Find shortest words.\n");
|
|
||||||
|
|
||||||
for(int i = 0; i < order; i++)
|
|
||||||
memset(graph[i].word, 0, hyperplanes*sizeof(int));
|
|
||||||
queue_init(&queue);
|
|
||||||
queue_put(&queue, 0);
|
|
||||||
while((current = queue_get(&queue)) != -1) {
|
|
||||||
for(int i = 0; i < rank; i++) {
|
|
||||||
int neighbor = graph[current].left[i];
|
|
||||||
if(graph[neighbor].wordlength == graph[current].wordlength + 1 && graph[neighbor].word[0] == 0) {
|
|
||||||
memcpy(&graph[neighbor].word[1], &graph[current].word[0], graph[current].wordlength*sizeof(int));
|
|
||||||
graph[neighbor].word[0] = i;
|
|
||||||
queue_put(&queue, neighbor);
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
LOG("Generate right edges.\n");
|
|
||||||
|
|
||||||
for(int i = 0; i < order; i++) {
|
|
||||||
for(int j = 0; j < rank; j++) {
|
|
||||||
current = graph[0].left[j];
|
|
||||||
for(int k = graph[i].wordlength - 1; k >= 0; k--) { // apply group element from right to left
|
|
||||||
current = graph[current].left[graph[i].word[k]];
|
|
||||||
}
|
|
||||||
graph[i].right[j] = current;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
LOG("Find opposites.\n");
|
|
||||||
|
|
||||||
node_t *longest = &graph[order-1];
|
|
||||||
for(int i = 0; i < order; i++) {
|
|
||||||
current = i;
|
|
||||||
for(int k = longest->wordlength - 1; k >= 0; k--)
|
|
||||||
current = graph[current].left[longest->word[k]];
|
|
||||||
graph[i].opposite = current;
|
|
||||||
}
|
|
||||||
|
|
||||||
LOG("Enumerate hyperplanes.\n");
|
|
||||||
|
|
||||||
hyperplane_count = 0;
|
|
||||||
for(int i = 0; i < order; i++) {
|
|
||||||
for(int j = 0; j < rank; j++) {
|
|
||||||
current = 0;
|
|
||||||
int *word1 = graph[i].word;
|
|
||||||
int word1len = graph[i].wordlength;
|
|
||||||
int *word2 = graph[graph[i].right[j]].word; // want to calculate word2 * word1^{-1}
|
|
||||||
int word2len = graph[graph[i].right[j]].wordlength;
|
|
||||||
for(int k = 0; k < word1len; k++) // apply inverse, i.e. go from left to right
|
|
||||||
current = graph[current].left[word1[k]];
|
|
||||||
for(int k = word2len - 1; k >= 0; k--) // now from right to left
|
|
||||||
current = graph[current].left[word2[k]];
|
|
||||||
if(graph[current].is_hyperplane_reflection == 0) {
|
|
||||||
graph[current].is_hyperplane_reflection = 1;
|
|
||||||
hyperplane_count++;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
LOG("Determine Bruhat order.\n");
|
|
||||||
|
|
||||||
edgelist_count = 0;
|
|
||||||
for(int i = 0; i < order; i++) {
|
|
||||||
if(graph[i].is_hyperplane_reflection) {
|
|
||||||
for(int j = 0; j < order; j++) {
|
|
||||||
|
|
||||||
current = j;
|
|
||||||
for(int k = graph[i].wordlength - 1; k >= 0; k--) // apply hyperplane reflection
|
|
||||||
current = graph[current].left[graph[i].word[k]];
|
|
||||||
|
|
||||||
if(graph[j].wordlength < graph[current].wordlength) { // current has higher bruhat order than j
|
|
||||||
edgelists_lower[edgelist_count].to = j;
|
|
||||||
edgelists_lower[edgelist_count].next = graph[current].bruhat_lower;
|
|
||||||
graph[current].bruhat_lower = &edgelists_lower[edgelist_count];
|
|
||||||
edgelist_count++;
|
|
||||||
} else if(graph[j].wordlength > graph[current].wordlength) { // j has higher bruhat order than current; these are already included from the other side
|
|
||||||
} else {
|
|
||||||
ERROR(1, "Chambers of equal word lengths should not be folded on each other!\n");
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
LOG("Perform transitive reduction.\n");
|
|
||||||
|
|
||||||
for(int i = 0; i < order; i++) {
|
|
||||||
memset(seen, 0, order*sizeof(int));
|
|
||||||
queue_init(&queue);
|
|
||||||
|
|
||||||
for(int len = 1; len <= graph[i].wordlength; len++) {
|
|
||||||
// remove all edges originating from i of length len which connect to something already seen using shorter edges
|
|
||||||
edge = graph[i].bruhat_lower;
|
|
||||||
previous = (edgelist_t*)0;
|
|
||||||
|
|
||||||
while(edge) {
|
|
||||||
if(graph[i].wordlength - graph[edge->to].wordlength != len) {
|
|
||||||
previous = edge;
|
|
||||||
} else if(seen[edge->to]) {
|
|
||||||
if(previous)
|
|
||||||
previous->next = edge->next;
|
|
||||||
else
|
|
||||||
graph[i].bruhat_lower = edge->next;
|
|
||||||
} else {
|
|
||||||
previous = edge;
|
|
||||||
seen[edge->to] = 1;
|
|
||||||
queue_put(&queue, edge->to);
|
|
||||||
}
|
|
||||||
edge = edge->next;
|
|
||||||
}
|
|
||||||
|
|
||||||
// see which nodes we can reach using only edges up to length len, mark them as seen
|
|
||||||
while((current = queue_get(&queue)) != -1) {
|
|
||||||
edge = graph[current].bruhat_lower;
|
|
||||||
while(edge) {
|
|
||||||
if(!seen[edge->to]) {
|
|
||||||
seen[edge->to] = 1;
|
|
||||||
queue_put(&queue, edge->to);
|
|
||||||
}
|
|
||||||
edge = edge->next;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
LOG("Revert Bruhat order.\n");
|
|
||||||
|
|
||||||
edgelist_count = 0;
|
|
||||||
for(int i = 0; i < order; i++) {
|
|
||||||
edge = graph[i].bruhat_lower;
|
|
||||||
while(edge) {
|
|
||||||
edgelists_higher[edgelist_count].to = i;
|
|
||||||
edgelists_higher[edgelist_count].next = graph[edge->to].bruhat_higher;
|
|
||||||
graph[edge->to].bruhat_higher = &edgelists_higher[edgelist_count];
|
|
||||||
edgelist_count++;
|
|
||||||
edge = edge->next;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
LOG("Sort opposites.\n");
|
|
||||||
|
|
||||||
// additional sorting step to force opposite property (opposite of j is at n - j - 1)
|
|
||||||
|
|
||||||
for(int i = 0; i < order; i++)
|
|
||||||
reverse_ordering[i] = -1;
|
|
||||||
for(int i = 0, j = 0; i < order; i++) { // i = old index, j = new index
|
|
||||||
if(reverse_ordering[i] == -1) {
|
|
||||||
reverse_ordering[i] = j;
|
|
||||||
ordering[j] = i;
|
|
||||||
reverse_ordering[graph[i].opposite] = order - j - 1;
|
|
||||||
ordering[order - j - 1] = graph[i].opposite;
|
|
||||||
j++;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
memcpy(graph_unsorted, graph, order*sizeof(node_t));
|
|
||||||
for(int i = 0; i < order; i++) {
|
|
||||||
graph[i] = graph_unsorted[ordering[i]];
|
|
||||||
graph[i].opposite = reverse_ordering[graph[i].opposite];
|
|
||||||
for(int j = 0; j < rank; j++) {
|
|
||||||
graph[i].left[j] = reverse_ordering[graph[i].left[j]];
|
|
||||||
graph[i].right[j] = reverse_ordering[graph[i].right[j]];
|
|
||||||
}
|
|
||||||
for(edge = graph[i].bruhat_lower; edge; edge = edge->next)
|
|
||||||
edge->to = reverse_ordering[edge->to];
|
|
||||||
for(edge = graph[i].bruhat_higher; edge; edge = edge->next)
|
|
||||||
edge->to = reverse_ordering[edge->to];
|
|
||||||
}
|
|
||||||
|
|
||||||
weyl_free(graph_data);
|
|
||||||
free(graph_unsorted);
|
|
||||||
free(ordering);
|
|
||||||
free(reverse_ordering);
|
|
||||||
free(seen);
|
|
||||||
}
|
|
||||||
|
|
||||||
static int edgelist_contains(edgelist_t *list, int x) {
|
|
||||||
while(list) {
|
|
||||||
if(list->to == x)
|
|
||||||
return 1;
|
|
||||||
list = list->next;
|
|
||||||
}
|
|
||||||
return 0;
|
|
||||||
}
|
|
||||||
|
|
||||||
static edgelist_t *edgelist_add(edgelist_t *list, int new, edgelist_t *storage, int *storage_index)
|
|
||||||
{
|
|
||||||
edgelist_t *new_link = &storage[*storage_index];
|
|
||||||
new_link->next = list;
|
|
||||||
new_link->to = new;
|
|
||||||
(*storage_index)++;
|
|
||||||
return new_link;
|
|
||||||
}
|
|
||||||
|
|
||||||
int prepare_simplified_graph(semisimple_type_t type, unsigned long left, unsigned long right, node_t *simplified_graph)
|
|
||||||
{
|
|
||||||
node_t *full_graph;
|
|
||||||
int edgelists_used;
|
|
||||||
int rank, order, hyperplanes;
|
|
||||||
int *reduced, *group, *simplified;
|
|
||||||
int *seen;
|
|
||||||
int current;
|
|
||||||
edgelist_t *edge, *previous;
|
|
||||||
queue_t queue;
|
|
||||||
int ncosets;
|
|
||||||
|
|
||||||
rank = weyl_rank(type);
|
|
||||||
order = weyl_order(type);
|
|
||||||
hyperplanes = weyl_hyperplanes(type);
|
|
||||||
|
|
||||||
for(int i = 0; i < rank; i++) {
|
|
||||||
int oppi = weyl_opposition(type, i);
|
|
||||||
if(left & BIT(i) && !(left & BIT(oppi)) ||
|
|
||||||
left & BIT(oppi) && !(left & BIT(i)))
|
|
||||||
return -1;
|
|
||||||
}
|
|
||||||
|
|
||||||
edgelist_t *edgelists_higher = &simplified_graph[0].bruhat_higher[0];
|
|
||||||
edgelist_t *edgelists_lower = &simplified_graph[0].bruhat_higher[order*hyperplanes/2];
|
|
||||||
|
|
||||||
// get full graph
|
|
||||||
|
|
||||||
full_graph = graph_alloc(type);
|
|
||||||
prepare_graph(type, full_graph);
|
|
||||||
|
|
||||||
LOG("Full graph generated.\n");
|
|
||||||
|
|
||||||
// initialize stuff
|
|
||||||
|
|
||||||
reduced = (int*)malloc(order*sizeof(int));
|
|
||||||
group = (int*)malloc(order*sizeof(int));
|
|
||||||
simplified = (int*)malloc(order*sizeof(int));
|
|
||||||
for(int i = 0; i < order; i++) {
|
|
||||||
group[i] = -1;
|
|
||||||
reduced[i] = i;
|
|
||||||
}
|
|
||||||
|
|
||||||
LOG("Group by double coset.\n");
|
|
||||||
|
|
||||||
// step 1: group
|
|
||||||
for(int i = 0; i < order; i++) {
|
|
||||||
if(group[i] != -1)
|
|
||||||
continue;
|
|
||||||
|
|
||||||
queue_init(&queue);
|
|
||||||
queue_put(&queue, i);
|
|
||||||
while((current = queue_get(&queue)) != -1) {
|
|
||||||
if(group[current] != -1)
|
|
||||||
continue;
|
|
||||||
group[current] = i;
|
|
||||||
|
|
||||||
for(int j = 0; j < rank; j++) {
|
|
||||||
if(left & (1 << j))
|
|
||||||
queue_put(&queue, full_graph[current].left[j]);
|
|
||||||
if(right & (1 << j))
|
|
||||||
queue_put(&queue, full_graph[current].right[j]);
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
LOG("Find minimal length elements.\n");
|
|
||||||
|
|
||||||
// step 2: find minimum
|
|
||||||
for(int i = 0; i < order; i++)
|
|
||||||
if(full_graph[i].wordlength < full_graph[reduced[group[i]]].wordlength)
|
|
||||||
reduced[group[i]] = i;
|
|
||||||
|
|
||||||
// step 3: assign minimum to all
|
|
||||||
for(int i = 0; i < order; i++)
|
|
||||||
reduced[i] = reduced[group[i]];
|
|
||||||
|
|
||||||
// step 4: assign indices to cosets
|
|
||||||
ncosets = 0;
|
|
||||||
for(int i = 0; i < order; i++)
|
|
||||||
if(reduced[i] == i)
|
|
||||||
simplified[i] = ncosets++;
|
|
||||||
|
|
||||||
for(int i = 0; i < order; i++)
|
|
||||||
simplified[i] = simplified[reduced[i]];
|
|
||||||
|
|
||||||
seen = (int*) malloc(ncosets*sizeof(int));
|
|
||||||
edgelists_used = 0;
|
|
||||||
|
|
||||||
LOG("Copy minimal elements.\n");
|
|
||||||
|
|
||||||
// step 5: set up nodes from minima
|
|
||||||
current = 0;
|
|
||||||
for(int i = 0; i < order; i++)
|
|
||||||
if(reduced[i] == i) { // is minimum
|
|
||||||
memcpy(simplified_graph[simplified[i]].word, full_graph[i].word, full_graph[i].wordlength*sizeof(int));
|
|
||||||
simplified_graph[simplified[i]].wordlength = full_graph[i].wordlength;
|
|
||||||
simplified_graph[simplified[i]].opposite = simplified[full_graph[i].opposite];
|
|
||||||
simplified_graph[simplified[i]].id = full_graph[i].id;
|
|
||||||
simplified_graph[simplified[i]].bruhat_lower = (edgelist_t*)0;
|
|
||||||
simplified_graph[simplified[i]].bruhat_higher = (edgelist_t*)0;
|
|
||||||
for(int j = 0; j < rank; j++) {
|
|
||||||
simplified_graph[simplified[i]].left[j] = simplified[full_graph[i].left[j]];
|
|
||||||
simplified_graph[simplified[i]].right[j] = simplified[full_graph[i].right[j]];
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
LOG("Find induced order.\n");
|
|
||||||
|
|
||||||
// step 6: find order relations
|
|
||||||
for(int i = 0; i < order; i++) {
|
|
||||||
edge = full_graph[i].bruhat_lower;
|
|
||||||
while(edge) {
|
|
||||||
int this = simplified[i];
|
|
||||||
int that = simplified[edge->to];
|
|
||||||
if(this != that) {
|
|
||||||
// found something
|
|
||||||
if(!edgelist_contains(simplified_graph[this].bruhat_lower, that))
|
|
||||||
simplified_graph[this].bruhat_lower = edgelist_add(simplified_graph[this].bruhat_lower, that, edgelists_lower, &edgelists_used);
|
|
||||||
ERROR(simplified_graph[this].wordlength <= simplified_graph[that].wordlength, "The order assumption is being violated!\n");
|
|
||||||
}
|
|
||||||
edge = edge->next;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
LOG("Perform transitive reduction.\n");
|
|
||||||
|
|
||||||
// step 7: remove redundant edges
|
|
||||||
for(int i = 0; i < ncosets; i++) {
|
|
||||||
memset(seen, 0, ncosets*sizeof(int));
|
|
||||||
queue_init(&queue);
|
|
||||||
|
|
||||||
for(int len = 1; len <= simplified_graph[i].wordlength; len++) {
|
|
||||||
edge = simplified_graph[i].bruhat_lower;
|
|
||||||
previous = (edgelist_t*)0;
|
|
||||||
|
|
||||||
while(edge) {
|
|
||||||
// only look at edges of this length now
|
|
||||||
if(simplified_graph[i].wordlength - simplified_graph[edge->to].wordlength != len) {
|
|
||||||
// we only consider edges of length len in this pass
|
|
||||||
previous = edge;
|
|
||||||
} else if(seen[edge->to]) {
|
|
||||||
// this edge is redundant, remove it
|
|
||||||
if(previous)
|
|
||||||
previous->next = edge->next;
|
|
||||||
else
|
|
||||||
simplified_graph[i].bruhat_lower = edge->next;
|
|
||||||
} else {
|
|
||||||
// this edge was not redundant, add to seen
|
|
||||||
previous = edge;
|
|
||||||
seen[edge->to] = 1;
|
|
||||||
queue_put(&queue, edge->to);
|
|
||||||
}
|
|
||||||
edge = edge->next;
|
|
||||||
}
|
|
||||||
|
|
||||||
// calculate transitive closure of seen nodes
|
|
||||||
while((current = queue_get(&queue)) != -1) {
|
|
||||||
edge = simplified_graph[current].bruhat_lower;
|
|
||||||
while(edge) {
|
|
||||||
if(!seen[edge->to]) {
|
|
||||||
seen[edge->to] = 1;
|
|
||||||
queue_put(&queue, edge->to);
|
|
||||||
}
|
|
||||||
edge = edge->next;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
LOG("Revert order.\n");
|
|
||||||
|
|
||||||
// step 8: revert order
|
|
||||||
edgelists_used = 0;
|
|
||||||
for(int i = 0; i < ncosets; i++) {
|
|
||||||
edge = simplified_graph[i].bruhat_lower;
|
|
||||||
while(edge) {
|
|
||||||
simplified_graph[edge->to].bruhat_higher =
|
|
||||||
edgelist_add(simplified_graph[edge->to].bruhat_higher,
|
|
||||||
i, edgelists_higher, &edgelists_used);
|
|
||||||
edge = edge->next;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
LOG("Sort opposites.\n");
|
|
||||||
|
|
||||||
int *ordering = (int*)malloc(ncosets*sizeof(int));
|
|
||||||
int *reverse_ordering = (int*)malloc(ncosets*sizeof(int));
|
|
||||||
node_t *unsorted = (node_t*)malloc(ncosets*sizeof(node_t));
|
|
||||||
int opp, pos;
|
|
||||||
|
|
||||||
pos = 0;
|
|
||||||
for(int i = 0; i < ncosets; i++) { // first all the pairs
|
|
||||||
opp = simplified_graph[i].opposite;
|
|
||||||
if(opp > i) { // first occurrence of this pair
|
|
||||||
ordering[pos] = i;
|
|
||||||
ordering[ncosets-1-pos] = opp;
|
|
||||||
reverse_ordering[i] = pos;
|
|
||||||
reverse_ordering[opp] = ncosets-1-pos;
|
|
||||||
pos++;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
for(int i = 0; i < ncosets; i++) // and finally the self-opposites
|
|
||||||
if(simplified_graph[i].opposite == i) {
|
|
||||||
ordering[pos] = i;
|
|
||||||
reverse_ordering[i] = pos;
|
|
||||||
pos++;
|
|
||||||
}
|
|
||||||
|
|
||||||
// now really do it
|
|
||||||
memcpy(unsorted, simplified_graph, ncosets*sizeof(node_t));
|
|
||||||
for(int i = 0; i < ncosets; i++) {
|
|
||||||
simplified_graph[i] = unsorted[ordering[i]];
|
|
||||||
simplified_graph[i].opposite = reverse_ordering[simplified_graph[i].opposite];
|
|
||||||
for(edgelist_t *edge = simplified_graph[i].bruhat_lower; edge != (edgelist_t*)0; edge = edge->next)
|
|
||||||
edge->to = reverse_ordering[edge->to];
|
|
||||||
for(edgelist_t *edge = simplified_graph[i].bruhat_higher; edge != (edgelist_t*)0; edge = edge->next)
|
|
||||||
edge->to = reverse_ordering[edge->to];
|
|
||||||
for(int j = 0; j < rank; j++) {
|
|
||||||
simplified_graph[i].left[j] = reverse_ordering[simplified_graph[i].left[j]];
|
|
||||||
simplified_graph[i].right[j] = reverse_ordering[simplified_graph[i].right[j]];
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
free(ordering);
|
|
||||||
free(reverse_ordering);
|
|
||||||
free(unsorted);
|
|
||||||
free(seen);
|
|
||||||
free(reduced);
|
|
||||||
free(group);
|
|
||||||
free(simplified);
|
|
||||||
graph_free(type, full_graph);
|
|
||||||
|
|
||||||
LOG("Simplified graph generated.\n");
|
|
||||||
|
|
||||||
return ncosets;
|
|
||||||
}
|
|
||||||
|
|
||||||
node_t *graph_alloc(semisimple_type_t type)
|
|
||||||
{
|
|
||||||
int rank = weyl_rank(type);
|
|
||||||
int order = weyl_order(type);
|
|
||||||
int hyperplanes = weyl_hyperplanes(type);
|
|
||||||
|
|
||||||
node_t *graph = (node_t*)malloc(order*sizeof(node_t));
|
|
||||||
int *left = (int*)malloc(order*rank*sizeof(int));
|
|
||||||
int *right = (int*)malloc(order*rank*sizeof(int));
|
|
||||||
edgelist_t *edgelists = (edgelist_t*)malloc(order*hyperplanes*sizeof(edgelist_t));
|
|
||||||
int *words = (int*)malloc(order*hyperplanes*sizeof(int));
|
|
||||||
|
|
||||||
for(int i = 0; i < order; i++) {
|
|
||||||
graph[i].left = &left[rank*i];
|
|
||||||
graph[i].right = &right[rank*i];
|
|
||||||
graph[i].word = &words[hyperplanes*i];
|
|
||||||
}
|
|
||||||
|
|
||||||
graph[0].bruhat_higher = edgelists;
|
|
||||||
|
|
||||||
return graph;
|
|
||||||
}
|
|
||||||
|
|
||||||
void graph_free(semisimple_type_t type, node_t *graph)
|
|
||||||
{
|
|
||||||
free(graph[0].left);
|
|
||||||
free(graph[0].right);
|
|
||||||
free(graph[0].word);
|
|
||||||
|
|
||||||
int order = weyl_order(type);
|
|
||||||
|
|
||||||
// find the head of all edgelists by just taking the one having the lowest address
|
|
||||||
edgelist_t *edgelists = graph[0].bruhat_lower;
|
|
||||||
for(int i = 0; i < order; i++) {
|
|
||||||
if(graph[i].bruhat_lower < edgelists && graph[i].bruhat_lower != 0)
|
|
||||||
edgelists = graph[i].bruhat_lower;
|
|
||||||
if(graph[i].bruhat_higher < edgelists && graph[i].bruhat_higher != 0)
|
|
||||||
edgelists = graph[i].bruhat_higher;
|
|
||||||
}
|
|
||||||
free(edgelists);
|
|
||||||
}
|
|
||||||
|
|
||||||
/*********************************** THE ACTUAL ENUMERATION ****************************************/
|
|
||||||
|
|
||||||
typedef struct {
|
typedef struct {
|
||||||
int size; // the size of the weyl group. We store however only the first size/2 elements
|
int size; // the size of the weyl group. We store however only the first size/2 elements
|
||||||
bitvec_t *principal_pos;
|
bitvec_t *principal_pos;
|
||||||
@ -680,18 +80,15 @@ static long enumerate_tree(const enumeration_info_t *info, const bitvec_t *pos,
|
|||||||
next_next_neg = bv_next_zero(&known, next_next_neg + 1);
|
next_next_neg = bv_next_zero(&known, next_next_neg + 1);
|
||||||
} while(next_next_neg <= info->size/2);
|
} while(next_next_neg <= info->size/2);
|
||||||
|
|
||||||
// multiprocessing stuff
|
|
||||||
// if(level == 3)
|
|
||||||
// fprintf(stderr, "%d\n", count);
|
|
||||||
|
|
||||||
return count;
|
return count;
|
||||||
}
|
}
|
||||||
|
|
||||||
void generate_principal_ideals(node_t *graph, int size, bitvec_t *pos, bitvec_t *neg, int *is_slim)
|
static void generate_principal_ideals(doublequotient_t *dq, bitvec_t *pos, bitvec_t *neg, int *is_slim)
|
||||||
{
|
{
|
||||||
queue_t queue;
|
queue_t queue;
|
||||||
int current;
|
int current;
|
||||||
edgelist_t *edge;
|
doublecoset_list_t *edge;
|
||||||
|
int size = dq->count;
|
||||||
|
|
||||||
// generate principal ideals
|
// generate principal ideals
|
||||||
int *principal = (int*)malloc(size*sizeof(int));
|
int *principal = (int*)malloc(size*sizeof(int));
|
||||||
@ -701,10 +98,10 @@ void generate_principal_ideals(node_t *graph, int size, bitvec_t *pos, bitvec_t
|
|||||||
queue_init(&queue);
|
queue_init(&queue);
|
||||||
queue_put(&queue, i);
|
queue_put(&queue, i);
|
||||||
while((current = queue_get(&queue)) != -1)
|
while((current = queue_get(&queue)) != -1)
|
||||||
for(edge = graph[current].bruhat_lower; edge; edge = edge->next)
|
for(edge = dq->cosets[current].bruhat_lower; edge; edge = edge->next)
|
||||||
if(!principal[edge->to]) {
|
if(!principal[edge->to - dq->cosets]) {
|
||||||
principal[edge->to] = 1;
|
principal[edge->to - dq->cosets] = 1;
|
||||||
queue_put(&queue, edge->to);
|
queue_put(&queue, edge->to - dq->cosets);
|
||||||
}
|
}
|
||||||
|
|
||||||
// copy the first half into bitvectors
|
// copy the first half into bitvectors
|
||||||
@ -726,7 +123,7 @@ void generate_principal_ideals(node_t *graph, int size, bitvec_t *pos, bitvec_t
|
|||||||
fprintf(stderr, " ids: [0");
|
fprintf(stderr, " ids: [0");
|
||||||
for(int j = 1; j < size; j++)
|
for(int j = 1; j < size; j++)
|
||||||
if(principal[j])
|
if(principal[j])
|
||||||
fprintf(stderr, ", %d", graph[j].id);
|
fprintf(stderr, ", %d", dq->cosets[j].min->id);
|
||||||
fprintf(stderr, "]\n");
|
fprintf(stderr, "]\n");
|
||||||
}
|
}
|
||||||
#endif
|
#endif
|
||||||
@ -757,12 +154,12 @@ void generate_principal_ideals(node_t *graph, int size, bitvec_t *pos, bitvec_t
|
|||||||
returns the number of balanced ideals
|
returns the number of balanced ideals
|
||||||
*/
|
*/
|
||||||
|
|
||||||
long enumerate_balanced_thickenings(node_t *graph, int size, void (*callback) (const bitvec_t *, int, void*), void *callback_data)
|
long enumerate_balanced_thickenings(doublequotient_t *dq, void (*callback) (const bitvec_t *, int, void*), void *callback_data)
|
||||||
{
|
{
|
||||||
long count = 0;
|
long count = 0;
|
||||||
enumeration_info_t info;
|
enumeration_info_t info;
|
||||||
|
|
||||||
info.size = size;
|
info.size = dq->count;
|
||||||
info.callback = callback;
|
info.callback = callback;
|
||||||
info.callback_data = callback_data;
|
info.callback_data = callback_data;
|
||||||
info.principal_pos = (bitvec_t*)malloc(info.size*sizeof(bitvec_t));
|
info.principal_pos = (bitvec_t*)malloc(info.size*sizeof(bitvec_t));
|
||||||
@ -771,15 +168,15 @@ long enumerate_balanced_thickenings(node_t *graph, int size, void (*callback) (c
|
|||||||
|
|
||||||
// the algorithm only works if the opposition pairing does not stabilize any element
|
// the algorithm only works if the opposition pairing does not stabilize any element
|
||||||
// if this happens, there can be no balanced thickenings
|
// if this happens, there can be no balanced thickenings
|
||||||
for(int i = 0; i < info.size; i++)
|
for(int i = 0; i < dq->count; i++)
|
||||||
if(graph[i].opposite == i)
|
if(dq->cosets[i].opposite->min->id == dq->cosets[i].min->id)
|
||||||
return 0;
|
return 0;
|
||||||
|
|
||||||
// we can only handle bitvectors up to 64*BV_QWORD_RANK bits, but we only store half of the weyl group
|
// we can only handle bitvectors up to 64*BV_QWORD_RANK bits, but we only store half of the weyl group
|
||||||
if(info.size > 128*BV_QWORD_RANK)
|
if(info.size > 128*BV_QWORD_RANK)
|
||||||
return -1;
|
return -1;
|
||||||
|
|
||||||
generate_principal_ideals(graph, size, info.principal_pos, info.principal_neg, info.principal_is_slim);
|
generate_principal_ideals(dq, info.principal_pos, info.principal_neg, info.principal_is_slim);
|
||||||
|
|
||||||
// enumerate balanced ideals
|
// enumerate balanced ideals
|
||||||
bitvec_t pos, neg;
|
bitvec_t pos, neg;
|
||||||
|
@ -3,48 +3,11 @@
|
|||||||
|
|
||||||
#define BV_QWORD_RANK 10
|
#define BV_QWORD_RANK 10
|
||||||
#include "bitvec.h"
|
#include "bitvec.h"
|
||||||
|
|
||||||
#include "weyl.h"
|
#include "weyl.h"
|
||||||
|
|
||||||
#define DEBUG(msg, ...) do{fprintf(stderr, msg, ##__VA_ARGS__); }while(0)
|
#define DEBUG(msg, ...) do{fprintf(stderr, msg, ##__VA_ARGS__); }while(0)
|
||||||
|
|
||||||
#define MAX_THICKENINGS 0 // 0 means infinite
|
|
||||||
#define HEAD_MARKER 127
|
|
||||||
|
|
||||||
typedef struct _edgelist {
|
|
||||||
int to;
|
|
||||||
struct _edgelist *next;
|
|
||||||
} edgelist_t;
|
|
||||||
|
|
||||||
// describes an element of the Weyl group; only "opposite" and "bruhat_lower" are being used for enumerating thickenings; everything else is just needed for initialization or output
|
|
||||||
typedef struct {
|
|
||||||
int *word;
|
|
||||||
int wordlength;
|
|
||||||
int *left;
|
|
||||||
int *right;
|
|
||||||
int opposite;
|
|
||||||
edgelist_t *bruhat_lower;
|
|
||||||
edgelist_t *bruhat_higher;
|
|
||||||
int is_hyperplane_reflection; // boolean value
|
|
||||||
weylid_t id;
|
|
||||||
} node_t;
|
|
||||||
|
|
||||||
// printing functions
|
|
||||||
char *alphabetize(int *word, int len, const char *alphabet, char *buffer);
|
|
||||||
void print_thickening(int rank, int order, const signed char *thickening, int level, const char *alphabet, FILE *f);
|
|
||||||
|
|
||||||
// generating the graph of the bruhat order
|
|
||||||
node_t *graph_alloc(semisimple_type_t type);
|
|
||||||
void graph_free(semisimple_type_t type, node_t *graph);
|
|
||||||
void prepare_graph(semisimple_type_t type, node_t *graph);
|
|
||||||
int prepare_simplified_graph(semisimple_type_t type, unsigned long left, unsigned long right, node_t *simplified_graph);
|
|
||||||
|
|
||||||
// enumerating balanced thickenings
|
// enumerating balanced thickenings
|
||||||
long enumerate_balanced_thickenings(node_t *graph, int size, void (*callback) (const bitvec_t *, int, void*), void *callback_data);
|
long enumerate_balanced_thickenings(doublequotient_t *dq, void (*callback) (const bitvec_t *, int, void*), void *callback_data);
|
||||||
|
|
||||||
// various helper functions
|
|
||||||
static int compare_wordlength(const void *a, const void *b, void *gr);
|
|
||||||
static int edgelist_contains(edgelist_t *list, int x);
|
|
||||||
static edgelist_t *edgelist_add(edgelist_t *list, int new, edgelist_t *storage, int *storage_index);
|
|
||||||
|
|
||||||
#endif
|
#endif
|
||||||
|
617
weyl.c
617
weyl.c
@ -12,15 +12,167 @@ typedef struct {
|
|||||||
int position;
|
int position;
|
||||||
} weylid_lookup_t;
|
} weylid_lookup_t;
|
||||||
|
|
||||||
|
static void generate_left_and_ids(semisimple_type_t type, weylgroup_element_t *group);
|
||||||
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 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(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_root_vectors_qsort(const void *x, const void *y, void *arg);
|
||||||
|
static int compare_weylid(const void *x, const void *y);
|
||||||
static int compare_weylid_lookup(const void *x, const void *y);
|
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 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 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);
|
static void reflect_root_vector(const int *cartan, int rank, int i, int *old, int *new);
|
||||||
|
static weylgroup_element_t* apply_word(int *word, int len, weylgroup_element_t *current);
|
||||||
|
static weylgroup_element_t* apply_word_reverse(int *word, int len, weylgroup_element_t *current);
|
||||||
|
|
||||||
/***************** simple helper functions **********************************/
|
/******** generate_left_and_ids and a pile of helper functions **************/
|
||||||
|
|
||||||
|
static void generate_left_and_ids(semisimple_type_t type, weylgroup_element_t *group)
|
||||||
|
{
|
||||||
|
int rank = weyl_rank(type);
|
||||||
|
int order = weyl_order(type);
|
||||||
|
int positive = weyl_positive(type);
|
||||||
|
|
||||||
|
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;
|
||||||
|
|
||||||
|
// allocate temporary stuff
|
||||||
|
|
||||||
|
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));
|
||||||
|
|
||||||
|
// get all information on the cartan type
|
||||||
|
LOG("Get Cartan matrix.\n");
|
||||||
|
|
||||||
|
weyl_cartan_matrix(type, cartan_matrix);
|
||||||
|
|
||||||
|
// enumerate roots, first the simple ones, then all others by reflecting
|
||||||
|
LOG("Enumerate roots.\n");
|
||||||
|
|
||||||
|
memset(root_vectors, 0, 2*positive*rank*sizeof(int));
|
||||||
|
roots_known = 0;
|
||||||
|
|
||||||
|
queue_init(&queue);
|
||||||
|
for(int i = 0; i < rank; i++) {
|
||||||
|
root_vectors[rank*i + i] = 1; // (r_i)_j = delta_ij
|
||||||
|
queue_put(&queue, i);
|
||||||
|
roots_known++;
|
||||||
|
}
|
||||||
|
|
||||||
|
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
|
||||||
|
LOG("Sort roots.\n");
|
||||||
|
|
||||||
|
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)); // this just copies the second part of the list onto the first; source and destination are disjoint!
|
||||||
|
|
||||||
|
// generate root_mapping, which gives the action of root reflections on positive roots (-1 if result is not a positive root)
|
||||||
|
LOG("Compute root reflections.\n");
|
||||||
|
|
||||||
|
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);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
// find simple roots in the list
|
||||||
|
LOG("Find simple roots.\n");
|
||||||
|
|
||||||
|
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
|
||||||
|
LOG("Enumerate Weyl group elements.\n");
|
||||||
|
|
||||||
|
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)
|
||||||
|
LOG("Reorder Weyl group elements.\n");
|
||||||
|
|
||||||
|
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);
|
||||||
|
|
||||||
|
// fill in results
|
||||||
|
LOG("Compute left multiplication.\n");
|
||||||
|
|
||||||
|
for(int i = 0; i < order; i++) {
|
||||||
|
group[i].id = ids[i];
|
||||||
|
for(int j = 0; j < rank; j++)
|
||||||
|
group[i].left[j] = group + lookup_id(edges[i*rank+j], lookup, order);
|
||||||
|
}
|
||||||
|
|
||||||
|
// free temporary stuff
|
||||||
|
|
||||||
|
free(cartan_matrix);
|
||||||
|
free(root_vectors);
|
||||||
|
free(vector);
|
||||||
|
free(root_mapping);
|
||||||
|
free(simple_roots);
|
||||||
|
free(ids);
|
||||||
|
free(edges);
|
||||||
|
free(nextids);
|
||||||
|
free(lookup);
|
||||||
|
}
|
||||||
|
|
||||||
// glibc search function, but with user pointer and returning index (or -1 if not found)
|
// 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)
|
static int search (const void *key, const void *base, size_t nmemb, size_t size, int (*compar) (const void *, const void *, void *), void *arg)
|
||||||
@ -176,46 +328,46 @@ int weyl_order(semisimple_type_t type)
|
|||||||
return order;
|
return order;
|
||||||
}
|
}
|
||||||
|
|
||||||
int weyl_hyperplanes(semisimple_type_t type)
|
int weyl_positive(semisimple_type_t type)
|
||||||
{
|
{
|
||||||
int hyperplanes = 0;
|
int positive = 0;
|
||||||
|
|
||||||
for(int i = 0; i < type.n; i++) {
|
for(int i = 0; i < type.n; i++) {
|
||||||
ERROR(!weyl_exists(type.factors[i]), "A Weyl group of type %c%d does not exist!\n", type.factors[i].series, type.factors[i].rank);
|
ERROR(!weyl_exists(type.factors[i]), "A Weyl group of type %c%d does not exist!\n", type.factors[i].series, type.factors[i].rank);
|
||||||
|
|
||||||
switch(type.factors[i].series) {
|
switch(type.factors[i].series) {
|
||||||
case 'A':
|
case 'A':
|
||||||
hyperplanes += (type.factors[i].rank * (type.factors[i].rank + 1)) / 2;
|
positive += (type.factors[i].rank * (type.factors[i].rank + 1)) / 2;
|
||||||
break;
|
break;
|
||||||
|
|
||||||
case 'B': case 'C':
|
case 'B': case 'C':
|
||||||
hyperplanes += type.factors[i].rank * type.factors[i].rank;
|
positive += type.factors[i].rank * type.factors[i].rank;
|
||||||
break;
|
break;
|
||||||
|
|
||||||
case 'D':
|
case 'D':
|
||||||
hyperplanes += type.factors[i].rank * (type.factors[i].rank - 1);
|
positive += type.factors[i].rank * (type.factors[i].rank - 1);
|
||||||
break;
|
break;
|
||||||
|
|
||||||
case 'E':
|
case 'E':
|
||||||
if(type.factors[i].rank == 6)
|
if(type.factors[i].rank == 6)
|
||||||
hyperplanes += 36;
|
positive += 36;
|
||||||
else if(type.factors[i].rank == 7)
|
else if(type.factors[i].rank == 7)
|
||||||
hyperplanes += 63;
|
positive += 63;
|
||||||
else if(type.factors[i].rank == 8)
|
else if(type.factors[i].rank == 8)
|
||||||
hyperplanes += 120;
|
positive += 120;
|
||||||
break;
|
break;
|
||||||
|
|
||||||
case 'F':
|
case 'F':
|
||||||
hyperplanes += 24;
|
positive += 24;
|
||||||
break;
|
break;
|
||||||
|
|
||||||
case 'G':
|
case 'G':
|
||||||
hyperplanes += 6;
|
positive += 6;
|
||||||
break;
|
break;
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
return hyperplanes;
|
return positive;
|
||||||
}
|
}
|
||||||
|
|
||||||
int weyl_opposition(semisimple_type_t type, int simple_root)
|
int weyl_opposition(semisimple_type_t type, int simple_root)
|
||||||
@ -313,157 +465,354 @@ void weyl_cartan_matrix(semisimple_type_t type, int *m)
|
|||||||
free(A);
|
free(A);
|
||||||
}
|
}
|
||||||
|
|
||||||
/************ memory allocation ********************/
|
/************ weyl_generate etc. ********************/
|
||||||
|
|
||||||
weylgroup_element_t *weyl_alloc(semisimple_type_t type)
|
static weylgroup_element_t* apply_word(int *word, int len, weylgroup_element_t *current)
|
||||||
|
{
|
||||||
|
for(int k = len - 1; k >= 0; k--) // apply group element from right to left
|
||||||
|
current = current->left[word[k]];
|
||||||
|
|
||||||
|
return current;
|
||||||
|
}
|
||||||
|
|
||||||
|
static weylgroup_element_t* apply_word_reverse(int *word, int len, weylgroup_element_t *current)
|
||||||
|
{
|
||||||
|
for(int k = 0; k < len; k++) // apply group element from left to right (i.e. apply inverse)
|
||||||
|
current = current->left[word[k]];
|
||||||
|
|
||||||
|
return current;
|
||||||
|
}
|
||||||
|
|
||||||
|
weylgroup_t *weyl_generate(semisimple_type_t type)
|
||||||
{
|
{
|
||||||
int rank = weyl_rank(type);
|
int rank = weyl_rank(type);
|
||||||
int order = weyl_order(type);
|
int order = weyl_order(type);
|
||||||
|
int positive = weyl_positive(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");
|
ERROR(positive > 64, "We can't handle root systems with more than 64 positive roots!\n");
|
||||||
|
|
||||||
cartan_matrix = (int*)malloc(rank*rank *sizeof(int));
|
// allocate result
|
||||||
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);
|
weylgroup_element_t *group = (weylgroup_element_t*)malloc(order*sizeof(weylgroup_element_t));
|
||||||
|
weylgroup_t *result = malloc(sizeof(weylgroup_t));
|
||||||
|
result->type = type;
|
||||||
|
result->elements = group;
|
||||||
|
result->lists = (weylgroup_element_t**)malloc(2*order*rank*sizeof(weylgroup_element_t*));
|
||||||
|
|
||||||
// enumerate roots
|
for(int i = 0; i < order; i++) {
|
||||||
memset(root_vectors, 0, 2*positive*rank*sizeof(int));
|
group[i].left = result->lists + 2*i*rank;
|
||||||
|
group[i].right = result->lists + (2*i+1)*rank;
|
||||||
// first the simple roots
|
group[i].coset = (doublecoset_t*)0;
|
||||||
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
|
// the main part
|
||||||
roots_known = rank;
|
LOG("Start generating Weyl group.\n");
|
||||||
while((current = queue_get(&queue)) != -1) {
|
|
||||||
for(int i = 0; i < rank; i++) {
|
generate_left_and_ids(type, group);
|
||||||
reflect_root_vector(cartan_matrix, rank, i, &root_vectors[rank*current], vector);
|
|
||||||
int j;
|
// word length is just the number of 1s in the binary id
|
||||||
for(j = 0; j < roots_known; j++)
|
LOG("Find word lengths.\n");
|
||||||
if(compare_root_vectors(rank, &root_vectors[rank*j], vector) == 0)
|
|
||||||
break;
|
for(int i = 0; i < order; i++) {
|
||||||
if(j == roots_known) {
|
group[i].wordlength = 0;
|
||||||
memcpy(&root_vectors[rank*roots_known], vector, rank*sizeof(int));
|
for(int j = 0; j < positive; j++)
|
||||||
queue_put(&queue, roots_known);
|
if(group[i].id & BIT(j))
|
||||||
roots_known++;
|
group[i].wordlength++;
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
}
|
||||||
|
|
||||||
ERROR(roots_known != 2*positive, "Number of roots does not match!\n")
|
// allocate letters
|
||||||
|
|
||||||
// sort roots and restrict to positives
|
int total_wordlength = 0;
|
||||||
qsort_r(root_vectors, 2*positive, rank*sizeof(int), compare_root_vectors_qsort, &rank);
|
for(int i = 0; i < order; i++)
|
||||||
memcpy(root_vectors, &root_vectors[positive*rank], positive*rank*sizeof(int));
|
total_wordlength += group[i].wordlength;
|
||||||
|
result->letters = (int*)malloc(total_wordlength*sizeof(int));
|
||||||
|
total_wordlength = 0;
|
||||||
|
for(int i = 0; i < order; i++) {
|
||||||
|
group[i].word = result->letters + total_wordlength;
|
||||||
|
total_wordlength += group[i].wordlength;
|
||||||
|
}
|
||||||
|
|
||||||
for(int i = 0; i < positive; i++) {
|
// find shortest words (using that the elements are already ordered by word length)
|
||||||
|
LOG("Find shortest words.\n");
|
||||||
|
|
||||||
|
memset(result->letters, -1, total_wordlength*sizeof(int));
|
||||||
|
for(int i = 0; i < order - 1; i++) {
|
||||||
|
weylgroup_element_t *this = &group[i];
|
||||||
for(int j = 0; j < rank; j++) {
|
for(int j = 0; j < rank; j++) {
|
||||||
reflect_root_vector(cartan_matrix, rank, j, &root_vectors[rank*i], vector);
|
weylgroup_element_t *that = group[i].left[j];
|
||||||
root_mapping[i*rank+j] =
|
if(that->wordlength > this->wordlength && that->word[0] == -1) {
|
||||||
search(vector, root_vectors, positive, rank*sizeof(int), compare_root_vectors_qsort, &rank);
|
memcpy(that->word + 1, this->word, this->wordlength*sizeof(int));
|
||||||
|
that->word[0] = j;
|
||||||
|
}
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
// where in the list are the simple roots?
|
// generate right edges
|
||||||
|
LOG("Compute right multiplication.\n");
|
||||||
|
|
||||||
|
for(int i = 0; i < order; i++)
|
||||||
|
for(int j = 0; j < rank; j++)
|
||||||
|
group[i].right[j] = apply_word(group[i].word, group[i].wordlength, group[0].left[j]);
|
||||||
|
|
||||||
|
// find opposites
|
||||||
|
LOG("Find opposites.\n");
|
||||||
|
|
||||||
|
weylgroup_element_t *longest = &group[order-1];
|
||||||
|
for(int i = 0; i < order; i++)
|
||||||
|
group[i].opposite = apply_word(longest->word, longest->wordlength, &group[i]);
|
||||||
|
|
||||||
|
// check for root reflections
|
||||||
|
LOG("Find root reflections.\n");
|
||||||
|
|
||||||
|
for(int i = 0; i < order; i++)
|
||||||
|
group[i].is_root_reflection = 0;
|
||||||
|
for(int i = 0; i < order; i++)
|
||||||
|
for(int j = 0; j < rank; j++) // we want to calculate word^{-1} * j * word; this is a root reflection
|
||||||
|
apply_word_reverse(group[i].word, group[i].wordlength, group[i].left[j]) -> is_root_reflection = 1;
|
||||||
|
|
||||||
|
return result;
|
||||||
|
}
|
||||||
|
|
||||||
|
void weyl_destroy(weylgroup_t *group)
|
||||||
|
{
|
||||||
|
free(group->elements);
|
||||||
|
free(group->lists);
|
||||||
|
free(group->letters);
|
||||||
|
free(group);
|
||||||
|
}
|
||||||
|
|
||||||
|
doublequotient_t *weyl_generate_bruhat(semisimple_type_t type, int left_invariance, int right_invariance)
|
||||||
|
{
|
||||||
|
int rank = weyl_rank(type);
|
||||||
|
int order = weyl_order(type);
|
||||||
|
int positive = weyl_positive(type);
|
||||||
|
int count;
|
||||||
|
|
||||||
|
int is_minimum, is_maximum;
|
||||||
|
|
||||||
|
weylgroup_t *wgroup = weyl_generate(type);
|
||||||
|
weylgroup_element_t *group = wgroup->elements;
|
||||||
|
doublecoset_t *cosets;
|
||||||
|
|
||||||
for(int i = 0; i < rank; i++) {
|
for(int i = 0; i < rank; i++) {
|
||||||
memset(vector, 0, rank*sizeof(int));
|
int oppi = weyl_opposition(type, i);
|
||||||
vector[i] = 1;
|
if(left_invariance & BIT(i) && !(left_invariance & BIT(oppi)) ||
|
||||||
simple_roots[i] = search(vector, root_vectors, positive, rank*sizeof(int), compare_root_vectors_qsort, &rank);
|
left_invariance & BIT(oppi) && !(left_invariance & BIT(i)))
|
||||||
|
ERROR(1, "The specified left invariance is not invariant under the opposition involution!\n");
|
||||||
}
|
}
|
||||||
|
|
||||||
// enumerate weyl group elements using difference sets
|
doublequotient_t *result = (doublequotient_t*)malloc(sizeof(doublequotient_t));
|
||||||
nextids[0] = 0;
|
result->type = type;
|
||||||
nextids_count = 1;
|
result->left_invariance = left_invariance;
|
||||||
elements = 0;
|
result->right_invariance = right_invariance;
|
||||||
for(int len = 0; len <= positive; len++) {
|
result->group = wgroup->elements;
|
||||||
length_elements = 0;
|
result->grouplists = wgroup->lists;
|
||||||
|
result->groupletters = wgroup->letters;
|
||||||
|
|
||||||
// find unique ids in edges added in the last iteration
|
free(wgroup); // dissolved in result and not needed anymore
|
||||||
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
|
// count cosets by finding the minimum length element in every coset
|
||||||
nextids_count = 0;
|
LOG("Count cosets.\n");
|
||||||
for(int i = elements; i < elements + length_elements; i++)
|
|
||||||
for(int j = 0; j < rank; j++) {
|
count = 0;
|
||||||
edges[i*rank+j] = multiply_generator(j, ids[i], simple_roots, root_mapping, rank, positive);
|
for(int i = 0; i < order; i++) {
|
||||||
if(!(ids[i] & BIT(simple_roots[j]))) // the new element is longer then the old one
|
is_minimum = 1;
|
||||||
nextids[nextids_count++] = edges[i*rank+j];
|
for(int j = 0; j < rank; j++)
|
||||||
|
if(left_invariance & BIT(j) && group[i].left[j]->wordlength < group[i].wordlength ||
|
||||||
|
right_invariance & BIT(j) && group[i].right[j]->wordlength < group[i].wordlength)
|
||||||
|
is_minimum = 0;
|
||||||
|
if(is_minimum)
|
||||||
|
count++;
|
||||||
|
}
|
||||||
|
result->count = count;
|
||||||
|
|
||||||
|
// alloc more stuff
|
||||||
|
|
||||||
|
cosets = result->cosets = (doublecoset_t*)malloc(count*sizeof(doublecoset_t));
|
||||||
|
for(int i = 0; i < count; i++) {
|
||||||
|
cosets[i].bruhat_lower = cosets[i].bruhat_higher = (doublecoset_list_t*)0;
|
||||||
|
}
|
||||||
|
result->lists = (doublecoset_list_t*)malloc(2*count*positive*sizeof(doublecoset_list_t)); // 2 times, for bruhat lower and higher
|
||||||
|
|
||||||
|
// find minima (basically same code as above)
|
||||||
|
LOG("Find minimal length elements in cosets.\n");
|
||||||
|
|
||||||
|
count = 0;
|
||||||
|
for(int i = 0; i < order; i++) {
|
||||||
|
is_minimum = 1;
|
||||||
|
for(int j = 0; j < rank; j++)
|
||||||
|
if(left_invariance & BIT(j) && group[i].left[j]->wordlength < group[i].wordlength ||
|
||||||
|
right_invariance & BIT(j) && group[i].right[j]->wordlength < group[i].wordlength)
|
||||||
|
is_minimum = 0;
|
||||||
|
if(is_minimum) {
|
||||||
|
cosets[count].min = &group[i];
|
||||||
|
group[i].coset = &cosets[count];
|
||||||
|
count++;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
// generate quotient map
|
||||||
|
LOG("Generate quotient map.\n");
|
||||||
|
|
||||||
|
for(int i = 0; i < order; i++) {
|
||||||
|
for(int j = 0; j < rank; j++) {
|
||||||
|
if(left_invariance & BIT(j) && group[i].left[j]->wordlength > group[i].wordlength)
|
||||||
|
group[i].left[j]->coset = group[i].coset;
|
||||||
|
if(right_invariance & BIT(j) && group[i].right[j]->wordlength > group[i].wordlength)
|
||||||
|
group[i].right[j]->coset = group[i].coset;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
// find maxima
|
||||||
|
LOG("Find maximal length elements.\n");
|
||||||
|
|
||||||
|
for(int i = 0; i < order; i++) {
|
||||||
|
is_maximum = 1;
|
||||||
|
for(int j = 0; j < rank; j++)
|
||||||
|
if(left_invariance & BIT(j) && group[i].left[j]->wordlength > group[i].wordlength ||
|
||||||
|
right_invariance & BIT(j) && group[i].right[j]->wordlength > group[i].wordlength)
|
||||||
|
is_maximum = 0;
|
||||||
|
if(is_maximum) {
|
||||||
|
group[i].coset->max = &group[i];
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
// opposites
|
||||||
|
LOG("Find opposites.\n");
|
||||||
|
|
||||||
|
for(int i = 0; i < count; i++)
|
||||||
|
cosets[i].opposite = cosets[i].min->opposite->coset;
|
||||||
|
|
||||||
|
// bruhat order
|
||||||
|
LOG("Find bruhat order.\n");
|
||||||
|
|
||||||
|
int edgecount = 0;
|
||||||
|
for(int i = 0; i < order; i++) {
|
||||||
|
if(group[i].is_root_reflection) {
|
||||||
|
for(int j = 0; j < count; j++) {
|
||||||
|
weylgroup_element_t *this = cosets[j].min;
|
||||||
|
weylgroup_element_t *that = apply_word(group[i].word, group[i].wordlength, cosets[j].min);
|
||||||
|
if(this->wordlength > that->wordlength) { // this is higher in bruhat order than that
|
||||||
|
doublecoset_list_t *new = &result->lists[edgecount++];
|
||||||
|
new->next = this->coset->bruhat_lower;
|
||||||
|
this->coset->bruhat_lower = new;
|
||||||
|
new->to = that->coset;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
// transitive reduction
|
||||||
|
LOG("Perform transitive reduction.\n");
|
||||||
|
|
||||||
|
doublecoset_t *offset = &cosets[0];
|
||||||
|
doublecoset_t *origin;
|
||||||
|
doublecoset_list_t *current;
|
||||||
|
doublecoset_list_t *prev;
|
||||||
|
queue_t queue;
|
||||||
|
int cur;
|
||||||
|
int *seen = malloc(count*sizeof(int));
|
||||||
|
for(int i = 0; i < count; i++) {
|
||||||
|
memset(seen, 0, count*sizeof(int));
|
||||||
|
queue_init(&queue);
|
||||||
|
|
||||||
|
for(int len = 1; len <= cosets[i].min->wordlength; len++) {
|
||||||
|
|
||||||
|
// remove all edges originating from i of length len which connect to something already seen using shorter edges
|
||||||
|
origin = &cosets[i];
|
||||||
|
prev = (doublecoset_list_t*)0;
|
||||||
|
|
||||||
|
for(current = origin->bruhat_lower; current; current = current->next) {
|
||||||
|
if(origin->min->wordlength - current->to->min->wordlength != len) {
|
||||||
|
prev = current;
|
||||||
|
} else if(seen[current->to - offset]) {
|
||||||
|
if(prev)
|
||||||
|
prev->next = current->next;
|
||||||
|
else
|
||||||
|
origin->bruhat_lower = current->next;
|
||||||
|
} else {
|
||||||
|
prev = current;
|
||||||
|
seen[current->to - offset] = 1;
|
||||||
|
queue_put(&queue, current->to - offset);
|
||||||
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
elements += length_elements;
|
// see which nodes we can reach using only edges up to length len, mark them as seen
|
||||||
|
while((cur = queue_get(&queue)) != -1) {
|
||||||
|
current = (cur + offset)->bruhat_lower;
|
||||||
|
for(current = (cur+offset)->bruhat_lower; current; current = current->next) {
|
||||||
|
if(!seen[current->to - offset]) {
|
||||||
|
seen[current->to - offset] = 1;
|
||||||
|
queue_put(&queue, current->to - offset);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
// translate the ids to list positions (i.e. local continuous ids)
|
free(seen);
|
||||||
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++) {
|
// reverse bruhat order
|
||||||
group[i].id = ids[i];
|
LOG("Revert bruhat order.\n");
|
||||||
for(int j = 0; j < rank; j++)
|
|
||||||
group[i].left[j] = lookup_id(edges[i*rank+j], lookup, order);
|
for(int i = 0; i < count; i++) {
|
||||||
|
for(current = cosets[i].bruhat_lower; current; current = current->next) {
|
||||||
|
doublecoset_list_t *new = &result->lists[edgecount++];
|
||||||
|
new->to = &cosets[i];
|
||||||
|
new->next = current->to->bruhat_higher;
|
||||||
|
current->to->bruhat_higher = new;
|
||||||
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
free(cartan_matrix);
|
// sort opposites and rewrite everything
|
||||||
free(root_vectors);
|
LOG("Sort opposites.\n");
|
||||||
free(vector);
|
|
||||||
free(root_mapping);
|
int *old2newindices = (int*)malloc(count*sizeof(int));
|
||||||
free(simple_roots);
|
int *new2oldindices = (int*)malloc(count*sizeof(int));
|
||||||
free(ids);
|
doublecoset_t *oldcosets = (doublecoset_t*)malloc(count*sizeof(doublecoset_t));
|
||||||
free(edges);
|
memcpy(oldcosets, cosets, count*sizeof(doublecoset_t));
|
||||||
free(nextids);
|
|
||||||
free(lookup);
|
int j = 0;
|
||||||
|
for(int i = 0; i < count; i++)
|
||||||
|
if(&cosets[i] < cosets[i].opposite) {
|
||||||
|
old2newindices[i] = j;
|
||||||
|
old2newindices[cosets[i].opposite - cosets] = count-1-j;
|
||||||
|
j++;
|
||||||
|
}
|
||||||
|
for(int i = 0; i < count; i++)
|
||||||
|
if(i == cosets[i].opposite - cosets)
|
||||||
|
old2newindices[i] = j++;
|
||||||
|
|
||||||
|
for(int i = 0; i < count; i++)
|
||||||
|
new2oldindices[old2newindices[i]] = i;
|
||||||
|
|
||||||
|
for(int i = 0; i < count; i++) {
|
||||||
|
cosets[i].min = oldcosets[new2oldindices[i]].min;
|
||||||
|
cosets[i].max = oldcosets[new2oldindices[i]].max;
|
||||||
|
cosets[i].opposite = old2newindices[oldcosets[new2oldindices[i]].opposite - cosets] + cosets;
|
||||||
|
cosets[i].bruhat_lower = oldcosets[new2oldindices[i]].bruhat_lower;
|
||||||
|
cosets[i].bruhat_higher = oldcosets[new2oldindices[i]].bruhat_higher;
|
||||||
|
for(current = cosets[i].bruhat_lower; current; current = current -> next)
|
||||||
|
current->to = old2newindices[current->to - cosets] + cosets;
|
||||||
|
for(current = cosets[i].bruhat_higher; current; current = current -> next)
|
||||||
|
current->to = old2newindices[current->to - cosets] + cosets;
|
||||||
|
}
|
||||||
|
for(int i = 0; i < order; i++)
|
||||||
|
group[i].coset = old2newindices[group[i].coset - cosets] + cosets;
|
||||||
|
|
||||||
|
free(old2newindices);
|
||||||
|
free(new2oldindices);
|
||||||
|
free(oldcosets);
|
||||||
|
|
||||||
|
return result;
|
||||||
|
}
|
||||||
|
|
||||||
|
void weyl_destroy_bruhat(doublequotient_t *dq)
|
||||||
|
{
|
||||||
|
free(dq->group);
|
||||||
|
free(dq->grouplists);
|
||||||
|
free(dq->groupletters);
|
||||||
|
free(dq->cosets);
|
||||||
|
free(dq->lists);
|
||||||
|
free(dq);
|
||||||
}
|
}
|
||||||
|
94
weyl.h
94
weyl.h
@ -3,34 +3,92 @@
|
|||||||
|
|
||||||
#include <inttypes.h>
|
#include <inttypes.h>
|
||||||
|
|
||||||
typedef struct {
|
struct _simple_type;
|
||||||
char series;
|
struct _semisimple_type;
|
||||||
int rank;
|
struct _weylgroup_element;
|
||||||
} simple_type_t;
|
struct _weylgroup;
|
||||||
|
struct _doublecoset;
|
||||||
typedef struct {
|
struct _doublecoset_list;
|
||||||
int n;
|
struct _doublequotient;
|
||||||
simple_type_t *factors;
|
|
||||||
} semisimple_type_t;
|
|
||||||
|
|
||||||
typedef uint64_t weylid_t;
|
typedef uint64_t weylid_t;
|
||||||
|
typedef struct _simple_type simple_type_t;
|
||||||
|
typedef struct _semisimple_type semisimple_type_t;
|
||||||
|
typedef struct _weylgroup_element weylgroup_element_t;
|
||||||
|
typedef struct _weylgroup weylgroup_t;
|
||||||
|
typedef struct _doublecoset doublecoset_t;
|
||||||
|
typedef struct _doublecoset_list doublecoset_list_t;
|
||||||
|
typedef struct _doublequotient doublequotient_t;
|
||||||
|
|
||||||
typedef struct {
|
/***************************** structures *******************************/
|
||||||
int *left;
|
|
||||||
int *right;
|
struct _simple_type {
|
||||||
int opposite;
|
char series;
|
||||||
|
int rank;
|
||||||
|
};
|
||||||
|
|
||||||
|
struct _semisimple_type {
|
||||||
|
int n;
|
||||||
|
simple_type_t *factors;
|
||||||
|
};
|
||||||
|
|
||||||
|
struct _weylgroup_element {
|
||||||
|
int *word;
|
||||||
|
int wordlength;
|
||||||
|
weylgroup_element_t **left;
|
||||||
|
weylgroup_element_t **right;
|
||||||
|
weylgroup_element_t *opposite;
|
||||||
|
int is_root_reflection; // boolean value
|
||||||
weylid_t id;
|
weylid_t id;
|
||||||
} weylgroup_element_t;
|
|
||||||
|
// only set if quotient is generated
|
||||||
|
doublecoset_t *coset;
|
||||||
|
};
|
||||||
|
|
||||||
|
struct _weylgroup {
|
||||||
|
semisimple_type_t type;
|
||||||
|
weylgroup_element_t *elements;
|
||||||
|
weylgroup_element_t **lists;
|
||||||
|
int *letters;
|
||||||
|
};
|
||||||
|
|
||||||
|
struct _doublecoset {
|
||||||
|
doublecoset_list_t *bruhat_lower;
|
||||||
|
doublecoset_list_t *bruhat_higher;
|
||||||
|
doublecoset_t *opposite;
|
||||||
|
weylgroup_element_t *max;
|
||||||
|
weylgroup_element_t *min;
|
||||||
|
};
|
||||||
|
|
||||||
|
struct _doublecoset_list {
|
||||||
|
doublecoset_t *to;
|
||||||
|
doublecoset_list_t *next;
|
||||||
|
};
|
||||||
|
|
||||||
|
struct _doublequotient {
|
||||||
|
semisimple_type_t type;
|
||||||
|
int left_invariance; // bitmask with rank bits
|
||||||
|
int right_invariance;
|
||||||
|
int count; // number of cosets
|
||||||
|
doublecoset_t *cosets;
|
||||||
|
weylgroup_element_t *group;
|
||||||
|
doublecoset_list_t *lists; // only for memory allocation / freeing
|
||||||
|
weylgroup_element_t **grouplists; // only for memory allocation / freeing
|
||||||
|
int *groupletters; // only for memory allocation / freeing
|
||||||
|
};
|
||||||
|
|
||||||
|
/***************************** functions **************************************/
|
||||||
|
|
||||||
int weyl_rank(semisimple_type_t type);
|
int weyl_rank(semisimple_type_t type);
|
||||||
int weyl_order(semisimple_type_t type);
|
int weyl_order(semisimple_type_t type);
|
||||||
int weyl_hyperplanes(semisimple_type_t type);
|
int weyl_positive(semisimple_type_t type);
|
||||||
void weyl_cartan_matrix(semisimple_type_t type, int *m);
|
void weyl_cartan_matrix(semisimple_type_t type, int *m);
|
||||||
int weyl_opposition(semisimple_type_t type, int simple_root);
|
int weyl_opposition(semisimple_type_t type, int simple_root);
|
||||||
|
|
||||||
weylgroup_element_t *weyl_alloc(semisimple_type_t type);
|
weylgroup_t *weyl_generate(semisimple_type_t type);
|
||||||
void weyl_free(weylgroup_element_t *x);
|
void weyl_destroy(weylgroup_t *group);
|
||||||
|
|
||||||
void weyl_generate(semisimple_type_t type, weylgroup_element_t *group);
|
doublequotient_t *weyl_generate_bruhat(semisimple_type_t type, int left_invariance, int right_invariance);
|
||||||
|
void weyl_destroy_bruhat(doublequotient_t *dq);
|
||||||
|
|
||||||
#endif
|
#endif
|
||||||
|
Loading…
Reference in New Issue
Block a user