Boolean expressions: postfix to multiple infix strings - php

Question

Given following (infix) expression:
(country = be or country = nl) and
(language = en or language = nl) and
message contains twitter
I'd like to create the following 4 infix notations:
message contains twitter and country = be and language = en
message contains twitter and country = be and language = en
message contains twitter and country = nl and language = nl
message contains twitter and country = nl and language = nl
So, basically, I would like to get rid of all OR's.
I already have a postfix notation for the first expression, so I'm currently trying to process that to get the desired notation. This particular situation, however, causes trouble.
(For illustration purposes, the postfix notation for this query would be:)
country be = country nl = or language en = language = nl or and message twitter contains and
Does anyone know of an algorithm to achieve this?

Answer 1

Break the problem into two steps: postfix to multiple postfix, postfix to infix. Each step is performed by "interpreting" a postfix expression.
For the postfix to multiple postfix interpreter: the stack values are collections of postfix expressions. The interpretation rules are as follows.
<predicate>: push a one-element collection containing <predicate>.
AND: pop the top two collections into C1 and C2. With two nested loops,
create a collection containing x y AND for all x in C1 and y in C2.
Push this collection.
OR: pop the top two collections into C1 and C2. Push the union of C1 and C2.
For the postfix to infix interpreter: the stack values are infix expressions.
<predicate>: push <predicate>.
AND: pop two expressions into x and y. Push the expression (x) and (y).
These steps could be combined, but I wanted to present two examples of this technique.

Answer 2

It might be easiest to work with a tree representation. Use the shunting yard algorithm to build a binary tree representing the equation. A node in the tree might be:
class Node {
const OP = 'operator';
const LEAF = 'leaf';
$type = null; // Will be eight Node::OP or Node::LEAF
$op = null; // could be 'or' or 'and' 'contains';
$value = null; // used for leaf eg 'twitter'
$left = null;
$right = null;
}
although you could use sub-classes. In the shunting yard algorithm you want the change the output steps to produce a tree.
Once you have a tree representation you need several algorithms.
First you need an algorithm to copy a tree
public function copy($node) {
if($node->type == Node::LEAF) {
$node2 = new Node();
$node2->type = Node::LEAF;
$node2->value = $node->value;
return $node2;
}
else {
$left = copy($node->left);
$right = copy($node->right);
$node2 = new Node();
$node2->type = Node::OP;
$node2->op = $node->op;
$node2->left = $node->left;
$node2->right = $node->right;
return $node2;
}
}
Next the algorithm to find the first 'or' operator node.
function findOr($node) {
if($node->type == Node::OP && $node->op == 'or') {
return $node;
} else if($node->type == Node::OP ) {
$leftRes = findOr($node->$left);
if( is_null($leftRes) ) {
$rightRes = findOr($node->$right); // will be null or a found node
return $rightRes;
} else {
return $leftRes; // found one on the left, no need to walk rest of tree
}
} else {
return null;
}
}
and finally an algorithm copyLR giving either the left (true) or right (false) branch. It behaves as copy unless the node matches $target when either the left or right branch is returned.
public function copyLR($node,$target,$leftRight) {
if($node == $target) {
if($leftRight)
return copy($node->left);
else
return copy($node->right);
}
else if($node->type == Node::LEAF) {
$node2 = new Node();
$node2->type = Node::LEAF;
$node2->value = $node->value;
return $node2;
}
else {
$left = copy($node->left,$target,$leftRight);
$right = copy($node->right,$target,$leftRight);
$node2 = new Node();
$node2->type = Node::OP;
$node2->op = $node->op;
$node2->left = $node->left;
$node2->right = $node->right;
return $node2;
}
}
The pieces are now put together
$root = parse(); // result from the parsing step
$queue = array($root);
$output = array();
while( count($queue) > 0) {
$base = array_shift($queue);
$target = findOr($base);
if(is_null($target)) {
$output[] = $base; // no or operators found so output
} else {
// an 'or' operator found
$left = copyLR($base,$target,true); // copy the left
$right = copyLR($base,$target,false); // copy the right
array_push($left); // push both onto the end of the queue
array_push($right);
}
}