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 void onInstanceActivated(ConceptInstance instance, BeamGenerator generator)
{
var activations = generator.GetInstanceActivations();
foreach (var relevantInstanceActivation in activations)
{
if (!relevantInstanceActivation.CanBeReferenced)
{
continue;
}
var relevantInstance = relevantInstanceActivation.Instance;
if (relevantInstance == instance)
{
//dont reference self
continue;
}
//try tunnel instances between turns
generator.Push(new StaticScoreEvent(0.05));
generator.Push(new InstanceReferencedEvent(relevantInstance));
generator.Pop();
generator.Pop();
}
}
private string getConstraintDescription(ConceptInstance conceptInstance)
{
if (conceptInstance is null || conceptInstance.Concept != Concept2.Something)
{
return(conceptInstance.ToPrintable());
}
var description = getPropertyValue(conceptInstance, Concept2.InstanceOf)?.ToPrintable();
if (description == null)
{
description = "thing";
}
//collect modifiers
foreach (var property in getProperties(conceptInstance))
{
if (property == Concept2.InstanceOf)
{
continue;
}
var modifier = getPropertyValue(conceptInstance, property).ToPrintable();
description = modifier + " " + description;
}
return(description);
}
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 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();
}
}
internal static List <ConceptInstance> FindRelevantConcepts(BeamGenerator generator, HashSet <Concept2> requiredProperties)
{
//TODO better matching logic
var concepts = generator.GetDefinedConcepts();
var result = new List <ConceptInstance>();
foreach (var concept in concepts)
{
var conceptInstance = new ConceptInstance(concept);
var missingProperties = new HashSet <Concept2>(requiredProperties);
foreach (var propertyValue in generator.GetPropertyValues(conceptInstance))
{
var property = propertyValue.Key;
var value = propertyValue.Value;
missingProperties.Remove(value.Concept);
}
if (missingProperties.Count == 0)
{
result.Add(conceptInstance);
}
}
return(result);
}
public ConceptInstance DefineConceptInstance(string conceptName)
{
var concept = DefineConcept(conceptName);
var instance = new ConceptInstance(concept);
return(instance);
}
internal Dictionary <ConceptInstance, string> GetPrefixingUnknowns(ConceptInstance instance)
{
//TODO all subvalues could be considered here
var result = new Dictionary <ConceptInstance, string>();
var activation = GetInstanceActivationRequest(instance);
if (activation == null || !activation.ActivationPhrases.Any())
{
return(result);
}
var inputs = new List <InputPhraseEvent>();
foreach (var input in GetPrecedingEvents(getCurrentNode(), activation.ActivationPhrases.First(), true))
{
if (IsInputUsed(input))
{
break;
}
inputs.Add(input);
}
if (inputs.Count > 0)
{
inputs.Reverse();
result[instance] = string.Join(" ", inputs.Select(i => i.Phrase));
}
return(result);
}
private void pushCompleteIfPossible(ConceptInstance instance, bool allowTurnReactivation = true, bool requireActivationRequest = true)
{
var request = GetInstanceActivationRequest(instance);
if (request == null && requireActivationRequest)
{
// only activated instances can fire completition
return;
}
if (!allowTurnReactivation && GetTurnInstanceActivation(instance) != null)
{
// we dont want to reactivate instance again
return;
}
var parameters = GetParameterDefinitions(instance);
foreach (var parameter in parameters)
{
var value = GetValue(instance, parameter);
if (value == null)
{
//instance is not complete yet
return;
}
}
var canBeReferenced = !requireActivationRequest || request.ActivationPhrases.Any();
Push(new InstanceActiveEvent(instance, canBeReferenced, request));
}
protected string singularWithProperty(ConceptInstance instance)
{
var properties = _generator.GetPropertyValues(instance, includeInheritedProps: false);
foreach (var property in properties.Keys.ToArray())
{
var value = properties[property];
if (value.Concept == Concept2.Something)
{
continue;
}
//properties.Remove(property);
}
if (properties.Count == 0)
{
return(instance.ToPrintable());
}
var reportedProperty = properties.Keys.First();
var reportedValue = properties[reportedProperty];
var propertyName = reportedProperty.Name;
if (reportedValue.Concept == Concept2.Something)
{
return(instance.ToPrintable() + " " + propertyName);
}
else
{
return(instance.ToPrintable() + " " + propertyName + " is " + reportedValue.ToPrintable());
}
}
internal AbilityBase Property(Concept2 instanceProperty, Concept2 value)
{
var target = _currentConcept == null ? new PropertySetTarget(_currentInstance, instanceProperty) : new PropertySetTarget(_currentConcept, instanceProperty);
var valueInstance = new ConceptInstance(value);
AddInitializationEvent(new PropertySetEvent(target, valueInstance));
return(this);
}
internal static ConceptInstance Create(BeamGenerator generator, Concept2 subject, string description)
{
var instance = new ConceptInstance(Concept2.RememberConceptDescription);
generator.SetValue(instance, Concept2.Subject, new ConceptInstance(subject));
generator.SetValue(instance, Concept2.Description, new ConceptInstance(Concept2.From(description)));
return(instance);
}
internal AbilityBase DefineInstance(string conceptName, out Concept2 concept)
{
DefineConcept(conceptName, out concept);
_currentConcept = null;
_currentInstance = new ConceptInstance(concept);
return(this);
}
internal static ConceptInstance Create(BeamGenerator generator, ConceptInstance yesInstance, ConceptInstance noInstance)
{
var prompt = new ConceptInstance(Concept2.Prompt);
generator.SetValue(prompt, Concept2.Yes, yesInstance);
generator.SetValue(prompt, Concept2.No, noInstance);
return(prompt);
}
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);
}
internal static ConceptInstance Create(ConceptInstance instanceToRefine, string unknown, BeamGenerator generator)
{
var assignUnknownProperty = new ConceptInstance(Concept2.AssignUnknownProperty);
var unknownPropertyCandidate = new ConceptInstance(Concept2.From(unknown));
generator.SetValue(assignUnknownProperty, Concept2.Subject, unknownPropertyCandidate);
generator.SetValue(assignUnknownProperty, Concept2.Target, instanceToRefine);
return(assignUnknownProperty);
}
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));
}
internal static void GenerateActivationRequest(string unknown, BeamGenerator generator)
{
var newConcept = Concept2.From(unknown);
var newConceptInstance = new ConceptInstance(newConcept);
var learnInstance = new ConceptInstance(Concept2.LearnNewConcept);
generator.SetValue(learnInstance, Concept2.Unknown, newConceptInstance);
generator.Push(new InstanceActivationRequestEvent(learnInstance));
}
internal static ConceptInstance Create(BeamGenerator generator, PropertySetTarget target, ConceptInstance value)
{
var rememberValue = new ConceptInstance(Concept2.RememberPropertyValue);
generator.SetValue(rememberValue, Concept2.Target, target.Instance);
generator.SetValue(rememberValue, Concept2.TargetProperty, new ConceptInstance(target.Property));
generator.SetValue(rememberValue, Concept2.Subject, value);
return(rememberValue);
}
private void pushNewOptions(IEnumerable <ConceptInstance> options, BeamGenerator generator)
{
var optionPrompt = new ConceptInstance(Concept2.OptionPrompt);
foreach (var option in options)
{
generator.SetValue(optionPrompt, Concept2.Option, option);
}
generator.Push(new InstanceActivationRequestEvent(optionPrompt));
}
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);
}
internal AbilityBase DefineConcept(string conceptName, out Concept2 concept, bool fireConceptDefinedEvt = true)
{
_currentInstance = null;
_currentConcept = concept = Concept2.From(conceptName);
if (fireConceptDefinedEvt)
{
AddInitializationEvent(new ConceptDefinedEvent(concept));
}
return(this);
}
internal AbilityBase DefineProperty(Concept2 property, params Concept2[] domain)
{
var target = new PropertySetTarget(property, Concept2.PropertyDomain);
foreach (var domainValue in domain)
{
var domainValueInstance = new ConceptInstance(domainValue);
AddInitializationEvent(new PropertySetEvent(target, domainValueInstance));
}
return(this);
}
private void pushNewDisambiguation(IEnumerable <ConceptInstance> indirectSubjects, ConceptInstance unknown, ConceptInstance target, BeamGenerator generator)
{
var disambiguation = new ConceptInstance(Concept2.PropertyValueDisambiguation);
generator.SetValue(disambiguation, Concept2.Unknown, unknown);
generator.SetValue(disambiguation, Concept2.Target, target);
foreach (var subject in indirectSubjects)
{
generator.SetValue(disambiguation, Concept2.Subject, subject);
}
generator.Push(new InstanceActivationRequestEvent(disambiguation));
}
internal static ConceptInstance CreatePrompt(Dictionary <Concept2, ConceptInstance> optionEffect, BeamGenerator generator)
{
var prompt = new ConceptInstance(Concept2.OptionPrompt);
foreach (var pair in optionEffect)
{
var optionInstance = new ConceptInstance(pair.Key);
var effect = pair.Value;
generator.SetValue(optionInstance, Concept2.Invocation, effect);
generator.SetValue(prompt, Concept2.Option, optionInstance);
}
return(prompt);
}
internal bool IsKnownPropertyOf(ConceptInstance instance, Concept2 property)
{
var hierarchy = GetClassHierarchy();
var hierarchyChain = new HashSet <Concept2>();
var currentConcept = instance.Concept;
while (currentConcept != null && hierarchyChain.Add(currentConcept))
{
hierarchy.TryGetValue(currentConcept, out currentConcept);
}
hierarchyChain.Remove(instance.Concept); //dont include instance's concept
return(GetAllEvents <PropertySetEvent>(getCurrentNode()).Where(s => s.SubstitutedValue.Concept == property && s.Target.Property == Concept2.HasProperty && hierarchyChain.Contains(s.Target.Concept)).Any());
}
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 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));
}
}
