Team3 regex Disjunctive Normal Form

textdb/textdb-dataflow/src/main/java/edu/uci/ics/textdb/dataflow/regexmatch/GramBooleanQuery.java

@@ -2,6 +2,7 @@
 
 import java.util.ArrayList;
 import java.util.HashSet;
+import java.util.Iterator;
 import java.util.List;
 import java.util.Set;
 import java.util.StringJoiner;
@@ -293,6 +294,152 @@ private static String toLuceneQueryString(GramBooleanQuery query) {
 			}
 		}
 	}
+
+	public boolean isEmpty() {
+		if (this.operandSet.size() > 0) {
+			return false;
+		}
+		for (GramBooleanQuery subQuery : this.subQuerySet) {
+			if (! subQuery.isEmpty()) {
+				return false;
+			}
+		}
+		return true;
+	}
+
+	// "AND" two DNF trees (trees are assumed to be in DNF form)
+	// Apply distributive laws:
+	// a AND (b OR c) = (a AND b) OR (a AND c)
+	// (a OR b) AND (c OR d) = (a AND c) OR (a AND d) OR (b AND c) OR (c AND d)
+	private static GramBooleanQuery andDNF(GramBooleanQuery left, GramBooleanQuery right) {
+		if (left.isEmpty()) {
+			return right;
+		}
+		if (right.isEmpty()) {
+			return left;
+		}
+		GramBooleanQuery resultQuery = new GramBooleanQuery(QueryOp.OR);
+		for (String leftOperand : left.operandSet) {
+			for (String rightOperand : right.operandSet) {
+				GramBooleanQuery tempQuery = new GramBooleanQuery(QueryOp.AND);
+				tempQuery.operandSet.add(leftOperand);
+				tempQuery.operandSet.add(rightOperand);
+				resultQuery.subQuerySet.add(tempQuery);
+			}
+			for (GramBooleanQuery rightSubQuery : right.subQuerySet) {
+				GramBooleanQuery tempQuery = new GramBooleanQuery(QueryOp.AND);
+				tempQuery.operandSet.add(leftOperand);
+				tempQuery.operandSet.addAll(rightSubQuery.operandSet);
+				resultQuery.subQuerySet.add(tempQuery);
+			}
+		}
+		for (GramBooleanQuery leftSubQuery : left.subQuerySet) {
+			for (String rightOperand : right.operandSet) {
+				GramBooleanQuery tempQuery = new GramBooleanQuery(QueryOp.AND);
+				tempQuery.operandSet.addAll(leftSubQuery.operandSet);
+				tempQuery.operandSet.add(rightOperand);
+				resultQuery.subQuerySet.add(tempQuery);
+			}
+			for (GramBooleanQuery rightSubQuery : right.subQuerySet) {
+				GramBooleanQuery tempQuery = new GramBooleanQuery(QueryOp.AND);
+				tempQuery.operandSet.addAll(leftSubQuery.operandSet);
+				tempQuery.operandSet.addAll(rightSubQuery.operandSet);
+				resultQuery.subQuerySet.add(tempQuery);
+			}
+		}
+		return resultQuery;
+	}
+
+
+	/**
+	 * Simplify a tree, which is assumed to be already in DNF form
+	 * Apply Absorption laws: a OR (a AND b) = a
+	 * 
+	 * Simplification is extremely important, because it removes lots of redundant information, 
+	 * thus enabling comparison of two trees, 
+	 *
+	 * @param DNFQuery
+	 * @return simplifiedDNFQuery
+	 */
+	public static GramBooleanQuery simplifyDNF(GramBooleanQuery query) {
+		GramBooleanQuery result = new GramBooleanQuery(QueryOp.OR);
+		result.operandSet.addAll(query.operandSet);
+
+		Iterator<GramBooleanQuery> outerIterator = query.subQuerySet.iterator();
+		OuterLoop:
+		while (outerIterator.hasNext()) {
+			GramBooleanQuery outerAndQuery = outerIterator.next();
+			for (String operand : query.operandSet) {
+				if (outerAndQuery.operandSet.contains(operand)) {
+					continue OuterLoop;
+				}
+			}
+			Iterator<GramBooleanQuery> innerIterator = query.subQuerySet.iterator();
+			while (innerIterator.hasNext()) {
+				GramBooleanQuery innerAndQuery = innerIterator.next();
+				if (outerAndQuery != innerAndQuery) {
+					if (outerAndQuery.operandSet.containsAll(innerAndQuery.operandSet)) {
+						outerIterator.remove();
+						continue OuterLoop;
+					}				
+				}
+			}
+			// if reach this code, then add a copy of it to result
+			GramBooleanQuery tempQuery = new GramBooleanQuery(QueryOp.AND);
+			tempQuery.operandSet.addAll(outerAndQuery.operandSet);
+			result.subQuerySet.add(tempQuery);
+		}
+
+		return query;
+	}
+
 
+	/**
+	 * The query tree generated by the translator is messy with possibly lots of redundant information.
+	 * This function transforms it into Disjunctive normal form (DNF), which is an OR of different ANDs.
+	 * 
+	 * To transform a tree to DNF form, the following laws are applied recursively from bottom to top:
+	 * Associative laws: (a OR b) OR c = a OR (b OR c) = a OR b OR c, when transforming OR nodes,
+	 * Distributive laws: a AND (b OR c) = (a AND b) OR (a AND c), when transforming AND nodes,
+	 * 
+	 * For each node, its children will be transformed to DNF form first, then 
+	 * if it's OR, apply associative laws, if it's AND, apply distributive laws.
+	 * Then recursively apply the same rules all the way up to the top node.
+	 * 
+	 * The result is NOT simplified. Must call simplifyDNF() to obtain the optimal tree.
+	 * 
+	 * @param query
+	 * @return DNFQuery
+	 */
+	public static GramBooleanQuery toDNF(GramBooleanQuery query) {
+		if (query.operator == QueryOp.AND) {
+			GramBooleanQuery firstOrNode = new GramBooleanQuery(QueryOp.OR);
+			if (query.operandSet.size() != 0) {
+				GramBooleanQuery firstAndNode = new GramBooleanQuery(QueryOp.AND);
+				firstAndNode.operandSet.addAll(query.operandSet);
+				firstOrNode.subQuerySet.add(firstAndNode);
+			}
+
+			ArrayList<GramBooleanQuery> subDNFList = new ArrayList<>();
+			for (GramBooleanQuery subQuery : query.subQuerySet) {
+				subDNFList.add(toDNF(subQuery));
+			}
+
+			GramBooleanQuery result = subDNFList.stream().reduce(firstOrNode, (left, right) -> andDNF(left, right));
+			return result;
+		} else if (query.operator == QueryOp.OR) {
+			GramBooleanQuery result = new GramBooleanQuery(QueryOp.OR);
+			result.operandSet.addAll(query.operandSet);
+			for (GramBooleanQuery subQuery : query.subQuerySet) {
+				GramBooleanQuery newSubQuery = toDNF(subQuery);
+				result.subQuerySet.addAll(newSubQuery.subQuerySet);
+				result.operandSet.addAll(newSubQuery.operandSet);
+			}
+			return result;
+		}
+
+		// ANY or NONE, no need to simplify
+		return query;
+	}
 
 }