getParents(Node node);
/**
* @return true iff node1 is adjacent to node2 in the graph.
*/
boolean isAdjacentTo(Node node1, Node node2);
/**
* Determines whether one node is an ancestor of another.
*/
boolean isAncestorOf(Node node1, Node node2);
/**
* added by ekorber, 2004/06/12
*
* @return true if node1 is a possible ancestor of node2.
*/
boolean possibleAncestor(Node node1, Node node2);
/**
* @return true iff node1 is a child of node2 in the graph.
*/
boolean isChildOf(Node node1, Node node2);
/**
* Determines whether node1 is a parent of node2.
*/
boolean isParentOf(Node node1, Node node2);
/**
* Determines whether one node is a proper ancestor of another.
*/
boolean isProperAncestorOf(Node node1, Node node2);
/**
* Determines whether one node is a proper decendent of another.
*/
boolean isProperDescendentOf(Node node1, Node node2);
/**
* @return true iff node1 is a (non-proper) descendant of node2.
*/
boolean isDescendentOf(Node node1, Node node2);
/**
* A node Y is a definite nondescendent of a node X just in case there is no
* semi-directed path from X to Y.
*
* added by ekorber, 2004/06/12.
*
* @return true if node 2 is a definite nondecendent of node 1
*/
boolean defNonDescendent(Node node1, Node node2);
/**
* Added by ekorber, 2004/6/9.
*
* @return true if node 2 is a definite noncollider between 1 and 3
*/
boolean isDefNoncollider(Node node1, Node node2, Node node3);
/**
* Added by ekorber, 2004/6/9.
*
* @return true if node 2 is a definite collider between 1 and 3
*/
boolean isDefCollider(Node node1, Node node2, Node node3);
/**
* Determines whether one node is d-connected to another. According to
* Spirtes, Richardson & Meek, two nodes are d- connected given some
* conditioning set Z if there is an acyclic undirected path U between them,
* such that every collider on U is an ancestor of some element in Z and
* every non-collider on U is not in Z. Two elements are d-separated just
* in case they are not d-connected. A collider is a node which two edges
* hold in common for which the endpoints leading into the node are both
* arrow endpoints.
*/
boolean isDConnectedTo(Node node1, Node node2, List z);
boolean isPattern();
void setPattern(boolean pattern);
boolean isPag();
void setPag(boolean pag);
/**
* Determines whether one node is d-separated from another. Two elements are E
* d-separated just in case they are not d-connected.
*/
boolean isDSeparatedFrom(Node node1, Node node2, List z);
/**
* Determines if nodes 1 and 2 are possibly d-connected given conditioning
* set z. A path U is possibly-d-connecting if every definite collider on U
* is a possible ancestor of a node in z and every definite non-collider is
* not in z.
*
* added by ekorber, 2004/06/15.
*
* @return true iff nodes 1 and 2 are possibly d-connected given z
*/
boolean possDConnectedTo(Node node1, Node node2, List z);
/**
* @return true iff there is a single directed edge from node1 to node2 in
* the graph.
*/
boolean isDirectedFromTo(Node node1, Node node2);
/**
* @return true iff there is a single undirected edge from node1 to node2 in
* the graph.
*/
boolean isUndirectedFromTo(Node node1, Node node2);
/**
* A directed edge A->B is definitely visible if there is a node C not
* adjacent to B such that C*->A is in the PAG. Added by ekorber,
* 2004/06/11.
*
* @return true if the given edge is definitely visible (Jiji, pg 25)
* @throws IllegalArgumentException if the given edge is not a directed edge
* in the graph
*/
boolean defVisible(Edge edge);
/**
* @return true iff the given node is exogenous in the graph.
*/
boolean isExogenous(Node node);
/**
* Nodes adjacent to the given node with the given proximal endpoint.
*/
List getNodesInTo(Node node, Endpoint n);
/**
* Nodes adjacent to the given node with the given distal endpoint.
*/
List getNodesOutTo(Node node, Endpoint n);
/**
* Removes the given edge from the graph.
*
* @return true if the edge was removed, false if not.
*/
boolean removeEdge(Edge edge);
/**
* Removes the edge connecting the two given nodes, provided there is
* exactly one such edge.
*
* @throws UnsupportedOperationException if multiple edges between node
* pairs are not supported.
*/
boolean removeEdge(Node node1, Node node2);
/**
* Removes all edges connecting node A to node B. In most cases, this will
* remove at most one edge, but since multiple edges are permitted in some
* graph implementations, the number will in some cases be greater than
* one.
*
* @return true if edges were removed, false if not.
*/
boolean removeEdges(Node node1, Node node2);
/**
* Iterates through the list and removes any permissible edges found. The
* order in which edges are added is the order in which they are presented
* in the iterator.
*
* @return true if edges were added, false if not.
*/
boolean removeEdges(Collection edges);
/**
* Removes a node from the graph.
*
* @return true if the node was removed, false if not.
*/
boolean removeNode(Node node);
/**
* Iterates through the list and removes any permissible nodes found. The
* order in which nodes are removed is the order in which they are presented
* in the iterator.
*
* @return true if nodes were added, false if not.
*/
boolean removeNodes(List nodes);
/**
* Sets the endpoint type at the 'to' end of the edge from 'from' to 'to' to
* the given endpoint. Note: NOT CONSTRAINT SAFE
*/
boolean setEndpoint(Node from, Node to, Endpoint endPoint);
/**
* Constructs and returns a subgraph consisting of a given subset of the
* nodes of this graph together with the edges between them.
*/
Graph subgraph(List nodes);
/**
* @return a string representation of the graph.
*/
String toString();
/**
* Transfers nodes and edges from one graph to another. One way this is
* used is to change graph types. One constructs a new graph based on the
* old graph, and this method is called to transfer the nodes and edges of
* the old graph to the new graph.
*
* @param graph the graph from which nodes and edges are to be pilfered.
* @throws java.lang.IllegalArgumentException This exception is thrown if adding some node.
*/
void transferNodesAndEdges(Graph graph) throws IllegalArgumentException;
/**
* @return the list of ambiguous triples associated with this graph. Triples that no longer
* lie along a path in the getModel graph are removed.
*/
Set getAmbiguousTriples();
/**
* @return the set of underlines associated with this graph. This is used currently by ION, DCI, and CCD.
* It used to be used by FCI, but it not in the getModel form. Triples that no longer
* lie along a path in the getModel graph are removed.
*/
Set getUnderLines();
/**
* @return the set of dotted underlines associated with this graph. This used to be used by FCI, but it is
* not used in the getModel form. It is used by CCD. Triples that no longer
* lie along a path in the getModel graph are removed.
*/
Set getDottedUnderlines();
/**
* @return true iff the triple is set as ambiguous. Triples that no longer
* lie along a path in the getModel graph are removed.
*/
boolean isAmbiguousTriple(Node x, Node y, Node z);
/**
* @return true iff the triple is set as underlined. Triples that no longer
* lie along a path in the getModel graph are removed.
*/
boolean isUnderlineTriple(Node x, Node y, Node z);
/**
* @return true iff the triple is set as dotted underlined. Triples that no longer
* lie along a path in the getModel graph are removed.
*/
boolean isDottedUnderlineTriple(Node x, Node y, Node z);
/**
* Adds the triple as an ambiguous triple in the graph.
*
* @throws IllegalArgumentException if does not lie along a path in the graph.
*/
void addAmbiguousTriple(Node x, Node y, Node Z);
/**
* Adds the triple as an underline triple in the graph.
*
* @throws IllegalArgumentException if does not lie along a path in the graph.
*/
void addUnderlineTriple(Node x, Node y, Node Z);
/**
* Adds the triple as a dotted underlined triple in the graph.
*
* @throws IllegalArgumentException if does not lie along a path in the graph.
*/
void addDottedUnderlineTriple(Node x, Node y, Node Z);
/**
* Removes the triple from thet set of ambiguous triples.
*/
void removeAmbiguousTriple(Node x, Node y, Node z);
/**
* Removes the triple from the set of underlined triples.
*/
void removeUnderlineTriple(Node x, Node y, Node z);
/**
* Removes the triple from the set of dotted underlined triples.
*/
void removeDottedUnderlineTriple(Node x, Node y, Node z);
/**
* Sets the list of ambiguous triples to the triples in the given set.
*
* @param triples The new set of ambiguous triples. This replaces the old list.
* @throws IllegalArgumentException if any triple in triples does not lie along a path in the graph.
*/
void setAmbiguousTriples(Set triples);
/**
* Sets the list of underlined triples to the triples in the given set.
*
* @param triples The new list of ambiguous triples. This replaces the old list.
* @throws IllegalArgumentException if any triple in triples does not lie along a path in the graph.
*/
void setUnderLineTriples(Set triples);
/**
* Sets the list of dotted underlined triples to the triples in the given set.
*
* @param triples The new list of dotted underlined triples. This replaces the old list.
* @throws IllegalArgumentException if any triple in triples does not lie along a path in the graph.
*/
void setDottedUnderLineTriples(Set triples);
/**
* @return a tier orderering, for acyclic graphs. Undefined for cyclic graphs.
*/
List getCausalOrdering();
/**
* Sets an edge to be highlighted.
*/
void setHighlighted(Edge edge, boolean highlighted);
/**
* @return true just in case the given edge is highlighted.
* @throws IllegalArgumentException if the given edge is not in the graph.
*/
boolean isHighlighted(Edge edge);
/**
* @return true if the given node is parameterizable.
*/
boolean isParameterizable(Node node);
/**
* @return true if this is a time lag model, in which case getTimeLagGraph() returns the graph.
*/
boolean isTimeLagModel();
/**
* @return the underlying time lag model, if there is one; otherwise, returns null.
*/
TimeLagGraph getTimeLagGraph();
void removeTriplesNotInGraph();
List getSepset(Node n1, Node n2);
void setNodes(List nodes);
}