SemanticGraph (Stanford JavaNLP API)

java.lang.Object
- edu.stanford.nlp.semgraph.SemanticGraph

All Implemented Interfaces:

java.io.Serializable
```
public class SemanticGraph
extends java.lang.Object
implements java.io.Serializable
```
Represents a semantic graph of a sentence or document, with IndexedWord objects for nodes. Notes: The root is not at present represented as a vertex in the graph. At present you need to get a root/roots from the separate roots variable and to know about it. This should maybe be changed, because otherwise, doing things like simply getting the set of nodes or edges from the graph doesn't give you root nodes or edges. Given the kinds of representations that we normally use with typedDependenciesCollapsed, there can be (small) cycles in a SemanticGraph, and these cycles may involve the node that is conceptually the root of the graph, so there may be no node without a parent node. You can better get at the root(s) via the variable and methods provided. There is no mechanism for returning all edges at once (e.g., edgeSet()). This is intentional. Use edgeIterable() to iterate over the edges if necessary.

Author:

Christopher Cox, Teg Grenager

See Also:

SemanticGraphEdge, IndexedWord, Serialized Form

Nested Class Summary

Nested Classes
Modifier and Type Class and Description

static class SemanticGraph.OutputFormat

Nested Classes
Modifier and Type	Class and Description
`static class`	`SemanticGraph.OutputFormat`

Field Summary

Fields
Modifier and Type Field and Description

static boolean addSRLArcs

Fields
Modifier and Type	Field and Description
`static boolean`	`addSRLArcs`

Constructor Summary

Constructors
Constructor and Description
`SemanticGraph()`
`SemanticGraph(java.util.Collection<TypedDependency> dependencies)` This is the constructor used by the parser.
`SemanticGraph(SemanticGraph g)` Returns a new SemanticGraph which is a copy of the supplied SemanticGraph.
`SemanticGraph(SemanticGraph g, java.util.Map<IndexedWord,IndexedWord> prevToNewMap)` Copies a the current graph, but also sets the mapping from the old to new graph.

Method Summary

All Methods Static Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`void`	`addComment(java.lang.String comment)` Store a comment line with this semantic graph.
`SemanticGraphEdge`	`addEdge(IndexedWord s, IndexedWord d, GrammaticalRelation reln, double weight, boolean isExtra)`
`SemanticGraphEdge`	`addEdge(SemanticGraphEdge edge)`
`void`	`addRoot(IndexedWord root)`
`void`	`addVertex(IndexedWord vertex)`
`boolean`	`attachedNegatedVerb(IndexedWord vertex)`
`java.util.List<Pair<GrammaticalRelation,IndexedWord>>`	`childPairs(IndexedWord vertex)` Returns a list of pairs of a relation name and the child IndexedFeatureLabel that bears that relation.
`java.util.Set<GrammaticalRelation>`	`childRelns(IndexedWord vertex)` Returns a list of relations which this node has with its children.
`int`	`commonAncestor(IndexedWord v1, IndexedWord v2)` Return the maximum distance to a least common ancestor.
`boolean`	`containsEdge(IndexedWord source, IndexedWord target)`
`boolean`	`containsEdge(SemanticGraphEdge edge)`
`boolean`	`containsVertex(IndexedWord vertex)`
`void`	`deleteDuplicateEdges()` Delete all duplicate edges.
`java.util.Set<IndexedWord>`	`descendants(IndexedWord vertex)` Returns the set of descendants governed by this node in the graph.
`int`	`edgeCount()`
`java.lang.Iterable<SemanticGraphEdge>`	`edgeIterable()`
`java.util.List<SemanticGraphEdge>`	`edgeListSorted()` Returns an ordered list of edges in the graph.
`boolean`	`equals(java.lang.Object o)`
`java.util.List<SemanticGraphEdge>`	`findAllRelns(GrammaticalRelation tgtRelation)` Given a semantic graph, and a target relation, returns a list of all relations (edges) matching.
`java.util.List<SemanticGraphEdge>`	`findAllRelns(java.lang.String tgtRelationShortname)` Given a semantic graph, and the short name of a target relation, returns a list of all relations (edges) matching.
`java.util.List<SemanticGraphEdge>`	`getAllEdges(IndexedWord gov, IndexedWord dep)`
`java.util.List<IndexedWord>`	`getAllNodesByPartOfSpeechPattern(java.lang.String pattern)`
`java.util.List<IndexedWord>`	`getAllNodesByWordPattern(java.lang.String pattern)` Returns all nodes of type `IndexedWord` in this `SemanticGraph` having the given word or regex, or returns empty list if no such found.
`java.util.List<IndexedWord>`	`getChildList(IndexedWord vertex)`
`java.util.Set<IndexedWord>`	`getChildren(IndexedWord vertex)`
`java.util.Set<IndexedWord>`	`getChildrenWithReln(IndexedWord vertex, GrammaticalRelation reln)` Returns a set of all children bearing a certain grammatical relation, or an empty set if none.
`java.util.Set<IndexedWord>`	`getChildrenWithRelns(IndexedWord vertex, java.util.Collection<GrammaticalRelation> relns)` Returns a set of all children bearing one of a set of grammatical relations, or an empty set if none.
`IndexedWord`	`getChildWithReln(IndexedWord vertex, GrammaticalRelation reln)` Returns the first IndexedFeatureLabel bearing a certain grammatical relation, or null if none.
`java.util.List<java.lang.String>`	`getComments()` Return the list of comments stored with this graph.
`IndexedWord`	`getCommonAncestor(IndexedWord v1, IndexedWord v2)` Returns the least common ancestor.
`SemanticGraphEdge`	`getEdge(IndexedWord gov, IndexedWord dep)`
`SemanticGraphEdge`	`getEdge(IndexedWord gov, IndexedWord dep, GrammaticalRelation reln)` Given a governor, dependent, and the relation between them, returns the SemanticGraphEdge object of that arc if it exists, otherwise returns null.
`IndexedWord`	`getFirstRoot()` Returns the (first) root of this SemanticGraph.
`java.util.List<SemanticGraphEdge>`	`getIncomingEdgesSorted(IndexedWord vertex)`
`java.util.Set<IndexedWord>`	`getLeafVertices()`
`IndexedWord`	`getNodeByIndex(int index)` Returns the first `IndexedWord` in this `SemanticGraph` having the given integer index, or throws `IllegalArgumentException` if no such node is found.
`IndexedWord`	`getNodeByIndexAndCopyCount(int index, int copyCount)` Returns the first `IndexedWord` in this `SemanticGraph` having the given integer index, or throws `IllegalArgumentException` if no such node is found.
`IndexedWord`	`getNodeByIndexAndCopyCountSafe(int index, int copyCount)` Same as above, but returns `null` if the index does not exist (instead of throwing an exception).
`IndexedWord`	`getNodeByIndexSafe(int index)` Same as above, but returns `null` if the index does not exist (instead of throwing an exception).
`IndexedWord`	`getNodeByWordPattern(java.lang.String pattern)` Returns the first `IndexedWord` in this `SemanticGraph` having the given word or regex, or return null if no such found.
`java.util.List<SemanticGraphEdge>`	`getOutEdgesSorted(IndexedWord vertex)`
`IndexedWord`	`getParent(IndexedWord vertex)` Return the real syntactic parent of vertex.
`java.util.List<IndexedWord>`	`getParentList(IndexedWord vertex)`
`java.util.Set<IndexedWord>`	`getParents(IndexedWord vertex)`
`java.util.Set<IndexedWord>`	`getParentsWithReln(IndexedWord vertex, GrammaticalRelation reln)` Returns a set of all parents bearing a certain grammatical relation, or an empty set if none.
`java.util.Set<IndexedWord>`	`getParentsWithReln(IndexedWord vertex, java.lang.String relnName)` Returns a set of all parents bearing a certain grammatical relation, or an empty set if none.
`java.util.List<IndexedWord>`	`getPathToRoot(IndexedWord vertex)` Find the path from the given node to a root.
`java.util.Collection<IndexedWord>`	`getRoots()`
`java.util.List<SemanticGraphEdge>`	`getShortestDirectedPathEdges(IndexedWord source, IndexedWord target)`
`java.util.List<IndexedWord>`	`getShortestDirectedPathNodes(IndexedWord source, IndexedWord target)` Returns the shortest directed path between two edges in the graph.
`java.util.List<SemanticGraphEdge>`	`getShortestUndirectedPathEdges(IndexedWord source, IndexedWord target)`
`java.util.List<IndexedWord>`	`getShortestUndirectedPathNodes(IndexedWord source, IndexedWord target)` Returns the nodes in the shortest undirected path between two edges in the graph.
`java.util.Collection<IndexedWord>`	`getSiblings(IndexedWord vertex)` Method for getting the siblings of a particular node.
`java.util.Set<IndexedWord>`	`getSubgraphVertices(IndexedWord root)` Returns all nodes reachable from `root`.
`boolean`	`hasChild(IndexedWord vertex, GrammaticalRelation reln, java.lang.String childLemma)` Does the given `vertex` have at least one child with the given `reln` and the lemma `childLemma`?
`boolean`	`hasChildren(IndexedWord vertex)`
`boolean`	`hasChildWithReln(IndexedWord vertex, GrammaticalRelation reln)` Does the given `vertex` have at least one child with the given `reln`?
`int`	`hashCode()`
`boolean`	`hasParentWithReln(IndexedWord vertex, GrammaticalRelation reln)` Returns true if vertex has an incoming relation reln
`java.lang.Iterable<SemanticGraphEdge>`	`incomingEdgeIterable(IndexedWord v)`
`java.util.Iterator<SemanticGraphEdge>`	`incomingEdgeIterator(IndexedWord v)`
`java.util.List<SemanticGraphEdge>`	`incomingEdgeList(IndexedWord v)`
`int`	`inDegree(IndexedWord vertex)`
`int`	`isAncestor(IndexedWord child, IndexedWord ancestor)` Searches up to 2 levels to determine how far ancestor is from child (i.e., returns 1 if "ancestor" is a parent, or 2 if ancestor is a grandparent.
`boolean`	`isAuxiliaryVerb(IndexedWord vertex)` Returns true iff this vertex stands in the "aux" relation to (any of) its parent(s).
`boolean`	`isDag()`
`boolean`	`isDag(IndexedWord root)`
`boolean`	`isEmpty()`
`boolean`	`isInConditionalContext(IndexedWord vertex)` Check if the vertex is in a "conditional" context.
`boolean`	`isNegatedVertex(IndexedWord vertex)`
`boolean`	`isRoot(IndexedWord vertex)`
`SemanticGraph`	`makeSoftCopy()`
`boolean`	`matchPatternToVertex(java.lang.String pattern, IndexedWord vertex)`
`boolean`	`matchPatternToVertex(java.lang.String pattern, IndexedWord vertex, boolean det)`
`int`	`outDegree(IndexedWord vertex)`
`java.lang.Iterable<SemanticGraphEdge>`	`outgoingEdgeIterable(IndexedWord v)`
`java.util.Iterator<SemanticGraphEdge>`	`outgoingEdgeIterator(IndexedWord v)`
`java.util.List<SemanticGraphEdge>`	`outgoingEdgeList(IndexedWord v)`
`java.util.List<Pair<GrammaticalRelation,IndexedWord>>`	`parentPairs(IndexedWord vertex)` Returns a list of pairs of a relation name and the parent IndexedFeatureLabel to which we bear that relation.
`void`	`prettyPrint()` Pretty-prints this semantic graph to `System.out`, formatted by the default semantic graph formatter.
`void`	`prettyPrint(SemanticGraphFormatter formatter)` Pretty-prints this semantic graph to `System.out`, formatted by the supplied semantic graph formatter.
`GrammaticalRelation`	`reln(IndexedWord a, IndexedWord b)` Returns the relation that node a has with node b.
`java.util.Set<GrammaticalRelation>`	`relns(IndexedWord vertex)` Returns a set of relations which this node has with its parents.
`boolean`	`removeEdge(SemanticGraphEdge e)`
`boolean`	`removeVertex(IndexedWord vertex)`
`void`	`resetRoots()` This method should not be used if possible.
`void`	`setRoot(IndexedWord word)`
`void`	`setRoots(java.util.Collection<IndexedWord> words)`
`int`	`size()` Returns the number of nodes in the graph
`java.lang.String`	`toCompactString()`
`java.lang.String`	`toCompactString(boolean showTags)`
`java.lang.String`	`toDotFormat()` Returns an unnamed dot format digraph.
`java.lang.String`	`toDotFormat(java.lang.String graphname)` Returns a dot format digraph with the given name.
`java.lang.String`	`toDotFormat(java.lang.String graphname, CoreLabel.OutputFormat indexedWordFormat)`
`java.lang.String`	`toEnUncollapsedSentenceString()` Similar to `toRecoveredString`, but will fill in words that were collapsed into relations (i.e.
`java.lang.String`	`toFormattedString()` Returns a `String` representation of this semantic graph, formatted by the default semantic graph formatter.
`java.lang.String`	`toFormattedString(SemanticGraphFormatter formatter)` Returns a `String` representation of this semantic graph, formatted by the supplied semantic graph formatter.
`java.lang.String`	`toList()` Returns a String representation of this graph as a list of typed dependencies, as exemplified by the following:
`java.util.List<IndexedWord>`	`topologicalSort()`
`java.lang.String`	`toPOSList()` Similar to toList(), but uses POS tags instead of word and index.
`java.lang.String`	`toRecoveredSentenceString()`
`java.lang.String`	`toRecoveredSentenceStringWithIndexMarking()`
`java.lang.String`	`toString()` Recursive depth first traversal.
`java.lang.String`	`toString(CoreLabel.OutputFormat wordFormat)`
`java.lang.String`	`toString(SemanticGraph.OutputFormat format)` Returns a String representation of the result of this set of typed dependencies in a user-specified format.
`java.util.Collection<TypedDependency>`	`typedDependencies()` Returns a list of TypedDependency in the graph.
`boolean`	`updateEdge(SemanticGraphEdge edge, GrammaticalRelation reln)`
`static SemanticGraph`	`valueOf(java.lang.String s)`
`static SemanticGraph`	`valueOf(java.lang.String s, int sentIndex)`
`static SemanticGraph`	`valueOf(java.lang.String s, Language language)`
`static SemanticGraph`	`valueOf(java.lang.String s, Language language, java.lang.Integer sentIndex)` Tries to parse a String representing a SemanticGraph.
`java.util.List<IndexedWord>`	`vertexListSorted()` This returns an ordered list of vertices (based upon their indices in the sentence).
`java.util.Set<IndexedWord>`	`vertexSet()`
`java.util.List<IndexedWord>`	`yield(IndexedWord word)` Returns the yield of a node, i.e., all descendents of the node.
`Pair<java.lang.Integer,java.lang.Integer>`	`yieldSpan(IndexedWord word)` Returns the span of the subtree yield of this node.

Methods inherited from class java.lang.Object
clone, finalize, getClass, notify, notifyAll, wait, wait, wait

- Field Detail
  - addSRLArcs
```
public static final boolean addSRLArcs
```
    See Also:
    
    Constant Field Values
- Constructor Detail
  - SemanticGraph
```
public SemanticGraph()
```
  - SemanticGraph
```
public SemanticGraph(SemanticGraph g)
```
    Returns a new SemanticGraph which is a copy of the supplied SemanticGraph. Both the nodes (IndexedWords) and the edges (SemanticGraphEdges) are copied.
  - SemanticGraph
```
public SemanticGraph(SemanticGraph g,
                     java.util.Map<IndexedWord,IndexedWord> prevToNewMap)
```
    Copies a the current graph, but also sets the mapping from the old to new graph.
  - SemanticGraph
```
public SemanticGraph(java.util.Collection<TypedDependency> dependencies)
```
    This is the constructor used by the parser.
- Method Detail
  - edgeCount
```
public int edgeCount()
```
  - outDegree
```
public int outDegree(IndexedWord vertex)
```
  - inDegree
```
public int inDegree(IndexedWord vertex)
```
  - getAllEdges
```
public java.util.List<SemanticGraphEdge> getAllEdges(IndexedWord gov,
                                                     IndexedWord dep)
```
  - getEdge
```
public SemanticGraphEdge getEdge(IndexedWord gov,
                                 IndexedWord dep)
```
  - addVertex
```
public void addVertex(IndexedWord vertex)
```
  - containsVertex
```
public boolean containsVertex(IndexedWord vertex)
```
  - containsEdge
```
public boolean containsEdge(IndexedWord source,
                            IndexedWord target)
```
  - containsEdge
```
public boolean containsEdge(SemanticGraphEdge edge)
```
  - vertexSet
```
public java.util.Set<IndexedWord> vertexSet()
```
  - removeEdge
```
public boolean removeEdge(SemanticGraphEdge e)
```
  - removeVertex
```
public boolean removeVertex(IndexedWord vertex)
```
  - updateEdge
```
public boolean updateEdge(SemanticGraphEdge edge,
                          GrammaticalRelation reln)
```
  - vertexListSorted
```
public java.util.List<IndexedWord> vertexListSorted()
```
    This returns an ordered list of vertices (based upon their indices in the sentence). This creates and sorts a list, so prefer vertexSet unless you have a good reason to want nodes in index order.
    
    Returns:
    
    Ordered list of vertices
  - edgeListSorted
```
public java.util.List<SemanticGraphEdge> edgeListSorted()
```
    Returns an ordered list of edges in the graph. This creates and sorts a list, so prefer edgeIterable().
    
    Returns:
    
    A ordered list of edges in the graph.
  - edgeIterable
```
public java.lang.Iterable<SemanticGraphEdge> edgeIterable()
```
  - outgoingEdgeIterator
```
public java.util.Iterator<SemanticGraphEdge> outgoingEdgeIterator(IndexedWord v)
```
  - outgoingEdgeIterable
```
public java.lang.Iterable<SemanticGraphEdge> outgoingEdgeIterable(IndexedWord v)
```
  - incomingEdgeIterator
```
public java.util.Iterator<SemanticGraphEdge> incomingEdgeIterator(IndexedWord v)
```
  - incomingEdgeIterable
```
public java.lang.Iterable<SemanticGraphEdge> incomingEdgeIterable(IndexedWord v)
```
  - outgoingEdgeList
```
public java.util.List<SemanticGraphEdge> outgoingEdgeList(IndexedWord v)
```
  - incomingEdgeList
```
public java.util.List<SemanticGraphEdge> incomingEdgeList(IndexedWord v)
```
  - isEmpty
```
public boolean isEmpty()
```
  - isAncestor
```
public int isAncestor(IndexedWord child,
                      IndexedWord ancestor)
```
    Searches up to 2 levels to determine how far ancestor is from child (i.e., returns 1 if "ancestor" is a parent, or 2 if ancestor is a grandparent.
    
    Parameters:
    
    child - candidate child
    
    ancestor - candidate ancestor
    
    Returns:
    
    the number of generations between "child" and "ancestor" (1 is an immediate parent), or -1 if there is no relationship found.
  - commonAncestor
```
public int commonAncestor(IndexedWord v1,
                          IndexedWord v2)
```
    Return the maximum distance to a least common ancestor. We only search as high as grandparents. We return -1 if no common parent or grandparent is found.
    
    Returns:
    
    The maximum distance to a least common ancestor.
  - getCommonAncestor
```
public IndexedWord getCommonAncestor(IndexedWord v1,
                                     IndexedWord v2)
```
    Returns the least common ancestor. We only search as high as grandparents. We return null if no common parent or grandparent is found. Any of the input words can also be the answer if one is the parent or grandparent of other, or if the input words are the same.
    
    Returns:
    
    The least common ancestor.
  - matchPatternToVertex
```
public boolean matchPatternToVertex(java.lang.String pattern,
                                    IndexedWord vertex,
                                    boolean det)
```
  - matchPatternToVertex
```
public boolean matchPatternToVertex(java.lang.String pattern,
                                    IndexedWord vertex)
```
  - getChildList
```
public java.util.List<IndexedWord> getChildList(IndexedWord vertex)
```
  - getChildren
```
public java.util.Set<IndexedWord> getChildren(IndexedWord vertex)
```
  - hasChildren
```
public boolean hasChildren(IndexedWord vertex)
```
  - getIncomingEdgesSorted
```
public java.util.List<SemanticGraphEdge> getIncomingEdgesSorted(IndexedWord vertex)
```
  - getOutEdgesSorted
```
public java.util.List<SemanticGraphEdge> getOutEdgesSorted(IndexedWord vertex)
```
  - getParentList
```
public java.util.List<IndexedWord> getParentList(IndexedWord vertex)
```
  - getParents
```
public java.util.Set<IndexedWord> getParents(IndexedWord vertex)
```
  - getSiblings
```
public java.util.Collection<IndexedWord> getSiblings(IndexedWord vertex)
```
    Method for getting the siblings of a particular node. Siblings are the other children of your parent, where parent is determined as the parent returned by getParent
    
    Returns:
    
    collection of sibling nodes (does not include vertex) the collection is empty if your parent is null
  - getPathToRoot
```
public java.util.List<IndexedWord> getPathToRoot(IndexedWord vertex)
```
    Find the path from the given node to a root. The path does not include the given node. Returns an empty list if vertex is a root. Returns null if a root is inaccessible (should never happen).
  - getParent
```
public IndexedWord getParent(IndexedWord vertex)
```
    Return the real syntactic parent of vertex.
  - getNodeByIndex
```
public IndexedWord getNodeByIndex(int index)
                           throws java.lang.IllegalArgumentException
```
    Returns the first IndexedWord in this SemanticGraph having the given integer index, or throws IllegalArgumentException if no such node is found.
    
    Throws:
    
    java.lang.IllegalArgumentException
  - getNodeByIndexSafe
```
public IndexedWord getNodeByIndexSafe(int index)
```
    Same as above, but returns null if the index does not exist (instead of throwing an exception).
  - getNodeByIndexAndCopyCount
```
public IndexedWord getNodeByIndexAndCopyCount(int index,
                                              int copyCount)
                                       throws java.lang.IllegalArgumentException
```
    Returns the first IndexedWord in this SemanticGraph having the given integer index, or throws IllegalArgumentException if no such node is found.
    
    Throws:
    
    java.lang.IllegalArgumentException
  - getNodeByIndexAndCopyCountSafe
```
public IndexedWord getNodeByIndexAndCopyCountSafe(int index,
                                                  int copyCount)
```
    Same as above, but returns null if the index does not exist (instead of throwing an exception).
  - getNodeByWordPattern
```
public IndexedWord getNodeByWordPattern(java.lang.String pattern)
```
    Returns the first IndexedWord in this SemanticGraph having the given word or regex, or return null if no such found.
  - getAllNodesByWordPattern
```
public java.util.List<IndexedWord> getAllNodesByWordPattern(java.lang.String pattern)
```
    Returns all nodes of type IndexedWord in this SemanticGraph having the given word or regex, or returns empty list if no such found.
  - getAllNodesByPartOfSpeechPattern
```
public java.util.List<IndexedWord> getAllNodesByPartOfSpeechPattern(java.lang.String pattern)
```
  - descendants
```
public java.util.Set<IndexedWord> descendants(IndexedWord vertex)
```
    Returns the set of descendants governed by this node in the graph.
  - childPairs
```
public java.util.List<Pair<GrammaticalRelation,IndexedWord>> childPairs(IndexedWord vertex)
```
    Returns a list of pairs of a relation name and the child IndexedFeatureLabel that bears that relation.
  - parentPairs
```
public java.util.List<Pair<GrammaticalRelation,IndexedWord>> parentPairs(IndexedWord vertex)
```
    Returns a list of pairs of a relation name and the parent IndexedFeatureLabel to which we bear that relation.
  - relns
```
public java.util.Set<GrammaticalRelation> relns(IndexedWord vertex)
```
    Returns a set of relations which this node has with its parents.
    
    Returns:
    
    The set of relations which this node has with its parents.
  - reln
```
public GrammaticalRelation reln(IndexedWord a,
                                IndexedWord b)
```
    Returns the relation that node a has with node b. Note: there may be multiple arcs between a and b, and this method only returns one relation.
  - childRelns
```
public java.util.Set<GrammaticalRelation> childRelns(IndexedWord vertex)
```
    Returns a list of relations which this node has with its children.
  - getRoots
```
public java.util.Collection<IndexedWord> getRoots()
```
  - isRoot
```
public boolean isRoot(IndexedWord vertex)
```
  - getFirstRoot
```
public IndexedWord getFirstRoot()
```
    Returns the (first) root of this SemanticGraph.
  - addRoot
```
public void addRoot(IndexedWord root)
```
  - resetRoots
```
public void resetRoots()
```
    This method should not be used if possible. TODO: delete it Recomputes the roots, based of actual candidates. This is done to ensure a rooted tree after a sequence of edits. If the none of the vertices can act as a root (due to a cycle), keep old rootset, retaining only the existing vertices on that list. TODO: this cannot deal with "Hamburg is a city which everyone likes", as the intended root node,'Hamburg, is also the dobj of the relative clause. A possible solution would be to create edgeset routines that allow filtering over a predicate, and specifically filter out dobj relations for choosing next best candidate. This could also be useful for dealing with non-syntactic arcs in the future. TODO: There is also the possibility the roots could be empty at the end, and will need to be resolved. TODO: determine if this is a reasonably correct solution.
  - setRoot
```
public void setRoot(IndexedWord word)
```
  - setRoots
```
public void setRoots(java.util.Collection<IndexedWord> words)
```
  - topologicalSort
```
public java.util.List<IndexedWord> topologicalSort()
```
    Returns:
    
    A sorted list of the vertices
    
    Throws:
    
    CyclicGraphException - (a subtype of IllegalStateException) if this graph is not a DAG
  - hasChild
```
public boolean hasChild(IndexedWord vertex,
                        GrammaticalRelation reln,
                        java.lang.String childLemma)
```
    Does the given vertex have at least one child with the given reln and the lemma childLemma?
  - hasChildWithReln
```
public boolean hasChildWithReln(IndexedWord vertex,
                                GrammaticalRelation reln)
```
    Does the given vertex have at least one child with the given reln?
  - hasParentWithReln
```
public boolean hasParentWithReln(IndexedWord vertex,
                                 GrammaticalRelation reln)
```
    Returns true if vertex has an incoming relation reln
    
    Parameters:
    
    vertex - A node in this graph
    
    reln - The relation we want to check
    
    Returns:
    
    true if vertex has an incoming relation reln
  - getChildWithReln
```
public IndexedWord getChildWithReln(IndexedWord vertex,
                                    GrammaticalRelation reln)
```
    Returns the first IndexedFeatureLabel bearing a certain grammatical relation, or null if none.
  - getParentsWithReln
```
public java.util.Set<IndexedWord> getParentsWithReln(IndexedWord vertex,
                                                     GrammaticalRelation reln)
```
    Returns a set of all parents bearing a certain grammatical relation, or an empty set if none.
  - getParentsWithReln
```
public java.util.Set<IndexedWord> getParentsWithReln(IndexedWord vertex,
                                                     java.lang.String relnName)
```
    Returns a set of all parents bearing a certain grammatical relation, or an empty set if none.
  - getChildrenWithReln
```
public java.util.Set<IndexedWord> getChildrenWithReln(IndexedWord vertex,
                                                      GrammaticalRelation reln)
```
    Returns a set of all children bearing a certain grammatical relation, or an empty set if none.
  - getChildrenWithRelns
```
public java.util.Set<IndexedWord> getChildrenWithRelns(IndexedWord vertex,
                                                       java.util.Collection<GrammaticalRelation> relns)
```
    Returns a set of all children bearing one of a set of grammatical relations, or an empty set if none. NOTE: this will only work for relation types that are classes. Those that are collapsed are currently not handled correctly since they are identified by strings.
  - getEdge
```
public SemanticGraphEdge getEdge(IndexedWord gov,
                                 IndexedWord dep,
                                 GrammaticalRelation reln)
```
    Given a governor, dependent, and the relation between them, returns the SemanticGraphEdge object of that arc if it exists, otherwise returns null.
  - isNegatedVertex
```
public boolean isNegatedVertex(IndexedWord vertex)
```
  - isInConditionalContext
```
public boolean isInConditionalContext(IndexedWord vertex)
```
    Check if the vertex is in a "conditional" context. Right now it's only returning true if vertex has an "if" marker attached to it, i.e. the vertex is in a clause headed by "if".
  - attachedNegatedVerb
```
public boolean attachedNegatedVerb(IndexedWord vertex)
```
  - isAuxiliaryVerb
```
public boolean isAuxiliaryVerb(IndexedWord vertex)
```
    Returns true iff this vertex stands in the "aux" relation to (any of) its parent(s).
  - getLeafVertices
```
public java.util.Set<IndexedWord> getLeafVertices()
```
  - size
```
public int size()
```
    Returns the number of nodes in the graph
  - getSubgraphVertices
```
public java.util.Set<IndexedWord> getSubgraphVertices(IndexedWord root)
```
    Returns all nodes reachable from root.
    
    Parameters:
    
    root - the root node of the subgraph
    
    Returns:
    
    all nodes in subgraph
  - isDag
```
public boolean isDag()
```
    Returns:
    
    true if the graph contains no cycles.
  - isDag
```
public boolean isDag(IndexedWord root)
```
    Parameters:
    
    root - root node of the subgraph.
    
    Returns:
    
    true if the subgraph rooted at root contains no cycles.
  - toString
```
public java.lang.String toString()
```
    Recursive depth first traversal. Returns a structured representation of the dependency graph. Example:
```
  -> need-3 (root)
    -> We-0 (nsubj)
    -> do-1 (aux)
    -> n't-2 (neg)
    -> badges-6 (dobj)
      -> no-4 (det)
      -> stinking-5 (amod)
 
```
    This is a quite ugly way to print a SemanticGraph. You might instead want to try toString(OutputFormat).
    Overrides:
    
    toString in class java.lang.Object
  - toString
```
public java.lang.String toString(CoreLabel.OutputFormat wordFormat)
```
  - toRecoveredSentenceString
```
public java.lang.String toRecoveredSentenceString()
```
  - toRecoveredSentenceStringWithIndexMarking
```
public java.lang.String toRecoveredSentenceStringWithIndexMarking()
```
  - toEnUncollapsedSentenceString
```
public java.lang.String toEnUncollapsedSentenceString()
```
    Similar to toRecoveredString, but will fill in words that were collapsed into relations (i.e. prep_for --> 'for'). Mostly to deal with collapsed dependency trees. TODO: consider merging with toRecoveredString() NOTE: assumptions currently are for English. NOTE: currently takes immediate successors to current word and expands them. This assumption may not be valid for other conditions or languages?
  - toString
```
public java.lang.String toString(SemanticGraph.OutputFormat format)
```
    Returns a String representation of the result of this set of typed dependencies in a user-specified format. Currently, four formats are supported (SemanticGraph.OutputFormat):
    list
    
    (Default.) Formats the dependencies as logical relations, as exemplified by the following:
    nsubj(died-1, Sam-0) tmod(died-1, today-2)
    
    readable
    
    Formats the dependencies as a table with columns dependent, relation, and governor, as exemplified by the following:
    Sam-0 nsubj died-1 today-2 tmod died-1
    
    xml
    
    Formats the dependencies as XML, as exemplified by the following:
    <dependencies> <dep type="nsubj"> <governor idx="1">died</governor> <dependent idx="0">Sam</dependent> </dep> <dep type="tmod"> <governor idx="1">died</governor> <dependent idx="2">today</dependent> </dep> </dependencies>
    
    recursive
    
    The default output for toString()
    Parameters:
    
    format - A String specifying the desired format
    
    Returns:
    
    A String representation of the typed dependencies in this GrammaticalStructure
  - toList
```
public java.lang.String toList()
```
    Returns a String representation of this graph as a list of typed dependencies, as exemplified by the following:
```
  nsubj(died-6, Sam-3)
  tmod(died-6, today-9)
 
```
    Returns:
    
    a String representation of this set of typed dependencies
  - toPOSList
```
public java.lang.String toPOSList()
```
    Similar to toList(), but uses POS tags instead of word and index.
  - toCompactString
```
public java.lang.String toCompactString()
```
  - toCompactString
```
public java.lang.String toCompactString(boolean showTags)
```
  - toFormattedString
```
public java.lang.String toFormattedString()
```
    Returns a String representation of this semantic graph, formatted by the default semantic graph formatter.
  - toFormattedString
```
public java.lang.String toFormattedString(SemanticGraphFormatter formatter)
```
    Returns a String representation of this semantic graph, formatted by the supplied semantic graph formatter.
  - prettyPrint
```
public void prettyPrint(SemanticGraphFormatter formatter)
```
    Pretty-prints this semantic graph to System.out, formatted by the supplied semantic graph formatter.
  - prettyPrint
```
public void prettyPrint()
```
    Pretty-prints this semantic graph to System.out, formatted by the default semantic graph formatter.
  - toDotFormat
```
public java.lang.String toDotFormat()
```
    Returns an unnamed dot format digraph. Nodes will be labeled with the word and edges will be labeled with the dependency.
  - toDotFormat
```
public java.lang.String toDotFormat(java.lang.String graphname)
```
    Returns a dot format digraph with the given name. Nodes will be labeled with the word and edges will be labeled with the dependency.
  - toDotFormat
```
public java.lang.String toDotFormat(java.lang.String graphname,
                                    CoreLabel.OutputFormat indexedWordFormat)
```
  - addEdge
```
public SemanticGraphEdge addEdge(IndexedWord s,
                                 IndexedWord d,
                                 GrammaticalRelation reln,
                                 double weight,
                                 boolean isExtra)
```
  - addEdge
```
public SemanticGraphEdge addEdge(SemanticGraphEdge edge)
```
  - valueOf
```
public static SemanticGraph valueOf(java.lang.String s,
                                    Language language,
                                    java.lang.Integer sentIndex)
```
    Tries to parse a String representing a SemanticGraph. Right now it's fairly dumb, could be made more sophisticated.
    Example: [ate subj>Bill dobj>[muffins compound>blueberry]]
    This is the same format generated by toCompactString().
    Indices are represented by a dash separated number after the word: [ate-1 subj>Bill-2 ...
  - valueOf
```
public static SemanticGraph valueOf(java.lang.String s,
                                    Language language)
```
    See Also:
    
    valueOf(String, Language, Integer)
  - valueOf
```
public static SemanticGraph valueOf(java.lang.String s)
```
    See Also:
    
    valueOf(String, Language, Integer)
  - valueOf
```
public static SemanticGraph valueOf(java.lang.String s,
                                    int sentIndex)
```
    See Also:
    
    valueOf(String, Language, Integer)
  - getShortestUndirectedPathNodes
```
public java.util.List<IndexedWord> getShortestUndirectedPathNodes(IndexedWord source,
                                                                  IndexedWord target)
```
    Returns the nodes in the shortest undirected path between two edges in the graph. if source == target, returns a singleton list
    
    Parameters:
    
    source - node
    
    target - node
    
    Returns:
    
    nodes along shortest undirected path from source to target, in order
  - getShortestUndirectedPathEdges
```
public java.util.List<SemanticGraphEdge> getShortestUndirectedPathEdges(IndexedWord source,
                                                                        IndexedWord target)
```
  - getShortestDirectedPathNodes
```
public java.util.List<IndexedWord> getShortestDirectedPathNodes(IndexedWord source,
                                                                IndexedWord target)
```
    Returns the shortest directed path between two edges in the graph.
    
    Parameters:
    
    source - node
    
    target - node
    
    Returns:
    
    shortest directed path from source to target
  - getShortestDirectedPathEdges
```
public java.util.List<SemanticGraphEdge> getShortestDirectedPathEdges(IndexedWord source,
                                                                      IndexedWord target)
```
  - makeSoftCopy
```
public SemanticGraph makeSoftCopy()
```
  - equals
```
public boolean equals(java.lang.Object o)
```
    Overrides:
    
    equals in class java.lang.Object
  - hashCode
```
public int hashCode()
```
    Overrides:
    
    hashCode in class java.lang.Object
  - findAllRelns
```
public java.util.List<SemanticGraphEdge> findAllRelns(GrammaticalRelation tgtRelation)
```
    Given a semantic graph, and a target relation, returns a list of all relations (edges) matching.
  - findAllRelns
```
public java.util.List<SemanticGraphEdge> findAllRelns(java.lang.String tgtRelationShortname)
```
    Given a semantic graph, and the short name of a target relation, returns a list of all relations (edges) matching.
  - deleteDuplicateEdges
```
public void deleteDuplicateEdges()
```
    Delete all duplicate edges.
  - typedDependencies
```
public java.util.Collection<TypedDependency> typedDependencies()
```
    Returns a list of TypedDependency in the graph. This method goes through all SemanticGraphEdge and converts them to TypedDependency.
    
    Returns:
    
    A List of TypedDependency in the graph
  - yieldSpan
```
public Pair<java.lang.Integer,java.lang.Integer> yieldSpan(IndexedWord word)
```
    Returns the span of the subtree yield of this node. That is, the span of all the nodes under it. In the case of projective graphs, the words in this span are also the yield of the constituent rooted at this node.
    
    Parameters:
    
    word - The word acting as the root of the constituent we are finding.
    
    Returns:
    
    A span, represented as a pair of integers. The span is zero indexed. The begin is inclusive and the end is exclusive.
  - yield
```
public java.util.List<IndexedWord> yield(IndexedWord word)
```
    Returns the yield of a node, i.e., all descendents of the node.
    
    Parameters:
    
    word - The word acting as the root of the constituent we are finding.
  - addComment
```
public void addComment(java.lang.String comment)
```
    Store a comment line with this semantic graph.
    
    Parameters:
    
    comment -
  - getComments
```
public java.util.List<java.lang.String> getComments()
```
    Return the list of comments stored with this graph.
    
    Returns:
    
    A list of comments.

Class SemanticGraph

Nested Class Summary

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

addSRLArcs

Constructor Detail

SemanticGraph

SemanticGraph

SemanticGraph

SemanticGraph

Method Detail

edgeCount

outDegree

inDegree

getAllEdges

getEdge

addVertex

containsVertex

containsEdge

containsEdge

vertexSet

removeEdge

removeVertex

updateEdge

vertexListSorted

edgeListSorted

edgeIterable

outgoingEdgeIterator

outgoingEdgeIterable

incomingEdgeIterator

incomingEdgeIterable

outgoingEdgeList

incomingEdgeList

isEmpty

isAncestor

commonAncestor

getCommonAncestor

matchPatternToVertex

matchPatternToVertex

getChildList

getChildren

hasChildren

getIncomingEdgesSorted

getOutEdgesSorted

getParentList

getParents

getSiblings

getPathToRoot

getParent

getNodeByIndex

getNodeByIndexSafe

getNodeByIndexAndCopyCount

getNodeByIndexAndCopyCountSafe

getNodeByWordPattern

getAllNodesByWordPattern

getAllNodesByPartOfSpeechPattern

descendants

childPairs

parentPairs

relns

reln

childRelns

getRoots

isRoot

getFirstRoot

addRoot

resetRoots

setRoot

setRoots

topologicalSort

hasChild

hasChildWithReln

hasParentWithReln

getChildWithReln

getParentsWithReln

getParentsWithReln

getChildrenWithReln