private IEnumerable <NestedQuestion> GetNestedQuestions(IQuestionProcessingContext <ComparisonQuestion> context)
{
foreach (var statement in context.SemanticNetwork.Statements.Enumerate <ComparisonStatement>(context.ActiveContexts))
{
IConcept newLeftValue = null;
if (statement.LeftValue == LeftValue)
{
newLeftValue = statement.RightValue;
}
else if (statement.RightValue == LeftValue)
{
newLeftValue = statement.LeftValue;
}
if (newLeftValue != null)
{
var involvedValues = new HashSet <IConcept>(context.ActiveContexts
.OfType <IQuestionProcessingContext <ComparisonQuestion> >()
.Select(c => c.Question.LeftValue));
if (!involvedValues.Contains(newLeftValue))
{
yield return(new NestedQuestion(new ComparisonQuestion(newLeftValue, RightValue), new IStatement[] { statement }));
}
}
}
}
private IAnswer ProcessChildAnswers(IQuestionProcessingContext <ComparisonQuestion> context, ICollection <ChildAnswer> childAnswers)
{
foreach (var answer in childAnswers)
{
var childStatement = (answer.Answer as StatementAnswer)?.Result as ComparisonStatement;
if (childStatement != null)
{
var transitiveStatement = (ComparisonStatement)answer.TransitiveStatements.Single();
var intermediateValue = new[] { childStatement.LeftValue, childStatement.RightValue }.Intersect(new[] { transitiveStatement.LeftValue, transitiveStatement.RightValue }).Single();
if ((childStatement.LeftValue == intermediateValue) == (transitiveStatement.LeftValue == intermediateValue))
{
transitiveStatement = transitiveStatement.SwapOperands();
}
var resultSign = ComparisonSigns.CompareThreeValues(childStatement.ComparisonSign, transitiveStatement.ComparisonSign);
if (resultSign != null)
{
var transitiveStatements = new List <IStatement>(answer.TransitiveStatements);
transitiveStatements.AddRange(answer.Answer.Explanation.Statements);
return(createAnswer(
new ComparisonStatement(null, LeftValue, RightValue, resultSign),
context,
transitiveStatements));
}
}
}
return(Answer.CreateUnknown());
}
public override IAnswer Process(IQuestionProcessingContext context)
{
var allStatements = context.SemanticNetwork.Statements.Enumerate(context.ActiveContexts).ToList();
var isStatements = allStatements.Enumerate <IsStatement>(context.ActiveContexts).Where(c => c.Descendant == Concept).ToList();
if (isStatements.Any())
{
var result = new Semantics.Text.Containers.UnstructuredContainer();
var explanation = new List <SignValueStatement>();
foreach (var statement in isStatements)
{
var difference = getDifferenceBetweenAncestorAndDescendant(allStatements, statement);
explanation.AddRange(difference);
if (difference.Count > 0)
{
writeClassificationWithDifference(result, statement, difference);
}
else
{
writeJustClassification(result, statement);
}
result.AppendLineBreak();
}
return(new Answer(result, new Explanation(explanation), false));
}
else
{
return(Answer.CreateUnknown());
}
}
public override IAnswer Process(IQuestionProcessingContext context)
{
var allStatements = context.SemanticNetwork.Statements.Enumerate(context.ActiveContexts);
IEnumerable <IStatement> statements;
var parentChild = Statement as IParentChild <IConcept>;
if (parentChild != null)
{
statements = allStatements.FindPath(Statement.GetType(), parentChild.Parent, parentChild.Child);
}
else
{
var statement = allStatements.FirstOrDefault(p => p.Equals(Statement));
statements = statement != null ? new[] { statement } : Array.Empty <IStatement>();
}
var result = new UnstructuredContainer();
System.Boolean isTrue = statements.Any();
result.Append(
language => Strings.ParamAnswer,
new Dictionary <String, IKnowledge> {
{ Strings.ParamAnswer, isTrue.ToLogicalValue() }
});
result.Append(isTrue ? Statement.DescribeTrue() : Statement.DescribeFalse());
return(new BooleanAnswer(
isTrue,
result,
new Explanation(statements)));
}
public override IAnswer Process(IQuestionProcessingContext context)
{
return(context
.From <ProcessesQuestion, ProcessesStatement>()
.WithTransitives(s => s.Count == 0, GetNestedQuestions)
.Where(s => (s.ProcessA == ProcessA && s.ProcessB == ProcessB) || (s.ProcessB == ProcessA && s.ProcessA == ProcessB))
.SelectCustom(CreateAnswer));
}
public override IAnswer Process(IQuestionProcessingContext context)
{
return(context
.From <ComparisonQuestion, ComparisonStatement>()
.WithTransitives(s => s.Count == 0, GetNestedQuestions)
.Where(s => (s.LeftValue == LeftValue && s.RightValue == RightValue) || (s.RightValue == LeftValue && s.LeftValue == RightValue))
.SelectCustom(CreateAnswer));
}
public override IAnswer Process(IQuestionProcessingContext context)
{
if (_createNestedContext)
{
new QuestionProcessingContext <TestQuestionCreateNestedContext>(context, new TestQuestionCreateNestedContext(false));
}
return(null);
}
public StatementQuestionProcessor(IQuestionProcessingContext context)
{
Context = (IQuestionProcessingContext <QuestionT>)context;
Statements = Array.Empty <StatementT>();
ChildAnswers = Array.Empty <ChildAnswer>();
AdditionalTransitives = Array.Empty <IStatement>();
NeedToProcessTransitives = statements => false;
GetTransitiveQuestions = c => Array.Empty <NestedQuestion>();
NeedToAggregateTransitivesToStatements = false;
}
public override IAnswer Process(IQuestionProcessingContext context)
{
return(context
.From <EnumerateDescendantsQuestion, IsStatement>()
.Where(s => s.Ancestor == Concept)
.SelectAllConcepts(
statement => statement.Descendant,
question => question.Concept,
Strings.ParamParent,
language => language.GetExtension <ILanguageClassificationModule>().Questions.Answers.EnumerateDescendants));
}
public override IAnswer Process(IQuestionProcessingContext context)
{
return(context
.From <FindSubjectAreaQuestion, GroupStatement>()
.Where(s => s.Concept == Concept)
.SelectAllConcepts(
statement => statement.Area,
question => question.Concept,
Semantics.Localization.Strings.ParamConcept,
language => language.GetExtension <ILanguageSetModule>().Questions.Answers.SubjectArea));
}
public override IAnswer Process(IQuestionProcessingContext context)
{
var random = new Random(DateTime.Now.Millisecond);
var allConcepts = context.SemanticNetwork.Concepts.ToList();
var resultConcept = allConcepts[random.Next(allConcepts.Count)];
return(new ConceptAnswer(
resultConcept,
new FormattedText(language => resultConcept.Name.GetValue(language)),
new Explanation(Array.Empty <IStatement>())));
}
public override IAnswer Process(IQuestionProcessingContext context)
{
return(context
.From <DescribeSubjectAreaQuestion, GroupStatement>()
.Where(s => s.Area == Concept)
.SelectAllConcepts(
statement => statement.Concept,
question => question.Concept,
Strings.ParamArea,
language => language.GetExtension <ILanguageSetModule>().Questions.Answers.SubjectAreaConcepts));
}
public override IAnswer Process(IQuestionProcessingContext context)
{
return(context
.From <EnumerateContainersQuestion, HasPartStatement>()
.Where(s => s.Part == Concept)
.SelectAllConcepts(
statement => statement.Whole,
question => question.Concept,
Semantics.Localization.Strings.ParamChild,
language => language.GetExtension <ILanguageSetModule>().Questions.Answers.EnumerateContainers));
}
public override IAnswer Process(IQuestionProcessingContext context)
{
IStatement testStatement;
context.SemanticNetwork.Statements.Add(testStatement = new TestStatement());
testStatement.Context = context;
context.Scope.Add(testStatement);
Assert.IsTrue(context.SemanticNetwork.Statements.Enumerate <TestStatement>(context).Any());
return(null);
}
private static StatementAnswer createAnswer(ComparisonStatement statement, IQuestionProcessingContext <ComparisonQuestion> context, ICollection <IStatement> transitiveStatements = null)
{
var resultStatement = statement.SwapOperandsToMatchOrder(context.Question);
var text = new UnstructuredContainer();
text.Append(resultStatement.DescribeTrue());
var explanation = transitiveStatements == null
? new Explanation(statement)
: new Explanation(transitiveStatements);
return(new StatementAnswer(resultStatement, text, explanation));
}
public override IAnswer Process(IQuestionProcessingContext context)
{
return(context
.From <IsValueQuestion, SignValueStatement>()
.Where(s => s.Value == Concept)
.SelectBoolean(
statements => Concept.HasAttribute <IsValueAttribute>(),
language => language.GetExtension <ILanguageSetModule>().Questions.Answers.ValueTrue,
language => language.GetExtension <ILanguageSetModule>().Questions.Answers.ValueFalse,
new Dictionary <String, IKnowledge>
{
{ Semantics.Localization.Strings.ParamConcept, Concept },
}));
}
public override IAnswer Process(IQuestionProcessingContext context)
{
return(context
.From <IsPartOfQuestion, HasPartStatement>()
.Where(s => s.Whole == Parent && s.Part == Child)
.SelectBoolean(
statements => statements.Any(),
language => language.GetExtension <ILanguageSetModule>().Questions.Answers.IsPartOfTrue,
language => language.GetExtension <ILanguageSetModule>().Questions.Answers.IsPartOfFalse,
new Dictionary <String, IKnowledge>
{
{ Semantics.Localization.Strings.ParamParent, Parent },
{ Semantics.Localization.Strings.ParamChild, Child },
}));
}
public override IAnswer Process(IQuestionProcessingContext context)
{
return(context
.From <IsSubjectAreaQuestion, GroupStatement>()
.Where(s => s.Area == Area && s.Concept == Concept)
.SelectBoolean(
statements => statements.Any(),
language => language.GetExtension <ILanguageSetModule>().Questions.Answers.IsSubjectAreaTrue,
language => language.GetExtension <ILanguageSetModule>().Questions.Answers.IsSubjectAreaFalse,
new Dictionary <String, IKnowledge>
{
{ Strings.ParamArea, Area },
{ Semantics.Localization.Strings.ParamConcept, Concept },
}));
}
public override IAnswer Process(IQuestionProcessingContext context)
{
return(context
.From <CustomQuestion, CustomStatement>()
.Where(s => s.Concept1 == Concept1 && s.Concept2 == Concept2)
.SelectBoolean(
statements => statements.Count > 0,
language => language.GetExtension <ILanguageCustomModule>().Questions.Answers.CustomTrue,
language => language.GetExtension <ILanguageCustomModule>().Questions.Answers.CustomFalse,
new Dictionary <String, IKnowledge>
{
{ CustomStatement.ParamConcept1, Concept1 },
{ CustomStatement.ParamConcept2, Concept2 },
}));
}
public override IAnswer Process(IQuestionProcessingContext context)
{
return(context
.From <EnumerateSignsQuestion, HasSignStatement>()
.WithTransitives(
statements => Recursive,
question => question.Concept,
newSubject => new EnumerateSignsQuestion(newSubject, true),
needToAggregateTransitivesToStatements: true)
.Where(s => s.Concept == Concept)
.SelectAllConcepts(
statement => statement.Sign,
question => question.Concept,
Semantics.Localization.Strings.ParamConcept,
language => language.GetExtension <ILanguageSetModule>().Questions.Answers.ConceptSigns + (Recursive ? language.Questions.Answers.RecursiveTrue : language.Questions.Answers.RecursiveFalse) + ": "));
}
private static void addStatementConsequences(
HashSet <ProcessesStatement> statements,
ProcessesStatement newStatement,
IQuestionProcessingContext <ProcessesQuestion> context)
{
foreach (var consequentSign in newStatement.SequenceSign.Consequently())
{
if (statements.All(s => s.SequenceSign != consequentSign))
{
statements.Add(new ProcessesStatement(null, context.Question.ProcessA, context.Question.ProcessB, consequentSign)
{
Context = context
});
}
}
}
public override IAnswer Process(IQuestionProcessingContext context)
{
return(context
.From <HasSignsQuestion, HasSignStatement>()
.WithTransitives(
statements => Recursive,
question => question.Concept,
newSubject => new HasSignsQuestion(newSubject, true))
.Where(s => s.Concept == Concept)
.SelectBooleanIncludingChildren(
statements => statements.Count > 0,
language => language.GetExtension <ILanguageSetModule>().Questions.Answers.HasSignsTrue + (Recursive ? language.Questions.Answers.RecursiveTrue : language.Questions.Answers.RecursiveFalse) + ".",
language => language.GetExtension <ILanguageSetModule>().Questions.Answers.HasSignsFalse + (Recursive ? language.Questions.Answers.RecursiveTrue : language.Questions.Answers.RecursiveFalse) + ".",
new Dictionary <String, IKnowledge>
{
{ Semantics.Localization.Strings.ParamConcept, Concept },
}));
}
private IAnswer ProcessChildAnswers(IQuestionProcessingContext <ProcessesQuestion> context, ICollection <ChildAnswer> childAnswers)
{
foreach (var answer in childAnswers)
{
var childStatements = (answer.Answer as StatementsAnswer <ProcessesStatement>)?.Result ?? Array.Empty <ProcessesStatement>();
var resultStatements = new List <ProcessesStatement>();
var transitiveStatements = answer.TransitiveStatements.OfType <ProcessesStatement>().ToList();
var firstChild = childStatements.First();
var firstTransitive = transitiveStatements.First();
var intermediateValue = new[] { firstChild.ProcessA, firstChild.ProcessB }.Intersect(new[] { firstTransitive.ProcessA, firstTransitive.ProcessB }).Single();
for (int i = 0; i < transitiveStatements.Count; i++)
{
if ((firstChild.ProcessA == intermediateValue) == (transitiveStatements[i].ProcessA == intermediateValue))
{
transitiveStatements[i] = transitiveStatements[i].SwapOperands();
}
}
foreach (var childStatement in childStatements)
{
foreach (var transitiveStatement in transitiveStatements)
{
var sign = SequenceSigns.TryToCombineMutualSequences(transitiveStatement.SequenceSign, childStatement.SequenceSign);
if (sign != null)
{
resultStatements.Add(new ProcessesStatement(null, ProcessA,
ProcessB,
sign));
}
}
}
if (resultStatements.Count > 0)
{
var resultTransitiveStatements = new List <IStatement>(answer.TransitiveStatements);
resultTransitiveStatements.AddRange(answer.Answer.Explanation.Statements);
return(createAnswer(resultStatements, context, resultTransitiveStatements));
}
}
return(Answer.CreateUnknown());
}
public override IAnswer Process(IQuestionProcessingContext context)
{
return(context
.From <IsQuestion, IsStatement>()
.WithTransitives(
statements => statements.Count == 0,
question => question.Child,
newSubject => new IsQuestion(newSubject, Parent))
.Where(s => s.Parent == Parent && s.Child == Child)
.SelectBooleanIncludingChildren(
statements => statements.Count > 0,
language => language.GetExtension <ILanguageClassificationModule>().Questions.Answers.IsTrue,
language => language.GetExtension <ILanguageClassificationModule>().Questions.Answers.IsFalse,
new Dictionary <String, IKnowledge>
{
{ Strings.ParamParent, Parent },
{ Strings.ParamChild, Child },
}));
}
private IEnumerable <NestedQuestion> GetNestedQuestions(IQuestionProcessingContext <ProcessesQuestion> context)
{
var involvedValues = new HashSet <IConcept>(context.ActiveContexts
.OfType <IQuestionProcessingContext <ProcessesQuestion> >()
.Select(c => c.Question.ProcessA));
var transitiveProcesses = new Dictionary <IConcept, ICollection <IStatement> >();
foreach (var statement in context.SemanticNetwork.Statements.Enumerate <ProcessesStatement>(context.ActiveContexts))
{
IConcept newProcessA = null;
if (statement.ProcessA == ProcessA)
{
newProcessA = statement.ProcessB;
}
else if (statement.ProcessB == ProcessA)
{
newProcessA = statement.ProcessA;
}
if (newProcessA != null && !involvedValues.Contains(newProcessA))
{
ICollection <IStatement> transitiveStatements;
if (!transitiveProcesses.TryGetValue(newProcessA, out transitiveStatements))
{
transitiveProcesses[newProcessA] = transitiveStatements = new List <IStatement>();
}
transitiveStatements.Add(statement);
}
}
foreach (var transitiveProcess in transitiveProcesses)
{
var consequentStatements = new HashSet <ProcessesStatement>();
foreach (var transitive in transitiveProcess.Value.OfType <ProcessesStatement>())
{
addStatementConsequences(consequentStatements, transitive, context);
}
yield return(new NestedQuestion(new ProcessesQuestion(transitiveProcess.Key, ProcessB, consequentStatements), transitiveProcess.Value));
}
}
public override IAnswer Process(IQuestionProcessingContext context)
{
return(context
.From <SignValueQuestion, SignValueStatement>()
.WithTransitives(
statements => statements.Count == 0,
question => question.Concept,
newSubject => new SignValueQuestion(newSubject, Sign))
.Where(s => s.Concept == Concept && s.Sign == Sign)
.SelectFirstConcept(
statement => statement.Value,
language => language.GetExtension <ILanguageSetModule>().Questions.Answers.SignValue,
statement => new Dictionary <String, IKnowledge>
{
{ Semantics.Localization.Strings.ParamConcept, Concept },
{ Strings.ParamSign, statement.Sign },
{ Strings.ParamValue, statement.Value },
{ Strings.ParamDefined, statement.Concept },
}));
}
public override IAnswer Process(IQuestionProcessingContext context)
{
return(context
.From <GetShorterQuestion, IsTallerThanStatement>()
.WithTransitives(
statements => true,
c => c.SemanticNetwork.Statements
.OfType <IsTallerThanStatement>()
.Where(s => s.TallerPerson == c.Question.Person)
.Select(s => new NestedQuestion(
new GetShorterQuestion(s.ShorterPerson),
new IStatement[] { s })),
true)
.Where(s => s.TallerPerson == Person)
.SelectAllConcepts(
statement => statement.ShorterPerson,
question => question.Person,
"#TALLER#",
language => $"#TALLER# is taller than",
concepts => concepts.Distinct()));
}
public override IAnswer Process(IQuestionProcessingContext context)
{
return(context
.From <IsTallerQuestion, IsTallerThanStatement>()
.WithTransitives(
statements => true,
c => c.SemanticNetwork.Statements
.OfType <IsTallerThanStatement>()
.Where(s => s.TallerPerson == c.Question.TallerPerson)
.Select(s => new NestedQuestion(
new IsTallerQuestion(s.ShorterPerson, c.Question.ShorterPerson),
new IStatement[] { s })))
.Where(s => s.TallerPerson == TallerPerson && s.ShorterPerson == ShorterPerson)
.SelectBooleanIncludingChildren(
statements => statements.Count > 0,
language => "Yes, #TALLER# is taller than #SHORTER#.",
language => "No, #SHORTER# is taller than #TALLER#.",
new Dictionary <String, IKnowledge>
{
{ "#TALLER#", TallerPerson },
{ "#SHORTER#", ShorterPerson },
}));
}
private static StatementsAnswer <ProcessesStatement> createAnswer(ICollection <ProcessesStatement> statements, IQuestionProcessingContext <ProcessesQuestion> context, ICollection <IStatement> transitiveStatements = null)
{
var resultStatements = new HashSet <ProcessesStatement>();
var text = new UnstructuredContainer();
foreach (var statement in statements)
{
var resultStatement = statement.SwapOperandsToMatchOrder(context.Question);
if (resultStatements.All(s => s.SequenceSign != resultStatement.SequenceSign))
{
resultStatements.Add(resultStatement);
text.Append(resultStatement.DescribeTrue());
}
addStatementConsequences(resultStatements, resultStatement, context);
}
var explanation = transitiveStatements == null
? new Explanation(statements)
: new Explanation(transitiveStatements);
return(new StatementsAnswer <ProcessesStatement>(resultStatements, text, explanation));
}
private IAnswer CreateAnswer(IQuestionProcessingContext <ComparisonQuestion> context, ICollection <ComparisonStatement> statements, ICollection <ChildAnswer> childAnswers)
{
return(statements.Count > 0
? createAnswer(statements.First(), context)
: ProcessChildAnswers(context, childAnswers));
}
