protected override void onInstanceActivated(ConceptInstance instance, BeamGenerator generator)
{
var subject = generator.GetValue(instance, Concept2.Subject);
var property = generator.GetValue(instance, Concept2.Property);
var inheritedProperties = generator.GetPropertyValues(subject, includeInstanceProps: false);
var value = generator.GetValue(subject, property.Concept);
if (value == null)
{
var refutation = new ConceptInstance(Concept2.KnowledgeRefutation);
var refutedInfo = new ConceptInstance(subject.Concept);
generator.SetValue(refutedInfo, property.Concept, new ConceptInstance(Concept2.Something));
generator.SetValue(refutation, Concept2.Subject, refutedInfo);
generator.SetValue(refutation, Concept2.Property, property);
generator.Push(new InstanceOutputEvent(refutation));
}
else
{
var confirmation = new ConceptInstance(Concept2.KnowledgeConfirmed);
var confirmedInfo = new ConceptInstance(subject.Concept);
generator.SetValue(confirmedInfo, property.Concept, value);
generator.SetValue(confirmation, Concept2.Subject, confirmedInfo);
generator.Push(new InstanceOutputEvent(confirmation));
}
}
protected override void onInstanceActivated(ConceptInstance instance, BeamGenerator generator)
{
var property = generator.GetValue(instance, _propertyParameter);
var subject = generator.GetValue(instance, _subjectParameter);
var answer = getAnswer(subject, property.Concept, generator);
if (answer.Count == 0)
{
//generator.Push(new StaticScoreEvent(-0.20));
generator.Push(new InstanceOutputEvent(new ConceptInstance(Concept2.NotFound)));
}
else if (answer.Count == 1)
{
generator.Push(new StaticScoreEvent(0.20));
generator.Push(new InstanceOutputEvent(answer.First()));
}
else
{
var needRefinementInstance = new ConceptInstance(Concept2.NeedsRefinement);
generator.SetValue(needRefinementInstance, Concept2.Subject, subject);
generator.SetValue(subject, Concept2.OnSetListener, instance);
generator.Push(new InstanceOutputEvent(needRefinementInstance));
}
}
protected override IEnumerable <string> execute(BeamGenerator generator)
{
var unknownPhrases = GetUnknownPhrases(generator);
var isInLearnPhraseMode = PreviousPolicy <LearnNewPhrase>(out var learnPolicy) || PreviousPolicy <UnknownAnsweredToLearnNewPhrase>(out learnPolicy);
if (!isInLearnPhraseMode || unknownPhrases.Count() != 1)
{
yield break;
}
var unknown = generator.GetValue(learnPolicy.Tag, Concept2.Unknown);
var prompt = generator.GetValue(learnPolicy.Tag, Concept2.Prompt);
//remember runtime info so others can use it
generator.SetValue(TagInstance, Concept2.Unknown, unknown);
generator.SetValue(TagInstance, Concept2.Prompt, prompt);
generator.Push(new InstanceActivationRequestEvent(prompt));
yield return($"Still, I'm not getting it. What does {singular(unknown)} mean?");
yield return($"That is complicated. What does {singular(unknown)} mean?");
yield return($"I don't know those words. Could you put {singular(unknown)} differently?");
}
protected override void onInstanceActivated(ConceptInstance instance, BeamGenerator generator)
{
var subject = generator.GetValue(instance, Concept2.Subject);
var target = generator.GetValue(instance, Concept2.Target);
var relevantProperties = getRelevantProperties(target, generator);
if (!relevantProperties.Any())
{
generator.Push(new StaticScoreEvent(-0.5));
return;
}
var disambiguation = new ConceptInstance(Concept2.PropertyValueDisambiguation);
generator.SetValue(disambiguation, Concept2.Unknown, subject);
generator.SetValue(disambiguation, Concept2.Target, target);
foreach (var pair in relevantProperties)
{
var propertyInstance = new ConceptInstance(pair.Key);
foreach (var value in pair.Value)
{
var valueInstance = new ConceptInstance(value);
generator.SetValue(valueInstance, Concept2.Property, propertyInstance);
generator.SetValue(disambiguation, Concept2.Subject, valueInstance);
}
}
generator.Push(new InstanceActivationRequestEvent(disambiguation));
}
protected override void onInstanceActivated(ConceptInstance instance, BeamGenerator generator)
{
var subjects = generator.GetValues(instance, Concept2.Subject).ToArray();
var answer = generator.GetValue(instance, Concept2.Answer);
var unknown = generator.GetValue(instance, Concept2.Unknown);
var target = generator.GetValue(instance, Concept2.Target);
var directSubjects = filterDirectSubjects(subjects, answer);
var indirectSubjects = filterIndirectSubjects(subjects, answer, generator);
if (answer.Concept == Concept2.Nothing)
{
// user does not like any option
return;
}
if (directSubjects.Count() == 1)
{
pushSetSubject(target, directSubjects.First(), generator, unknown);
return;
}
if (indirectSubjects.Count() == 1)
{
pushSetSubject(target, indirectSubjects.First(), generator, unknown);
return;
}
if (indirectSubjects.Count() == 0)
{
generator.Push(new InstanceOutputEvent(new ConceptInstance(Concept2.DisambiguationFailed)));
return;
}
if (indirectSubjects.Count() < subjects.Count())
{
//create new disambiguation
generator.Push(new StaticScoreEvent(0.1));
pushNewDisambiguation(indirectSubjects, unknown, target, generator);
return;
}
if (indirectSubjects.Count() == subjects.Count())
{
var knowledgeConfirmation = new ConceptInstance(Concept2.DisambiguatedKnowledgeConfirmed);
generator.SetValue(knowledgeConfirmation, Concept2.Subject, answer);
generator.SetValue(knowledgeConfirmation, Concept2.Target, instance);
generator.Push(new StaticScoreEvent(0.05));
generator.Push(new InstanceOutputEvent(knowledgeConfirmation));
return;
}
//disambiguation was not helpful
generator.Push(new StaticScoreEvent(-1.0));
}
protected override void onInstanceActivated(ConceptInstance instance, BeamGenerator generator)
{
var property = generator.GetValue(instance, Concept2.Property);
var target = generator.GetValue(instance, Concept2.Target);
var setTarget = new PropertySetTarget(target, Concept2.HasProperty);
var evt = new PropertySetEvent(setTarget, property, allowActivation: false);
generator.Push(evt);
generator.Push(new ExportEvent(evt));
}
protected override void onInstanceActivated(ConceptInstance instance, BeamGenerator generator)
{
var subject = generator.GetValue(instance, Concept2.Subject);
var description = generator.GetValue(instance, Concept2.Description);
var conceptDescription = new ConceptDescriptionEvent(subject.Concept, description.Concept.Name);
var export = new ExportEvent(conceptDescription);
generator.Push(export);
generator.Push(conceptDescription);
}
protected override void onInstanceActivated(ConceptInstance instance, BeamGenerator generator)
{
var unknown = generator.GetValue(instance, Concept2.Unknown);
var answer = generator.GetValue(instance, Concept2.Answer).Concept;
if (answer == Concept2.Nothing || answer == Concept2.No || answer == Concept2.Nothing)
{
//nothing to report
}
else
{
generator.Push(new InstanceOutputEvent(instance));
}
}
protected override void onInstanceActivated(ConceptInstance instance, BeamGenerator generator)
{
var parameterValue = generator.GetValue(instance, _parameter);
var relevantInstances = getRelevantInstances(instance, parameterValue.Concept, generator).ToArray();
foreach (var relevantInstance in relevantInstances)
{
//avoid reference circles
if (relevantInstance.Concept == instance.Concept)
{
continue;
}
if (!generator.IsDefined(relevantInstance.Concept))
{
continue;
}
//try tunnel instances between turns
generator.Push(new StaticScoreEvent(0.05));
generator.Push(new InstanceReferencedEvent(relevantInstance));
generator.Pop();
generator.Pop();
}
}
protected override void onInstanceActivated(ConceptInstance instance, BeamGenerator generator)
{
var target = generator.GetValue(instance, Concept2.Target);
var targetProperty = generator.GetValue(instance, Concept2.TargetProperty);
var subject = generator.GetValue(instance, Concept2.Subject);
var generalTarget = new PropertySetTarget(target.Concept, targetProperty.Concept);
var setEvent = new PropertySetEvent(generalTarget, subject);
generator.Push(new ExportEvent(setEvent));
generator.Push(setEvent);
if (generator.IsDefined(instance.Concept))
{
generator.Push(new InstanceOutputEvent(instance));
}
}
protected override IEnumerable <string> execute(BeamGenerator generator)
{
var evt = Get <InstanceOutputEvent>();
if (evt?.Instance.Concept != Concept2.NeedsRefinement)
{
yield break;
}
var instanceToRefine = generator.GetValue(evt.Instance, Concept2.Subject);
var activationTarget = generator.GetValue(evt.Instance, Concept2.Target);
var prefixesForRefine = generator.GetPrefixingUnknowns(instanceToRefine);
if (!prefixesForRefine.TryGetValue(instanceToRefine, out var propertyUnknownRaw))
{
//nothing to ask for
yield break;
}
var propertyUnknown = toMeaningfulPhrase(propertyUnknownRaw);
if (propertyUnknown == "")
{
yield break;
}
/*
* //TODO feature based questions
*
* //ACTION SEQUENCE
* //Do you want X which is UNKNOWN ? * Prompt
* //-yes: what property UNKNOWN is ? * yes -> expect (properties)
* //-- expect property *
* //-no: So which X you want ? * no -> ?
* //--standard refinement *
*
* yield return $"I know many {plural(instanceToRefine)} which one would you like?";*/
var assignUnknownProperty = AssignUnknownProperty.Create(instanceToRefine, propertyUnknown, generator);
YesNoPrompt.Generate(generator, assignUnknownProperty, instanceToRefine);
yield return($"So, you would like to find {plural(instanceToRefine)} which are {propertyUnknown}?");
}
private void pushSetSubject(ConceptInstance target, ConceptInstance resolvedSubject, BeamGenerator generator, ConceptInstance unknown)
{
RememberConceptDescription.Activate(resolvedSubject.Concept, unknown.Concept.Name, generator);
var relevantProperty = generator.GetValue(resolvedSubject, Concept2.Property);
generator.Push(new StaticScoreEvent(0.1));
generator.SetValue(target, relevantProperty.Concept, resolvedSubject);
}
protected override IEnumerable <string> execute(BeamGenerator generator)
{
var evt = Get <InstanceOutputEvent>(i => i.Instance.Concept == Concept2.LearnNewConcept);
if (evt == null)
{
yield break;
}
var collection = evt.Instance;
var answer = generator.GetValue(collection, Concept2.Answer);
var unknown = generator.GetValue(collection, Concept2.Unknown);
var rememberDescription = RememberConceptDescription.Create(generator, answer.Concept, unknown.Concept.Name);
YesNoPrompt.Generate(generator, rememberDescription, new ConceptInstance(Concept2.Nothing));
yield return($"So you think {singular(unknown)} is {singular(answer)} ?");
}
protected override void onInstanceActivated(ConceptInstance instance, BeamGenerator generator)
{
var answer = generator.GetValue(instance, Concept2.Answer).Concept;
if (answer == Concept2.Yes)
{
var yesInstance = generator.GetValue(instance, Concept2.Yes);
generator.Push(new InstanceActivationRequestEvent(yesInstance));
}
else if (answer == Concept2.No)
{
var noInstance = generator.GetValue(instance, Concept2.No);
generator.Push(new InstanceActivationRequestEvent(noInstance));
}
else
{
generator.Push(new StaticScoreEvent(-1));
}
}
protected override IEnumerable <string> execute(BeamGenerator generator)
{
var request = Get <IncompleteRelationEvent>(p => !p.IsFilled);
if (request == null || request.Subject == null)
{
yield break;
}
var instanceConcept = request.Subject?.Concept;
if (instanceConcept.Name == "the" || instanceConcept.Name == "a")
{
yield break;
}
if (instanceConcept == Concept2.What)
{
var subject = generator.GetValue(request.Subject, Concept2.Subject);
var property = generator.GetValue(request.Subject, Concept2.Property);
generator.Push(request);
if (subject == null && property != null)
{
yield return($"{singular(property)} of what ?");
}
else if (property == null && subject != null)
{
yield return($"What are you interested in about {singular(subject)} ?");
}
else
{
yield return("What are you interested in?");
}
}
else
{
generator.Push(request);
yield return("What should I " + singular(request.Subject) + " ?");
}
}
protected override IEnumerable <string> execute(BeamGenerator generator)
{
var evt = Get <IncompleteRelationEvent>(s => !s.IsFilled && s.Subject?.Concept == Concept2.PropertyValueDisambiguation, searchInsideTurnOnly: false);
if (evt == null)
{
yield break;
}
generator.Push(evt);
var disambiguation = evt.Subject;
var unknown = generator.GetValue(disambiguation, Concept2.Unknown);
var candidates = generator.GetValues(disambiguation, Concept2.Subject);
var candidateProperties = new HashSet <Concept2>();
foreach (var candidate in candidates)
{
var relevantProperty = generator.GetValue(candidate, Concept2.Property);
candidateProperties.Add(relevantProperty.Concept);
}
if (candidateProperties.Count == 1)
{
var candidateString = string.Join(", ", candidates.Select(c => singular(c.Concept)));
yield return($"I can recognize {candidateString} as {plural(candidateProperties.First())}. Which of them is related to {singular(unknown)}?");
}
else if (candidateProperties.Count < 4)
{
var candidateString = string.Join(" or ", candidateProperties.Select(c => singular(c)));
yield return($"What does {singular(unknown)} mean?");
yield return($"I think, It can be {candidateString}. Which fits best the meaning of {singular(unknown)}?");
}
else
{
yield return($"What does {singular(unknown)} mean ?");
}
}
private List <ConceptInstance> getAnswer(ConceptInstance subject, Concept2 property, BeamGenerator generator)
{
var result = new List <ConceptInstance>();
var directValue = generator.GetValue(subject, property);
if (directValue != null)
{
result.Add(directValue);
return(result);
}
var criterionValues = generator.GetPropertyValues(subject);
criterionValues.Remove(Concept2.OnSetListener); // TODO internal property removal should be done in more systematic way
var requiredProperties = new HashSet <Concept2>(criterionValues.Values.Select(i => i.Concept));
requiredProperties.Add(subject.Concept);
var relevantConcepts = FindProvider.FindRelevantConcepts(generator, requiredProperties);
foreach (var concept in relevantConcepts)
{
var searchedPropertyValue = generator.GetValue(concept, property);
if (searchedPropertyValue == null)
{
continue;
}
result.Add(searchedPropertyValue);
}
return(result);
}
protected override IEnumerable <string> execute(BeamGenerator generator)
{
//we are searching for deactivated instances because after call instance is deactivated
var rememberAbility = FindDeactivatedTurnInstances(i => i.Concept == Concept2.RememberConceptDescription).FirstOrDefault();
if (rememberAbility == null)
{
yield break;
}
var subject = generator.GetValue(rememberAbility, Concept2.Subject);
generator.Push(new Events.InstanceReferencedEvent(subject));
yield return($"Thank you. What should I do with {singular(subject)}?");
}
protected override void onInstanceActivated(ConceptInstance instance, BeamGenerator generator)
{
var answer = generator.GetValue(instance, Concept2.Answer);
var options = generator.GetValues(instance, Concept2.Option);
var disambiguatedOptions = disambiguate(options, answer);
if (disambiguatedOptions.Count() == 1)
{
var activeOption = disambiguatedOptions.First();
var instanceToActivate = generator.GetValue(activeOption, Concept2.Invocation);
generator.Push(new StaticScoreEvent(0.1));
generator.Push(new InstanceActivationRequestEvent(instanceToActivate));
}
else if (disambiguatedOptions.Count() == 0)
{
generator.Push(new StaticScoreEvent(-0.2));
//push same options again
pushNewOptions(options, generator);
}
else
{
pushNewOptions(disambiguatedOptions, generator);
}
}
private IEnumerable <ConceptInstance> filterIndirectSubjects(ConceptInstance[] subjects, ConceptInstance answer, BeamGenerator generator)
{
var result = new List <ConceptInstance>();
foreach (var subject in subjects)
{
var propertyInfo = generator.GetValue(subject, Concept2.Property);
if (propertyInfo.Concept == answer.Concept)
{
result.Add(subject);
}
}
return(result);
}
protected override void onInstanceActivated(ConceptInstance instance, BeamGenerator generator)
{
var criterion = generator.GetValue(instance, _parameter);
var criterionValues = generator.GetPropertyValues(criterion);
criterionValues.Remove(Concept2.OnSetListener); // TODO internal property removal should be done in more systematic way
criterionValues.Remove(Concept2.HasProperty);
criterionValues.Remove(Concept2.HasPropertyValue);
var requiredProperties = new HashSet <Concept2>(criterionValues.Values.Select(i => i.Concept));
requiredProperties.Add(criterion.Concept);
var result = FindRelevantConcepts(generator, requiredProperties);
var isSubjectClass = generator.GetInverseConceptValues(Concept2.InstanceOf, criterion).Any();
if (result.Count == 0)
{
if (isSubjectClass)
{
generator.Push(new StaticScoreEvent(0.1));
}
else
{
generator.Push(new StaticScoreEvent(-0.1));
}
generator.Push(new InstanceOutputEvent(new ConceptInstance(Concept2.NotFound)));
}
else if (result.Count == 1)
{
generator.Push(new StaticScoreEvent(0.5));
generator.Push(new InstanceOutputEvent(result.First()));
}
else
{
if (generator.IsProperty(criterion.Concept))
{
generator.Push(new StaticScoreEvent(-0.15));
}
var needRefinementInstance = new ConceptInstance(Concept2.NeedsRefinement);
generator.SetValue(needRefinementInstance, Concept2.Subject, criterion);
generator.SetValue(criterion, Concept2.OnSetListener, instance);
generator.Push(new InstanceOutputEvent(needRefinementInstance));
}
}
protected override IEnumerable <string> execute(BeamGenerator generator)
{
var unknownPhrases = GetUnknownPhrases(generator);
if (!PreviousPolicy <RequestRefinement>(out var refinementPolicy) || unknownPhrases.Count() != 1)
{
yield break;
}
var instanceToRefine = generator.GetValue(refinementPolicy.Tag, Concept2.Target);
var unknown = unknownPhrases.First();
var assignUnknownProperty = AssignUnknownProperty.Create(instanceToRefine, unknown, generator);
YesNoPrompt.Generate(generator, assignUnknownProperty, instanceToRefine);
yield return($"I suppose, you would like to find {plural(instanceToRefine)} which are {unknown}?");
}
protected override IEnumerable <string> execute(BeamGenerator generator)
{
var evt = Find <IncompleteRelationEvent>(s => !s.IsFilled && s.Subject?.Concept == Concept2.AssignUnknownProperty, precedingTurns: 1);
if (evt == null)
{
yield break;
}
var disambiguation = evt.Subject;
var unknown = generator.GetValue(disambiguation, Concept2.Unknown);
// retry the event
generator.Push(evt);
yield return($"I'm sorry, I don't understand that either. What does {singular(unknown)} mean?");
yield return($"It seems to be very complicated. What does {singular(unknown)} mean?");
}
protected override void onInstanceActivated(ConceptInstance instance, BeamGenerator generator)
{
var subject = generator.GetValue(instance, Concept2.Subject);
var inheritedProperties = generator.GetPropertyValues(subject, includeInstanceProps: false);
var pureInstanceProperties = generator.GetPropertyValues(subject, includeInheritedProps: false);
if (!pureInstanceProperties.Any())
{
var confirmation = new ConceptInstance(Concept2.KnowledgeConfirmed);
generator.SetValue(confirmation, Concept2.Subject, subject);
generator.Push(new InstanceOutputEvent(confirmation));
return;
}
var unknown = new List <KeyValuePair <Concept2, ConceptInstance> >();
foreach (var propertyValue in pureInstanceProperties)
{
if (!inheritedProperties.TryGetValue(propertyValue.Key, out var knownValue) || knownValue.Concept != propertyValue.Value.Concept)
{
unknown.Add(propertyValue);
}
}
if (unknown.Count == 0)
{
var confirmation2 = new ConceptInstance(Concept2.KnowledgeConfirmed);
generator.SetValue(confirmation2, Concept2.Subject, subject);
generator.Push(new InstanceOutputEvent(confirmation2));
return;
}
var unknownReport = new ConceptInstance(subject.Concept);
foreach (var propertyValue in unknown)
{
generator.SetValue(unknownReport, propertyValue.Key, propertyValue.Value);
}
var confirmation3 = new ConceptInstance(Concept2.KnowledgeRefutation);
generator.SetValue(confirmation3, Concept2.Subject, subject);
generator.Push(new InstanceOutputEvent(unknownReport));
}
protected override IEnumerable <string> execute(BeamGenerator generator)
{
var evt = Get <InstanceOutputEvent>();
var priorityEvt = Get <InstanceOutputEvent>(p => p.Instance.Concept != Concept2.NeedsRefinement && p.Instance.Concept != Concept2.NotFound);
if (priorityEvt != null || evt?.Instance.Concept != Concept2.NeedsRefinement)
{
yield break;
}
var instanceToRefine = generator.GetValue(evt.Instance, Concept2.Subject);
// let following policies know about the refinement target
generator.SetValue(TagInstance, Concept2.Target, instanceToRefine);
// generate a question
generator.Push(new IncompleteRelationEvent(instanceToRefine, Concept2.Something, null));
yield return($"I know many {plural(instanceToRefine)} which one would you like?");
}
private Dictionary <Concept2, HashSet <Concept2> > getRelevantProperties(ConceptInstance targetInstance, BeamGenerator generator)
{
var properties = new Dictionary <Concept2, HashSet <Concept2> >();
var definedConcepts = new HashSet <Concept2>(generator.GetDefinedConcepts());
foreach (var conceptCandidate in definedConcepts)
{
var conceptCandidateInstance = new ConceptInstance(conceptCandidate);
var instanceOf = generator.GetValue(conceptCandidateInstance, Concept2.InstanceOf);
if (conceptCandidate != targetInstance.Concept && instanceOf?.Concept != targetInstance.Concept)
{
continue;
}
var instanceProperties = generator.GetPropertyValues(conceptCandidateInstance);
foreach (var instanceProperty in instanceProperties)
{
if (!definedConcepts.Contains(instanceProperty.Value.Concept))
{
continue;
}
if (!definedConcepts.Contains(instanceProperty.Key))
{
continue;
}
if (!properties.TryGetValue(instanceProperty.Key, out var propertyValues))
{
properties[instanceProperty.Key] = propertyValues = new HashSet <Concept2>();
}
propertyValues.Add(instanceProperty.Value.Concept);
}
}
return(properties);
}
protected override IEnumerable <string> execute(BeamGenerator generator)
{
var askedForLearning = PreviousPolicy <LearnNewPhrase>(out var policyTag) || PreviousPolicy <UnknownAnsweredToLearnNewPhrase>(out policyTag);
if (!askedForLearning)
{
yield break;
}
var instances = FindTurnInstances().ToArray();
if (!instances.Any())
{
yield break;
}
var unknown = generator.GetValue(policyTag.Tag, Concept2.Unknown);
var hypothesis = instances.Last();
generator.Push(new StaticScoreEvent(0.1));
YesNoPrompt.Generate(generator, RememberConceptDescription.Create(generator, hypothesis.Concept, unknown.Concept.Name), new ConceptInstance(Concept2.Nothing));
yield return($"So, you think that {singular(unknown)} means {singular(hypothesis)} ?");
}
private ConceptInstance getProperty(ConceptInstance instance, Concept2 property)
{
return(BeamGenerator.GetValue(instance, property, _processedNode));
}
protected override IEnumerable <string> execute(BeamGenerator generator)
{
var suppressedConcepts = new HashSet <Concept2>
{
Concept2.NotFound,
Concept2.DisambiguatedKnowledgeConfirmed,
Concept2.NeedsRefinement
};
var evt = Get <InstanceOutputEvent>();
var priorityEvt = Get <InstanceOutputEvent>(p => !suppressedConcepts.Contains(p.Instance.Concept));
if (priorityEvt != null)
{
evt = priorityEvt;
}
if (evt == null)
{
yield break;
}
var concept = evt.Instance.Concept;
generator.SetValue(TagInstance, Concept2.Subject, evt.Instance);
if (concept == Concept2.DisambiguatedKnowledgeConfirmed)
{
var disamb = Find <IncompleteRelationEvent>(s => !s.IsFilled && s.Subject?.Concept == Concept2.PropertyValueDisambiguation, precedingTurns: 1);
var confirmed = generator.GetValue(evt.Instance, Concept2.Subject);
var disambiguator = generator.GetValue(evt.Instance, Concept2.Target);
generator.Push(new IncompleteRelationEvent(disambiguator, Concept2.Answer, null));
yield return($"I know it is {singular(confirmed)} already. Could you be more specific?");
}
else if (concept == Concept2.NotFound)
{
yield return($"I don't know anything like that.");
}
else if (concept == Concept2.DisambiguationFailed)
{
yield return($"It is too complex for me. Could you use different words?");
}
else if (concept == Concept2.RememberPropertyValue)
{
yield return($"Ok, I'll remember that.");
yield return($"Thank you for the information!");
}
else if (concept == Concept2.KnowledgeConfirmed)
{
var information = generator.GetValue(evt.Instance, Concept2.Subject);
generator.Push(new InstanceActiveEvent(information, canBeReferenced: true));
yield return($"Yes, I know {singularWithProperty(information)}");
}
else if (concept == Concept2.KnowledgeRefutation)
{
var information = generator.GetValue(evt.Instance, Concept2.Subject);
var property = generator.GetValue(evt.Instance, Concept2.Property).Concept;
generator.Push(new InstanceActiveEvent(information, canBeReferenced: true));
generator.Push(new IncompleteRelationEvent(information, property, null));
yield return($"No, I don't know {singularWithProperty(information)}");
}
else
{
generator.Push(new InstanceActiveEvent(evt.Instance, canBeReferenced: true));
yield return($"It is {singular(evt.Instance)}");
yield return($"I found {singular(evt.Instance)}");
}
}
