/*
Research Project:   Graphical Database for Category Theory
                    J. Bradbury, Dr. R. Rosebrugh, I. Rutherford
                    Mount Allison University 2001
File:               Category.java
Description:	      This class contains all of the information that is needed
                    for a category and some useful functions
*/
import java.io.*;

public class Category
{
	IniSettings ini;                      //IniSettings class that contains the lengths
	                                      //of the arrays in the Category class
	String name;                          //Name of the category

	String[] obj;                         //Names of the objects in the category
	int num_objects = 0;                  //Number of objects in category

	int[][] arr;                          //domain and codomain of arrows
	String[] arrow;                       //Names of arrows in a category
	int num_arrows = 0;                   //Number of arrows in category

	Relation[] relations;                 //Contains relations in category
	int num_relations = 0;                //Number of relations in category

	String comment;                       //Comments about the category
	File file_;                           //Name of file that category was opened,
	                                      //loaded, or saved in
	String gml;                           //Text version of graphical interpretation
	                                      //of thecategory
	String originalGml;                   //Text version of the original graphical
	                                      //interpretation of the category

	CategoryModified mod;                 //This contains all of the information
	                                      //about modifications to the original
	                                      //category fill
	                                       
	public Category() // default constructor
	{
		ini = new IniSettings();
		name = new String();
		
		obj = new String[ini.getMAXWORD()];
		num_objects = 0;
		
		arr = new int[ini.getMAXARR()][2];
		arrow = new String[ini.getMAXARR()];
		num_arrows = 0;
		
		relations = new Relation[ini.getMAXARR()];
		num_relations = 0;

		comment = new String();

		gml = "graph [\ndirected 1\n]\n";
		originalGml = "graph [\ndirected 1\n]\n";
		
		mod = new CategoryModified();
	}



	public boolean isModified()
	//Return true if the category was not originally saved
	//or has been modified since it was last saved
	{
		if (mod.functorCat || mod.createCat || mod.dualCat || mod.dataAdded
			|| mod.dataRemoved || /*(!gml.equals(originalGml) && !originalGml.equals(""))
			|| mod.nameChanged ||*/ mod.madeConfluent)
			return true;
		else
			return false;
	}

	public void copyCategory(Category c)
	{
		if (c == null) return;
		int i, j, temp;

		name = new String(c.name);
		num_objects = c.num_objects;
		num_arrows = c.num_arrows;
		num_relations = c.num_relations;
		for (i=0; i<num_objects; i++)
			obj[i] = new String(c.obj[i]);
		for (i=0; i<num_arrows; i++)
		{
			arr[i][0] = c.arr[i][0];
			arr[i][1] = c.arr[i][1];
			arrow[i] = new String(c.arrow[i]);
		}
		relations = new Relation[ini.getMAXARR()];
		for (i=0; i<num_relations; i++)
		{
			relations[i] = new Relation();
			j = -1;
			do
			{
				j++;
				relations[i].rhs[j] = c.relations[i].rhs[j];
			} while (c.relations[i].rhs[j] != -1 && c.relations[i].rhs[j] != ini.getIdentityCode());
			j = -1;
			do
			{
				j++;
				relations[i].lhs[j] = c.relations[i].lhs[j];
			} while (c.relations[i].lhs[j] != -1 && c.relations[i].lhs[j] != ini.getIdentityCode());
		}
		comment = new String(c.comment);
		//file_ = new File(c.file_.getName());
		gml = new String(c.gml);
		originalGml = new String(c.originalGml);
		CategoryModified mod = new CategoryModified();
	}

	public boolean check_arr(String str)
	/*
	Parameters:
				 str - the name of the arrow being checked
	Purpose:
				 To determine whether an arrow is in the category
	Design:
				 Returns true if the arrow is in the category and false if it is not
	*/
	{
		int i;

		for(i=0; i<num_arrows; i++)
		{
			if (str.equals(arrow[i]))
			{
				return true;
			}
		}
		return false;
	}

	public boolean check_obj(String object)
	/*
	Parameters:
				 object - the name of the object being checked
	Purpose:
				 To determine whether an object is in the category
	Returns:
				 Returns true if the object is in the category and false if it is not
	*/
	{
		int i;

		for(i=0; i<num_objects; i++)
		{
			if(object.equals(obj[i]))
			{
				return true;
			}
		}
		return false;
	}

	boolean check_path(int path[])
	/*
	Parameters:
				 path - the path to be checked
	Purpose:
				 To check that the domains and codomains of all the arrows in the path
				 match up, ie. checks if the path is a valid path in this category
	Returns:
				 Checks that all the domains and codomains of the arrows in the path match
				 up and returns true if this is the case and false otherwise
	*/
	{
		int i, cur, next;

		for (i=0; i<(path_len(path)-1); i++)
		{
			 cur = path[i];
			 next = path[i+1];
			 if ((arr[cur][0]) != (arr[next][1]))
			 {
				 return(false);
			 }
		}
		return(true);
	}

	public int path_len(int path[])
	/*
	Parameters:
				 path - an array of integers terminated by -1 which is a path
	Returns:
				 an integer specifying the length of the path
	Purpose:
				 To determine the length of an array of integers terminated by -1
	*/
	{
		int length = 0;
		while (path[length] != -1 && path[length] != ini.getIdentityCode())
		{
			//System.out.println(path[length]);
			length++;
		}
			
		return length;
	}

	public int search(int sub[], int target[], int start)
	/*
	Parameters:
				sub		- an array of integers which is the subpath we are looking for
				target - an array of integers which is being searched for sub
				start	- The place in target where the search is to begin
	Purpose:
				To search one path, begining at some starting position, to see if another
				path is a subpath
	Returns:
				Returns the position where the subpath begins in the path being searched,
				or -1 if sub is not a subpath of target
	*/
	{
		int i, j, len1, len2;
		boolean found;
		len1 = path_len(target);
		len2 = path_len(sub);

		found = false;
		for (i=start; i<=len1-len2; i++)
		{
			if (sub[0] == target[i])
			{
				found = true;
				for (j=0; j<len2; j++)
					if (target[i+j] != sub[j])
						found = false;
			}
			if (found)
				break;
		}

		if (found)
			return i;
		else
			return -1;
	}

	public int[] reduce(int path[])
	/*
	Parameters:
				 path - the array of integers being reduced
	Returns:
				 an array of integers which will be set to equal the reduced path
	Purpose:
				 To reduce a path using the set of relations stored in a category
 */
	{
		int i,j = path_len(path);
		int spot;	//the spot where the left side of a relation begins in the path being reduced
		int temp=1;	//a temporary variable used to store the length of a path
		int diff;	//the difference in length between the left side of a relation and the
					//right side of the relation
		int reducedpath[] = copy_path(path);

		for (i=0;i<num_relations;i++)
		{
			if((spot = search(relations[i].lhs,reducedpath,0)) != -1)
			{
				for (j=spot;j<spot+path_len(relations[i].rhs);j++)
				{
					reducedpath[j] = relations[i].rhs[j - spot];
				}
				temp = path_len(reducedpath);
				diff = path_len(relations[i].lhs) - path_len(relations[i].rhs);
				for (j=spot+path_len(relations[i].lhs);j<temp;j++)
				{
					reducedpath[j - diff] = reducedpath[j];
				}
				reducedpath[j - diff] = -1;
				i = -1;
			}
		}

		j = path_len(path);
		if (reducedpath[j] == ini.getIdentityCode())
			reducedpath[j] = -1;
		if (reducedpath[0] == -1 || reducedpath[0] == ini.getIdentityCode())
		{
			reducedpath[0] = ini.getIdentityCode();
			reducedpath[1] = -1;
		}
		return(reducedpath);
	}

	public int arrow_number(String name)
	/*
	Parameters:
				name - the name of the arrow to check
	Purpose:
				To check if an arrow of a given name exists in the
				category, and to get its number if it exists
	Returns:
				the number of the named arrow, or -1 if the arrow doesn't exist
	*/
	{
		int i;

		for(i=0; i<num_arrows; i++)
		{
			if(arrow[i].equals(name))
			{
				return(i);
			}
		}
		if (name == "1") return(-2);
		else return(-1);
	}

	public int object_number(String name)
	/*
	Parameters:
				 name:	 the name of the object that we want the integer value of
	Purpose:
				 To get the integer representation for the character representation
				 of an object
	 Design:
				 Returns the integer value of an object, -1 if the object is not in the
				 category
	*/
	{
		int i;

		for(i=0; i<num_objects; i++)
		{
			if(obj[i].equals(name))
			{
				return(i);
			}
		}
		return(-1);
	}

	int[] string_to_path(String st)
	/*
	Parameters:
				st:		 the string that we want to convert to an array of integers terminated
								by -1
	Purpose:
				To convert a string of characters, where the characters represent arrows, into
				an array of integers, terminated by -1, where the integers represent arrows.
	Design:
				Returns an array of integers terminated by -1, and does not change the st.
	*/
	{
		int i;
		int temp[] = new int [ini.getMAXWORD()];

		if (st.length() == 0)
		{
			temp[0] = -1;
			return temp;
		}
		else if (st.equals("1"))
		{
			temp[0] = -2;
			temp[1] = -1;
			return temp;
		}
		else
		{
			String arr = new String();
			int arrnum = 0;
			int prev = 0;

			for (i=0; i<st.length(); i++)
			{
				if ((st.charAt(i) == '*'))
				{
					arr = st.substring(prev, i);
					temp[arrnum] = arrow_number(arr);
					prev = i+1;
					arrnum++;
				}
				else if (i == (st.length()-1))
				{
					arr =	st.substring(prev, i+1);
					temp[arrnum]= arrow_number(arr);
					prev = i+1;
					arrnum++;
				}
			}

			temp[arrnum] = -1;

			return temp;
		}
	}

	public String path_to_string(int path[])
	{
		int i, len = path_len(path);
		String temp = new String();

		for (i=0; i<len; i++)
		{
			temp += arrow[path[i]];
			if (i != len-1)
				temp += "*";
		}
		if (temp.length() == 0)
			return new String("1");
		return temp;
	}

	public int[] append_path(int path1[], int path2[])
	/*
	Parameters:
				 dest	 - an array of integers is appended to this array of integers
				 source - this array of integers is appended to dest
	Purpose:
				 To append one array of intgers to another array of integers,
				 all terminated by -1
	Returns:
				 Appends source to dest and returns dest
	*/
	{
		int i, size1 = path_len(path2), size2 = path_len(path1);
		int ret[] = new int[ini.getMAXWORD()];//[size1 + size2 + 1];

		for(i=0; i<size1; i++)
			ret[i] = path2[i];
		for (i=0; i<=size2; i++)
			ret[i+size1] = path1[i];

		return ret;
	}

  public boolean equals(int path1[], int path2[])
	/*
	Parameters:
				 path1: an array of integers terminated by -1 which is a path
				 path2: an array of integers terminated by -1 which is a path
	Purpose:
				 To determine if two paths are identical
	Design:
				 Returns true if path1 is identical to path2 and false otherwise
				 Note: this function does not reduce the paths to check for
				 equivalence - it checks for exact equality
	*/
	{
		int i;
		if (path_len(path1) == path_len(path2))
		{
			if (path_len(path1) == 0)
				return true;
			for(i=0; i<path_len(path1); i++)
			{
				if(path1[i] != path2[i])
				{
					return(false);
				}
			}
			return(true);
		}
		else
		{
			return(false);
		}
	}

	public int[] copy_path(int source[])
	/*
	Parameters:
				source - an array of integers which is copied
	Purpose:
				To copy one array of integers to another array of integers
	Returns:
				Copies source into a new integer array and returns it
	*/
	{
		int i = path_len(source)+1;
		if (i < ini.getMAXWORD()) i = ini.getMAXWORD();
		int temp[] = new int[i];

		for(i=0; i<=path_len(source); i++)
		{
			temp[i] = source[i];
		}
		if (temp[0] == ini.getIdentityCode())
			temp[1] = -1;
		return(temp);
	}

  public int[] copy_path(int source[], int maxlen)
	/*
	Parameters:
				source - an array of integers which is copied
				maxlen - maximum number of arrows to copy
	Purpose:
				To copy one path to path
	Returns:
				Copies source into a new integer array and returns it
				up to a maximum length of maxlen
	*/
	{
		int i, len = path_len(source);
		int temp[] = new int [ini.getMAXWORD()];

		if (len <= maxlen)
		{
			for (i=0; i<=len; i++)
			{
				temp[i] = source[i];
			}
		}
		else
		{
			for (i=len-maxlen; i<len; i++)
			{
				temp[i-len+maxlen] = source[i];
			}
			temp[maxlen] = -1;
		}
		return(temp);
	}

	public boolean check_string(String str)
	//This function is designed to verify that all arrows in the str are
	//valid arrows of the category c. For each arrow of the string checks
	//that it exists in the category c. Returns true if this is the case
	//and false otherwise. The parameter str is the string to check and the
	//parameter c is the current category
	{
		if (str.length() == 0) return false;
		if (str.equals("1")) return true;
		String arr = new String();
		int prev = 0;
		int i;

		for (i=0; i<str.length(); i++)
		{
			if ((str.charAt(i) == '*'))
			{
				arr = str.substring(prev, i);
				if (!check_arr(arr))
				{
					return(false);
				}
				prev = i+1;
			}
			else if (i == (str.length()-1))
			{
				arr =	str.substring(prev, i+1);
				if (!check_arr(arr))
				{
					return(false);
				}
				prev = i+1;
			}
		}
		return(true);
	}

	public boolean greater(int path1[], int path2[])
	/*
	Parameters:
				path1:	an array of integers terminated by -1
				path2:	an array of integers terminated by -1
	Purpose:
				To determine if path1 has a greater ordering than path2
	Design:
				Returns true if path1 is of greater order than path2
	*/
	{
		int j;

		if(path_len(path1) > path_len(path2))
		{
			return(true);
		}
		else
		{
			if ((path_len(path1)) == (path_len(path2)))
			{
				if ((path_len(path1) == 1) && (path1[0] == ini.getIdentityCode()))
				return(false);
				j = 0;
				while	(j < path_len(path1))
				{
					if (path2[j] > path1[j])
					{
						return(false);
					}
					else
					{
						if (path2[j] < path1[j])
						{
							return(true);
						}
					}
					j++;
				}
			}
		}
		return(false);
	}

	public Category makeDual()
	/*
	Purpose:
				To dualize a category
	Design:
				Makes a dual of the category and returns it
	*/
	{
		char over, leave;
		int i, j, temp;
		int temp2[] = new int [ini.getMAXWORD()];
		int temp3[] = new int [ini.getMAXWORD()];
		boolean done;

		Category B = new Category();
		B.name = name; // + "DUAL";

		B.num_objects = num_objects;
		B.num_arrows = num_arrows;
		B.num_relations = num_relations;
		for(i=0;i<num_objects;i++)
			B.obj[i] = obj[i];
		for(i=0;i<num_arrows;i++)
		{
			B.arrow[i] = arrow[i];
			B.arr[i][0] = arr[i][1];
			B.arr[i][1] = arr[i][0];
		}
		for(i=0;i<num_relations;i++)
		{
			for(j=path_len(relations[i].lhs)-1;j>=0;j--)
			{
				temp2[path_len(relations[i].lhs)-1-j] = relations[i].lhs[j];
			}
			temp2[path_len(relations[i].lhs)] = -1;
			for(j=path_len(relations[i].rhs)-1;j>=0;j--)
			{
				temp3[path_len(relations[i].rhs)-1-j] = relations[i].rhs[j];
			}
			temp3[path_len(relations[i].rhs)] = -1;
			Relation r = new Relation();
			if (greater(temp2,temp3))
			{
				r.lhs = copy_path(temp2);
				r.rhs = copy_path(temp3);
			}
			else
			{
				r.lhs = copy_path(temp3);
				r.rhs = copy_path(temp2);
			}
			B.relations[i] = r;
		}
		return B;
	}

	public int all_arr(int obj, int arrows[])
	/*
	Parameters:
				 obj:			integer representing an object in the category
				 arrows:	 array containing all arrows with object obj as their domain
	Purpose:
				 Returns an integer whose value is the number of arrows in the category
				 with object obj as their domain.	The array is passed back containing
				 all such arrows.
	*/
	{
		int j, k=0;

		for (j=0;j<num_arrows;j++)
		{
			if (arr[j][0] == obj)
			{
				arrows[k] = j;
				k++;
			}
		}
		return k;
	}

	public int[] reverse_path(int[] path)
	{
		// reverse the array before comparing it with the relations

		if (path[0] == -2)
		{
			return path;
		}

		int i, j = path_len(path);
		int size = ini.getMAXARR();
		if (j > size) size = j;
		int[] ret = new int[j+1];

		for (i=0; i<j; i++)
		{
			ret[i] = path[j-i-1];
		}
		ret[j] = -1;
		return ret;
	}


// Added May 27th (taken from original MainWindow), jesse

	public int[] arrowsBetween(String domain, String codomain)
	// returns array of integers that are indices of arrows between two objects
	{
		int[] arrows_between = new int[ini.getMAXARR()];
		int num_arrows_between = 0;
		
		for (int i=0; i<num_arrows; i++)
		{
			if (arr[i][0] == object_number(domain) && arr[i][1] == object_number(codomain))
				arrows_between[num_arrows_between++] = i;
		}
		return arrows_between;
	}






	public void setGML()
	{
		addObjectsGML();
		addArrowsGML();
		addRelationsGML();
	}

	public void addObjectsGML()
	//This function adds an object to the GML text representation of the
	//current category
	{
		//Remove the last "]" from the text representation
		String curr = gml.substring(0, gml.length()-2);
		//Add in text for a new node(ie category object)
		for (int i=0; i<num_objects; i++)
			{
				curr += "node [\nid " + i /*(num_objects-1)*/ + "\nlabel \"" + obj[i] + "\"\ngraphics [\nImage [\nType \"\"\nLocation \"\"\n]\ncenter [\nx " + (((int) (Math.random() * 350)) - 175) + "\ny " + (((int) (Math.random() * 325)) - 125) + "\nz 0.0\n]\nwidth 20.0\nheight 20.0\ndepth 20.0\n]\nvgj [\nlabelPosition \"in\"\nshape \"Oval\"\n]\n]\n";
	 		} 
		//Add closing "]" to text representation
		curr += "\n]\n";
		//save text representation in gml string of current category
		gml = curr;
	}

	public void addArrowsGML()
	//This function adds an arrow to the GML text representation of the
	//current category
	{
		String curr = gml.substring(0, gml.length()-2);
		boolean[] done = new boolean[num_arrows]; for (int i=0; i<done.length; i++) {done[i] = false;}
		for (int i=0; i<num_arrows; i++)
		{
			if (done[i] == false)
			{
				String newArrow = arrow[i];

				for (int j = 0; j < num_arrows; j++)
				{
					if ((i != j) && (arr[i][0] == arr[j][0]) && (arr[i][1] == arr[j][1]))
					{
						newArrow = newArrow.concat("," + arrow[j]);
						done[j] = true;
					}
				}
			
				curr += "edge [\n";
				curr += "linestyle \"solid\"\n";
				curr += "label \"" + newArrow + "\"\n";
				curr += "source " + arr[i][0] + "\n";
				curr += "target " + arr[i][1] + "\n";
				curr += "]\n"; // added this
			}
		}

		//Add closing "]" to text representation
		curr += "\n]\n";	// took away one of "]\n" those
		//save text representation in gml string of current category
		gml = curr;
	}






	public void addRelationsGML()
	//This function adds a node which contains the relations to the GML text
	//representation of the current category
	{
		String curr = gml.substring(0, gml.length()-2);
		if (num_relations != 0)
		{
			curr += "node [\nid " + num_objects + "\nlabel \"" + relnode_label() + "\"\ngraphics [\nImage [\nType \"\"\nLocation \"\"\n]\ncenter [\nx 0\ny 0\nz 0.0\n]\nwidth 20.0\nheight 20.0\ndepth 20.0\n]\nvgj [\nlabelPosition \"center\"\nshape \"Oval\"\n]\n]\n";
		}
		//Add closing "]" to text representation
		curr += "\n]\n";
		//save text representation in gml string of current category
		gml = curr;
	}



	public String relationsToString()
	//prints relations of category on the screen
	{
		String relationString = new String();
		int i,j;
		for (i=0;i<num_relations;i++)
		{
			j = 0;
			//Display left side of relation
			while (relations[i].lhs[j] != -1)
			{
				if (j == 0)
				relationString += arrow[relations[i].lhs[j]];
				else
				{
					relationString += ini.getSeparator() + "";
					relationString += arrow[relations[i].lhs[j]];
				}
				j++;
			}
			relationString += " = ";
			j = 0;
			//Display right side of relation
			if (relations[i].rhs[0] == ini.getIdentityCode())
			relationString += "1";
			else
			{
				while (relations[i].rhs[j] != -1)
				{
					if (j == 0)
					relationString += "" + arrow[relations[i].rhs[j]];
					else
					{
						relationString += ini.getSeparator() + "";
						relationString += arrow[relations[i].rhs[j]];
					}
					j++;
				}
			}
			if (i < num_relations-1)
				relationString += ",\n";
			else
				relationString += ".";
			
		}
		return relationString;
	}


	public String relnode_label()
	//prints relations of category on the screen
	{
		int i,j;
		int counter = 0;
		String rel_label = "relations\\n ";

		for (i=0;i<num_relations-1;i++)
		{
			j = 0;
			while (relations[i].lhs[j] != -1)
			{
				if (j == 0)
					rel_label += arrow[relations[i].lhs[j]];
				else
					rel_label += "*" + arrow[relations[i].lhs[j]];
				j++;
			}
			rel_label += " = ";
			j = 0;
			if (relations[i].rhs[0] == ini.getIdentityCode())
				rel_label += "1";
			else
			{
				while (relations[i].rhs[j] != -1)
				{
					if (j == 0)
						rel_label += arrow[relations[i].rhs[j]];
					else
						rel_label += "*" + arrow[relations[i].rhs[j]];
					j++;
				}
			}
			counter++;
			rel_label += ",";
			if (counter == 5)
			{
				counter = 0;
				rel_label = rel_label.concat("\\n");
			}
		}
		if (num_relations != 0)
		{
			j = 0;
			while (relations[i].lhs[j] != -1)
			{
				if (j == 0)
				rel_label += "" + arrow[relations[i].lhs[j]];
				else
				rel_label += "*" + arrow[relations[i].lhs[j]];
				j++;
			}
			rel_label += " = ";
			j = 0;
			if (relations[i].rhs[0] == ini.getIdentityCode())
			rel_label += "1";
			else
			{
				while (relations[i].rhs[j] != -1)
				{
					if (j == 0)
						rel_label += "" + arrow[relations[i].rhs[j]];
					else
						rel_label += "*" + arrow[relations[i].rhs[j]];
					j++;
				}
			}
		}
		return rel_label;
	}



	public Relation get_rel(String relation_)
	/*
	Parameters:

	Purpose:
	Allows the user to input as many relations as they want to
	Design:
	Allocates space for the new relations and checks them for valid composition
	as well as valid left and right domains and codomains.
	*/
	{
		
		final int LEFT = 0, RIGHT = 1;
		boolean add;
		int left_side[] = new int [ini.getMAXWORD()];
		int right_side[] = new int [ini.getMAXWORD()];
		int j;
		relation_ = relation_.replaceAll(" ", "");
		String sides[] = relation_.split("=");

		add = true;
		if (sides[RIGHT].compareTo("1") == 0)
		{
			right_side[0] = ini.getIdentityCode();
			right_side[1] = -1; //right = "0"; //right[0] = '\x0';
			if(!(check_string(sides[LEFT])))
			{
				add = false;
			}
			left_side = copy_path(string_to_path(sides[LEFT]));
			for (j=0;j<path_len(left_side)-1;j++)
			{
				if ((arr[left_side[j]][0]) != (arr[left_side[j+1]][1]))
					System.out.println("Error: Invalid Composition. Domain of " + arr[left_side[j]][0] + " does not equal Codomain of " + arr[left_side[j+1]][1]);
			}
			if (((arr[left_side[0]][1]) != (arr[left_side[path_len(left_side)-1]][0])) && (right_side[0] == ini.getIdentityCode()))
			{
				System.out.println("Error: " + sides[LEFT] + " cannot equal identity, not an endomorphism");
				add = false;
			}
		}
		else if(sides[LEFT].length() != 0)
		{
			if(!(check_string(sides[LEFT])))
			{
				add = false;
			}
			if(!(check_string(sides[RIGHT])))
			{
				add = false;
			}
			if(add)
			{
				left_side = copy_path(string_to_path(sides[LEFT]));
				right_side = copy_path(string_to_path(sides[RIGHT]));
				for (j=0; j<path_len(left_side)-1; j++)
				{
					if ((arr[left_side[j]][0]) != (arr[left_side[j+1]][1]))
					{
						System.out.println("Error: Invalid Composition. Domain of " + arr[left_side[j]][0] + " does not equal Codomain of " + arr[left_side[j+1]][1]);
					}
				}
				for (j=0; j<path_len(right_side); j++)
				{
					if(!check_arr(arrow[right_side[j]]))
					{
						System.out.println("Error: " + arrow[right_side[j]] + " is not an arrow of " + name);
						add = false;
					}
				}
				for (j=0; j<path_len(right_side)-1; j++)
				{
					if ((arr[right_side[j]][0]) != (arr[right_side[j+1]][1]))
					{
						System.out.println("Error: Invalid Composition. Domain of " + sides[RIGHT].charAt(j) + " does not equal codomain of " + sides[RIGHT].charAt(j+1));
						add = false;
					}
				}
				if ((arr[left_side[path_len(left_side)-1]][0]) != (arr[right_side[path_len(right_side)-1]][0]) && (right_side[0] != -1))
				{
					System.out.println("Error: Invalid Composition. Domain of left side does not equal domain of right side.");
					add = false;
				}
				if ((arr[left_side[0]][1]) != (arr[right_side[0]][1])	&& (right_side[0] != -1))
				{
					System.out.println("Error: Invalid Composition. Codomain of left side does not equal Codomain of right side.");
					add = false;
				}
				if (((arr[left_side[0]][1]) != (arr[left_side[path_len(left_side)-1]][0])) && (right_side[0] == ini.getIdentityCode()))
				{
					System.out.println("Error: " + sides[LEFT] + " cannot equal identity, not an endomorphism");
					add = false;
				}
			}
		}
		if(add)
		{
			Relation newRelation_ = new Relation();
			if(greater(right_side, left_side))
			{
				newRelation_.lhs = copy_path(right_side);
				newRelation_.rhs = copy_path(left_side);
//				System.out.println(path_to_string(newRelation_.lhs) + " = " + path_to_string(newRelation_.rhs));
			}
			else
			{
				newRelation_.rhs = copy_path(right_side);
				newRelation_.lhs = copy_path(left_side);
//				System.out.println(path_to_string(newRelation_.lhs) + " = " + path_to_string(newRelation_.rhs));
			}
				return newRelation_;
		}
		return null;
	}

	//object parser
	public void parseObjects (String obje)
	//This method parse a string of objects
	{
		int i =0;
		int prev = 0;

		for (i=0; i < obje.length(); i++)
		{
			if (obje.charAt(i)	== ' ')
			{
				prev++;
			}
			else
			{
				if ((obje.charAt(i) == ',') || (obje.charAt(i) == '.'))
				{
					if (prev == 0)
						obj[num_objects] = obje.substring(prev, i);
					else
						obj[num_objects] = obje.substring(prev+1, i);
					num_objects++;
					prev = i;
				}
			}
		}
	}
	//end of object parser

	//start of parse arrows
	public void parseArrows(String arro)
	//This method parses a string of arrows
	{
		int i =0;
		int prev = 0;
		int colon = 0;
		int tail = 0; int head = 0;

		if (arro.charAt(0) != '.')
		for (i=0; i < arro.length(); i++)
		{
			if (arro.charAt(i)	== ' ')
			{
				prev++;
			}
			else
			{
				if (arro.charAt(i) == ':')
					colon = i;
				if (arro.charAt(i) == '>')
				{
					head = i-1;
					tail = i;
				}
				if ((arro.charAt(i) == ',') || (arro.charAt(i) == '.'))
				{
					if (prev == 0)
						arrow[num_arrows] = arro.substring(prev, colon);
					else
						arrow[num_arrows] = arro.substring(prev+1, colon);
					String domain = arro.substring(colon+1, head);
					for (int j = 0; j < num_objects; j++)
					{
						if (obj[j].equals(domain))
								arr[num_arrows][0] = j;
					}
					String codomain = arro.substring(tail+1, i);
					for (int j = 0; j < num_objects; j++)
					{
						if (obj[j].equals(codomain))
								arr[num_arrows][1] = j;
					}
					num_arrows++;
					prev = i;
				}
			}
		}
	}
	//end of parse arrows

	//start of parse relations
	public void parseRelations(String rel)
	//This method parses a string of relations
	{
		int i =0;
		int prev = 0;
		int equals = 0;

		rel = rel.replaceAll(" ", "");
		rel = rel.replaceAll("\t", "");

		if (rel.charAt(0) != '.')
		{
			for (i=0; i < rel.length(); i++)
			{
				if ((rel.charAt(i) == ',') || (rel.charAt(i) == '.'))
				{
					String relation = rel.substring(prev, i);
					prev = i+1;
					relations[num_relations++] = get_rel(relation);
//					System.out.println(path_to_string(relations[num_relations-1].lhs) + " = " + path_to_string(relations[num_relations-1].rhs));
				}
			}
		 
		}
	}

	public boolean check_oneone(int path[], int domain, int codomain, HomTree gamalbet, int alpha[], int beta[], HomTree gammatree, int maxloop, HomTree pathtree)
	/*
	Parameters:
	        path:      the current path
	        domain:    the current object of the path
	        codomain:  the object we are trying to find all arrows to
	        objects:   an array of integers which keeps the function from exceeding
	                      the maximum number of loops
	        gamalbet:  a tree returned with all gamma-alphas and gamma-betas
	        alpha:     first projection to the productobj being tested
	        beta:      second projection to the productobj being tested
	        gammatree: the tree of all arrows from productobj to codomain
	        maxloop :  endomorphism limit
	
	 Purpose:
	        To generate the reduced hom set from one object to another and check 1-1
	
	 Design:
	        Creates a tree gamalbet containing the reduced form
	        of all the gamma-alphas and each gamma-alpha having a subtree which contains
	        all of the gamma-betas paired with it. Also creates a tree gammatree with all
	        the gamma paths
	*/
	{
		int i, j, len, number, codom, endo = 0;
		int arrow_array[] = new int [num_arrows];
		int reducedGammaBeta[] = new int[ini.getMAXWORD()];
		int reducedGammaAlpha[] = new int[ini.getMAXWORD()];
	
		path = reduce(path);
		len = path_len(path);
		if (path[0] == -2)
			path[0] = -1;
		for (i=0; i<len; i++)
		{
			if (arr[path[i]][1] == arr[path[len-1]][0])
			{
				endo++;
			}
		}
	
		if (endo < maxloop && len < ini.getMAXWORD()-1)
		{
			if (!pathtree.containsPath(path) || len == 0)
			{
				if (len == 0)
					codom = -1;
				else
				{
					pathtree.addPath(path);
					codom = arr[path[0]][1];	// the codomain of the last arrow in the path
				}
				if (codom == codomain)  // if the codomain of the last arrow in the path is the test object
				{
					int newpath[] = reduce(path);
					if (gammatree.addPath(newpath))	// add gamma (sumobj to testobj) to the gamma-tree
					{
						reducedGammaAlpha = reduce(append_path(alpha, path));
						reducedGammaBeta = reduce(append_path(beta, path));
						if (path_len(reducedGammaAlpha) == 0)
						{
							reducedGammaAlpha[0] = -2;
							reducedGammaAlpha[1] = -1;
						}
						if (path_len(reducedGammaBeta) == 0)
						{
							reducedGammaBeta[0] = -2;
							reducedGammaBeta[1] = -1;
						}
						gamalbet.addPath(reducedGammaAlpha);	// add gamma-alpha to the gamalbet tree
						if (gamalbet.prev.tree == null)
							gamalbet.prev.tree = new HomTree(); // the gamma-beta subtree attached to the gamma-alpha tree
						if (!gamalbet.prev.tree.addPath(reducedGammaBeta))	// if gamma-beta is already in the tree, return false
							return false;
					}
				}

				number = all_arr(domain, arrow_array);	// all arrows from the domain are now stored in arrow_array
				for (i=0; i<number; i++)	// loop through all arrows from the domain
				{
					domain = arr[arrow_array[i]][1];	// now set domain to be the codomain of the ith arrow
					for (j=len; j>=0; j--)
						path[j+1] = path[j];	// add the ith arrow to the path
					path[0] = arrow_array[i];
					// then check all arrows from the object recursively.
					if (!check_oneone(path, domain, codomain, gamalbet, alpha, beta, gammatree, maxloop, pathtree))
						return false;
	
					len = path_len(path);
					for (j=0; j<len; j++)	
						path[j] = path[j+1];	// remove that arrow from the path; then loops around to check the next arrow
				}								// like a depth first search of a graph
				return true;
			}
		}
		else
		{
//			this.setEndoPassed(true);
		}
		return true;
	}

	public boolean check_onto(int path[], int domain, int codomain, HomTree gamalbet, HomTree rhotree, int maxloop, HomTree pathtree)
	/*
	Parameters:
	        path:   the current path
	        domain: the current object of the path
	        codomain:the object we are trying to find all arrows to
	        objects: an array of integers which keeps the function from exceeding
	                 the maximum number of loops
	        gamalbet: the tree of gamma alphas with gamma betas
	        rho_tree:    a tree of all the rhos
	Local Variables:
	        number: stores the number of arrows from an object
	        current_arrow:  stores the number of the current arrow in the path
	        codom:  stores the codomain of the current arrow
	        arrow_array:    contains all of the arrows from an object
	Purpose:
	        To check that a sum is onto
	Design:
	        Generates all of the lambdas from one object to another and uses the rho tree
	        it is passed to check that all of the pairs <lambda,rho> are in our tree.
	*/
	{
		int i, j, len, number, codom, endo = 0;
		int arrow_array[] = new int[num_arrows];
		path = reduce(path);
		if (path[0] == -2)
			path[0] = -1;
	
		// check to see if we've passed the endomorphism limit
		len = path_len(path);
		for (i=0; i<len; i++)
		{
			if (arr[path[i]][1] == arr[path[len-1]][0])
			{
				endo++;
			}
		}
	
		if (endo < maxloop && len < ini.getMAXWORD()-1)
		{
			if (!pathtree.containsPath(path) || len == 0)
			{
				if (len == 0)
					codom = domain;
				else
				{
					pathtree.addPath(path);
					codom = arr[path[0]][1];	// sets codom to be the codomain of the first (or maybe the last) arrow in the path
				}
				if (codom == codomain)
				{
					int newpath[] = reduce(path);
					if (path[0] == -1)
					{
						path[0] = -2;
						path[1] = -1;
					}
					if (!gamalbet.containsPath(newpath))	// if the gamma-alpha tree already contains the path, 
					{										// return false
						return false;
					}
					else
					{
						if (!rhotree.isEqual(gamalbet.prev.tree))	// if the rhotree is not the same as the gamma-beta
							return false;							// subtree attached to the gamma-alpha tree, return false 
					}
				}
				if (path[0] == -2) path[0] = -1;			
	
				number = all_arr(domain, arrow_array);	// all arrows from domain
				if (number > 0)
					for (i=0; i<number; i++)			// loop through all arrows from domain
					{									// reset domain to be the codomain of the first arrow from
						domain = arr[arrow_array[i]][1];// the original domain
						for (j=len; j>=0; j--)					
							path[j+1] = path[j];			// add the new arrow to the path
						path[0] = arrow_array[i];
						// recursively check all paths; like a depth-first search
						if (!check_onto(path, domain, codomain, gamalbet, rhotree, maxloop, pathtree))
							return false;
			
						for (j=0; j<=len; j++)
							path[j] = path[j+1];	// remove the newest arrow from the path; "pop" it
					}
			}
		}
		else
		{ //endopassed = true;
			return false;
		}
		return true;
	}

	public int makeHomTree(int path[], HomTree homtree, int obj1, int obj2, int maxloop, HomTree pathtree)
	/*
	Parameters:
	      path[]        - integer array containing the path followed so far
	      objects[]     - integer array containing a list of all the objects visited along the path
	      homtree       - the tree to contain the paths
	      obj1 and obj2 - check for paths from obj1 to obj2
	      maxloop       - max endomorphism limit
	Purpose:
	      To generate the reduced hom set from one object to another as a tree
	Design:
	      Creates a tree homtree of all the reduced paths from one object to another.
	*/
	{
		int i, j;
		int endo = 0;
		path = reduce(path);
		int pathlen = path_len(path);
		int numpaths = 0;
	
		if (path[0] == -2)
			path[0] = -1;
		
		for (i=0; i<pathlen; i++)
			if (arr[path[i]][1] == arr[path[pathlen-1]][0])
				endo++;
	
		if (endo < maxloop && pathlen < ini.getMAXWORD()-1)
		{
			int newpath[] = reduce(path);
			if ((!pathtree.containsPath(newpath) || pathlen == 0))
			{
				if (pathlen != 0) pathtree.addPath(newpath);
				// now check all paths from here, recursively
				int arrows[] = new int[num_arrows];

				if (pathlen < ini.getMAXWORD()-1)
					for (i = all_arr(obj1, arrows)-1; i>=0; i--)	// all arrows from obj1
					{
						// add the new arrow to the path, and the new object to the object list
						for (j=path_len(path); j>=0; j--)
							path[j+1] = path[j];
						path[0] = arrows[i];
		
						// recursive check on all paths; like a depth-first search on a graph
						numpaths += makeHomTree(path, homtree, arr[arrows[i]][1], obj2, maxloop, pathtree);
		
						// now remove the arrow and object from the path and object list
						for (j=0; j<=pathlen; j++)
							path[j] = path[j+1];
					}
	
				// if we're at the second object, then add the path to the tree
				if (obj1 == obj2 && pathlen != 0)
				{
					numpaths++;
					homtree.addPath(newpath);
				}
			}
		}
		else
		{
			//this.setEndoPassed(true);
		}
		return numpaths;
	}
		
		
	public String toString()
	{
		return name;
	}
}