public Set<Set<Integer>> hopcroftMinimization() {
  Set<Set<Integer>> P = new HashSet<>();
  Set<Set<Integer>> W = new HashSet<>();
  P.add(new HashSet<Integer>(accepting));
  P.add(setSubtraction(states, accepting));
  W.addAll(P);

  while (!W.isEmpty()) {
    System.out.println(W.toString());
    Object[] wArr = W.toArray();
    Object[] pArr = P.toArray();

    for (Object A : wArr) {
      W.remove(A);
      System.out.println(W.toString());
      for (char input : validInputs) {
        Set<Integer> X = findX((Set)A, input);

        for (Object Y : pArr) {
          Set<Integer> xAndY = intersection(X, (Set)Y);
          Set<Integer> yNotX = setSubtraction((Set)Y, X);
          if (!xAndY.isEmpty() && !yNotX.isEmpty()) {
            P.remove(Y);
            P.add(xAndY);
            P.add(yNotX);
            if (W.contains(Y)) {
              W.remove(Y);
              W.add(xAndY);
              W.add(yNotX);
            }
          } else {
            if (xAndY.size() <= yNotX.size()) {
              W.add(xAndY);
            } else {
              W.add(yNotX);
            }
          }
        }
      }

    }
  }

  return P;
}

public Set<Integer> intersection(Set<Integer> A, Set<Integer> B) {
  Set<Integer> ret = new HashSet<>();
  ret.addAll(A);
  ret.retainAll(B);
  return ret;
}

public Set<Integer> setSubtraction(Set<Integer> A, Set<Integer> B) {
  Set<Integer> ret = new HashSet<>();
  ret.addAll(A);
  ret.removeAll(B);
  return ret;
}

public Set<Integer> findX(Set<Integer> currA, char currC) {
  Set<Integer> X = new HashSet<>();
  for (int state : currA) {
    if (map.doesInputLeadToState(currC, state)) {
      X.add(state);
    }
  }
  return X;
}