private boolean quartetVanishes(Set<Integer> quartet) {
if (quartet.size() != 4)
throw new IllegalArgumentException("Expecting a quartet, size = " + quartet.size());
Iterator<Integer> iter = quartet.iterator();
int x = iter.next();
int y = iter.next();
int z = iter.next();
int w = iter.next();
return testVanishing(x, y, z, w);
}
/** Orients according to background knowledge */
private void fciOrientbk(IKnowledge bk, Graph graph, List<Node> variables) {
logger.log("info", "Starting BK Orientation.");
for (Iterator<KnowledgeEdge> it = bk.forbiddenEdgesIterator(); it.hasNext(); ) {
KnowledgeEdge edge = it.next();
// match strings to variables in the graph.
Node from = SearchGraphUtils.translate(edge.getFrom(), variables);
Node to = SearchGraphUtils.translate(edge.getTo(), variables);
if (from == null || to == null) {
continue;
}
if (graph.getEdge(from, to) == null) {
continue;
}
// Orient to*->from
graph.setEndpoint(to, from, Endpoint.ARROW);
graph.setEndpoint(from, to, Endpoint.CIRCLE);
changeFlag = true;
logger.log(
"knowledgeOrientation",
SearchLogUtils.edgeOrientedMsg("Knowledge", graph.getEdge(from, to)));
}
for (Iterator<KnowledgeEdge> it = bk.requiredEdgesIterator(); it.hasNext(); ) {
KnowledgeEdge edge = it.next();
// match strings to variables in this graph
Node from = SearchGraphUtils.translate(edge.getFrom(), variables);
Node to = SearchGraphUtils.translate(edge.getTo(), variables);
if (from == null || to == null) {
continue;
}
if (graph.getEdge(from, to) == null) {
continue;
}
graph.setEndpoint(to, from, Endpoint.TAIL);
graph.setEndpoint(from, to, Endpoint.ARROW);
changeFlag = true;
logger.log(
"knowledgeOrientation",
SearchLogUtils.edgeOrientedMsg("Knowledge", graph.getEdge(from, to)));
}
logger.log("info", "Finishing BK Orientation.");
}
/** Orients according to background knowledge. */
public static void pcOrientbk(Knowledge bk, Graph graph, List<Node> nodes) {
TetradLogger.getInstance().log("info", "Staring BK Orientation.");
for (Iterator<KnowledgeEdge> it = bk.forbiddenEdgesIterator(); it.hasNext(); ) {
KnowledgeEdge edge = it.next();
// match strings to variables in the graph.
Node from = translate(edge.getFrom(), nodes);
Node to = translate(edge.getTo(), nodes);
if (from == null || to == null) {
continue;
}
if (graph.getEdge(from, to) == null) {
continue;
}
// Orient to-->from
graph.removeEdge(from, to);
graph.addDirectedEdge(from, to);
graph.setEndpoint(from, to, Endpoint.TAIL);
graph.setEndpoint(to, from, Endpoint.ARROW);
TetradLogger.getInstance()
.edgeOriented(SearchLogUtils.edgeOrientedMsg("Knowledge", graph.getEdge(to, from)));
}
for (Iterator<KnowledgeEdge> it = bk.requiredEdgesIterator(); it.hasNext(); ) {
KnowledgeEdge edge = it.next();
// match strings to variables in this graph
Node from = translate(edge.getFrom(), nodes);
Node to = translate(edge.getTo(), nodes);
if (from == null || to == null) {
continue;
}
if (graph.getEdge(from, to) == null) {
continue;
}
// Orient from-->to
graph.setEndpoint(to, from, Endpoint.TAIL);
graph.setEndpoint(from, to, Endpoint.ARROW);
TetradLogger.getInstance()
.edgeOriented(SearchLogUtils.edgeOrientedMsg("Knowledge", graph.getEdge(from, to)));
}
TetradLogger.getInstance().log("info", "Finishing BK Orientation.");
}
// ===========================SCORING METHODS===================//
public double scoreDag(Graph graph) {
Graph dag = new EdgeListGraphSingleConnections(graph);
buildIndexing(graph);
double score = 0.0;
for (Node y : dag.getNodes()) {
Set<Node> parents = new HashSet<Node>(dag.getParents(y));
int nextIndex = -1;
for (int i = 0; i < getVariables().size(); i++) {
nextIndex = hashIndices.get(variables.get(i));
}
int parentIndices[] = new int[parents.size()];
Iterator<Node> pi = parents.iterator();
int count = 0;
while (pi.hasNext()) {
Node nextParent = pi.next();
parentIndices[count++] = hashIndices.get(nextParent);
}
if (this.isDiscrete()) {
score += localDiscreteScore(nextIndex, parentIndices);
} else {
score += localSemScore(nextIndex, parentIndices);
}
}
return score;
}
/**
* Returns a list of all the SessionNodeWrappers (TetradNodes) and SessionNodeEdges that are model
* components for the respective SessionNodes and SessionEdges selected in the workbench. Note
* that the workbench, not the SessionEditorNodes themselves, keeps track of the selection.
*
* @return the set of selected model nodes.
*/
public List getSelectedModelComponents() {
List<Component> selectedComponents = getWorkbench().getSelectedComponents();
List<TetradSerializable> selectedModelComponents = new ArrayList<TetradSerializable>();
for (Iterator<Component> it = selectedComponents.iterator(); it.hasNext(); ) {
Object comp = it.next();
if (comp instanceof DisplayNode) {
selectedModelComponents.add(((DisplayNode) comp).getModelNode());
} else if (comp instanceof DisplayEdge) {
selectedModelComponents.add(((DisplayEdge) comp).getModelEdge());
}
}
return selectedModelComponents;
}
private void addRequiredEdges(Graph graph) {
if (true) return;
if (knowledgeEmpty()) return;
for (Iterator<KnowledgeEdge> it = getKnowledge().requiredEdgesIterator(); it.hasNext(); ) {
KnowledgeEdge next = it.next();
Node nodeA = graph.getNode(next.getFrom());
Node nodeB = graph.getNode(next.getTo());
if (!graph.isAncestorOf(nodeB, nodeA)) {
graph.removeEdges(nodeA, nodeB);
graph.addDirectedEdge(nodeA, nodeB);
TetradLogger.getInstance()
.log("insertedEdges", "Adding edge by knowledge: " + graph.getEdge(nodeA, nodeB));
}
}
for (Edge edge : graph.getEdges()) {
final String A = edge.getNode1().getName();
final String B = edge.getNode2().getName();
if (knowledge.isForbidden(A, B)) {
Node nodeA = edge.getNode1();
Node nodeB = edge.getNode2();
if (nodeA != null
&& nodeB != null
&& graph.isAdjacentTo(nodeA, nodeB)
&& !graph.isChildOf(nodeA, nodeB)) {
if (!graph.isAncestorOf(nodeA, nodeB)) {
graph.removeEdges(nodeA, nodeB);
graph.addDirectedEdge(nodeB, nodeA);
TetradLogger.getInstance()
.log("insertedEdges", "Adding edge by knowledge: " + graph.getEdge(nodeB, nodeA));
}
}
if (!graph.isChildOf(nodeA, nodeB)
&& getKnowledge().isForbidden(nodeA.getName(), nodeB.getName())) {
if (!graph.isAncestorOf(nodeA, nodeB)) {
graph.removeEdges(nodeA, nodeB);
graph.addDirectedEdge(nodeB, nodeA);
TetradLogger.getInstance()
.log("insertedEdges", "Adding edge by knowledge: " + graph.getEdge(nodeB, nodeA));
}
}
} else if (knowledge.isForbidden(B, A)) {
Node nodeA = edge.getNode2();
Node nodeB = edge.getNode1();
if (nodeA != null
&& nodeB != null
&& graph.isAdjacentTo(nodeA, nodeB)
&& !graph.isChildOf(nodeA, nodeB)) {
if (!graph.isAncestorOf(nodeA, nodeB)) {
graph.removeEdges(nodeA, nodeB);
graph.addDirectedEdge(nodeB, nodeA);
TetradLogger.getInstance()
.log("insertedEdges", "Adding edge by knowledge: " + graph.getEdge(nodeB, nodeA));
}
}
if (!graph.isChildOf(nodeA, nodeB)
&& getKnowledge().isForbidden(nodeA.getName(), nodeB.getName())) {
if (!graph.isAncestorOf(nodeA, nodeB)) {
graph.removeEdges(nodeA, nodeB);
graph.addDirectedEdge(nodeB, nodeA);
TetradLogger.getInstance()
.log("insertedEdges", "Adding edge by knowledge: " + graph.getEdge(nodeB, nodeA));
}
}
}
}
}
////////////////////////////////////////////
// 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");
}
}
}