Zachary H. Jones
Advisor: Dr.
The above examples illustrate the first two types of matrices. Note the right matrix of each example. Both are doubly stochastic and (0,1). Thus, both are examples of permutation matrices. In return, permutation matrices are a special case of the previous types. Notice how forcing both properties result in being exactly one '1' in each row and column.
The preceding figures are simple polyhedrons. The first three are convex. The last is not convex because if you draw a line between two of the endpoints the line will exist outside the polyhedron. Since the first three figures are convex polyhedron, the compact set of points forming the polyhedron constructs polytopes.
Now with all the necessary terminology defined, the Birkhoff Polytope can be formally introduced.
From a geometric perspective the Birkhoff Polytope is a type of convex polyhedra, like a pentagon and a hexagon are types of convex polygons. Since the set of vertices of the polytope is the set of permutation matrices, the number of vertices is
. This means that the size of the Birkhoff Polytope grows very fast. As an illustration,
has
vertices, while
has
vertices. While the permutation matrices represent just the vertices of
, all nonnegative doubly stochastic matrices compose the entire polytope. The non-permutation matrices will be discussed further in polytope relations. Use a ref tag here
Polytopes can intersect a hyperplane at a single point, across a line segment, and so forth. A single point is a
-dimensional object and thus a vertex is a
-dimensional face. With the same logic, edges are
-dimensional faces and planes are
-dimensional faces. A facet is
-dimensional face of an
-dimensional polytope. With Birkhoff Polytopes, faces have a matrix representation in addition. There is a subset of all
x
matrices that forms a
correspondence to the set of faces of
. To define the subset that corresponds to the set of faces of
, a few more ideas need to be introduced.
A matrix with total support is a matrix that can be decomposed into a set of permutation matrices. The number of permutation matrices that are decomposed from any
matrix is called the permanent.
The permanent, though complex looking, performs a simple and elegant procedure. The function takes the sum of a product for every element of
, or for each vertex of
. The product is taken of selected
elements from the matrix. The rows of the matrix are selected in order, 1 through
. The columns are determined from
, which will return the column in which row
has a 1 in the matrix representation of
. This means that the permanent is comparing each vertex of the polytope to the matrix. The product taken will either be 0 or 1, because
is a
matrix. Furthermore, the product is one when the 1s in the permutation matrix of
are in matrix
. Otherwise, the product is 0. Thus, the sum returned is the number of vertices contained in the matrix
.
Consider an
x
matrix filled with all ones, call it
. Every permutation matrix is found in
. The permanent of
supports the claim as the function returns a value of
. This case turns out to be special.
is the face corresponding the whole polytope,
. This face is generally referred to as
. The permanent function is powerful and has several uses beyond the scope of this research.
Determining the cycle number may seem like a tedious task, when considering it in terms of matrices. Finding matrix inverses and matrix multiplication are laborious tasks. However, vertices also have permutation representations from
, the symmetric group. The inverse of an element of a group is computed by reversing the mapping. The product of two elements is found by composing the two mappings. Furthermore, tracing and counting cycles is much easier because the permutation lays out the mapping.
In order to prove that the cycle number needs to be one, for the edge to exist, previous definitions are used to obtain a matrix from
and
, which can be simplified due to the invariance of permutations to
and
. Recall, that multiplying a matrix by a permutation matrix shuffles columns and rows. The
picked allows the rows and columns to be shuffled to create a matrix that can represented by a direct sum (
). Each
has an order of at least two, implying that the
. The
because since the matrix is only being shuffled, ever vertex that is lost from the shuffling is replaced by a new one.
, since the permanent is equivalent to product of permanents of the direct sum. In order for a face to be an edge, it must contain exactly two vertices, therefore
must equal
.
With this technique, it would be nice to know what the edge graphs of some of the smaller graphs looks like. This would help in visualizing the polytope and understanding the nature of it. To accomplish this, I wrote a simple that program performed the cycle number test on each pairing on vertices to obtain a graph. Figure 1. includes the graphs of
and
. Each vertex was assigned a letter, starting with
and continuing until all vertices are labeled.
Several observations can be gathered from the graphs. First, there exists symmetry across both diagonals of the edges graphs of the polytopes. The forward diagonal (starting in the top left corner) is expected because the graph is undirected and therefore an edge from
to
implies there exists an edge from
to
. The backward diagonal (starting in the top right corner) is an unanticipated result. In the case of
, why should edge
related to
. It turns out
as a result of
. Further observation leads to the fact that each vertex has the same number edges, meaning that the degree of each vertex is the same. This result relies on vertices being represented by elements of the
.
A computer program tested the diameter of Birkhoff polytopes of size 1 through 9, by generating an edge graph and utilizing a Transitive Closure algorithm [Cormen et al., 2001]. Each polytope has a diameter of 2. The method in which the diameter is calculated requires large computer resources. For instance, to find the diameter of
used over half the memory on the department sever and ran for seven days. To compute the diameter of larger Birkhoff polytopes in this manner would require more memory and much more time. Using this method,
would require more computational time than the age of the universe. This leads to looking for alternative methods for determining the diameter.
To gain some understanding of the diameter of the graph, the question of is the diameter of all Birkhoff polytopes 2 is addressed. Past research that Dr. Hightower and I have conducted suggested that this may be possible. To address this idea, the ratio of the degree of a vertex of
to the degree of a vertex of a complete graph
is considered. Since
has
vertices the complete graph being compared must also have
vertices. Graphs with a diameter of 2 are very dense, meaning that as the number of vertices increases to infinity, the number of edges will also increase to infinity. If the sequence of ratios
Consider that for the edge to exist there must be exactly one cycle of length greater than one. This implies that at least two vertices must be permuted and all vertices not permuted map to themselves. In order to count the permutations of
with the given property, first select a cycle of length from 2 to
, call it
. For the selected cycle length, determine the number of ways of choosing which elements of the permutation to be part of the mapping,
. Once, the cycle location is picked, the different orders of the cycle are calculated,
. This means that there are
elements of
with a cycle length of
. To consider all elements with a cycle length greater than one, gives the degree of a vertex of
. The formula follows.
One observation noted from the chart is that though the polytopes become more sparse as the
becomes large, the chart shows that the degree of each vertex is still very large number.
Quadratic assignment problems are another member of this family. There are
facilities and
locations. For each pair of locations there is a distance and cost associated. An example of the cost could be the money or time needed to transport goods between factories. The problem is to assign all facilities to different locations with the goal of minimizing the sum of the distances multiplied by the corresponding costs [Kabel, 1997].
Other types of Assignment Problems, which will not be talked about any further include: Multiple Assignment Problems which allow for there to be more tasks than agents and 3D Linear Assignment Problems which add another constraint to traditional agent/task situation. Many members of the family of problems are variations of other problems. The Multiple Assignment is an example of this.
Recall that that LAP assigns each task to an agent. To represent a possible assignment with an
x
matrix, place a 1 where agent
is assigned to task
and place 0s everywhere else. The matrix created is identical to a permutation matrix from
. The polytope represents all possible ways to assign the tasks. However, if the assignment matrix is not representing a vertex then the assignments are split among different agents, thus making it not a feasible solution. Only the vertices are feasible solutions, reiterating each agent being assigned one task.
With the permutation selected, a set of equations need to be set up to use the algorithm. For each of the row set, let the left side of the equation equal the element from the permutation. Since the matrix is doubly stochastic, the right side of the equation is 1 subtracted by the other elements in the row. Now two other elements need to be selected. As before these elements form equations as stated before, but this time with columns instead of rows. However, any elements that are on the left hand side of the system cannot be on the right and must be substituted out of the right hand side.
It turns out that the permutations that can be pivoted to are those with edges connecting the vertices of the permutations. The network simplex method optimizes the problem by traversing the Birkhoff polytope of the problem.
public class Birkhoff {
int FACTN;
int N;
int C;
int E;
int[][] Sn;
byte[][][] verticies;
byte[][] G;
int factorial(int n) {
int fact=1;
for(int i=2; i<=n; i++) fact*=i;
return fact;
}
void permute(int list[], int n, int prelist[], int m) {
if(n>0){
int[] sublist = new int[n-1];
for(int i=0; i<n; i++) {
int k=0;
for(int j=0; j<n; j++)
if(i != j) sublist[k++] = list[j];
prelist[m] = list[i];
permute(sublist, n-1, prelist, m+1);
}
} else {
for(int i=0; i<N; i++)
Sn[C][i] = prelist[i];
C++;
}
}
void combine(int sublist[], int prelist[], int n, int m, int r){
if(n == r) {
if(n==2) {
//Edge Test
cyclenumber(prelist[0], prelist[1]);
} else {
} else {
for(int i=m; i<sublist.length; i++) {
prelist[n] = sublist[i];
combine(sublist, prelist, n+1, i+1, r);
}
}
}
void cyclenumber (int p, int q) {
//First print cycles for each permutation
int[] pT = new int[N];
for(int i=0; i<N; i++) {
int image = Sn[p][i];
pT[image] = i;
}
//Q
int[] Q = new int[N];
for(int i=0; i<N; i++) Q[i] = Sn[q][i];
//Compose cycles
int[] pTq = new int[N];
for(int i=0; i<N; i++) pTq[i] = Q[pT[i]];
//Check Cycles
int v;
int ct=0;
for(int i=0; i<N; i++) {
v=0;
if(pTq[i] != -1) {
int next=i;
int prev;
do {
v++;
prev = next;
next = pTq[next];
pTq[prev] = -1;
} while(next != i);
if(v > 1) ct++;
}
}
if(ct == 1) {
if(!(G[p][q] == 1 | G[q][p] ==1) ) E++;
G[p][q] = G[q][p] = 1;
}
}
void run() {
N=8;
FACTN=factorial(N);
C=0;
int[] list = new int[N];
int[] prelist = new int[N];
Sn = new int[FACTN][N];
verticies= new byte[FACTN][N][N];
G = new byte[FACTN][FACTN];
for(int i=0; i<FACTN; i++) {
for(int j=0; j<FACTN; j++) G[i][j] = 50;
G[i][i] = 0;
}
for(int i=0; i<N; i++) list[i] = i;
//Create the Symertic Group
permute(list, N, prelist, 0);
list = new int[FACTN];
for(int i=0; i<FACTN; i++) list[i] = i;
E=0;
for(int i=2; i<3; i++){
prelist = new int[i];
//Combine (n!,2) -> (n!,n-1)
combine(list, prelist, 0, 0, i);
}
System.out.println("Edge Count - " + E);
byte max = 0;
for(int i=0; i<FACTN; i++)
for(int j=0; j<FACTN; j++)
if(max < G[i][j]) max = G[i][j];
System.out.println("Degree - " +max);
}
public static void main(String args[]) {
combinations birkoff = new combinations();
birkoff.run();
}
void transitive_closure() {
int k,i,j;
for(k=FACTN-1; k>=0; k--) {
for(i=FACTN-1; i>=0; i--)
for(j=FACTN-1; j>=0; j--)
if((G[i][j] > G[i][k] + G[k][j] ) )
G[i][j] = (byte)(G[i][k] + G[k][j]);
if(k%1000 == 0)
System.out.print(" " + k + " of " + FACTN);
}
}
void degree() {
for(int i=0; i<FACTN; i++) {
int sum = 0;
for(int j=0; j<FACTN; j++)
if(G[i][j] == 1) sum ++;
System.out.println("Degree of " + i +":" + sum);
}
}
}
This document was generated using the LaTeX2HTML translator Version 2002-2-1 (1.70)
Copyright © 1993, 1994, 1995, 1996,
Nikos Drakos,
Computer Based Learning Unit, University of Leeds.
Copyright © 1997, 1998, 1999,
Ross Moore,
Mathematics Department, Macquarie University, Sydney.
The command line arguments were:
latex2html -split +0 -white final.tex
The translation was initiated by Zach Jones on 2006-03-19