public static Set<DefaultRule> selectNonisomorphicDefaultRules( Iterable<DefaultRule> defaultRules) { List<Clause> candidates = new ArrayList<Clause>(); for (DefaultRule rule : defaultRules) { DefaultRule preprocessed = preprocess(rule); candidates.add( new Clause( Sugar.<Literal>iterable( preprocessed.antecedent().literals(), preprocessed.consequent().literals()))); } Matching m = new Matching(); Set<DefaultRule> retVal = new HashSet<DefaultRule>(); for (Clause c : m.nonisomorphic(candidates)) { List<Literal> head = new ArrayList<Literal>(); List<Literal> body = new ArrayList<Literal>(); for (Literal l : c.literals()) { Literal newLiteral = new Literal( l.predicate().substring(l.predicate().indexOf(":") + 1), l.isNegated(), l.arity()); for (int i = 0; i < l.arity(); i++) { newLiteral.set(l.get(i), i); } if (l.predicate().startsWith("antecedent:") || l.predicate().startsWith(SymmetricPredicates.PREFIX + "antecedent:")) { body.add(newLiteral); } else { head.add(newLiteral); } } retVal.add(new DefaultRule(new Clause(body), new Clause(head))); } return retVal; }
public int compare(Clause clause1, Clause clause2) { if (clause1.getNumOfLiterals() < clause2.getNumOfLiterals()) { return -1; } else { return 1; } }
// ------------------------------------------------------------------------------- // find the literal that minimizes the number of UNSAT clauses private int findLiteral(boolean[] minterm) { int num_lits = cnf.num_lits, best = -Integer.MAX_VALUE, tos = 0; for (int i = 0; i < cnf.curr; i++) cnf.clauses[i].flag = cnf.clauses[i].satisfies(minterm) ? 1 : 0; for (int i = 0; i < num_lits; i++) { int sat = 0; for (Enumeration e = cnf.vars[i].occurs.elements(); e.hasMoreElements(); ) { Clause c = (Clause) e.nextElement(); boolean was_sat = (c.flag == 1); minterm[i] = !minterm[i]; boolean new_sat = c.satisfies(minterm); minterm[i] = !minterm[i]; if (was_sat && !new_sat) sat--; if (!was_sat && new_sat) sat++; } if (sat > best) { tos = 0; best = sat; } if (best == sat) stack[tos++] = i; } return (tos == 0) ? random(num_lits) : stack[random(tos)]; }
public static Literal allDiffLiteral(Clause c) { Literal l = new Literal(SpecialVarargPredicates.ALLDIFF, c.variables().size()); int i = 0; for (Variable v : c.variables()) { l.set(v, i++); } return l; }
// make private? public Clause maxClause() { Clause maxClause = null; for (Clause clause : clauses) { if (maxClause == null || clause.ordinal() > maxClause.ordinal()) { maxClause = clause; } } assert maxClause != null; return maxClause; }
private static MultiMap<Variable, Variable> surelyDifferent(DefaultRule rule) { Clause body = rule.antecedent(); Clause head = rule.consequent(); final MultiMap<Variable, Variable> different = new MultiMap<Variable, Variable>(); for (Literal literal : Sugar.union( body.getLiteralsByPredicate(SpecialBinaryPredicates.NEQ), body.getLiteralsByPredicate(SpecialBinaryPredicates.GT), body.getLiteralsByPredicate(SpecialBinaryPredicates.LT), body.getLiteralsByPredicate(SpecialVarargPredicates.ALLDIFF), head.getLiteralsByPredicate(SpecialBinaryPredicates.NEQ), head.getLiteralsByPredicate(SpecialBinaryPredicates.GT), head.getLiteralsByPredicate(SpecialBinaryPredicates.LT), head.getLiteralsByPredicate(SpecialVarargPredicates.ALLDIFF))) { for (Term a : literal.terms()) { if (a instanceof Variable) { Variable v1 = (Variable) a; for (Term b : literal.terms()) { if (b instanceof Variable) { Variable v2 = (Variable) b; if (v1 != v2) { different.put(v1, v2); } } } } } } return different; }
public boolean resolve(LinkedList<Clause> clauses) { // Storing onto the stack to verify clauses in reverse order // LinkedList<Clause> expansionStack = new LinkedList<Clause>(); PriorityQueue<Clause> expansionQueue = new PriorityQueue<Clause>(10000, new ClauseSizeComparator()); for (int count = 0; count < clauses.size(); count++) { expansionQueue.add(clauses.get(count)); } while (!expansionQueue.isEmpty()) // Until the stack is empty { Clause lastClause = expansionQueue.poll(); for (int clauseCount = 0; clauseCount < lastClause.getClauseID() - 1; clauseCount++) { // If any new clauses are added since last execution // if(!clauses.getLast().equals(lastClause)) { // break; } Clause tempClause = clauses.get(clauseCount); int numClausesBeforeExpansion = clauses.size(); boolean result = lastClause.resolution(tempClause, clauses); if (!result) { return false; } int numClausesAfterExpansion = clauses.size(); // System.out.println(numClausesAfterExpansion - numClausesBeforeExpansion); //Size does not // change // If new clauses are added, expand the newly added clause before expanding any other clause if (numClausesAfterExpansion - numClausesBeforeExpansion > 0) { expansionQueue.add(clauses.getLast()); } } } return true; }
/** * Once you have a Result of implementing a child relational expression, call this method to * create a Builder to implement the current relational expression by adding additional clauses * to the SQL query. * * <p>You need to declare which clauses you intend to add. If the clauses are "later", you can * add to the same query. For example, "GROUP BY" comes after "WHERE". But if they are the same * or earlier, this method will start a new SELECT that wraps the previous result. * * <p>When you have called {@link Builder#setSelect(org.eigenbase.sql.SqlNodeList)}, {@link * Builder#setWhere(org.eigenbase.sql.SqlNode)} etc. call {@link * Builder#result(org.eigenbase.sql.SqlNode, java.util.Collection, org.eigenbase.rel.RelNode)} * to fix the new query. * * @param rel Relational expression being implemented * @param clauses Clauses that will be generated to implement current relational expression * @return A builder */ public Builder builder(JdbcRel rel, Clause... clauses) { final Clause maxClause = maxClause(); boolean needNew = false; for (Clause clause : clauses) { if (maxClause.ordinal() >= clause.ordinal()) { needNew = true; } } SqlSelect select; Expressions.FluentList<Clause> clauseList = Expressions.list(); if (needNew) { select = subSelect(); } else { select = asSelect(); clauseList.addAll(this.clauses); } clauseList.addAll(Arrays.asList(clauses)); Context newContext; final SqlNodeList selectList = select.getSelectList(); if (selectList != null) { newContext = new Context(selectList.size()) { @Override public SqlNode field(int ordinal) { final SqlNode selectItem = selectList.get(ordinal); switch (selectItem.getKind()) { case AS: return ((SqlCall) selectItem).operand(0); } return selectItem; } }; } else { newContext = new AliasContext(aliases, aliases.size() > 1); } return new Builder(rel, clauseList, select, newContext); }
public void printProofTree(Clause finalClause, LinkedList<Clause> clauseList) { PriorityQueue<Integer> proofTree = new PriorityQueue< Integer>(); // Will be used to order the ancestors of the finalClause for output LinkedList<Clause> treeQueue = new LinkedList< Clause>(); // Will take in the ancestors of the finalClause. Dequeue each element, add // it to the proofTree, then add the parents to the queue int[] parentIDs; treeQueue.add(finalClause); while (!treeQueue.isEmpty()) { Clause polledClause = treeQueue.poll(); if (proofTree.contains( polledClause .getClauseID())) // Skip this iteration if the clause has already been added to the // proofTree { continue; } proofTree.add(polledClause.getClauseID()); parentIDs = polledClause.getParentIDs(); if (parentIDs[0] != -1) // if one parent exists, the other must exist and we add the parents to the queue { treeQueue.add(clauseList.get(parentIDs[0] - 1)); // add the first parent to the queue treeQueue.add(clauseList.get(parentIDs[1] - 1)); // add the second parent to the queue } } // output all the clauses in the proof tree while (proofTree.peek() != null) { clauseList.get(proofTree.poll() - 1).outputClause(); } }
public static boolean isomorphic(DefaultRule a, DefaultRule b) { a = preprocess(a); b = preprocess(b); Matching m = new Matching(); Clause ca = new Clause(Sugar.iterable(a.antecedent().literals(), a.consequent().literals())); Clause cb = new Clause(Sugar.iterable(b.antecedent().literals(), b.consequent().literals())); return ca.variables().size() == cb.variables().size() && ca.literals().size() == cb.literals().size() && m.isomorphism(ca, cb); }
private static Clause preprocessClause(Clause c, String prefix) { List<Literal> newLiterals = new ArrayList<Literal>(); int specialID = 0; for (Literal l : c.literals()) { String predicate = l.predicate(); if (predicate.equals(SpecialBinaryPredicates.NEQ) || predicate.equals(SpecialBinaryPredicates.EQ) || predicate.equals(SpecialVarargPredicates.ALLDIFF)) { predicate = SymmetricPredicates.PREFIX + prefix + predicate; } else { predicate = prefix + predicate; } Literal newLit = new Literal(predicate, l.isNegated(), l.arity()); for (int i = 0; i < l.arity(); i++) { newLit.set(l.get(i), i); } newLiterals.add(newLit); } return new Clause(newLiterals); }
public static void main(String[] args) { DefaultRule a = new DefaultRule(Clause.parse("a(X)"), Clause.parse("a(Y)")); DefaultRule b = new DefaultRule(Clause.parse("a(A)"), Clause.parse("a(B)")); DefaultRule c = new DefaultRule(Clause.parse("a(A)"), Clause.parse("a(A)")); DefaultRule d = new DefaultRule(Clause.parse("a(A,a)"), Clause.parse("b(B,b)")); DefaultRule e = new DefaultRule(Clause.parse("a(A,b)"), Clause.parse("b(B,a)")); DefaultRule f = new DefaultRule(Clause.parse("a(A,c)"), Clause.parse("b(B,d)")); for (DefaultRule r : selectNonisomorphicDefaultRules(Sugar.list(a, b, c, d))) { System.out.println(r); } System.out.println( partitionInterchangeableConstants(Sugar.list(a, b, c, d, e, f), Sugar.<Clause>set())); }
public static MultiMap<DefaultRule, DefaultRule> representativeBodySpecializations( DefaultRule rule, List<Set<Constant>> interchangeableConstants) { Clause body = rule.antecedent(); Clause head = rule.consequent(); final MultiMap<Variable, Variable> different = surelyDifferent(rule); final List<Variable> variables = Sugar.<Variable>listFromCollections(body.variables()); List<Integer> indices = VectorUtils.toList(VectorUtils.sequence(0, variables.size() - 1)); List<Tuple<Integer>> unifications = Combinatorics.<Integer>cartesianPower( indices, indices.size(), new Sugar.Fun<Tuple<Integer>, Boolean>() { @Override public Boolean apply(Tuple<Integer> integerTuple) { for (int i = 0; i < integerTuple.size(); i++) { if (integerTuple.get(i) > i || !integerTuple.get(i).equals(integerTuple.get(integerTuple.get(i))) || different .get(variables.get(integerTuple.get(i))) .contains(variables.get(i)) || !sameType(variables.get(integerTuple.get(i)), variables.get(i))) { return Boolean.FALSE; } } return Boolean.TRUE; } }); Set<DefaultRule> nonIsomorphicUnifications = new HashSet<DefaultRule>(); for (Tuple<Integer> unification : unifications) { Map<Term, Term> substitution = new HashMap<Term, Term>(); for (int i = 0; i < unification.size(); i++) { substitution.put(variables.get(i), variables.get(unification.get(i))); } Clause newBody = LogicUtils.substitute(rule.antecedent(), substitution); Clause newHead = LogicUtils.substitute(rule.consequent(), substitution); nonIsomorphicUnifications.add( new DefaultRule( newBody.variables().size() > 1 ? new Clause(Sugar.union(newBody.literals(), allDiffLiteral(newBody))) : newBody, newHead)); } nonIsomorphicUnifications = DefaultTransformationUtils.selectNonisomorphicDefaultRules(nonIsomorphicUnifications); MultiMap<DefaultRule, DefaultRule> retVal = new MultiMap<DefaultRule, DefaultRule>(); // this needs to be improved... e.g. using typing information... MultiList<Integer, Constant> consts = new MultiList<Integer, Constant>(); int index = 0; for (Set<Constant> interch : interchangeableConstants) { consts.putAll(index++, interch); } for (DefaultRule unifiedRule : nonIsomorphicUnifications) { List<Variable> unifsVariables = Sugar.listFromCollections(unifiedRule.variables()); if (unifsVariables.isEmpty()) { retVal.put(unifiedRule, unifiedRule); } else { Set<DefaultRule> substituted = new HashSet<DefaultRule>(); middleLoop: for (Tuple<Integer> tuple : Combinatorics.cartesianPower( new NaturalNumbersList(0, interchangeableConstants.size()), unifsVariables.size())) { Counters<Integer> used = new Counters<Integer>(); Map<Term, Term> substitution = new HashMap<Term, Term>(); for (int i = 0; i < unifsVariables.size(); i++) { int j = used.incrementPost(tuple.get(i)); if (j >= consts.get(tuple.get(i)).size()) { continue middleLoop; } else { if (unifsVariables.get(i).type() == null) { substitution.put( unifsVariables.get(i), Variable.construct( unifsVariables.get(i).name(), consts.get(tuple.get(i)).get(j).type())); } else { if (unifsVariables.get(i).type().equals(consts.get(tuple.get(i)).get(j).type())) { substitution.put( unifsVariables.get(i), Variable.construct( unifsVariables.get(i).name(), consts.get(tuple.get(i)).get(j).type())); } else { continue middleLoop; } } } } substituted.add(DefaultTransformationUtils.substitute(unifiedRule, substitution)); } retVal.putAll( unifiedRule, DefaultTransformationUtils.selectNonisomorphicDefaultRules(substituted)); } } return retVal; }