/// <summary>Parse a JSON formatted tree into a SemanticGraph.</summary>
/// <param name="jsonString">
/// The JSON string tree to parse, e.g:
/// "[{\"\"dependent\"\": 7, \"\"dep\"\": \"\"root\"\", \"\"governorgloss\"\": \"\"root\"\", \"\"governor\"\": 0, \"\"dependentgloss\"\": \"\"sport\"\"}, {\"\"dependent\"\": 1, \"\"dep\"\": \"\"nsubj\"\", \"\"governorgloss\"\": \"\"sport\"\", \"\"governor\"\": 7, \"\"dependentgloss\"\": \"\"chess\"\"}, {\"\"dependent\"\": 2, \"\"dep\"\": \"\"cop\"\", \"\"governorgloss\"\": \"\"sport\"\", \"\"governor\"\": 7, \"\"dependentgloss\"\": \"\"is\"\"}, {\"\"dependent\"\": 3, \"\"dep\"\": \"\"neg\"\", \"\"governorgloss\"\": \"\"sport\"\", \"\"governor\"\": 7, \"\"dependentgloss\"\": \"\"not\"\"}, {\"\"dependent\"\": 4, \"\"dep\"\": \"\"det\"\", \"\"governorgloss\"\": \"\"sport\"\", \"\"governor\"\": 7, \"\"dependentgloss\"\": \"\"a\"\"}, {\"\"dependent\"\": 5, \"\"dep\"\": \"\"advmod\"\", \"\"governorgloss\"\": \"\"physical\"\", \"\"governor\"\": 6, \"\"dependentgloss\"\": \"\"predominantly\"\"}, {\"\"dependent\"\": 6, \"\"dep\"\": \"\"amod\"\", \"\"governorgloss\"\": \"\"sport\"\", \"\"governor\"\": 7, \"\"dependentgloss\"\": \"\"physical\"\"}, {\"\"dependent\"\": 9, \"\"dep\"\": \"\"advmod\"\", \"\"governorgloss\"\": \"\"sport\"\", \"\"governor\"\": 7, \"\"dependentgloss\"\": \"\"yet\"\"}, {\"\"dependent\"\": 10, \"\"dep\"\": \"\"nsubj\"\", \"\"governorgloss\"\": \"\"shooting\"\", \"\"governor\"\": 12, \"\"dependentgloss\"\": \"\"neither\"\"}, {\"\"dependent\"\": 11, \"\"dep\"\": \"\"cop\"\", \"\"governorgloss\"\": \"\"shooting\"\", \"\"governor\"\": 12, \"\"dependentgloss\"\": \"\"are\"\"}, {\"\"dependent\"\": 12, \"\"dep\"\": \"\"parataxis\"\", \"\"governorgloss\"\": \"\"sport\"\", \"\"governor\"\": 7, \"\"dependentgloss\"\": \"\"shooting\"\"}, {\"\"dependent\"\": 13, \"\"dep\"\": \"\"cc\"\", \"\"governorgloss\"\": \"\"shooting\"\", \"\"governor\"\": 12, \"\"dependentgloss\"\": \"\"and\"\"}, {\"\"dependent\"\": 14, \"\"dep\"\": \"\"parataxis\"\", \"\"governorgloss\"\": \"\"sport\"\", \"\"governor\"\": 7, \"\"dependentgloss\"\": \"\"curling\"\"}, {\"\"dependent\"\": 14, \"\"dep\"\": \"\"conj:and\"\", \"\"governorgloss\"\": \"\"shooting\"\", \"\"governor\"\": 12, \"\"dependentgloss\"\": \"\"curling\"\"}, {\"\"dependent\"\": 16, \"\"dep\"\": \"\"nsubjpass\"\", \"\"governorgloss\"\": \"\"nicknamed\"\", \"\"governor\"\": 23, \"\"dependentgloss\"\": \"\"which\"\"}, {\"\"dependent\"\": 18, \"\"dep\"\": \"\"case\"\", \"\"governorgloss\"\": \"\"fact\"\", \"\"governor\"\": 19, \"\"dependentgloss\"\": \"\"in\"\"}, {\"\"dependent\"\": 19, \"\"dep\"\": \"\"nmod:in\"\", \"\"governorgloss\"\": \"\"nicknamed\"\", \"\"governor\"\": 23, \"\"dependentgloss\"\": \"\"fact\"\"}, {\"\"dependent\"\": 21, \"\"dep\"\": \"\"aux\"\", \"\"governorgloss\"\": \"\"nicknamed\"\", \"\"governor\"\": 23, \"\"dependentgloss\"\": \"\"has\"\"}, {\"\"dependent\"\": 22, \"\"dep\"\": \"\"auxpass\"\", \"\"governorgloss\"\": \"\"nicknamed\"\", \"\"governor\"\": 23, \"\"dependentgloss\"\": \"\"been\"\"}, {\"\"dependent\"\": 23, \"\"dep\"\": \"\"dep\"\", \"\"governorgloss\"\": \"\"shooting\"\", \"\"governor\"\": 12, \"\"dependentgloss\"\": \"\"nicknamed\"\"}, {\"\"dependent\"\": 25, \"\"dep\"\": \"\"dobj\"\", \"\"governorgloss\"\": \"\"nicknamed\"\", \"\"governor\"\": 23, \"\"dependentgloss\"\": \"\"chess\"\"}, {\"\"dependent\"\": 26, \"\"dep\"\": \"\"case\"\", \"\"governorgloss\"\": \"\"ice\"\", \"\"governor\"\": 27, \"\"dependentgloss\"\": \"\"on\"\"}, {\"\"dependent\"\": 27, \"\"dep\"\": \"\"nmod:on\"\", \"\"governorgloss\"\": \"\"chess\"\", \"\"governor\"\": 25, \"\"dependentgloss\"\": \"\"ice\"\"}, {\"\"dependent\"\": 29, \"\"dep\"\": \"\"amod\"\", \"\"governorgloss\"\": \"\"chess\"\", \"\"governor\"\": 25, \"\"dependentgloss\"\": \"\"5\"\"}]");
/// </param>
/// <param name="tokens">The tokens of the sentence, to form the backing labels of the tree.</param>
/// <returns>A semantic graph of the sentence, according to the given tree.</returns>
public static SemanticGraph ParseJsonTree(string jsonString, IList <CoreLabel> tokens)
{
// Escape quoted string parts
IJsonReader json = Javax.Json.Json.CreateReader(new StringReader(jsonString));
SemanticGraph tree = new SemanticGraph();
IJsonArray array = json.ReadArray();
if (array == null || array.IsEmpty())
{
return(tree);
}
IndexedWord[] vertices = new IndexedWord[tokens.Count + 2];
// Add edges
for (int i = 0; i < array.Count; i++)
{
IJsonObject entry = array.GetJsonObject(i);
// Parse row
int dependentIndex = entry.GetInt("dependent");
if (vertices[dependentIndex] == null)
{
if (dependentIndex > tokens.Count)
{
// Bizarre mismatch in sizes; the malt parser seems to do this often
return(new SemanticGraph());
}
vertices[dependentIndex] = new IndexedWord(tokens[dependentIndex - 1]);
}
IndexedWord dependent = vertices[dependentIndex];
int governorIndex = entry.GetInt("governor");
if (governorIndex > tokens.Count)
{
// Bizarre mismatch in sizes; the malt parser seems to do this often
return(new SemanticGraph());
}
if (vertices[governorIndex] == null && governorIndex > 0)
{
vertices[governorIndex] = new IndexedWord(tokens[governorIndex - 1]);
}
IndexedWord governor = vertices[governorIndex];
string relation = entry.GetString("dep");
// Process row
if (governorIndex == 0)
{
tree.AddRoot(dependent);
}
else
{
tree.AddVertex(dependent);
if (!tree.ContainsVertex(governor))
{
tree.AddVertex(governor);
}
if (!"ref".Equals(relation))
{
tree.AddEdge(governor, dependent, GrammaticalRelation.ValueOf(Language.English, relation), double.NegativeInfinity, false);
}
}
}
return(tree);
}
/// <summary>Parse a CoNLL formatted tree into a SemanticGraph.</summary>
/// <param name="conll">The CoNLL tree to parse.</param>
/// <param name="tokens">The tokens of the sentence, to form the backing labels of the tree.</param>
/// <returns>A semantic graph of the sentence, according to the given tree.</returns>
public static SemanticGraph ParseTree(string conll, IList <CoreLabel> tokens)
{
SemanticGraph tree = new SemanticGraph();
if (conll == null || conll.IsEmpty())
{
return(tree);
}
string[] treeLines = newline.Split(conll);
IndexedWord[] vertices = new IndexedWord[tokens.Count + 2];
// Add edges
foreach (string line in treeLines)
{
// Parse row
string[] fields = tab.Split(line);
int dependentIndex = System.Convert.ToInt32(fields[0]);
if (vertices[dependentIndex] == null)
{
if (dependentIndex > tokens.Count)
{
// Bizarre mismatch in sizes; the malt parser seems to do this often
return(new SemanticGraph());
}
vertices[dependentIndex] = new IndexedWord(tokens[dependentIndex - 1]);
}
IndexedWord dependent = vertices[dependentIndex];
int governorIndex = System.Convert.ToInt32(fields[1]);
if (governorIndex > tokens.Count)
{
// Bizarre mismatch in sizes; the malt parser seems to do this often
return(new SemanticGraph());
}
if (vertices[governorIndex] == null && governorIndex > 0)
{
vertices[governorIndex] = new IndexedWord(tokens[governorIndex - 1]);
}
IndexedWord governor = vertices[governorIndex];
string relation = fields[2];
// Process row
if (governorIndex == 0)
{
tree.AddRoot(dependent);
}
else
{
tree.AddVertex(dependent);
if (!tree.ContainsVertex(governor))
{
tree.AddVertex(governor);
}
if (!"ref".Equals(relation))
{
tree.AddEdge(governor, dependent, GrammaticalRelation.ValueOf(Language.English, relation), double.NegativeInfinity, false);
}
}
}
return(tree);
}
public override void Evaluate(SemanticGraph sg, SemgrexMatcher sm)
{
IndexedWord govNode = GetNamedNode(govName, sm);
IndexedWord depNode = GetNamedNode(depName, sm);
SemanticGraphEdge existingEdge = sg.GetEdge(govNode, depNode, relation);
if (existingEdge == null)
{
// When adding the edge, check to see if the gov/dep nodes are presently in the graph.
//
if (!sg.ContainsVertex(govNode))
{
sg.AddVertex(govNode);
}
if (!sg.ContainsVertex(depNode))
{
sg.AddVertex(depNode);
}
sg.AddEdge(govNode, depNode, relation, weight, false);
}
}
public override void Evaluate(SemanticGraph sg, SemgrexMatcher sm)
{
IndexedWord seedNode = GetNamedNode(destroyNodeName, sm);
// TODO: do not execute if seedNode if not in graph (or just error?)
if (sg.ContainsVertex(seedNode))
{
ICollection <IndexedWord> nodesToDestroy = Crawl(seedNode, sg);
foreach (IndexedWord node in nodesToDestroy)
{
sg.RemoveVertex(node);
}
// After destroy nodes, need to reset the roots, since it's possible a root node
// was destroyed.
sg.ResetRoots();
}
}
/// <summary>The search algorithm, starting with a full sentence and iteratively shortening it to its entailed sentences.</summary>
/// <returns>A list of search results, corresponding to shortenings of the sentence.</returns>
private IList <ForwardEntailerSearchProblem.SearchResult> SearchImplementation()
{
// Pre-process the tree
SemanticGraph parseTree = new SemanticGraph(this.parseTree);
System.Diagnostics.Debug.Assert(Edu.Stanford.Nlp.Naturalli.Util.IsTree(parseTree));
// (remove common determiners)
IList <string> determinerRemovals = new List <string>();
parseTree.GetLeafVertices().Stream().Filter(null).ForEach(null);
// (cut conj_and nodes)
ICollection <SemanticGraphEdge> andsToAdd = new HashSet <SemanticGraphEdge>();
foreach (IndexedWord vertex in parseTree.VertexSet())
{
if (parseTree.InDegree(vertex) > 1)
{
SemanticGraphEdge conjAnd = null;
foreach (SemanticGraphEdge edge in parseTree.IncomingEdgeIterable(vertex))
{
if ("conj:and".Equals(edge.GetRelation().ToString()))
{
conjAnd = edge;
}
}
if (conjAnd != null)
{
parseTree.RemoveEdge(conjAnd);
System.Diagnostics.Debug.Assert(Edu.Stanford.Nlp.Naturalli.Util.IsTree(parseTree));
andsToAdd.Add(conjAnd);
}
}
}
// Clean the tree
Edu.Stanford.Nlp.Naturalli.Util.CleanTree(parseTree);
System.Diagnostics.Debug.Assert(Edu.Stanford.Nlp.Naturalli.Util.IsTree(parseTree));
// Find the subject / object split
// This takes max O(n^2) time, expected O(n*log(n)) time.
// Optimal is O(n), but I'm too lazy to implement it.
BitSet isSubject = new BitSet(256);
foreach (IndexedWord vertex_1 in parseTree.VertexSet())
{
// Search up the tree for a subj node; if found, mark that vertex as a subject.
IEnumerator <SemanticGraphEdge> incomingEdges = parseTree.IncomingEdgeIterator(vertex_1);
SemanticGraphEdge edge = null;
if (incomingEdges.MoveNext())
{
edge = incomingEdges.Current;
}
int numIters = 0;
while (edge != null)
{
if (edge.GetRelation().ToString().EndsWith("subj"))
{
System.Diagnostics.Debug.Assert(vertex_1.Index() > 0);
isSubject.Set(vertex_1.Index() - 1);
break;
}
incomingEdges = parseTree.IncomingEdgeIterator(edge.GetGovernor());
if (incomingEdges.MoveNext())
{
edge = incomingEdges.Current;
}
else
{
edge = null;
}
numIters += 1;
if (numIters > 100)
{
// log.error("tree has apparent depth > 100");
return(Java.Util.Collections.EmptyList);
}
}
}
// Outputs
IList <ForwardEntailerSearchProblem.SearchResult> results = new List <ForwardEntailerSearchProblem.SearchResult>();
if (!determinerRemovals.IsEmpty())
{
if (andsToAdd.IsEmpty())
{
double score = Math.Pow(weights.DeletionProbability("det"), (double)determinerRemovals.Count);
System.Diagnostics.Debug.Assert(!double.IsNaN(score));
System.Diagnostics.Debug.Assert(!double.IsInfinite(score));
results.Add(new ForwardEntailerSearchProblem.SearchResult(parseTree, determinerRemovals, score));
}
else
{
SemanticGraph treeWithAnds = new SemanticGraph(parseTree);
System.Diagnostics.Debug.Assert(Edu.Stanford.Nlp.Naturalli.Util.IsTree(treeWithAnds));
foreach (SemanticGraphEdge and in andsToAdd)
{
treeWithAnds.AddEdge(and.GetGovernor(), and.GetDependent(), and.GetRelation(), double.NegativeInfinity, false);
}
System.Diagnostics.Debug.Assert(Edu.Stanford.Nlp.Naturalli.Util.IsTree(treeWithAnds));
results.Add(new ForwardEntailerSearchProblem.SearchResult(treeWithAnds, determinerRemovals, Math.Pow(weights.DeletionProbability("det"), (double)determinerRemovals.Count)));
}
}
// Initialize the search
System.Diagnostics.Debug.Assert(Edu.Stanford.Nlp.Naturalli.Util.IsTree(parseTree));
IList <IndexedWord> topologicalVertices;
try
{
topologicalVertices = parseTree.TopologicalSort();
}
catch (InvalidOperationException)
{
// log.info("Could not topologically sort the vertices! Using left-to-right traversal.");
topologicalVertices = parseTree.VertexListSorted();
}
if (topologicalVertices.IsEmpty())
{
return(results);
}
Stack <ForwardEntailerSearchProblem.SearchState> fringe = new Stack <ForwardEntailerSearchProblem.SearchState>();
fringe.Push(new ForwardEntailerSearchProblem.SearchState(new BitSet(256), 0, parseTree, null, null, 1.0));
// Start the search
int numTicks = 0;
while (!fringe.IsEmpty())
{
// Overhead with popping a node.
if (numTicks >= maxTicks)
{
return(results);
}
numTicks += 1;
if (results.Count >= maxResults)
{
return(results);
}
ForwardEntailerSearchProblem.SearchState state = fringe.Pop();
System.Diagnostics.Debug.Assert(state.score > 0.0);
IndexedWord currentWord = topologicalVertices[state.currentIndex];
// Push the case where we don't delete
int nextIndex = state.currentIndex + 1;
int numIters = 0;
while (nextIndex < topologicalVertices.Count)
{
IndexedWord nextWord = topologicalVertices[nextIndex];
System.Diagnostics.Debug.Assert(nextWord.Index() > 0);
if (!state.deletionMask.Get(nextWord.Index() - 1))
{
fringe.Push(new ForwardEntailerSearchProblem.SearchState(state.deletionMask, nextIndex, state.tree, null, state, state.score));
break;
}
else
{
nextIndex += 1;
}
numIters += 1;
if (numIters > 10000)
{
// log.error("logic error (apparent infinite loop); returning");
return(results);
}
}
// Check if we can delete this subtree
bool canDelete = !state.tree.GetFirstRoot().Equals(currentWord);
foreach (SemanticGraphEdge edge in state.tree.IncomingEdgeIterable(currentWord))
{
if ("CD".Equals(edge.GetGovernor().Tag()))
{
canDelete = false;
}
else
{
// Get token information
CoreLabel token = edge.GetDependent().BackingLabel();
OperatorSpec @operator;
NaturalLogicRelation lexicalRelation;
Polarity tokenPolarity = token.Get(typeof(NaturalLogicAnnotations.PolarityAnnotation));
if (tokenPolarity == null)
{
tokenPolarity = Polarity.Default;
}
// Get the relation for this deletion
if ((@operator = token.Get(typeof(NaturalLogicAnnotations.OperatorAnnotation))) != null)
{
lexicalRelation = @operator.instance.deleteRelation;
}
else
{
System.Diagnostics.Debug.Assert(edge.GetDependent().Index() > 0);
lexicalRelation = NaturalLogicRelation.ForDependencyDeletion(edge.GetRelation().ToString(), isSubject.Get(edge.GetDependent().Index() - 1));
}
NaturalLogicRelation projectedRelation = tokenPolarity.ProjectLexicalRelation(lexicalRelation);
// Make sure this is a valid entailment
if (!projectedRelation.ApplyToTruthValue(truthOfPremise).IsTrue())
{
canDelete = false;
}
}
}
if (canDelete)
{
// Register the deletion
Lazy <Pair <SemanticGraph, BitSet> > treeWithDeletionsAndNewMask = Lazy.Of(null);
// Compute the score of the sentence
double newScore = state.score;
foreach (SemanticGraphEdge edge_1 in state.tree.IncomingEdgeIterable(currentWord))
{
double multiplier = weights.DeletionProbability(edge_1, state.tree.OutgoingEdgeIterable(edge_1.GetGovernor()));
System.Diagnostics.Debug.Assert(!double.IsNaN(multiplier));
System.Diagnostics.Debug.Assert(!double.IsInfinite(multiplier));
newScore *= multiplier;
}
// Register the result
if (newScore > 0.0)
{
SemanticGraph resultTree = new SemanticGraph(treeWithDeletionsAndNewMask.Get().first);
andsToAdd.Stream().Filter(null).ForEach(null);
results.Add(new ForwardEntailerSearchProblem.SearchResult(resultTree, AggregateDeletedEdges(state, state.tree.IncomingEdgeIterable(currentWord), determinerRemovals), newScore));
// Push the state with this subtree deleted
nextIndex = state.currentIndex + 1;
numIters = 0;
while (nextIndex < topologicalVertices.Count)
{
IndexedWord nextWord = topologicalVertices[nextIndex];
BitSet newMask = treeWithDeletionsAndNewMask.Get().second;
SemanticGraph treeWithDeletions = treeWithDeletionsAndNewMask.Get().first;
if (!newMask.Get(nextWord.Index() - 1))
{
System.Diagnostics.Debug.Assert(treeWithDeletions.ContainsVertex(topologicalVertices[nextIndex]));
fringe.Push(new ForwardEntailerSearchProblem.SearchState(newMask, nextIndex, treeWithDeletions, null, state, newScore));
break;
}
else
{
nextIndex += 1;
}
numIters += 1;
if (numIters > 10000)
{
// log.error("logic error (apparent infinite loop); returning");
return(results);
}
}
}
}
}
// Return
return(results);
}