code: public BinaryTree leftBinarize() {
          BinaryTree leftChild;
          BinaryTree rightChild;
          if (isLeaf()) {
              leftChild = null;
              rightChild = null;
          } else if (children.size() == 1) {
              leftChild = children.get(0).leftBinarize();
              rightChild = null;
          } else if (children.size() == 2) {
              leftChild = children.get(0).leftBinarize();
              rightChild = children.get(1).leftBinarize();
          } else {
              // Define the label of the new parent node as in the Berkeley grammar.
              String xbarParent = GrammarConstants.getBinarizedTag(symbol);
              
              LinkedList<NaryTree> queue = new LinkedList<NaryTree>(children);
              // Start by binarizing the left-most child, and store as L.
              leftChild = queue.removeFirst().leftBinarize();
              while (true) {
                  // Working left-to-right, remove and binarize the next-left-most child, and store as R.
                  rightChild = queue.removeFirst().leftBinarize();
                  // Break once we've acquired the right-most child.
                  if (queue.isEmpty()) {
                      break;
                  }
                  // Then form a new binary node that has left/right children: L and R.
                  // That is, a node (@symbolStr --> (L) (R)).
                  // Store this new node as L and repeat.
                  leftChild = new BinaryTree(xbarParent, leftChild.getStart(),
                          rightChild.getEnd(), leftChild, rightChild, isLexical);
              }
          }
          return new BinaryTree(symbol, start, end, leftChild, rightChild , isLexical);                
      }
docs: Get a left-binarized form of this tree.
  
  This returns a binarized form that relabels the nodes just as in the
  Berkeley parser.