def getSentenceFormsFromModel(self):
""" generated source for method getSentenceFormsFromModel """
results = Sets.newHashSet()
for sentenceEntry in sentencesModel.entrySet():
# We'll end up taking the Cartesian product of the different
# types of terms we have available
if nameAndArity.getArity() == 0:
results.add(SimpleSentenceForm.create(sentence))
else:
for terms in Sets.cartesianProduct(sampleTerms):
results.add(SimpleSentenceForm.create(sentence))
return results
def addOrMergeStratumAndAncestors(cls, curStratum, ordering, toAdd, strataDependencyGraph, downstreamStrata):
""" generated source for method addOrMergeStratumAndAncestors """
if downstreamStrata.contains(curStratum):
mergeStrata(Sets.newHashSet(toMerge), toAdd, strataDependencyGraph)
return
downstreamStrata.add(curStratum)
for parent in ImmutableList.copyOf(strataDependencyGraph.get(curStratum)):
# We could merge away the parent here, so we protect against CMEs and
# make sure the parent is still in toAdd before recursing.
if toAdd.contains(parent):
cls.addOrMergeStratumAndAncestors(parent, ordering, toAdd, strataDependencyGraph, downstreamStrata)
downstreamStrata.remove(curStratum)
# - If we've added all our parents, we will still be in toAdd
# and none of our dependencies will be in toAdd. Add to the ordering.
# - If there was a merge upstream that we weren't involved in,
# we will still be in toAdd, but we will have (possibly new)
# dependencies that are still in toAdd. Do nothing.
# - If there was a merge upstream that we were involved in,
# we won't be in toAdd anymore. Do nothing.
if not toAdd.contains(curStratum):
return
for parent in strataDependencyGraph.get(curStratum):
if toAdd.contains(parent):
return
ordering.add(curStratum)
toAdd.remove(curStratum)
def replaceVariablesAndConstants(self, function_):
""" generated source for method replaceVariablesAndConstants """
assignment = Maps.newHashMap()
termsToReplace = Sets.newHashSet()
GdlVisitors.visitAll(function_, GdlVisitor())
for var in GdlUtils.getVariables(function_):
assignment.put(var, getUnusedVariable())
return CommonTransforms.replaceVariables(function_, assignment)
def getAllSentenceForms(cls, model):
""" generated source for method getAllSentenceForms """
# The model may only have sentence forms for sentences that can actually be
# true. It may be missing sentence forms that are used in the rules only,
# with no actual corresponding sentences. We want to make sure these are
# included.
forms = Sets.newHashSet(model.getSentenceForms())
GdlVisitors.visitAll(model.getDescription(), GdlVisitor())
return forms
def toSampleTerms_0(self, termModel):
""" generated source for method toSampleTerms_0 """
results = Sets.newHashSet()
if not termModel.getPossibleConstants().isEmpty():
results.add(termModel.getPossibleConstants().iterator().next())
for nameAndArity in termModel.getPossibleFunctions().keySet():
for functionBody in functionBodies:
results.add(function_)
return results
def getMatchingAndUpstream(cls, allNodes, dependencyGraph, matcher):
""" generated source for method getMatchingAndUpstream """
results = Sets.newHashSet()
toTry = Queues.newArrayDeque()
toTry.addAll(Collections2.filter(allNodes, matcher))
while not toTry.isEmpty():
if not results.contains(curElem):
results.add(curElem)
toTry.addAll(dependencyGraph.get(curElem))
return ImmutableSet.copyOf(results)
def getIntersection(cls, domains):
""" generated source for method getIntersection """
if domains.isEmpty():
raise IllegalArgumentException("Unsafe rule has no positive conjuncts")
intersection = Sets.newHashSet(domains.get(0))
i = 1
while i < len(domains):
intersection.retainAll(curDomain)
i += 1
return intersection
def reinsertLiteralInRightPlace(cls, ruleBody, literalToReinsert):
""" generated source for method reinsertLiteralInRightPlace """
setVars = Sets.newHashSet()
i = 0
while i < len(ruleBody):
if isinstance(literal, (GdlSentence, )):
setVars.addAll(GdlUtils.getVariables(literal))
if allVarsInLiteralAlreadySet(literalToReinsert, setVars):
ruleBody.add(i + 1, literalToReinsert)
return
i += 1
def getVarsToModelsMap(self, rule):
""" generated source for method getVarsToModelsMap """
varsToUse = Sets.newHashSet(GdlUtils.getVariables(rule.getHead()))
varsToModelsMap = Maps.newHashMap()
for var in varsToUse:
varsToModelsMap.put(var, TermModel())
for literal in rule.getBody():
if isinstance(literal, (GdlRelation, )):
if not self.sentencesModel.containsKey(nameAndArity):
self.sentencesModel.put(nameAndArity, getNTermModels(nameAndArity.getArity()))
addVariablesToMap(literalBody, literalModel, varsToModelsMap)
return varsToModelsMap
def intersectSets(cls, input):
""" generated source for method intersectSets """
if input.isEmpty():
raise IllegalArgumentException("Can't take an intersection of no sets")
result = None
for set in input:
if result == None:
result = Sets.newHashSet(set)
else:
result.retainAll(set)
assert result != None
return result
def findDistinctOrNotToMoveIndex(cls, ruleBody):
""" generated source for method findDistinctOrNotToMoveIndex """
setVars = Sets.newHashSet()
i = 0
while i < len(ruleBody):
if isinstance(literal, (GdlSentence, )):
setVars.addAll(GdlUtils.getVariables(literal))
elif isinstance(literal, (GdlDistinct, )) or isinstance(literal, (GdlNot, )):
if not allVarsInLiteralAlreadySet(literal, setVars):
return i
i += 1
return None
def getCartesianDomainsFromModel(self):
""" generated source for method getCartesianDomainsFromModel """
results = Maps.newHashMap()
for sentenceEntry in sentencesModel.entrySet():
ConcurrencyUtils.checkForInterruption()
# We'll end up taking the Cartesian product of the different
# types of terms we have available
if nameAndArity.getArity() == 0:
results.put(form, CartesianSentenceFormDomain.create(form, ImmutableList.of()))
else:
for terms in Sets.cartesianProduct(sampleTerms):
ConcurrencyUtils.checkForInterruption()
results.put(form, domain)
return results
def testSafeToposort(self):
""" generated source for method testSafeToposort """
allElements = Sets.newHashSet(1, 2, 3, 4, 5, 6, 7, 8)
graph = HashMultimap.create()
graph.put(2, 1)
graph.put(3, 2)
graph.put(4, 2)
graph.put(5, 3)
graph.put(5, 4)
graph.put(3, 4)
graph.put(4, 3)
graph.put(4, 6)
graph.put(6, 7)
graph.put(7, 8)
graph.put(8, 3)
print DependencyGraphs.toposortSafe(allElements, graph)
def getIndependentSentenceForms(cls, sentenceForms, dependencyGraph):
""" generated source for method getIndependentSentenceForms """
augmentedGraph = augmentGraphWithLanguageRules(dependencyGraph, sentenceForms)
moveDependentSentenceForms = DependencyGraphs.getMatchingAndDownstream(sentenceForms, augmentedGraph, SentenceForms.DOES_PRED)
return ImmutableSet.copyOf(Sets.difference(sentenceForms, moveDependentSentenceForms))
def __init__(self, description):
""" generated source for method __init__ """
super(AimaProver, self).__init__()
description = DistinctAndNotMover.run(description)
self.knowledgeBase = KnowledgeBase(Sets.newHashSet(description))
def getNames(cls, forms):
""" generated source for method getNames """
names = Sets.newHashSet()
for form in forms:
names.add(form.__name__.getValue())
return names
def __init__(self, interfaceClass):
""" generated source for method __init__ """
self.interfaceClass = interfaceClass
self.allClasses = ImmutableSet.copyOf(self.REFLECTIONS.getSubTypesOf(interfaceClass))
self.concreteClasses = ImmutableSet.copyOf(Sets.filter(self.allClasses, self.IS_CONCRETE_CLASS))
def iterator(self):
""" generated source for method iterator """
return Iterators.transform(Sets.cartesianProduct(self.domainsForSlots).iterator(), Function())
def createAllStrata(cls, allElements):
""" generated source for method createAllStrata """
result = Sets.newHashSet()
for element in allElements:
result.add(ImmutableSet.of(element))
return result
def __init__(self, initialNames):
""" generated source for method __init__ """
self.allNamesSoFar = Sets.newHashSet(initialNames)
def getConstantSentenceForms(cls, sentenceForms, dependencyGraph):
""" generated source for method getConstantSentenceForms """
augmentedGraph = augmentGraphWithLanguageRules(dependencyGraph, sentenceForms)
changingSentenceForms = DependencyGraphs.getMatchingAndDownstream(sentenceForms, augmentedGraph, Predicates.or_(SentenceForms.TRUE_PRED, SentenceForms.DOES_PRED))
return ImmutableSet.copyOf(Sets.difference(sentenceForms, changingSentenceForms))
