private static MultiList<Object, Set<Constant>> partitionExchangeable_impl(
Iterable<DefaultRule> rules) {
MultiMap<Term, Term> partitioning = new MultiMap<Term, Term>();
List<Term> constants = Sugar.arrayListFromCollections(constants(rules));
Set<Term> closed = new HashSet<Term>();
// checking interchangeability pairwise
for (int i = 0; i < constants.size(); i++) {
if (!closed.contains(constants.get(i))) {
partitioning.put(constants.get(i), constants.get(i));
for (int j = i + 1; j < constants.size(); j++) {
if (areExchangeable(constants.get(i), constants.get(j), rules)) {
partitioning.put(constants.get(i), constants.get(j));
closed.add(constants.get(j));
}
}
}
}
Map<Constant, Constant> map = new HashMap<Constant, Constant>();
for (Map.Entry<Term, Set<Term>> entry : partitioning.entrySet()) {
Constant lexmin = null;
for (Term t : entry.getValue()) {
if (t instanceof Constant) {
if (lexmin == null || t.toString().compareTo(lexmin.toString()) < 0) {
lexmin = (Constant) t;
}
}
}
for (Term t : entry.getValue()) {
if (t instanceof Constant) {
map.put((Constant) t, lexmin);
}
}
}
MultiMap<Pair<Object, Constant>, Constant> mm =
new MultiMap<Pair<Object, Constant>, Constant>();
for (Map.Entry<Constant, Constant> entry : map.entrySet()) {
mm.put(
new Pair<Object, Constant>(
entry.getValue().type() == null ? Sugar.NIL : entry.getValue().type(),
entry.getValue()),
entry.getKey());
}
MultiList<Object, Set<Constant>> retVal = new MultiList<Object, Set<Constant>>();
for (Map.Entry<Pair<Object, Constant>, Set<Constant>> entry : mm.entrySet()) {
retVal.put(entry.getKey().r, entry.getValue());
}
return retVal;
}
public static Triple<Set<DefaultRule>, Set<Clause>, List<Set<Constant>>> preprocessConstants(
Collection<DefaultRule> rules,
Collection<Clause> hardRules,
List<Set<Constant>> interchangeable) {
final Map<Term, Term> typedConstants = new HashMap<Term, Term>();
List<Set<Constant>> retInterchangeable = new ArrayList<Set<Constant>>();
for (Set<Constant> set : interchangeable) {
String type = min(set).name();
Set<Constant> newSet = new HashSet<Constant>();
for (Constant c : set) {
Constant typedConstant = Constant.construct(c.name(), type);
typedConstants.put(c, typedConstant);
newSet.add(typedConstant);
}
retInterchangeable.add(newSet);
}
Collection<DefaultRule> retDefaultRules =
Sugar.funcall(
rules,
new Sugar.Fun<DefaultRule, DefaultRule>() {
@Override
public DefaultRule apply(DefaultRule defaultRule) {
return DefaultTransformationUtils.substitute(defaultRule, typedConstants);
}
});
Collection<Clause> retHardRules =
Sugar.funcall(
hardRules,
new Sugar.Fun<Clause, Clause>() {
@Override
public Clause apply(Clause hardRule) {
return LogicUtils.substitute(hardRule, typedConstants);
}
});
return new Triple<Set<DefaultRule>, Set<Clause>, List<Set<Constant>>>(
Sugar.setFromCollections(retDefaultRules),
Sugar.setFromCollections(retHardRules),
Sugar.listFromCollections(retInterchangeable));
}