/*
Research Project:   Graphical Database for Category Theory
                    J. Bradbury, Dr. R. Rosebrugh, I. Rutherford
                    Mount Allison University 2001
File:               MakeConfluentFrame.java
Description:	      This file is displayed when the user selects the "Make
                    Confluent " menu option in the main window. The user
                    can select a category from a choice menu and then
                    changes made to the category to make it confluent will be
                    displayed in the text area. To save the changes to the current
                    category press "ok".
*/

//import statements
import java.awt.*;
import java.awt.event.*;

public class MakeConfluentFrame extends Frame
{
  Category cat = new Category();
  CategoryList l = new CategoryList();
  int check_enter = 0;

  //Array to store relations that needed to be
  //added to current category in order to make it confluent.
  String newRelations = new String();

  //Constants
  IniSettings ini = new IniSettings();
  
  //Objects in the Graphical User Interface(GUI)
  Button exit = new Button();
  Panel button_panel = new Panel();
  BorderLayout borderLayout1 = new BorderLayout();
  Button okButton = new Button();
  Button cancelButton = new Button();
  Label label2 = new Label();
  TextArea textArea1 = new TextArea("", 10, 10, TextArea.SCROLLBARS_VERTICAL_ONLY);
  MainWindow edit;
  TextField categoryField = new TextField();
  GridBagLayout gridBagLayout1 = new GridBagLayout();
  GBConstraintsEditor g = new GBConstraintsEditor();

  public MakeConfluentFrame(MainWindow ed)
  //Default Constructor with the list of categories and the ok
  //button as parameters
  {
    edit = ed;
    cat.copyCategory(ed.cat);
    edit.enableMenus(false);
    try  {
      jbInit();
    }
    catch (Exception e) {
      e.printStackTrace();
    }
  }

  public boolean handleEvent(Event e)
  {
    if ((e.id == Event.WINDOW_DESTROY) || (e.id == Event.ACTION_EVENT))
    {
     edit.enableMenus(true);
     hide();            //hide frame
     dispose();         //free resources
     return true;
    }
    else if (e.key == Event.ENTER)
    {
      if (check_enter == 0)
       check_enter++;
      else
      {
       edit.enableMenus(true);
       hide();            //hide frame
       dispose();         //free resources
      }
      return true;
    }
    return super.handleEvent(e);
  }

  public boolean action(Event e, Object o)
  {
    if ((e.target == exit) || (e.key == Event.ENTER))
    {
      edit.enableMenus(true);
      hide();            //hide frame
      dispose();         //free resources
      return true;
    }
    return false;
  }

  private void jbInit() throws Exception
  //This function intializes the GUI
  {
    this.setTitle("GDCT: Make Category Confluent");
    this.setBackground(new Color(192,192,192));
    okButton.setLabel("OK");
    okButton.addActionListener(new java.awt.event.ActionListener() {
      public void actionPerformed(ActionEvent e) {
        okButton_actionPerformed(e);
      }
    });
    cancelButton.setLabel("Cancel");
    cancelButton.addActionListener(new java.awt.event.ActionListener() {
      public void actionPerformed(ActionEvent e) {
        cancelButton_actionPerformed(e);
      }
    });
    label2.setText("Current Category:");
    this.setLayout(gridBagLayout1);
    categoryField.setBackground(Color.white);
    this.add(okButton, g.getConstraints(0, 2, 2, 1, 0.0, 0.0
            ,GridBagConstraints.CENTER, GridBagConstraints.NONE, new Insets(6, 17, 8, 0), 114, 8));
    this.add(cancelButton, g.getConstraints(2, 2, 1, 1, 0.0, 0.0
            ,GridBagConstraints.CENTER, GridBagConstraints.NONE, new Insets(6, 7, 8, 15), 95, 8));
    this.add(label2, g.getConstraints(0, 0, 1, 1, 0.0, 0.0
            ,GridBagConstraints.WEST, GridBagConstraints.NONE, new Insets(7, 17, 0, 0), 0, 0));
    this.add(textArea1, g.getConstraints(0, 1, 3, 1, 1.0, 1.0
            ,GridBagConstraints.CENTER, GridBagConstraints.BOTH, new Insets(7, 17, 0, 15), 205, -72));
    this.add(categoryField, g.getConstraints(2, 0, 1, 1, 1.0, 0.0
            ,GridBagConstraints.WEST, GridBagConstraints.HORIZONTAL, new Insets(7, 0, 0, 16), 128, 2));
    categoryField.setText(cat.name);
    categoryField.setEditable(false);
    textArea1.setBackground(Color.white);
    make_confluent();    //Call confluence
  }

  void okButton_actionPerformed(ActionEvent e)
  //Function called when OK button is pressed. This function
  //take the string in the nameField and makes it the name of
  //the current category
  {
    if (!newRelations.equals(""))
    {
      //textArea1.append("HERE");
      //Indicate that relations have been added
      //to the category through the make confluent tool
      cat.mod.madeConfluent = true;

      //Save modified category in list
      edit.catList.replaceNode(cat);
      edit.cat.copyCategory(cat);

      //Edit graphical display of category
      GMLEditor gEdit = new GMLEditor();
      gEdit.addRelation(cat, newRelations);

      //Display category graphically
      edit.displayCategoryGraph(cat.gml, edit.graph_);
      //edit.displayCategory(edit.cat);
      //edit.GraphCategory(edit.graph_, edit.graphCanvas_, edit.cat);
    }
    //Close frame
    edit.enableMenus(true);
    hide();
    dispose();
  }

  void cancelButton_actionPerformed(ActionEvent e)
  {
  	edit.enableMenus(true);
  	hide();
  	dispose();
  }

  public int overlap(int path1[], int path2[])
  /*
  Parameters:
        path1, path2: arrays of integers representing two paths of arrows.
  Purpose:
        To determine if there is an overlap between the two paths and to
        return its length; if there is no overlap, returns -1.
  Design:
        Compare the beginning of path1 to the end of path2.  If they are
        the same, return the size of the overlap; otherwise return -1.
  */
  {
    int i, k;
    //the length of the smaller of path1 and path2
    int size =0;
    //temporary variables to store portions of path1 and path2
    int temp1[] = new int [edit.ini.getMAXWORD()];
    int temp2[] = new int [edit.ini.getMAXWORD()];

    if(path_len(path1) > path_len(path2))
    {
      size = path_len(path2);
    }
    else
    {
      size = path_len(path1);
    }
    for(i=0;i<size;i++)
    {
      temp1 = copy_path(temp1,path1);
      temp1[size-i] = -1;
      for(k=0;k<size-i;k++)
      {
        int indexof = path_len(path2) - size + k +i;
        temp2[k] = path2[indexof];
      }
      temp2[k] = -1;
      if(equals(temp1,temp2))
      {
        return(size-i);
      }
    }
    return(-1);
  }

  public void add_relation(int w1[], int w2[])
  /*
  Parameters:
        w1,w2:  arrays of integers representing paths which are the left and
                        right sides of a relation to be added to the category.
        A:      pointer to the current category.
  Purpose:
        To add the relation w1 = w2 to the set of relations in the category *A.
  Design:
        The number of relations in the category is incremented.  Whichever of
        w1 and w2 has the greater order is stored as the left side of the new
        relation, and the other as the right side.
  */
  {
    Relation r = new Relation();

    cat.num_rel++;

    if (greater(w1,w2))
    {
      r.lhs = copy_path(r.lhs,w1);
      r.rhs = copy_path(r.rhs,w2);
    }
    else
    {
      r.lhs = copy_path(r.lhs,w2);
      r.rhs = copy_path(r.rhs,w1);
    }
    cat.rel_set[cat.num_rel-1] = r;

    int i = 0;
    while (cat.rel_set[cat.num_rel-1].lhs[i] != -1)
    {
      //textArea1.append("cat.rel_set[cat.num_rel-1].lhs[" + i + "] = " + cat.rel_set[cat.num_rel-1].lhs[i] + "\n");
      i++;
    }
    i = 0;
    while (cat.rel_set[cat.num_rel-1].rhs[i] != -1)
    {
      //textArea1.append("cat.rel_set[cat.num_rel-1].rhs[" + i + "] = " + cat.rel_set[cat.num_rel-1].rhs[i] + "\n");
      i++;
    }

    //Display  on the screen relation that is being added to category
    textArea1.append("\nThe relation " + path_to_string(cat.rel_set[cat.num_rel-1].lhs, cat));
    textArea1.append(" = " + path_to_string(cat.rel_set[cat.num_rel-1].rhs, cat) + " will be added to the set of relations.");

    //Add relatiom to graphical dispaly of category
    if (newRelations.equals(""))
      newRelations = path_to_string(cat.rel_set[cat.num_rel-1].lhs, cat) + " = " + path_to_string(cat.rel_set[cat.num_rel-1].rhs, cat);
    else
      newRelations = newRelations  + ", " + path_to_string(cat.rel_set[cat.num_rel-1].lhs, cat) + " = " + path_to_string(cat.rel_set[cat.num_rel-1].rhs, cat);
  }

  public boolean reduce_overlap(Relation rel1, Relation rel2, int olap_size)
  /*
  Parameters:
        rel1, rel2:     two relations from the current category whose left sides
                        have an overlap.
        olap_size:      the size of the overlap between rel1 and rel2.
        A:              pointer to the current category.
  Purpose:
        To check to see that rel1 and rel2 satisfy the Overlap rule of the
        Knuth-Bendix algorithm and if not, to add a relation to the set
        of relations in the category.  Returns a boolean indicating whether
        or not a relation was added.
  Design:
        Construct r1 and r2 as described below in the variable declarations.
        If w1 and w2 (the reduced forms of r1 and r2) are not equal, then
        add the relation w1 = w2 to the category.
  */
  {
    //arrows in left side of rel1 BEFORE the overlap, plus right side of rel2
    int r1[] = new int [edit.ini.getMAXWORD()];
    // right side of rel1, plus arrows in left side of rel2 AFTER the overlap
    int r2[] = new int [edit.ini.getMAXWORD()];
    //reduced forms of r1 and r2
    int w1[] = new int [edit.ini.getMAXWORD()];
    int w2[] = new int [edit.ini.getMAXWORD()];
    //temporary variable to store path
    int temp[] = new int[edit.ini.getMAXWORD()];

    //textArea1.append("Entering reduce_overlap()\n");
    //Copy the rhs of rel1 into r2
    r2 = copy_path(r2,rel1.rhs);
    //Copy subpath of rel2 (ie. arrows after overlap) into temp array
    temp = copy_sub(temp, rel2.lhs, olap_size, path_len(rel2.lhs)-olap_size);
    //Append temp array to r2
    r2 = append_path(r2,temp);

    //Copy subpath of rel1(ie. arrows before the overlap) into r1
    r1 = copy_sub(r1, rel1.lhs, 0, path_len(rel1.lhs) - olap_size);
    //Append the rhs of rel2 to r1
    r1 = append_path(r1, rel2.rhs);

    //textArea1.append("Reducing r1 to w1\n");
    //textArea1.append("r1 = ");
    if (r1[0] == -2)
    {
     // textArea1.append(" 1 \n");
    }
    else
    {
      int i=0;
      while (r1[i] != -1)
      {
    //    textArea1.append(" " + r1[i] + " ");
        i++;
      }
    //  textArea1.append("\n");
    }

    //Reduce r1 and r2 into w1 and w2
    w1 = reduce(w1, r1, cat);
    //textArea1.append("Reducing r2 to w2\n");
    w2 = reduce(w2, r2, cat);

    //textArea1.append("Comparing w1 and w2 for equality\n");

    //If the reduced forms of r1 and r2 are not equal,
    //add relation w1 = w2 to category
    if (!(equals(w1,w2)))
    {
      add_relation(w1,w2);
    //  textArea1.append("Leaving reduce_overlap() [Relations added]\n");
      return(true);
    }
    //textArea1.append("Leaving reduce_overlap() [No relations added]\n");
    return(false);
  }

  public boolean reduce_subpath(Relation rel1, Relation rel2, int location)
  /*
  Parameters:
        rel1, rel2:     two relations from the current category where the left
                        side of rel2 is a subpath of the left side of rel1.
        location:       the location of rel2 inside rel1.
        A:              pointer to the current category.
  Purpose:
        To check to see that rel1 and rel2 satisfy the Subpath rule of the
        Knuth-Bendix algorithm and if not, to add a relation to the set of
        relations in the category.  Returns a boolean indicating whether
        or not a relation was added.
  Design:
        Construct r1 and r2 as described below in the variable declarations.
        If w1 and w2 (the reduced forms of r1 and r2) are not equal, then
        add the relation w1 = w2 to the category.
  */
  {
    //right side of rel1
    int r1[] = new int [edit.ini.getMAXWORD()];
    //left side of rel1 with left side of rel2
    //(substring) replaced by right side of rel2
    int r2[] = new int [edit.ini.getMAXWORD()];
    //reduced forms of r1 and r2
    int w1[] = new int [edit.ini.getMAXWORD()];
    int w2[] = new int [edit.ini.getMAXWORD()];
    //temporary variable to store path
    int temp[] = new int [edit.ini.getMAXWORD()];

    //Copy rhs of rel1 into r1
    r1 = copy_path(r1,rel1.rhs);

    //Copy subpath of lhs of rel1 into r2
    r2 = copy_sub(r2,rel1.lhs,0,location);

    //Append rhs of rel2 to r2
    r2 = append_path(r2,rel2.rhs);
    //Copy a subpath of lhs of re11 into temp
    temp = copy_sub(temp,rel1.lhs,location+path_len(rel2.lhs),path_len(rel1.lhs)-(location+path_len(rel2.lhs)));
    //Append temp to r2
    r2 = append_path(r2,temp);

    //Reduce r1 and r2 into w1 and w2
    w1 = reduce(w1,r1, cat);
    w2 = reduce(w2,r2, cat);

    //If the reduced forms of r1 and r2 are not equal,
    //add relation w1 = w2 to category
    if (!equals(w1,w2))
    {
      add_relation(w1,w2);
      return(true);
    }
    return(false);
  }

  public void make_confluent()
  /*
  Parameter:
        A:      pointer to the current category
  Purpose:
        To check all pairs of relations in the category for the Overlap and
        Subpath rules and to add relations to make the set of relations confluent.
  Design:
        Using a double for loop, compare all pairs of relations.  Check for
        any overlaps between the left sides of the two relations, and call
        function reduce_overlap to add any relations necessary to make the
        set of relations confluent.  Then, check if the left side of one
        relation is a subpath of the other left side, and call function
        reduce_subpath to add any necessary relations to the category.
  */
  {
    //set to true when all overlaps and subpaths have been checked,
    //and the set of relations is confluent
    boolean done;
    //set to true when all overlaps have been checked
    boolean finished;

    int i,j;
    //size of an overlap between two paths
    int size;
    //location of one path inside another
    int loc;
    //position in one path to begin searching for another path as a substring
    int position;
    //temporary variables to store paths
    int temp1[] = new int [edit.ini.getMAXWORD()];
    int temp2[] = new int [edit.ini.getMAXWORD()];

    //Initialize done to fale
    done = false;
    //While not done...
    while(!done)
    {
      done = true;
    //  textArea1.appendText("NUMBER OF RELATIONS IN CATEGORY = " + cat.num_rel + "\n");
      //For all of the relations in category cat
      for(i=0;i<cat.num_rel;i++)
      {
    //    textArea1.append("---------------------------------\n");
    //    textArea1.append("Cat Relation Number = " + i + "\n");
        //For all other relations in category cat
        for(j=0;j<cat.num_rel;j++)
        {
          //If an overlap between the lhs of the two relations exists...
          if((size = overlap(cat.rel_set[j].lhs,cat.rel_set[i].lhs)) != -1)
          {
     //       textArea1.appendText("Size of overlap = " + size+ "\n");
            //Set finished to false
            finished = false;
     //       textArea1.appendText("EnteringLoop while!(finished)\n");
            while(!finished)
            {
     //         textArea1.appendText("Comparing Relation " + i + " to Relation = " + j + "\n");
              Relation t1 = cat.rel_set[i];
              Relation t2 = cat.rel_set[j];
              //If a relation was added to the category
              //due to overlap, set done to false
              if(reduce_overlap(t1,t2,size))
              {
     //           textArea1.append("Reduce_overlap() added a relation [Done = false]\n");
                done = false;
              }
              //viewbox.appendText("size =" + size);
              //If size of overlap is 1 then set finished
              //to equal true
              if(size == 1)
              {
                //viewbox.appendText("\nfinished = true");
                finished = true;
              }
              //If size of overlap is greater than 1
              else
              {
                //viewbox.appendText("make con");
                size--;
                //Into temp1 copy a subpath of lhs of current relation (ie. copy
                //the last size arrows in path
                temp1 = copy_sub(temp1,cat.rel_set[i].lhs,(path_len(cat.rel_set[i].lhs) - size),size);
                //Into temp2 copy the first size arrows of lhs of current relation
                temp2 = copy_sub(temp2,cat.rel_set[j].lhs,0,size);

                //If temp1 equals temp2 let finished by true
                if(!equals(temp1,temp2))
                {
                  //viewbox.appendText("\nfinished = true2");
                  finished = true;
                }
              }
            }
      //      textArea1.appendText("Exiting Loop while!(finished)\n");
          }
          //workbox.getText();
          //Set position to be zero
          position = 0;
          //Starting at position searc for lhs of relation j inside lhs of relation
          //i until search returns a match
          while((loc = search(cat.rel_set[i].lhs,cat.rel_set[j].lhs,position)) != -1)
          {
            //Set position to be loc + 1
            position = loc + 1;
            //Call reduce subpath on relations i and j
            //and set done to false if true
            if(reduce_subpath(cat.rel_set[j],cat.rel_set[i],loc))
            {
              done = false;
            }
          }
        }
      }
    }
    if (textArea1.getText().equals(""))
      textArea1.appendText("No relations need to be added to the category");
    textArea1.appendText("\nThe set of reductions is now confluent...");
  }

  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 them at all
  */
  {
    int i;

    if((path_len(path1)) == (path_len(path2)))
    {
      for(i=0;i<path_len(path1);i++)
      {
        if(path1[i] != path2[i])
        {
          return(false);
        }
      }
      return(true);
    }
    else
    {
      return(false);
    }
  }

  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
  Design:
        Returns the position where the subpath begins in the path being searched,
         and -1 if sub is not a subpath of target
  */
  {
    int i,j;
    boolean found;  //Boolean variable to show if the subpath has been found

    //Initialize found to false
    found = false;
    //Search for subpath in target starting at start
    for (i=start;i<path_len(target);i++)
    {
      if (sub[0] == target[i])
      {
        found = true;
        for (j=0;j<path_len(sub);j++)
        {
          if (target[i+j] != sub[j])
          {
            found = false;
          }
        }
      }
      if (found)
      {
        break;
      }
    }
    //If the subpath is found, return the position
    //at which it starts in target
    if (found)
    {
      return(i);
    }
    //If the subpath is not found return -1
    else
    {
      return(-1);
    }
  }

  public int[] copy_sub(int dest[], int source[], int start, int length)
  /*
  Parameters:
        dest:   a substring of source is copied into dest
        source: a substring of source is copied into dest
        start:  the position in source at which the substring starts
        length: the length of the substring
  Purpose:
        To copy a substring of one array into another array
  Design:
          Makes dest equal a substring of source
  */
  {
    int i;

    //Starting at position start in source, copy length
    //arrows from dest
    for(i=0;i<length;i++)
    {
      dest[i] = source[start+i];
    }
    //End the path of arrows with a -1
    dest[i] = -1;
    return(dest);
  }

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

    //Copy the path being reduced into reducedpath
    reducedpath = copy_path(reducedpath,path);
    //For all of the relations in the category...
    for (i=0;i<c.num_rel;i++)
    {
      //if lhs of relation is a subpath of reducedpath...
      if((spot = search(c.rel_set[i].lhs,reducedpath,0)) != -1)
      {
        //Starting at the spot where lhs of relation is in reducedpath,
        //copy the rhs of relation into the reduced path
        //NOTE-This makes sense since lhs > rhs is always true
        for (j=spot;j<spot+path_len(c.rel_set[i].rhs);j++)
        {
          reducedpath[j] = c.rel_set[i].rhs[j - spot];
        }
        //viewbox.appendText("reducedpath[i] = " + reducedpath[i]  + "\n");

        //Assign path length of reducedpath to integere temp
        temp = path_len(reducedpath);
        //Determine the difference between the lhs and the rhs
        //of the current relation
        diff = path_len(c.rel_set[i].lhs) - path_len(c.rel_set[i].rhs);
        //Move all arrows in reduced path that are located above subpath that
        //was relpaced down in the array by the value diff
        for (j=spot+path_len(c.rel_set[i].lhs);j<temp;j++)
        {
          reducedpath[j - diff] = reducedpath[j];
        }
        //Append a -1 to the end of the new reducedpath
        reducedpath[j - diff] = -1;
        i = -1;
      }
    }
    return(reducedpath);
  }

  public int[] append_path(int dest[], int source[])
  /*
  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 integers to another array of integers, all terminated
        by -1
  Design:
        Appends source to dest
  */
  {
    int i;
    int size = path_len(dest);

    if (source[0] == -2)
      return(dest);

    //append source to end of destination
    for(i=0;i<=path_len(source);i++)
    {
      dest[size+i] = source[i];
    }
    //return destination array
    return (dest);
  }

  public String path_to_string(int path[], Category A)
  /*
  Parameters:
        path:   the path to be converted to a string(function does not change
                path)
        A:      a category that contains the arrows of the path
  Purpose:
        To convert an array of integers, which represent arrows, terminated by -1
        into a path which is a string of characters which are arrows and the string
        is terminated by \0.
  Design:
        Returns a string which is the path represented by the integers in the
        integer array
  */
  {
    int i;
    String temp = new String();

    //If path is an identity arrow return "1"
    if (path_len(path) == 0)
    {
      return("1");
    }
    else
    {
      for(i=0;i<path_len(path);i++)
      {
        //If current arrow is not the last
        //append a * after it
        if (i < path_len(path)-1)
  		    temp = temp + A.arrow[path[i]] + "*";
        else
  		    temp = temp + A.arrow[path[i]];
      }
      //temp = temp + '\0';
      return(temp);
    }
  }

  public int path_len(int path[])
  /*
  Parameters:
        path:   an array of integers terminated by -1 which is a path
  Purpose:
        To determine the length of an array of integers terminated by -1
  Design:
        Returns the number of integers in the path, does not count -1
  */
  {
    //length of path
    int length = 0;

    //If identity arrow return
    //length of 0
    if (path[0] == -2)
      return(0);
    //Otherwise determine the length
    //of the path of arrows
    else
    {
      while (path[length] != -1)
      {
        length++;
      }
      return(length);
    }
  }

  public int[] copy_path(int dest[], int source[])
  /*
  Parameters:
        dest:   an array of integers which will be set to equal source
        source: an array of integers which is copied into dest
  Purpose:
         To copy one array of integers to another array of integers
  Design:
        Copies source into dest
  */
  {
    int i;
    int temp[] = new int [edit.ini.getMAXWORD()];

    for(i=0;i<=path_len(source);i++)
    {
      temp[i] = source[i];
    }
    return(temp);
  }

  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 path1 is longer than it is greater
    //so return true
    if(path_len(path1) > path_len(path2))
    {
      return(true);
    }
    //Otherwise...
    else
    {
      //If the paths are equal in length
      if ((path_len(path1)) == (path_len(path2)))
      {
        //if ((path_len(path1) == 1) && (path1[0] == cons.id_code))
        //  return(false);
        j = 0;
        while  (j < path_len(path1))
        {
          //If index of current arrow in path2 is greater
          //then that in path1 return false since path2
          //is greater than path1
          if (path2[j] > path1[j])
          {
            return(false);
          }
          //If index of current arrow in path2 is less than
          //that in path1 return true since path1
          //is greater than path2
          else
          {
            if (path2[j] < path1[j])
            {
              return(true);
            }
          }
          j++;
        }
      }
    }
    //If path2 is greater in length than
    //path1 then return false
    return(false);
  }
}