package org.ggp.base.util.reasoner.gdl;
import java.util.Collection;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Set;
import org.ggp.base.util.concurrency.ConcurrencyUtils;
import org.ggp.base.util.gdl.GdlUtils;
import org.ggp.base.util.gdl.grammar.GdlConstant;
import org.ggp.base.util.gdl.grammar.GdlDistinct;
import org.ggp.base.util.gdl.grammar.GdlLiteral;
import org.ggp.base.util.gdl.grammar.GdlNot;
import org.ggp.base.util.gdl.grammar.GdlOr;
import org.ggp.base.util.gdl.grammar.GdlRule;
import org.ggp.base.util.gdl.grammar.GdlSentence;
import org.ggp.base.util.gdl.grammar.GdlVariable;
import org.ggp.base.util.gdl.model.SentenceDomainModel;
import org.ggp.base.util.gdl.model.SentenceDomainModels;
import org.ggp.base.util.gdl.model.SentenceDomainModels.VarDomainOpts;
import org.ggp.base.util.gdl.model.SentenceForm;
import org.ggp.base.util.gdl.model.SentenceFormModel;
import org.ggp.base.util.gdl.model.assignments.AddibleFunctionInfo;
import org.ggp.base.util.gdl.model.assignments.AssignmentIterator;
import org.ggp.base.util.gdl.model.assignments.Assignments;
import org.ggp.base.util.gdl.model.assignments.AssignmentsImpl;
import org.ggp.base.util.gdl.model.assignments.FunctionInfo;
import org.ggp.base.util.gdl.transforms.CommonTransforms;
import org.ggp.base.util.reasoner.DifferentialForwardChainingReasoner;
import com.google.common.collect.ImmutableMultimap;
import com.google.common.collect.SetMultimap;
/**
* An implementation of a ForwardChainingReasoner that uses Gdl objects
* directly and allows for differential processing of rules.
*/
public class GdlChainingReasoner implements
DifferentialForwardChainingReasoner<GdlRule, GdlSentenceSet> {
private final SentenceFormModel model;
private final ImmutableMultimap<SentenceForm, GdlSentence> constants;
private GdlChainingReasoner(SentenceFormModel model, ImmutableMultimap<SentenceForm, GdlSentence> constants) {
this.model = model;
this.constants = constants;
}
public static GdlChainingReasoner create(SentenceFormModel model) {
ImmutableMultimap.Builder<SentenceForm, GdlSentence> constantsBuilder = ImmutableMultimap.builder();
for (SentenceForm form : model.getSentenceForms()) {
constantsBuilder.putAll(form, model.getSentencesListedAsTrue(form));
}
return new GdlChainingReasoner(model, constantsBuilder.build());
}
@Override
public GdlSentenceSet getConstantSentences() {
return GdlSentenceSet.create(constants);
}
@Override
public GdlSentenceSet getRuleResults(GdlRule rule,
SentenceDomainModel domainModel,
GdlSentenceSet sentencesSoFar) throws InterruptedException {
ConcurrencyUtils.checkForInterruption();
SentenceForm headForm = model.getSentenceForm(rule.getHead());
Map<GdlVariable, Set<GdlConstant>> varDomains = SentenceDomainModels.getVarDomains(rule, domainModel, VarDomainOpts.INCLUDE_HEAD);
Map<SentenceForm, ? extends FunctionInfo> functionInfoMap = sentencesSoFar.getFunctionInfo();
Map<SentenceForm, ? extends Collection<GdlSentence>> completedSentenceFormValues = sentencesSoFar.getSentences().asMap();
AssignmentsImpl assignments = new AssignmentsImpl(rule, varDomains, functionInfoMap, completedSentenceFormValues);
AssignmentIterator asnItr = assignments.getIterator();
GdlSentenceSet sentencesToAdd = GdlSentenceSet.create();
while (asnItr.hasNext()) {
Map<GdlVariable, GdlConstant> assignment = asnItr.next();
boolean allSatisfied = true;
for (GdlLiteral literal : rule.getBody()) {
ConcurrencyUtils.checkForInterruption();
if (!satisfies(assignment, literal, sentencesSoFar.getSentences())) {
asnItr.changeOneInNext(GdlUtils.getVariables(literal), assignment);
allSatisfied = false;
break;
}
}
if (allSatisfied) {
GdlSentence head = rule.getHead();
sentencesToAdd.put(headForm, CommonTransforms.replaceVariables(head, assignment));
asnItr.changeOneInNext(GdlUtils.getVariables(head), assignment);
}
}
return sentencesToAdd;
}
private boolean satisfies(Map<GdlVariable, GdlConstant> assignment,
GdlLiteral literal, SetMultimap<SentenceForm, GdlSentence> sentencesSoFar) {
if (literal instanceof GdlSentence) {
return satisfiesSentence(assignment, (GdlSentence) literal, sentencesSoFar);
} else if (literal instanceof GdlNot) {
GdlLiteral body = ((GdlNot) literal).getBody();
if (!(body instanceof GdlSentence)) {
throw new IllegalStateException("Negated literal should be a sentence but isn't: " + body);
}
return !satisfiesSentence(assignment, (GdlSentence) body, sentencesSoFar);
} else if (literal instanceof GdlDistinct) {
return satisfiesDistinct(assignment, (GdlDistinct) literal);
} else if (literal instanceof GdlOr) {
GdlOr or = (GdlOr) literal;
for (int i = 0; i < or.arity(); i++) {
GdlLiteral innerLiteral = or.get(i);
if (satisfies(assignment, innerLiteral, sentencesSoFar)) {
return true;
}
}
return false;
} else {
throw new IllegalArgumentException("Unrecognized type of literal " + literal.getClass() + " for literal " + literal);
}
}
private boolean satisfiesSentence(Map<GdlVariable, GdlConstant> assignment,
GdlSentence sentence,
SetMultimap<SentenceForm, GdlSentence> sentencesSoFar) {
sentence = CommonTransforms.replaceVariables(sentence, assignment);
SentenceForm form = model.getSentenceForm(sentence);
return sentencesSoFar.get(form).contains(sentence);
}
private boolean satisfiesDistinct(Map<GdlVariable, GdlConstant> assignment,
GdlDistinct distinct) {
distinct = CommonTransforms.replaceVariables(distinct, assignment);
return distinct.getArg1() != distinct.getArg2();
}
@Override
public GdlSentenceSet getUnion(
GdlSentenceSet oldSentences,
GdlSentenceSet newSentences) {
oldSentences.putAll(newSentences.getSentences());
return oldSentences;
}
@Override
public boolean isSubsetOf(
GdlSentenceSet oldSentences,
GdlSentenceSet newSentences) {
for (Entry<SentenceForm, GdlSentence> entry : newSentences.getSentences().entries()) {
if (!oldSentences.containsSentence(entry.getKey(), entry.getValue())) {
return false;
}
}
return true;
}
@Override
public GdlSentenceSet getRuleResultsForNewSentences(
GdlRule rule, SentenceDomainModel domainModel,
GdlSentenceSet allSentences,
GdlSentenceSet newSentences) throws InterruptedException {
GdlSentenceSet results = GdlSentenceSet.create();
for (GdlLiteral literal : rule.getBody()) {
ConcurrencyUtils.checkForInterruption();
if (literal instanceof GdlSentence) {
SentenceForm literalForm = domainModel.getSentenceForm((GdlSentence) literal);
addRuleResultsForChosenLiteral(
rule,
(GdlSentence) literal,
newSentences.getSentences().get(literalForm),
domainModel,
allSentences,
results);
} else if (literal instanceof GdlOr) {
throw new IllegalArgumentException("Need more implementation work for this to work with ORs here");
}
}
return results;
}
private void addRuleResultsForChosenLiteral(GdlRule rule,
GdlSentence chosenLiteral, Set<GdlSentence> chosenNewSentences,
SentenceDomainModel domainModel,
GdlSentenceSet allSentences,
GdlSentenceSet sentencesToAdd) {
SentenceForm headForm = model.getSentenceForm(rule.getHead());
Map<GdlVariable, Set<GdlConstant>> varDomains = SentenceDomainModels.getVarDomains(rule, domainModel, VarDomainOpts.INCLUDE_HEAD);
Map<SentenceForm, AddibleFunctionInfo> functionInfoMap = allSentences.getFunctionInfo();
Map<SentenceForm, ? extends Collection<GdlSentence>> completedSentenceFormValues = allSentences.getSentences().asMap();
for (GdlSentence chosenNewSentence : chosenNewSentences) {
Map<GdlVariable, GdlConstant> preassignments = GdlUtils.getAssignmentMakingLeftIntoRight(chosenLiteral, chosenNewSentence);
if (preassignments != null) {
Assignments assignments = new AssignmentsImpl(preassignments, rule, varDomains, functionInfoMap, completedSentenceFormValues);
AssignmentIterator asnItr = assignments.getIterator();
while (asnItr.hasNext()) {
Map<GdlVariable, GdlConstant> assignment = asnItr.next();
boolean allSatisfied = true;
for (GdlLiteral literal : rule.getBody()) {
if (literal == chosenLiteral) {
//Already satisfied
continue;
}
if (!satisfies(assignment, literal, allSentences.getSentences())) {
asnItr.changeOneInNext(GdlUtils.getVariables(literal), assignment);
allSatisfied = false;
break;
}
}
if (allSatisfied) {
GdlSentence head = rule.getHead();
GdlSentence newHead = CommonTransforms.replaceVariables(head, assignment);
if (!allSentences.containsSentence(headForm, newHead)) {
sentencesToAdd.put(headForm, newHead);
}
asnItr.changeOneInNext(GdlUtils.getVariables(head), assignment);
}
}
}
}
}
}