/** * Return the passed knowledge after removing any traits of the passed base type, or * the original knowledge if the trait was absent. * * @param knowledge * @return knowledge without the trait * @throws KlabValidationException */ public static IKnowledge removeTrait(IConcept knowledge, IConcept baseTrait) throws KlabValidationException { Pair<IConcept, Collection<IConcept>> trs = separateAttributes(knowledge); ArrayList<IConcept> traits = new ArrayList<>(); boolean found = false; for (IConcept tr : trs.getSecond()) { if (tr.is(baseTrait)) { found = true; } else { traits.add(tr); } } return found ? Observables.declareObservable(trs.getFirst(), traits, Observables .getContextType(knowledge), Observables .getInherentType(knowledge)) : knowledge; }
private boolean checkContextCompatibility(IConcept type, IConcept context) { // FIXME this is the proper check, as long as isCompatible can go and observe // missing // traits (such as whether a region is terrestrial) by running a classifier: // return Observables.isCompatible(subject.getType(), context); // weak check to use until we get smarter. For now assume users aren't monkeys and // can make some calls themselves, not observing watersheds in the open sea etc. IConcept coretype = Observables.getCoreObservable(type); IConcept corecont = Observables.getCoreObservable(context); return coretype.is(corecont); }
/** * True if observable has a stated context (mandatory for qualities) and context * isCompatible with the stated context for observable. * * @param observable * @param context * @return */ public static boolean isContextCompatible(IConcept observable, IConcept context) { IConcept ctx = getContextType(observable); return ctx != null && isCompatible(context, ctx); }
public Collection<IKnowledge> getAllFundamentalAttributes() { return filter(getAllFundamentalAttributesFilter()); }
public Collection<IKnowledge> getAllRootEvents() { return filter(getAllRootEventsFilter()); }
.declareObservable(main, trs, ctx, inh, rls, byt, dnt, onto); if (observability || observable) { ret = Traits.getObservabilityOf(ret, observability); return Observables.makeCount(ret); case DISTANCE: return Observables.makeDistance(ret); case PRESENCE: return Observables.makePresence(ret); case PROBABILITY: return Observables.makeProbability(ret); case OCCURRENCE: return Observables.makeOccurrence(ret); case PROPORTION: return Observables.makeProportion(ret, other); case RATIO: return Observables.makeRatio(ret, other); case TYPE: return Observables.makeTypeFor(ret); case UNCERTAINTY: return Observables.makeUncertainty(ret); case VALUE: return Observables.makeValue(ret, other); case ASSESSMENT: return Observables.makeAssessment(ret); default: break;
Collection<IConcept> applicables = Observables.getApplicableObservables(k); IConcept describes = Observables.getDescribedQuality(k); IConcept baseType = Observables.getCoreObservable(k); report.writeln(filler + "* root observable: " + baseType); report.writeln(filler + "* identities:"); for (IConcept i : identities) { describeConcept(i, report, indent + 4); report.writeln(filler + "* realms:"); for (IConcept i : realms) { describeConcept(i, report, indent + 4); report.writeln(filler + "* attributes:"); for (IConcept i : attributes) { describeConcept(i, report, indent + 4); IConcept context = Observables.getContextType(k); } else { report.writeln(filler + "* context:"); describeConcept(context, report, indent + 4); IConcept inherent = Observables.getInherentType(k); } else { report.writeln(filler + "* inherent to:"); describeConcept(inherent, report, indent + 4);
IConcept core1 = getCoreObservable(o1); IConcept core2 = getCoreObservable(o2); IConcept cc1 = getContextType(o1); IConcept cc2 = getContextType(o2); if (!isCompatible(cc1, cc2, ACCEPT_REALM_DIFFERENCES)) { return false; IConcept ic1 = getInherentType(o1); IConcept ic2 = getInherentType(o2); if (!isCompatible(ic1, ic2)) { return false;
Collections.sort(tids); for (String s : tids) { cId += cleanInternalId(s); cDs += cleanInternalId(s); uId += cleanInternalId(s); cId += cleanInternalId(main.getLocalName()); cDs += cleanInternalId(main.getLocalName()); uId += cleanInternalId(main.getLocalName()); IConcept other = getInherentType(main); if (other != null && !isCompatible(inherent, other)) { throw new KlabValidationException("cannot add inherent type " + inherent + " to concept " cId += "Of" + cleanInternalId(inherent.getLocalName()); cDs += "Of" + cleanInternalId(inherent.getLocalName()); uId += "Of" + cleanInternalId(inherent.getLocalName()); inherentDefinition = inherent.getDefinition(); IConcept other = getContextType(main); if (other != null && !isCompatible(context, other)) { throw new KlabValidationException("cannot add context " + context + " to concept " + main + " as it already has an incompatible context: " + other); cId += "In" + cleanInternalId(context.getLocalName()); cDs += "In" + cleanInternalId(context.getLocalName()); uId += "In" + cleanInternalId(context.getLocalName());
return Observables.describe(k); case "coreobs": return Observables.getCoreObservable((IConcept) k); case "flush": KLAB.REASONER.flush(); case "compatible": if (ko == null) { return Observables.getCompatibleWith((IConcept) k); return Observables.isCompatible((IConcept) k, (IConcept) ko) ? "true" : "false"; case "ccompatible": return Observables .isContextCompatible((IConcept) k, (IConcept) ko) ? "true" : "false"; case "commonparent":
: Observables.getContextType(ko.getType()); IConcept ctx = Observables.getContextType(ko.getType()); if (ctx != null) { if (!Observables .isCompatible(refContext, ctx, Observables.ACCEPT_REALM_DIFFERENCES)) { context.error("observable " + NS.getDisplayName(ko.getType()) + " has incompatible context (" try { IConcept fixedObs = Observables .declareObservable(ko .getType(), null, refContext, null); ko.setType(fixedObs); .makeAssessment(observer.getObservable().getType()); .declareObservable(assessment, null, null, null, Collections .singleton(NS.LEARNING_PROCESS_ROLE), null, null, KLAB.REASONER .getOntology()); IConcept type; try { type = Observables.contextualizeTo(learned .getType(), dependency .getObservable().getType());
IConcept other = Observables.getInherentType(concept); if (other != null && !inherent.is(other)) { throw new KlabValidationException("cannot add inherent type " + inherent + " to concept " IConcept other = Observables.getContextType(concept); if (other != null && !context.is(other)) { throw new KlabValidationException("cannot add context " + context + " to concept " + concept
private static IConcept getContextType(IKnowledge concept, boolean recurse) { if (!(concept instanceof IConcept)) { return null; } IConcept ret = null; if (recurse && (NS.isAttribute(concept) || NS.isRealm(concept) || NS.isClass(concept) || NS.isConfiguration(concept))) { IConcept described = getDescribedQuality((IConcept) concept); ret = described == null ? null : getContextType(described, false); } else if (recurse && (NS.isIdentity(concept) || NS.isProcess(concept))) { Collection<IConcept> described = getApplicableObservables(concept); ret = described.size() > 0 ? NS.getLeastGeneralCommonConcept(described) : null; } else { Collection<IConcept> cls = OWL .getRestrictedClasses((IConcept) concept, KLAB .p(NS.HAS_CONTEXT_PROPERTY)); ret = cls.isEmpty() ? null : cls.iterator().next(); } if (ret == null && NS.isObservable(concept)) { IConcept inherent = getInherentType(concept); if (inherent != null) { ret = getContextType(inherent, false); } } return ret; }
IConcept restrictedContextType = getContextType(concept); IConcept actualContextType = context == null ? null : (IConcept) context.getObservable().getType(); + " cannot be contextualized because it does not describe a contextualizable observable"); observable = Observables.makeTypeFor(concept); } else if (NS.isRole(concept)) { observable = Roles.getObservableWithRole(concept, actualContextType); && !isCompatible(actualContextType, restrictedContextType)) {
.setApplicableObservables(knowledge, applicables); } catch (KlabValidationException e) { context.error(e Observables.setConferredTraits(knowledge, conferred); } catch (KlabValidationException e) { context.error(e.getMessage(), lineNumber(statement.getConferredTraits())); .getDescribedQuality(), this); try { Observables.setDescribedQuality(knowledge, ko.getConcept()); } catch (KlabValidationException e) { context.error(e.getMessage(), ko.getFirstLineNumber()); IConcept ctx = Observables.getContextType(knowledge); if (ctx == null && !isInternal) { context.error("any non-abstract quality must identify a context", getFirstLineNumber()); && NS.isTrait(knowledge) && !context.getNamespace().getProject().isWorldview()) { IConcept ctx = Observables.getContextType(knowledge); if (ctx == null && !isInternal) { context.error("non-abstract traits without a context (stated in 'describes' or 'applies to') are only allowed in worldviews", getFirstLineNumber());
insertIds(concept, ret); IConcept coreObservable = getCoreObservable(concept); if (coreObservable != null) { try { IConcept traitsOnly = Observables .declareObservable(coreObservable, traits, null, null); if (!traitsOnly.equals(concept)) { insertIds(traitsOnly, ret); insertIds(coreObservable, ret);
IConcept main = Observables.getCoreObservable(observable); if (main == null) { if (Observables.isCompatible(candidate, observable, main.isAbstract() ? 0 : Observables.REQUIRE_SAME_CORE_TYPE)) {
IConcept inherent = Observables.getInherentType(observable); IConcept cinh = getInherentType(context); if (cinh != null && inherent.is(cinh)) { return ret; ret = declareObservable(observable, null, context, null);
/** * True if o1 and o2 are observables from recognized domains, have compatible context * and inherency, o1 is o2, and o1 adopts all the traits and roles that o2 adopts. * * @param o1 * @param o2 * @return */ public static boolean isCompatible(IConcept o1, IConcept o2) { return isCompatible(o1, o2, 0); }
@Override public IConcept getEventType() { return Observables.getInherentType(getObservable().getType()); }