/////////////////////////////////////////////////////////////////////////////
// set the sepSet of x and y to the minimal such subset of the given sepSet
// and remove the edge <x, y> if background knowledge allows
/////////////////////////////////////////////////////////////////////////////
private void setMinSepSet(List<Node> sepSet, Node x, Node y) {
// It is assumed that BK has been considered before calling this method
// (for example, setting independent1 and independent2 in ruleR0_RFCI)
/*
// background knowledge requires this edge
if (knowledge.noEdgeRequired(x.getNode(), y.getNode()))
{
return;
}
*/
List<Node> empty = Collections.emptyList();
boolean indep;
try {
indep = independenceTest.isIndependent(x, y, empty);
} catch (Exception e) {
indep = false;
}
if (indep) {
getSepsets().set(x, y, empty);
return;
}
int sepSetSize = sepSet.size();
for (int i = 1; i <= sepSetSize; i++) {
ChoiceGenerator cg = new ChoiceGenerator(sepSetSize, i);
int[] combination;
while ((combination = cg.next()) != null) {
List<Node> condSet = GraphUtils.asList(combination, sepSet);
try {
indep = independenceTest.isIndependent(x, y, condSet);
} catch (Exception e) {
indep = false;
}
if (indep) {
getSepsets().set(x, y, condSet);
return;
}
}
}
}
private boolean localMarkovIndep(Node x, Node y, Graph pattern, IndependenceTest test) {
List<Node> future = pattern.getDescendants(Collections.singletonList(x));
List<Node> boundary = pattern.getAdjacentNodes(x);
boundary.removeAll(future);
List<Node> closure = new ArrayList<>(boundary);
closure.add(x);
closure.remove(y);
if (future.contains(y) || boundary.contains(y)) return false;
return test.isIndependent(x, y, boundary);
}
////////////////////////////////////////////
// RFCI Algorithm 4.4 (Colombo et al, 2012)
// Orient colliders
////////////////////////////////////////////
private void ruleR0_RFCI(List<Node[]> rTuples) {
List<Node[]> lTuples = new ArrayList<Node[]>();
List<Node> nodes = graph.getNodes();
///////////////////////////////
// process tuples in rTuples
while (!rTuples.isEmpty()) {
Node[] thisTuple = rTuples.remove(0);
Node i = thisTuple[0];
Node j = thisTuple[1];
Node k = thisTuple[2];
final List<Node> nodes1 = getSepset(i, k);
if (nodes1 == null) continue;
List<Node> sepSet = new ArrayList<Node>(nodes1);
sepSet.remove(j);
boolean independent1 = false;
if (knowledge.noEdgeRequired(i.getName(), j.getName())) // if BK allows
{
try {
independent1 = independenceTest.isIndependent(i, j, sepSet);
} catch (Exception e) {
independent1 = true;
}
}
boolean independent2 = false;
if (knowledge.noEdgeRequired(j.getName(), k.getName())) // if BK allows
{
try {
independent2 = independenceTest.isIndependent(j, k, sepSet);
} catch (Exception e) {
independent2 = true;
}
}
if (!independent1 && !independent2) {
lTuples.add(thisTuple);
} else {
// set sepSets to minimal separating sets
if (independent1) {
setMinSepSet(sepSet, i, j);
graph.removeEdge(i, j);
}
if (independent2) {
setMinSepSet(sepSet, j, k);
graph.removeEdge(j, k);
}
// add new unshielded tuples to rTuples
for (Node thisNode : nodes) {
List<Node> adjacentNodes = graph.getAdjacentNodes(thisNode);
if (independent1) // <i, ., j>
{
if (adjacentNodes.contains(i) && adjacentNodes.contains(j)) {
Node[] newTuple = {i, thisNode, j};
rTuples.add(newTuple);
}
}
if (independent2) // <j, ., k>
{
if (adjacentNodes.contains(j) && adjacentNodes.contains(k)) {
Node[] newTuple = {j, thisNode, k};
rTuples.add(newTuple);
}
}
}
// remove tuples involving either (if independent1) <i, j>
// or (if independent2) <j, k> from rTuples
Iterator<Node[]> iter = rTuples.iterator();
while (iter.hasNext()) {
Node[] curTuple = iter.next();
if ((independent1 && (curTuple[1] == i) && ((curTuple[0] == j) || (curTuple[2] == j)))
|| (independent2 && (curTuple[1] == k) && ((curTuple[0] == j) || (curTuple[2] == j)))
|| (independent1 && (curTuple[1] == j) && ((curTuple[0] == i) || (curTuple[2] == i)))
|| (independent2
&& (curTuple[1] == j)
&& ((curTuple[0] == k) || (curTuple[2] == k)))) {
iter.remove();
}
}
// remove tuples involving either (if independent1) <i, j>
// or (if independent2) <j, k> from lTuples
iter = lTuples.iterator();
while (iter.hasNext()) {
Node[] curTuple = iter.next();
if ((independent1 && (curTuple[1] == i) && ((curTuple[0] == j) || (curTuple[2] == j)))
|| (independent2 && (curTuple[1] == k) && ((curTuple[0] == j) || (curTuple[2] == j)))
|| (independent1 && (curTuple[1] == j) && ((curTuple[0] == i) || (curTuple[2] == i)))
|| (independent2
&& (curTuple[1] == j)
&& ((curTuple[0] == k) || (curTuple[2] == k)))) {
iter.remove();
}
}
}
}
///////////////////////////////////////////////////////
// orient colliders (similar to original FCI ruleR0)
for (Node[] thisTuple : lTuples) {
Node i = thisTuple[0];
Node j = thisTuple[1];
Node k = thisTuple[2];
List<Node> sepset = getSepset(i, k);
if (sepset == null) {
continue;
}
if (!sepset.contains(j) && graph.isAdjacentTo(i, j) && graph.isAdjacentTo(j, k)) {
if (!isArrowpointAllowed(i, j)) {
continue;
}
if (!isArrowpointAllowed(k, j)) {
continue;
}
graph.setEndpoint(i, j, Endpoint.ARROW);
graph.setEndpoint(k, j, Endpoint.ARROW);
printWrongColliderMessage(i, j, k, "R0_RFCI");
}
}
}