15:- module(utility_translation, [load_owl/1, load_owl_from_string/1, expand_all_ns/4, expand_all_ns/5, is_axiom/1]).   16
   17:- dynamic trill_input_mode/1.   18
   19:- use_module(library(lists),[member/2]).   20:- use_module(library(pengines)).   21
   22:- use_module(library(sandbox)).   23
   24:- discontiguous(valid_axiom/1).   25:- discontiguous(axiompred/1).   26:- discontiguous(axiom_arguments/2).   27:- discontiguous(expand_axiom/4).   28
   29/*****************************
   30  MESSAGES
   31******************************/
   32:- multifile prolog:message/1.   33
   34prolog:message(under_development) -->
   35  [ 'NOTE: This function is under development. It may not work properly or may not work at all.' ].
   36
   37
   38
   39builtin_class('http://www.w3.org/2002/07/owl#Thing').
   40builtin_class('http://www.w3.org/2002/07/owl#Nothing').
   41builtin_datatype('http://www.w3.org/2002/07/owl#real').
   42builtin_datatype('http://www.w3.org/2002/07/owl#rational').
   43builtin_datatype('http://www.w3.org/2001/XMLSchema#decimal').
   44builtin_datatype('http://www.w3.org/2001/XMLSchema#integer').
   45builtin_datatype('http://www.w3.org/2001/XMLSchema#nonNegativeInteger').
   46builtin_datatype('http://www.w3.org/2001/XMLSchema#nonPositiveInteger').
   47builtin_datatype('http://www.w3.org/2001/XMLSchema#positiveInteger').
   48builtin_datatype('http://www.w3.org/2001/XMLSchema#negativeInteger').
   49builtin_datatype('http://www.w3.org/2001/XMLSchema#long').
   50builtin_datatype('http://www.w3.org/2001/XMLSchema#int').
   51builtin_datatype('http://www.w3.org/2001/XMLSchema#short').
   52builtin_datatype('http://www.w3.org/2001/XMLSchema#byte').
   53builtin_datatype('http://www.w3.org/2001/XMLSchema#unsignedLong').
   54builtin_datatype('http://www.w3.org/2001/XMLSchema#unsignedInt').
   55builtin_datatype('http://www.w3.org/2001/XMLSchema#unsignedShort').
   56builtin_datatype('http://www.w3.org/2001/XMLSchema#unsignedByte').
   57builtin_datatype('http://www.w3.org/2001/XMLSchema#double').
   58builtin_datatype('http://www.w3.org/2001/XMLSchema#float').
   59builtin_datatype('http://www.w3.org/2001/XMLSchema#string').
   60builtin_datatype('http://www.w3.org/2001/XMLSchema#normalizedString').
   61builtin_datatype('http://www.w3.org/2001/XMLSchema#token').
   62builtin_datatype('http://www.w3.org/2001/XMLSchema#language').
   63builtin_datatype('http://www.w3.org/2001/XMLSchema#Name').
   64builtin_datatype('http://www.w3.org/2001/XMLSchema#NCName').
   65builtin_datatype('http://www.w3.org/2001/XMLSchema#NMTOKEN').
   66builtin_datatype('http://www.w3.org/2001/XMLSchema#boolean').
   67builtin_datatype('http://www.w3.org/2001/XMLSchema#hexBinary').
   68builtin_datatype('http://www.w3.org/2001/XMLSchema#base64Binary').
   69builtin_datatype('http://www.w3.org/2001/XMLSchema#minLength').
   70builtin_datatype('http://www.w3.org/2001/XMLSchema#maxLength').
   71builtin_datatype('http://www.w3.org/2001/XMLSchema#length').
   72builtin_datatype('http://www.w3.org/2001/XMLSchema#dateTime').
   73builtin_datatype('http://www.w3.org/2001/XMLSchema#dateTimeStamp').
   74builtin_datatype('http://www.w3.org/2000/01/rdf-schema#Literal').
   75
   76is_class(C) :- get_module(M),M:class(C).
   77is_class(C) :- builtin_class(C).
   78
   79/****************************************
   80  UTILITY
   81  ****************************************/
   82set_trdf(Setting,Value):-
   83  get_module(M),
   84  retractall(M:trdf_setting(Setting,_)),
   85  assert(M:trdf_setting(Setting,Value)).
   86
   87% TODO: hasKey
   88
   89/****************************************
   90  AXIOMS
   91  ****************************************/

 entity(:IRI)

the fundamental building blocks of owl 2 ontologies, and they define the vocabulary (the named terms) of an ontology

See also

- individual/1, property/1, class/1, datatype/1

   97:- meta_predicate entity(:).   98
   99entity(M:A) :- individual(M:A).
  100entity(M:A) :- property(M:A).
  101entity(M:A) :- M:class(A).
  102entity(M:A) :- M:datatype(A).
  103axiom_arguments(entity,[iri]).
  104valid_axiom(entity(A)) :- subsumed_by([A],[iri]).
  105
  106% declarationAxiom(M:individual(A)) :- individual(M:A).
  107declarationAxiom(M:namedIndividual(A)) :- M:namedIndividual(A).
  108declarationAxiom(M:objectProperty(A)) :- M:objectProperty(A).
  109declarationAxiom(M:dataProperty(A)) :- M:dataProperty(A).
  110declarationAxiom(M:annotationProperty(A)) :- M:annotationProperty(A).
  111declarationAxiom(M:class(A)) :- M:class(A).
  112declarationAxiom(M:datatype(A)) :- M:datatype(A).
  113% TODO: check. here we treat the ontology declaration as an axiom;
  114% this liberal definition of axiom allows us to iterate over axiom/1
  115% to find every piece of information in the ontology.
  116declarationAxiom(M:ontology(A)) :- M:ontology(A).

 class(?IRI)

Classes can be understood as sets of individuals :- thread_local(class/1).

  122axiompred(class/1).
  123axiom_arguments(class,[iri]).
  124
  125expand_class(M,C,NSList,ExpC) :- 
  126  expand_iri(M,C,NSList,ExpC),
  127  \+ builtin_datatype(ExpC).
  128
  129valid_axiom(class(A)) :- subsumed_by([A],[iri]).
  130expand_axiom(M,class(A),NSList,class(A_full_URL)) :- 
  131  expand_iri(M,A,NSList,A_full_URL),
  132  ( M:addKBName -> add_kb_atoms(M,class,[A_full_URL]) ; true).

 datatype(?IRI)

Datatypes are entities that refer to sets of values described by a datatype map :- thread_local(datatype/1).

  138axiompred(datatype/1).
  139axiom_arguments(datatype,[iri]).
  140valid_axiom(datatype(A)) :- subsumed_by([A],[iri]).
  141expand_axiom(M,datatype(A),NSList,datatype(A_full_URL)) :- 
  142  expand_iri(M,A,NSList,A_full_URL),
  143  \+ name(A_full_URL,[95, 58, 68, 101, 115, 99, 114, 105, 112, 116, 105, 111, 110|_]),
  144  ( M:addKBName -> add_kb_atoms(M,datatype,[A_full_URL]) ; true).

 property(?IRI)

Properties connect individuals with either other individuals or with literals

See also

- dataProperty/1, objectProperty/1, annotationProperty/1

  150:- meta_predicate property(:).  151
  152property(M:A) :- M:dataProperty(A).
  153property(M:A) :- M:objectProperty(A).
  154property(M:A) :- M:annotationProperty(A).
  155axiom_arguments(property,[iri]).
  156valid_axiom(property(A)) :- subsumed_by([A],[iri]).

 objectProperty(?IRI)

Object properties connect pairs of individuals :- thread_local(objectProperty/1).

  162axiompred(objectProperty/1).
  163axiom_arguments(objectProperty,[iri]).
  164
  165expand_objectProperty(M,P,NSList,ExpP) :- 
  166  expand_iri(M,P,NSList,ExpP),
  167  ( M:addKBName -> add_kb_atoms(M,objectProperty,[ExpP]) ; true ).
  168
  169valid_axiom(objectProperty(A)) :- subsumed_by([A],[iri]).
  170expand_axiom(M,objectProperty(A),NSList,objectProperty(A_full_URL)) :- 
  171  expand_iri(M,A,NSList,A_full_URL),
  172  ( M:addKBName -> add_kb_atoms(M,objectProperty,[A_full_URL]) ; true).

 dataProperty(?IRI)

Data properties connect individuals with literals. In some knowledge representation systems, functional data properties are called attributes. :- thread_local(dataProperty/1).

  178axiompred(dataProperty/1).
  179axiom_arguments(dataProperty,[iri]).
  180
  181expand_dataProperty(M,P,NSList,ExpP) :- 
  182  expand_iri(M,P,NSList,ExpP),
  183  ( M:addKBName -> add_kb_atoms(M,dataProperty,[ExpP]) ; true).
  184
  185
  186valid_axiom(dataProperty(A)) :- subsumed_by([A],[iri]).
  187expand_axiom(M,dataProperty(A),NSList,dataProperty(A_full_URL)) :- 
  188  expand_iri(M,A,NSList,A_full_URL),
  189  ( M:addKBName -> add_kb_atoms(M,dataProperty,[A_full_URL]) ; true).

 annotationProperty(?IRI)

Annotation properties can be used to provide an annotation for an ontology, axiom, or an IRI :- thread_local(annotationProperty/1).

  195axiompred(annotationProperty/1).
  196axiom_arguments(annotationProperty,[iri]).
  197
  198expand_annotationProperty(M,P,NSList,ExpP) :- 
  199  expand_iri(M,P,NSList,ExpP),
  200  ( M:addKBName -> add_kb_atoms(M,annotationProperty,[ExpP]) ; true ).
  201
  202expand_annotationSubject(M,P,NSList,ExpP) :- 
  203  (expand_classExpression(M,P,NSList,ExpP),!) ;
  204  (expand_individual(M,P,NSList,ExpP),!) ;
  205  (expand_propertyExpression(M,P,NSList,ExpP),!) ;
  206  (expand_axiom(M,P,NSList,ExpP),!).
  207
  208expand_annotationValue(M,P,NSList,ExpP) :- 
  209  (expand_literal(M,P,NSList,ExpP),!) ;
  210  (expand_classExpression(M,P,NSList,ExpP),!) ;
  211  (expand_individual(M,P,NSList,ExpP),!) ;
  212  (expand_propertyExpression(M,P,NSList,ExpP),!) ;
  213  (expand_axiom(M,P,NSList,ExpP),!) .
  214
  215
  216valid_axiom(annotationProperty(A)) :- subsumed_by([A],[iri]).
  217expand_axiom(M,annotationProperty(A),NSList,annotationProperty(A_full_URL)) :- 
  218  expand_iri(M,A,NSList,A_full_URL),
  219  ( M:addKBName -> add_kb_atoms(M,annotationProperty,[A_full_URL]) ; true).
  220
  221expand_axiom(M,annotation(A,B,C),NSList,annotation(A_full_URL,B_full_URL,C_full_URL)) :-
  222  ( M:addKBName -> (retractall(M:addKBName), Add=true) ; Add=false ),
  223  expand_argument(M,A,NSList,A_full_URL),
  224  expand_argument(M,B,NSList,B_full_URL),
  225  expand_argument(M,C,NSList,C_full_URL),
  226  ( Add=true -> assert(M:addKBName) ; true ).

 individual(:IRI)

Individuals represent actual objects from the domain being modeled @see anonymousIndividual/1, namedIndividual/1

  232:- meta_predicate individual(:).  233
  234individual(M:A) :- M:anonymousIndividual(A).
  235individual(M:A) :- M:namedIndividual(A).
  236%individual(A) :- nonvar(A),iri(A),\+property(A),\+class(A),\+ontology(A). % TODO: check: make individuals the default
  237axiom_arguments(individual,[iri]).
  238valid_axiom(individual(A)) :- subsumed_by([A],[iri]).
  239
  240expand_individuals(_M,[],_NSList,[]) :- !.
  241expand_individuals(M,[H|T],NSList,[ExpH|ExpT]) :-
  242  expand_individual(M,H,NSList,ExpH),
  243  expand_individuals(M,T,NSList,ExpT).
  244
  245expand_individual(M,I,NSList,ExpI) :- 
  246  expand_iri(M,I,NSList,ExpI),
  247  \+ builtin_datatype(ExpI),
  248  ( M:addKBName -> add_kb_atoms(M,individual,[ExpI]) ; true ).

 namedIndividual(?IRI)

Named individuals are given an explicit name that can be used in any ontology in the import closure to refer to the same individual :- thread_local(namedIndividual/1).

  254axiompred(namedIndividual/1).
  255axiom_arguments(namedIndividual,[iri]).
  256valid_axiom(namedIndividual(A)) :- subsumed_by([A],[iri]).
  257expand_axiom(M,namedIndividual(A),NSList,namedIndividual(A_full_URL)) :- 
  258  expand_iri(M,A,NSList,A_full_URL),
  259  ( M:addKBName -> add_kb_atoms(M,individual,[A_full_URL]) ; true).

 anonymousIndividual(?IRI)

Anonymous individuals are local to the ontology they are contained in. Analagous to bnodes @see construct/1 :- thread_local(anonymousIndividual/1).

  266axiompred(anonymousIndividual/1).
  267axiom_arguments(anonymousIndividual,[iri]).
  268valid_axiom(anonymousIndividual(A)) :- subsumed_by([A],[iri]).
  269expand_axiom(M,anonymousIndividual(A),NSList,anonymousIndividual(A_full_URL)) :- 
  270  expand_iri(M,A,NSList,A_full_URL),
  271  ( M:addKBName -> add_kb_atoms(M,individual,[A_full_URL]) ; true).

 construct(:IRI)

See also

- axiom/1, annotation/1, ontology/1

  275:- meta_predicate costruct(:).  276
  277construct(M:A) :- trill:axiom(M:A).
  278construct(M:A) :- annotation(M:A).
  279construct(M:A) :- M:ontology(A).
  280axiom_arguments(construct,[iri]).
  281valid_axiom(construct(A)) :- subsumed_by([A],[iri]).

 axiom(:Axiom)

The main component of an OWL 2 ontology is a set of axioms - statements that say what is true in the domain being modeled. @see classAxiom/1, propertyAxiom/1, fact/1

  286:- multifile trill:axiom/1.  287
  288trill:axiom(M:A) :- classAxiom(M:A).
  289trill:axiom(M:A) :- propertyAxiom(M:A).
  290trill:axiom(M:hasKey(A,B)) :- M:hasKey(A,B).
  291trill:axiom(M:A) :- fact(M:A).
  292trill:axiom(M:A) :- declarationAxiom(M:A).
  293%axiom(annotation(A,B,C)) :-
  294%	annotation(A,B,C). % CJM-treat annotations as axioms
  295axiom_arguments(axiom,[axiom]).
  296valid_axiom(axiom(A)) :- subsumed_by([A],[axiom]).

 classAxiom(:Axiom)

OWL 2 provides axioms that allow relationships to be established between class expressions. This predicate reifies the actual axiom @see equivalentClasses/1, disjointClasses/1, subClassOf/2, disjointUnion/2

  301:- meta_predicate classAxiom(:).  302
  303classAxiom(M:equivalentClasses(A)) :- M:equivalentClasses(A).
  304classAxiom(M:disjointClasses(A)) :- M:disjointClasses(A).
  305classAxiom(M:subClassOf(A, B)) :- M:subClassOf(A, B).
  306classAxiom(M:disjointUnion(A, B)) :- M:disjointUnion(A, B).
  307axiom_arguments(classAxiom,[axiom]).
  308valid_axiom(classAxiom(A)) :- subsumed_by([A],[axiom]).

 subClassOf(?SubClass:ClassExpression, ?SuperClass:ClassExpression)

A subclass axiom SubClassOf( CE1 CE2 ) states that the class expression CE1 is a subclass of the class expression CE2

Arguments:

SubClass	- a classExpression/1 representing the more specific class
SuperClass	- a classExpression/1 representing the more general class :- thread_local(subClassOf/2).

  317axiompred(subClassOf/2).
  318axiom_arguments(subClassOf,[classExpression, classExpression]).
  319valid_axiom(subClassOf(A, B)) :- subsumed_by([A, B],[classExpression, classExpression]).
  320expand_axiom(M,subClassOf(A,B),NSList,subClassOf(A_full_URL,B_full_URL)) :- 
  321  expand_classExpression(M,A,NSList,A_full_URL),
  322  expand_classExpression(M,B,NSList,B_full_URL).

 equivalentClasses(?ClassExpressions:set(ClassExpression))

An equivalent classes axiom EquivalentClasses( CE1 ... CEn ) states that all of the class expressions CEi, 1 <= i <= n, are semantically equivalent to each other. :- thread_local(equivalentClasses/1).

  329axiompred(equivalentClasses/1).
  330axiom_arguments(equivalentClasses,[set(classExpression)]).
  331valid_axiom(equivalentClasses(A)) :- subsumed_by([A],[set(classExpression)]).
  332expand_axiom(M,equivalentClasses(A),NSList,equivalentClasses(A_full_URL)) :- 
  333  expand_classExpressions(M,A,NSList,A_full_URL).

 disjointClasses(?ClassExpressions:set(ClassExpression))

A disjoint classes axiom DisjointClasses( CE1 ... CEn ) states that all of the class expressions CEi, 1 <= i <= n, are pairwise disjoint; that is, no individual can be at the same time an instance of both CEi and CEj for i != j :- thread_local(disjointClasses/1).

  339axiompred(disjointClasses/1).
  340axiom_arguments(disjointClasses,[set(classExpression)]).
  341valid_axiom(disjointClasses(A)) :- subsumed_by([A],[set(classExpression)]).
  342expand_axiom(M,disjointClasses(A),NSList,disjointClasses(A_full_URL)) :- 
  343  expand_classExpressions(M,A,NSList,A_full_URL).

 disjointUnion(?ClassExpression, ?ClassExpressions:set(ClassExpression))

A disjoint union axiom DisjointUnion( C CE1 ... CEn ) states that a class C is a disjoint union of the class expressions CEi, 1 <= i <= n, all of which are pairwise disjoint. :- thread_local(disjointUnion/2).

  349axiompred(disjointUnion/2).
  350axiom_arguments(disjointUnion,[classExpression,set(classExpression)]).
  351valid_axiom(disjointUnion(A,B)) :- subsumed_by([A,B],[classExpression,set(classExpression)]).
  352expand_axiom(M,disjointUnion(A,B),NSList,disjointUnion(A_full_URL,B_full_URL)) :- 
  353  expand_classExpression(M,A,NSList,A_full_URL),
  354  expand_classExpressions(M,B,NSList,B_full_URL).

 propertyAxiom(:Axiom)

OWL 2 provides axioms that can be used to characterize and establish relationships between object property expressions. This predicate reifies the actual axiom

See also

- symmetricProperty/1, inverseFunctionalProperty/1, transitiveProperty/1, asymmetricProperty/1, subPropertyOf/2, functionalProperty/1, irreflexiveProperty/1, disjointProperties/1, propertyDomain/2, reflexiveProperty/1, propertyRange/2, equivalentProperties/1, inverseProperties/2

  360:- meta_predicate propertyAxiom(:).  361
  362propertyAxiom(M:symmetricProperty(A)) :- M:symmetricProperty(A).
  363propertyAxiom(M:inverseFunctionalProperty(A)) :- M:inverseFunctionalProperty(A).
  364propertyAxiom(M:transitiveProperty(A)) :- M:transitiveProperty(A).
  365propertyAxiom(M:asymmetricProperty(A)) :- M:asymmetricProperty(A).
  366propertyAxiom(M:subPropertyOf(A, B)) :- M:subPropertyOf(A, B).
  367propertyAxiom(M:functionalProperty(A)) :- M:functionalProperty(A).
  368propertyAxiom(M:irreflexiveProperty(A)) :- M:irreflexiveProperty(A).
  369propertyAxiom(M:disjointProperties(A)) :- M:disjointProperties(A).
  370propertyAxiom(M:propertyDomain(A, B)) :- M:propertyDomain(A, B).
  371propertyAxiom(M:reflexiveProperty(A)) :- M:reflexiveProperty(A).
  372propertyAxiom(M:propertyRange(A, B)) :- M:propertyRange(A, B).
  373propertyAxiom(M:equivalentProperties(A)) :- M:equivalentProperties(A).
  374propertyAxiom(M:inverseProperties(A, B)) :- M:inverseProperties(A, B).
  375axiom_arguments(propertyAxiom,[axiom]).
  376valid_axiom(propertyAxiom(A)) :- subsumed_by([A],[axiom]).

 subPropertyOf(?Sub:PropertyExpression, ?Super:ObjectPropertyExpression)

subproperty axioms are analogous to subclass axioms (extensional predicate - can be asserted) :- thread_local(subPropertyOf/2).

  384axiompred(subPropertyOf/2).
  385axiom_arguments(subPropertyOf,[propertyExpression, objectPropertyExpression]).
  386valid_axiom(subPropertyOf(A, B)) :- subsumed_by([A, B],[propertyExpression, objectPropertyExpression]).
  387%expand_axiom(M,subPropertyOf(A,B),NSList,subPropertyOf(A_full_URL,B_full_URL)) :- %TODO: fix for data properties
  388%  expand_propertyExpression(M,A,NSList,A_full_URL),
  389%  expand_objectPropertyExpression(M,B,NSList,B_full_URL).

 subObjectPropertyOf(?Sub:ObjectPropertyExpressionOrChain, ?Super:ObjectPropertyExpression)

The basic form is SubPropertyOf( OPE1 OPE2 ). This axiom states that the object property expression OPE1 is a subproperty of the object property expression OPE2 - that is, if an individual x is connected by OPE1 to an individual y, then x is also connected by OPE2 to y. The more complex form is SubPropertyOf( PropertyChain( OPE1 ... OPEn ) OPE ). This axiom states that, if an individual x is connected by a sequence of object property expressions OPE1, ..., OPEn with an individual y, then x is also connected with y by the object property expression OPE

  393subObjectPropertyOf(A, B) :- get_module(M),M:subPropertyOf(A, B),subsumed_by([A, B],[objectPropertyExpressionOrChain, objectPropertyExpression]).
  394axiom_arguments(subObjectPropertyOf,[objectPropertyExpressionOrChain, objectPropertyExpression]).
  395valid_axiom(subObjectPropertyOf(A, B)) :- subsumed_by([A, B],[objectPropertyExpressionOrChain, objectPropertyExpression]).
  396expand_axiom(M,subPropertyOf(A,B),NSList,subPropertyOf(A_full_URL,B_full_URL)) :- 
  397  expand_objectPropertyExpressionOrChain(M,A,NSList,A_full_URL),
  398  expand_objectPropertyExpression(M,B,NSList,B_full_URL).
  399  %add_expressivity(M,h).

 subDataPropertyOf(?Sub:DataPropertyExpression, ?Super:DataPropertyExpression)

A data subproperty axiom SubPropertyOf( DPE1 DPE2 ) states that the data property expression DPE1 is a subproperty of the data property expression DPE2 - that is, if an individual x is connected by OPE1 to a literal y, then x is connected by OPE2 to y as well.

  403subDataPropertyOf(A, B) :- get_module(M),M:subPropertyOf(A, B),subsumed_by([A, B],[dataPropertyExpression, dataPropertyExpression]).
  404axiom_arguments(subDataPropertyOf,[dataPropertyExpression, dataPropertyExpression]).
  405valid_axiom(subDataPropertyOf(A, B)) :- subsumed_by([A, B],[dataPropertyExpression, dataPropertyExpression]).

 subAnnotationPropertyOf(?Sub:AnnotationProperty, ?Super:AnnotationProperty)

An annotation subproperty axiom SubPropertyOf( AP1 AP2 ) states that the annotation property AP1 is a subproperty of the annotation property AP2

  409subAnnotationPropertyOf(A, B) :- get_module(M),M:subPropertyOf(A, B),subsumed_by([A, B],[annotationProperty, annotationProperty]).
  410axiom_arguments(subAnnotationPropertyOf,[annotationProperty, annotationProperty]).
  411valid_axiom(subAnnotationPropertyOf(A, B)) :- subsumed_by([A, B],[annotationProperty, annotationProperty]).

 equivalentProperties(?PropertyExpressions:set(PropertyExpression))

An equivalent object properties axiom EquivalentProperties( OPE1 ... OPEn ) states that all of the object property expressions OPEi, 1 <= i <= n, are semantically equivalent to each other (extensional predicate - can be asserted) :- thread_local(equivalentProperties/1).

  418axiompred(equivalentProperties/1).
  419axiom_arguments(equivalentProperties,[set(propertyExpression)]).
  420valid_axiom(equivalentProperties(A)) :- subsumed_by([A],[set(propertyExpression)]).
  421expand_axiom(M,equivalentProperties(A),NSList,equivalentProperties(A_full_URL)) :- 
  422  expand_propertyExpressions(M,A,NSList,A_full_URL).

 equivalentObjectProperties(?PropertyExpressions:set(ObjectPropertyExpression))

An equivalent object properties axiom EquivalentObjectProperties( OPE1 ... OPEn ) states that all of the object property expressions OPEi, 1 <= i <= n, are semantically equivalent to each other

  426equivalentObjectProperties(A) :- get_module(M),M:equivalentProperties(A),subsumed_by([A],[set(objectPropertyExpression)]).
  427axiom_arguments(equivalentObjectProperties,[set(objectPropertyExpression)]).
  428valid_axiom(equivalentObjectProperties(A)) :- subsumed_by([A],[set(objectPropertyExpression)]).

 equivalentDataProperties(?PropertyExpressions:set(DataPropertyExpression))

An equivalent data properties axiom EquivalentProperties( DPE1 ... DPEn ) states that all the data property expressions DPEi, 1 <= i <= n, are semantically equivalent to each other. This axiom allows one to use each DPEi as a synonym for each DPEj - that is, in any expression in the ontology containing such an axiom, DPEi can be replaced with DPEj without affecting the meaning of the ontology

  432equivalentDataProperties(A) :- get_module(M),M:equivalentProperties(A),subsumed_by([A],[set(dataPropertyExpression)]).
  433axiom_arguments(equivalentDataProperties,[set(dataPropertyExpression)]).
  434valid_axiom(equivalentDataProperties(A)) :- subsumed_by([A],[set(dataPropertyExpression)]).

 disjointProperties(?PropertyExpressions:set(PropertyExpression))

A disjoint properties axiom DisjointProperties( PE1 ... PEn ) states that all of the property expressions PEi, 1 <= i <= n, are pairwise disjoint (extensional predicate - can be asserted) :- thread_local(disjointProperties/1).

  441axiompred(disjointProperties/1).
  442axiom_arguments(disjointProperties,[set(propertyExpression)]).
  443valid_axiom(disjointProperties(A)) :- subsumed_by([A],[set(propertyExpression)]).
  444expand_axiom(M,disjointProperties(A),NSList,disjointProperties(A_full_URL)) :- 
  445  expand_propertyExpressions(M,A,NSList,A_full_URL).

 disjointObjectProperties(?PropertyExpressions:set(ObjectPropertyExpression))

A disjoint object properties axiom DisjointProperties( OPE1 ... OPEn ) states that all of the object property expressions OPEi, 1 <= i <= n, are pairwise disjoint; that is, no individual x can be connected to an individual y by both OPEi and OPEj for i != j.

  449disjointObjectProperties(A) :- get_module(M),M:disjointProperties(A),subsumed_by([A],[set(objectPropertyExpression)]).
  450axiom_arguments(disjointObjectProperties,[set(objectPropertyExpression)]).
  451valid_axiom(disjointObjectProperties(A)) :- subsumed_by([A],[set(objectPropertyExpression)]).

 disjointDataProperties(?PropertyExpressions:set(DataPropertyExpression))

A disjoint data properties axiom DisjointProperties( DPE1 ... DPEn ) states that all of the data property expressions DPEi, 1 <= i <= n, are pairwise disjoint; that is, no individual x can be connected to a literal y by both DPEi and DPEj for i !- j.

  455disjointDataProperties(A) :- get_module(M),M:disjointProperties(A),subsumed_by([A],[set(dataPropertyExpression)]).
  456axiom_arguments(disjointDataProperties,[set(dataPropertyExpression)]).
  457valid_axiom(disjointDataProperties(A)) :- subsumed_by([A],[set(dataPropertyExpression)]).

 inverseProperties(?ObjectPropertyExpression1:ObjectPropertyExpression, ?ObjectPropertyExpression2:ObjectPropertyExpression)

An inverse object properties axiom InverseProperties( OPE1 OPE2 ) states that the object property expression OPE1 is an inverse of the object property expression OPE2 (note there are no inverse data properties, as literals are not connected to individuals) Example: inverseProperties(partOf,hasPart) (extensional predicate - can be asserted) :- thread_local(inverseProperties/2).

  467axiompred(inverseProperties/2).
  468axiom_arguments(inverseProperties,[objectPropertyExpression, objectPropertyExpression]).
  469valid_axiom(inverseProperties(A, B)) :- subsumed_by([A, B],[objectPropertyExpression, objectPropertyExpression]).
  470expand_axiom(M,inverseProperties(A,B),NSList,inverseProperties(A_full_URL,B_full_URL)) :- 
  471  expand_objectPropertyExpression(M,A,NSList,A_full_URL),
  472  expand_objectPropertyExpression(M,B,NSList,B_full_URL).
  473  %add_expressivity(M,i).

 propertyDomain(?PropertyExpression, ?CE)

A property domain axiom PropertyDomain( PE CE ) states that the domain of the property expression PE is CE (extensional predicate - can be asserted)

  480%:- thread_local(propertyDomain/2).
  481
  482axiompred(propertyDomain/2).
  483axiom_arguments(propertyDomain,[propertyExpression, classExpression]).
  484valid_axiom(propertyDomain(A, B)) :- subsumed_by([A, B],[propertyExpression, classExpression]).
  485expand_axiom(M,propertyDomain(A,B),NSList,propertyDomain(A_full_URL,B_full_URL)) :- 
  486  expand_propertyExpression(M,A,NSList,A_full_URL),
  487  expand_classExpression(M,B,NSList,B_full_URL).

 objectPropertyDomain(?ObjectPropertyExpression, ?ClassExpression)

An object property domain axiom PropertyDomain( OPE CE ) states that the domain of the object property expression OPE is the class expression CE - that is, if an individual x is connected by OPE with some other individual, then x is an instance of CE

  491objectPropertyDomain(A, B) :- get_module(M),M:propertyDomain(A, B),subsumed_by([A, B],[objectPropertyExpression, classExpression]).
  492axiom_arguments(objectPropertyDomain,[objectPropertyExpression, classExpression]).
  493valid_axiom(objectPropertyDomain(A, B)) :- subsumed_by([A, B],[objectPropertyExpression, classExpression]).

 dataPropertyDomain(?DataPropertyExpression, ?ClassExpression)

A data property domain axiom PropertyDomain( DPE CE ) states that the domain of the data property expression DPE is the class expression CE - that is, if an individual x is connected by DPE with some literal, then x is an instance of CE

  497dataPropertyDomain(A, B) :- get_module(M),M:propertyDomain(A, B),subsumed_by([A, B],[dataPropertyExpression, classExpression]).
  498axiom_arguments(dataPropertyDomain,[dataPropertyExpression, classExpression]).
  499valid_axiom(dataPropertyDomain(A, B)) :- subsumed_by([A, B],[dataPropertyExpression, classExpression]).

 annotationPropertyDomain(?AnnotationProperty, ?IRI)

An annotation property domain axiom PropertyDomain( AP U ) states that the domain of the annotation property AP is the IRI U. Such axioms have no effect on the Direct Semantics of OWL 2

  503annotationPropertyDomain(A, B) :- get_module(M),M:propertyDomain(A, B),subsumed_by([A, B],[annotationProperty, iri]).
  504axiom_arguments(annotationPropertyDomain,[annotationProperty, iri]).
  505valid_axiom(annotationPropertyDomain(A, B)) :- subsumed_by([A, B],[annotationProperty, iri]).

 propertyRange(?PropertyExpression, ?ClassExpression)

An object property domain axiom PropertyRange( OPE CE ) states that the domain of the object property expression OPE is the class expression CE - that is, if an individual x is connected by OPE with some other individual, then x is an instance of CE (extensional predicate - can be asserted) :- thread_local(propertyRange/2).

  512axiompred(propertyRange/2).
  513axiom_arguments(propertyRange,[propertyExpression, classExpression]).
  514valid_axiom(propertyRange(A, B)) :- subsumed_by([A, B],[propertyExpression, classExpression]).
  515expand_axiom(M,propertyRange(A,B),NSList,propertyRange(A_full_URL,B_full_URL)) :- 
  516  expand_iri(M,B,NSList,Datatype),
  517  builtin_datatype(Datatype),!,
  518  expand_dataRange(M,B,NSList,B_full_URL),
  519  expand_dataPropertyExpression(M,A,NSList,A_full_URL).
  520expand_axiom(M,propertyRange(A,B),NSList,propertyRange(A_full_URL,B_full_URL)) :- 
  521  expand_propertyExpression(M,A,NSList,A_full_URL),
  522  expand_classExpression(M,B,NSList,B_full_URL).

 objectPropertyRange(?ObjectPropertyExpression, ?ClassExpression)

An object property domain axiom PropertyRange( OPE CE ) states that the domain of the object property expression OPE is the class expression CE - that is, if an individual x is connected by OPE with some other individual, then x is an instance of CE

  526objectPropertyRange(A, B) :- propertyRange(A, B),subsumed_by([A, B],[objectPropertyExpression, classExpression]).
  527axiom_arguments(objectPropertyRange,[objectPropertyExpression, classExpression]).
  528valid_axiom(objectPropertyRange(A, B)) :- subsumed_by([A, B],[objectPropertyExpression, classExpression]).

 dataPropertyRange(?ObjectPropertyExpression, ?DataRange)

A data property range axiom PropertyRange( DPE DR ) states that the range of the data property expression DPE is the data range DR - that is, if some individual is connected by DPE with a literal x, then x is in DR. The arity of DR MUST be one

  532dataPropertyRange(A, B) :- get_module(M),M:propertyRange(A, B),subsumed_by([A, B],[dataPropertyExpression, dataRange]).
  533axiom_arguments(dataPropertyRange,[objectPropertyExpression, dataRange]).
  534valid_axiom(dataPropertyRange(A, B)) :- subsumed_by([A, B],[objectPropertyExpression, dataRange]).

 annotationPropertyRange(?AnnotationProperty, ?IRI)

An annotation property range axiom PropertyRange( AP U ) states that the range of the annotation property AP is the IRI U. Such axioms have no effect on the Direct Semantics of OWL 2

  538annotationPropertyRange(A, B) :- get_module(M),M:propertyRange(A, B),subsumed_by([A, B],[annotationProperty, iri]).
  539axiom_arguments(annotationPropertyRange,[annotationProperty, iri]).
  540valid_axiom(annotationPropertyRange(A, B)) :- subsumed_by([A, B],[annotationProperty, iri]).

 functionalProperty(?PropertyExpression)

An object property functionality axiom FunctionalProperty( OPE ) states that the object property expression OPE is functional - that is, for each individual x, there can be at most one distinct individual y such that x is connected by OPE to y (extensional predicate - can be asserted) :- thread_local(functionalProperty/1).

  547axiompred(functionalProperty/1).
  548axiom_arguments(functionalProperty,[propertyExpression]).
  549valid_axiom(functionalProperty(A)) :- subsumed_by([A],[propertyExpression]).
  550expand_axiom(M,functionalProperty(A),NSList,functionalProperty(A_full_URL)) :- 
  551  expand_propertyExpression(M,A,NSList,A_full_URL).
  552  %add_expressivity(M,f).

 functionalObjectProperty(?ObjectPropertyExpression)

An object property functionality axiom FunctionalProperty( OPE ) states that the object property expression OPE is functional - that is, for each individual x, there can be at most one distinct individual y such that x is connected by OPE to y

  556functionalObjectProperty(A) :- get_module(M),M:functionalProperty(A),subsumed_by([A],[objectPropertyExpression]).
  557axiom_arguments(functionalObjectProperty,[objectPropertyExpression]).
  558valid_axiom(functionalObjectProperty(A)) :- subsumed_by([A],[objectPropertyExpression]).

 functionalDataProperty(?DataPropertyExpression)

A data property functionality axiom FunctionalProperty( DPE ) states that the data property expression DPE is functional - that is, for each individual x, there can be at most one distinct literal y such that x is connected by DPE with y

  562functionalDataProperty(A) :- get_module(M),M:functionalProperty(A),subsumed_by([A],[dataPropertyExpression]).
  563axiom_arguments(functionalDataProperty,[dataPropertyExpression]).
  564valid_axiom(functionalDataProperty(A)) :- subsumed_by([A],[dataPropertyExpression]).

 inverseFunctionalProperty(?ObjectPropertyExpression)

An object property inverse functionality axiom InverseFunctionalProperty( OPE ) states that the object property expression OPE is inverse-functional - that is, for each individual x, there can be at most one individual y such that y is connected by OPE with x. Note there are no InverseFunctional DataProperties :- thread_local(inverseFunctionalProperty/1).

  570axiompred(inverseFunctionalProperty/1).
  571axiom_arguments(inverseFunctionalProperty,[objectPropertyExpression]).
  572valid_axiom(inverseFunctionalProperty(A)) :- subsumed_by([A],[objectPropertyExpression]).
  573expand_axiom(M,inverseFunctionalProperty(A),NSList,inverseFunctionalProperty(A_full_URL)) :- 
  574  expand_objectPropertyExpression(M,A,NSList,A_full_URL).
  575  %add_expressivity(M,i),
  576  %add_expressivity(M,f).

 reflexiveProperty(?ObjectPropertyExpression)

An object property reflexivity axiom ReflexiveProperty( OPE ) states that the object property expression OPE is reflexive - that is, each individual is connected by OPE to itself :- thread_local(reflexiveProperty/1).

  582axiompred(reflexiveProperty/1).
  583axiom_arguments(reflexiveProperty,[objectPropertyExpression]).
  584valid_axiom(reflexiveProperty(A)) :- subsumed_by([A],[objectPropertyExpression]).
  585expand_axiom(M,reflexiveProperty(A),NSList,reflexiveProperty(A_full_URL)) :- 
  586  expand_objectPropertyExpression(M,A,NSList,A_full_URL).

 irreflexiveProperty(?ObjectPropertyExpression)

An object property reflexivity axiom ReflexiveProperty( OPE ) states that the object property expression OPE is reflexive - that is, no individual is connected by OPE to itsel :- thread_local(irreflexiveProperty/1).

  592axiompred(irreflexiveProperty/1).
  593axiom_arguments(irreflexiveProperty,[objectPropertyExpression]).
  594valid_axiom(irreflexiveProperty(A)) :- subsumed_by([A],[objectPropertyExpression]).
  595expand_axiom(M,irreflexiveProperty(A),NSList,irreflexiveProperty(A_full_URL)) :- 
  596  expand_objectPropertyExpression(M,A,NSList,A_full_URL).

 symmetricProperty(?ObjectPropertyExpression)

An object property symmetry axiom SymmetricProperty( OPE ) states that the object property expression OPE is symmetric - that is, if an individual x is connected by OPE to an individual y, then y is also connected by OPE to x :- thread_local(symmetricProperty/1).

  602axiompred(symmetricProperty/1).
  603axiom_arguments(symmetricProperty,[objectPropertyExpression]).
  604valid_axiom(symmetricProperty(A)) :- subsumed_by([A],[objectPropertyExpression]).
  605expand_axiom(M,symmetricProperty(A),NSList,symmetricProperty(A_full_URL)) :- 
  606  expand_objectPropertyExpression(M,A,NSList,A_full_URL).

 asymmetricProperty(?ObjectPropertyExpression)

An object property asymmetry axiom AsymmetricProperty( OPE ) states that the object property expression OPE is asymmetric - that is, if an individual x is connected by OPE to an individual y, then y cannot be connected by OPE to x :- thread_local(asymmetricProperty/1).

  612axiompred(asymmetricProperty/1).
  613axiom_arguments(asymmetricProperty,[objectPropertyExpression]).
  614valid_axiom(asymmetricProperty(A)) :- subsumed_by([A],[objectPropertyExpression]).
  615expand_axiom(M,asymmetricProperty(A),NSList,asymmetricProperty(A_full_URL)) :- 
  616  expand_objectPropertyExpression(M,A,NSList,A_full_URL).

 transitiveProperty(?ObjectPropertyExpression)

An object property transitivity axiom TransitiveProperty( OPE ) states that the object property expression OPE is transitive - that is, if an individual x is connected by OPE to an individual y that is connected by OPE to an individual z, then x is also connected by OPE to z :- thread_local(transitiveProperty/1).

  622axiompred(transitiveProperty/1).
  623axiom_arguments(transitiveProperty,[objectPropertyExpression]).
  624valid_axiom(transitiveProperty(A)) :- subsumed_by([A],[objectPropertyExpression]).
  625expand_axiom(M,transitiveProperty(A),NSList,transitiveProperty(A_full_URL)) :- 
  626  expand_objectPropertyExpression(M,A,NSList,A_full_URL).
  627  %add_rule(M,forall_plus_rule),
  628  %add_expressivity(M,s).

 hasKey(?ClassExpression, ?PropertyExpression)

A key axiom HasKey( CE PE1 ... PEn ) states that each (named) instance of the class expression CE is uniquely identified by the (data or object) property expressions PEi - that is, no two distinct (named) instances of CE can coincide on the values of all property expressions PEi :- thread_local(hasKey/2).

  634axiompred(hasKey/2).
  635axiom_arguments(hasKey,[classExpression,propertyExpression]).
  636valid_axiom(hasKey(CE,PE)) :- subsumed_by([CE,PE],[classExpression,propertyExpression]).
  637expand_axiom(M,hasKey(A,B),NSList,hasKey(A_full_URL,B_full_URL)) :- 
  638  expand_classExpression(M,A,NSList,A_full_URL),
  639  expand_propertyExpression(M,B,NSList,B_full_URL).

 fact(:Axiom)

OWL 2 supports a rich set of axioms for stating assertions - axioms about individuals that are often also called facts. The fact/1 predicate reifies the fact predicate

See also

- annotationAssertion/3, differentIndividuals/1, negativePropertyAssertion/3, propertyAssertion/3, sameIndividual/1, classAssertion/2

  646:- meta_predicate fact(:).  647
  648fact(M:annotationAssertion(A, B, C)) :- M:annotationAssertion(A, B, C).
  649fact(M:differentIndividuals(A)) :- M:differentIndividuals(A).
  650fact(M:negativePropertyAssertion(A, B, C)) :- M:negativePropertyAssertion(A, B, C).
  651fact(M:propertyAssertion(A, B, C)) :- M:propertyAssertion(A, B, C).
  652fact(M:sameIndividual(A)) :- M:sameIndividual(A).
  653fact(M:classAssertion(A, B)) :- M:classAssertion(A, B).
  654axiom_arguments(fact,[axiom]).
  655valid_axiom(fact(A)) :- subsumed_by([A],[axiom]).

 sameIndividual(?Individuals:set(Individual))

An individual equality axiom SameIndividual( a1 ... an ) states that all of the individuals ai, 1 <= i <= n, are equal to each other. note that despite the name of this predicate, it accepts a list of individuals as argument :- thread_local(sameIndividual/1).

  662axiompred(sameIndividual/1).
  663axiom_arguments(sameIndividual,[set(individual)]).
  664valid_axiom(sameIndividual(A)) :- subsumed_by([A],[set(individual)]).
  665expand_axiom(M,sameIndividual(A),NSList,sameIndividual(A_full_URL)) :- 
  666  expand_individuals(M,A,NSList,A_full_URL).

 differentIndividuals(?Individuals:set(Individual))

An individual inequality axiom DifferentIndividuals( a1 ... an ) states that all of the individuals ai, 1 <= i <= n, are different from each other :- thread_local(differentIndividuals/1).

  672axiompred(differentIndividuals/1).
  673axiom_arguments(differentIndividuals,[set(individual)]).
  674valid_axiom(differentIndividuals(A)) :- subsumed_by([A],[set(individual)]).
  675expand_axiom(M,differentIndividuals(A),NSList,differentIndividuals(A_full_URL)) :- 
  676  expand_individuals(M,A,NSList,A_full_URL).

 classAssertion(?ClassExpression, ?Individual)

A class assertion ClassAssertion( CE a ) states that the individual a is an instance of the class expression CE :- thread_local(classAssertion/2).

  682axiompred(classAssertion/2).
  683axiom_arguments(classAssertion,[classExpression, individual]).
  684valid_axiom(classAssertion(A, B)) :- subsumed_by([A, B],[classExpression, individual]).
  685expand_axiom(M,classAssertion(A,B),NSList,B_full_URL) :- 
  686  expand_iri(M,A,NSList,'http://www.w3.org/2000/01/rdf-schema#Datatype'),!,
  687  ( expand_axiom(M,datatype(B),NSList,B_full_URL) -> true ; B_full_URL='none' ).
  688expand_axiom(M,classAssertion(A,B),NSList,classAssertion(A_full_URL,B_full_URL)) :- 
  689  expand_classExpression(M,A,NSList,A_full_URL),
  690  expand_individual(M,B,NSList,B_full_URL).

 propertyAssertion(?PropertyExpression, ?SourceIndividual:Individual, ?TargetIndividual:Individual)

A positive object property assertion PropertyAssertion( OPE a1 a2 ) states that the individual a1 is connected by the object property expression OPE to the individual a2 (extensional predicate - can be asserted) :- thread_local(propertyAssertion/3).

  697axiompred(propertyAssertion/3).
  698axiom_arguments(propertyAssertion,[propertyExpression, individual, individual]).
  699valid_axiom(propertyAssertion(A, B, C)) :- subsumed_by([A, B, C],[propertyExpression, individual, individual]).
  700expand_axiom(M,propertyAssertion(A,B,C),NSList,propertyAssertion(IRI,B_full_URL,C_full_URL)) :- 
  701  expand_iri(M,A,NSList,IRI),
  702  ( IRI='http://www.w3.org/2000/01/rdf-schema#label' ; IRI='http://www.w3.org/2000/01/rdf-schema#comment' ),!,
  703  expand_iri(M,B,NSList,B_full_URL),
  704  ( expand_iri(M,C,NSList,C_full_URL) ; expand_literal(M,C,NSList,C_full_URL) ), !.
  705expand_axiom(M,propertyAssertion(A,B,C),NSList,propertyAssertion(A_full_URL,B_full_URL,C_full_URL)) :- 
  706  expand_individual(M,C,NSList,C_full_URL),!,
  707  expand_individual(M,B,NSList,B_full_URL),
  708  expand_objectPropertyExpression(M,A,NSList,A_full_URL).
  709expand_axiom(M,propertyAssertion(A,B,C),NSList,propertyAssertion(A_full_URL,B_full_URL,C_full_URL)) :- 
  710  expand_literal(M,C,NSList,C_full_URL),
  711  expand_individual(M,B,NSList,B_full_URL),
  712  expand_dataPropertyExpression(M,A,NSList,A_full_URL).

 objectPropertyAssertion(?ObjectPropertyExpression, ?SourceIndividual:Individual, ?TargetIndividual:Individual)

A positive object property assertion PropertyAssertion( OPE a1 a2 ) states that the individual a1 is connected by the object property expression OPE to the individual a2

  717objectPropertyAssertion(A, B, C) :- get_module(M),M:propertyAssertion(A, B, C),subsumed_by([A, B, C],[objectPropertyExpression, individual, individual]).
  718axiom_arguments(objectPropertyAssertion,[objectPropertyExpression, individual, individual]).
  719valid_axiom(objectPropertyAssertion(A, B, C)) :- subsumed_by([A, B, C],[objectPropertyExpression, individual, individual]).

 dataPropertyAssertion(?ObjectPropertyExpression, ?SourceIndividual:Individual, ?TargetValue:Literal)

A positive data property assertion PropertyAssertion( DPE a lt ) states that the individual a is connected by the data property expression DPE to the literal lt

  723dataPropertyAssertion(A, B, C) :- get_module(M),M:propertyAssertion(A, B, C),subsumed_by([A, B, C],[dataPropertyExpression, individual, literal]).
  724axiom_arguments(dataPropertyAssertion,[objectPropertyExpression, individual, literal]).
  725valid_axiom(dataPropertyAssertion(A, B, C)) :- subsumed_by([A, B, C],[dataPropertyExpression, individual, literal]).

 negativePropertyAssertion(?PropertyExpression, ?SourceIndividual:Individual, ?TargetIndividual:Individual)

A negative object property assertion NegativePropertyAssertion( OPE a1 a2 ) states that the individual a1 is not connected by the object property expression OPE to the individual a2 (extensional predicate - can be asserted) :- thread_local(negativePropertyAssertion/3).

  732axiompred(negativePropertyAssertion/3).
  733axiom_arguments(negativePropertyAssertion,[propertyExpression, individual, individual]).
  734valid_axiom(negativePropertyAssertion(A, B, C)) :- subsumed_by([A, B, C],[propertyExpression, individual, individual]).
  735expand_axiom(M,negativePropertyAssertion(A,B,C),NSList,negativePropertyAssertion(A_full_URL,B_full_URL,C_full_URL)) :- 
  736  expand_individual(M,C,NSList,C_full_URL),!,
  737  expand_individual(M,B,NSList,B_full_URL),
  738  expand_objectPropertyExpression(M,A,NSList,A_full_URL).
  739expand_axiom(M,negativePropertyAssertion(A,B,C),NSList,negativePropertyAssertion(A_full_URL,B_full_URL,C_full_URL)) :- 
  740  expand_literal(M,C,NSList,C_full_URL),
  741  expand_individual(M,B,NSList,B_full_URL),
  742  expand_dataPropertyExpression(M,A,NSList,A_full_URL).

 negativeObjectPropertyAssertion(?ObjectPropertyExpression, ?SourceIndividual:Individual, ?TargetIndividual:Individual)

A negative object property assertion NegativePropertyAssertion( OPE a1 a2 ) states that the individual a1 is not connected by the object property expression OPE to the individual a2

  746negativeObjectPropertyAssertion(A, B, C) :- get_module(M),M:negativePropertyAssertion(A, B, C),subsumed_by([A, B, C],[objectPropertyExpression, individual, individual]).
  747axiom_arguments(negativeObjectPropertyAssertion,[objectPropertyExpression, individual, individual]).
  748valid_axiom(negativeObjectPropertyAssertion(A, B, C)) :- subsumed_by([A, B, C],[objectPropertyExpression, individual, individual]).

 negativeDataPropertyAssertion(?DataPropertyExpression, ?SourceIndividual:Individual, ?TargetValue:Literal)

A negative data property assertion NegativePropertyAssertion( DPE a lt ) states that the individual a is not connected by the data property expression DPE to the literal lt

  752negativeDataPropertyAssertion(A, B, C) :- get_module(M),M:negativePropertyAssertion(A, B, C),subsumed_by([A, B, C],[dataPropertyExpression, individual, literal]).
  753axiom_arguments(negativeDataPropertyAssertion,[dataPropertyExpression, individual, literal]).
  754valid_axiom(negativeDataPropertyAssertion(A, B, C)) :- subsumed_by([A, B, C],[dataPropertyExpression, individual, literal]).

 annotationAssertion(?AnnotationProperty, ?AnnotationSubject, ?AnnotationValue)

An annotation assertion AnnotationAssertion( AP as av ) states that the annotation subject as - an IRI or an anonymous individual - is annotated with the annotation property AP and the annotation value av :- thread_local(annotationAssertion/3).

  760axiompred(annotationAssertion/3).
  761axiom_arguments(annotationAssertion,[annotationProperty, annotationSubject, annotationValue]).
  762valid_axiom(annotationAssertion(A, B, C)) :- subsumed_by([A, B, C],[annotationProperty, annotationSubject, annotationValue]).
  763annotationSubject(_).
  764annotationValue(_).
  765expand_axiom(M,annotationAssertion(A,B,C),NSList,annotationAssertion(A_full_URL,B_full_URL,C_full_URL)) :-
  766  expand_annotationProperty(M,A,NSList,A_full_URL),
  767  expand_annotationSubject(M,B,NSList,B_full_URL),
  768  expand_annotationValue(M,C,NSList,C_full_URL).

 annotation(:IRI, ?AnnotationProperty, ?AnnotationValue)

See also

- annotationAnnotation/3, ontologyAnnotation/3, axiomAnnotation/3 :- thread_local(annotation/3).

  775axiompred(annotation/3).
  776
  777annotation(M:annotationAnnotation(A, B, C)) :- M:annotationAnnotation(M:A, B, C).
  778annotation(M:axiomAnnotation(A, B, C)) :- M:axiomAnnotation(M:A, B, C).
  779axiom_arguments(annotation,[iri,annotationProperty,annotationValue]).
  780valid_axiom(annotation(A,B,C)) :- subsumed_by([A,B,C],[iri,annotationProperty,annotationValue]).
  781expand_axiom(M,annotationAnnotation(A,B,C),NSList,annotationAnnotation(A_full_URL,B_full_URL,C_full_URL)) :- 
  782  expand_iri(M,A,NSList,A_full_URL),
  783  expand_annotationProperty(M,B,NSList,B_full_URL),
  784  expand_annotationValue(M,C,NSList,C_full_URL),
  785  ( M:addKBName -> add_kb_atoms(M,annotationProperty,[A_full_URL]) ; true ).

 ontologyAnnotation(?Ontology, ?AnnotationProperty, ?AnnotationValue)

  788ontologyAnnotation(M:Ontology,AP,AV) :-
  789	M:annotation(Ontology,AP,AV),
  790	M:ontology(Ontology).
  791axiom_arguments(ontologyAnnotation,[ontology, annotationProperty, annotationValue]).
  792valid_axiom(ontologyAnnotation(A, B, C)) :- subsumed_by([A, B, C],[ontology, annotationProperty, annotationValue]).

 axiomAnnotation(?Axiom, ?AnnotationProperty, ?AnnotationValue)

  795axiomAnnotation(M:Axiom,AP,AV) :-
  796	M:annotation(Axiom,AP,AV),
  797	M:axiom(Axiom).
  798axiom_arguments(axiomAnnotation,[axiom, annotationProperty, annotationValue]).
  799valid_axiom(axiomAnnotation(A, B, C)) :- subsumed_by([A, B, C],[axiom, annotationProperty, annotationValue]).

 annotationAnnotation(?Annotation, ?AnnotationProperty, ?AnnotationValue)

  802annotationAnnotation(M:Annotation,AP,AV) :-
  803	M:annotation(Annotation,AP,AV),
  804	annotation(M:Annotation).
  805axiom_arguments(annotationAnnotation,[annotation, annotationProperty, annotationValue]).
  806valid_axiom(annotationAnnotation(A, B, C)) :- subsumed_by([A, B, C],[annotation, annotationProperty, annotationValue]).

 ontology(?IRI)

An ontology in OWL2 is a collection of OWL Axioms :- thread_local(ontology/1).

  812expand_ontology(M,A,NSList,A_full_URL) :-
  813  expand_iri(M,A,NSList,A_full_URL).
  814
  815axiompred(ontology/1).
  816axiom_arguments(ontology,[iri]).
  817valid_axiom(ontology(A)) :- subsumed_by([A],[iri]).
  818expand_axiom(M,ontology(A),NSList,ontology(A_full_URL)) :- 
  819  expand_iri(M,A,NSList,A_full_URL).

 ontologyDirective(:OntologyIRI, ?IRI)

See also

- ontologyImport/2, ontologyAxiom/2

  823:- meta_predicate ontologyDirective(:,?).  824
  825ontologyDirective(M:A, B) :- M:ontologyImport(A, B).
  826ontologyDirective(M:A, B) :- M:ontologyAxiom(A, B).
  827ontologyDirective(M:A, B) :- M:ontologyVersionInfo(A, B).
  828axiom_arguments(ontologyDirective,[ontology, iri]).
  829valid_axiom(ontologyDirective(A, B)) :- subsumed_by([A, B],[ontology, iri]).

 ontologyAxiom(?Ontology, ?Axiom)

True if Ontology contains Axiom. Axiom is a prolog term that is typically asserted and separately and can thus can be executed as a goal. For example, an ontology http://example.org# will contain redundant assertions:

subClassOf('http://example.org#a', 'http://example.org#b').
ontologyAxiom('http://example.org#', subClassOf('http://example.org#a','http://example.org#b')).

:- thread_local(ontologyAxiom/2).

  841axiompred(ontologyAxiom/2).
  842axiom_arguments(ontologyAxiom,[ontology, axiom]).
  843valid_axiom(ontologyAxiom(A, B)) :- subsumed_by([A, B],[ontology, axiom]).
  844expand_axiom(M,ontologyAxiom(A,B),NSList,ontology(A_full_URL,B_full_URL)) :- 
  845  expand_ontology(M,A,NSList,A_full_URL),
  846  expand_axiom(M,B,NSList,B_full_URL).

 ontologyImport(?Ontology, ?IRI)

True of Ontology imports document IRI :- thread_local(ontologyImport/2).

  852axiompred(ontologyImport/2).
  853axiom_arguments(ontologyImport,[ontology, iri]).
  854valid_axiom(ontologyImport(A, B)) :- subsumed_by([A, B],[ontology, iri]).
  855expand_axiom(M,ontologyImport(A,B),NSList,ontology(A_full_URL,B)) :- 
  856  expand_iri(M,A,NSList,A_full_URL),
  857  M:consult(B).

 ontologyVersionInfo(?Ontology, ?IRI)

:- thread_local(ontologyVersionInfo/2).

  862axiompred(ontologyVersionInfo/2).
  863axiom_arguments(ontologyVersionInfo,[ontology, iri]).
  864valid_axiom(ontologyVersionInfo(A, B)) :- subsumed_by([A, B],[ontology, iri]).
  865
  866/****************************************
  867  RESTRICTIONS ON AXIOMS
  868  ****************************************/
  869
  870% 11.1
  871% An object property expression OPE is simple in Ax if, for each object property expression OPE' such that OPE' ->* OPE holds, OPE' is not composite.
  872% (The property hierarchy relation ->* is the reflexive-transitive closure of ->)
  873%simpleObjectPropertyExpresion(OPE) :-
  874%        objectPropertyExpression(OPE),
  875
  876
  877/****************************************
  878  EXPRESSIONS
  879  ****************************************/
  880
  881subsumed_by(X,_) :- var(X),!.
  882subsumed_by([],[]) :- !.
  883subsumed_by([I|IL],[T|TL]) :-
  884	!,
  885	subsumed_by(I,T),
  886	subsumed_by(IL,TL).
  887subsumed_by(L,set(T)):-
  888        !,
  889        forall(member(I,L),
  890               subsumed_by(I,T)).
  891subsumed_by(I,T):-
  892        !,
  893	G=..[T,I],
  894	get_module(M),
  895	M:G.

 iri(?IRI)

true if IRI is an IRI. TODO: currently underconstrained, any atomic term can be an IRI

  900iri(IRI) :- atomic(IRI).	%
  901expand_iri(_M,NS_URL,NSList,Full_URL):-
  902  atomic(NS_URL),
  903  NS_URL \= literal(_),
  904  uri_split(NS_URL,Short_NS,Term, ':'),
  905  member((Short_NS=Long_NS),NSList),
  906  concat_atom([Long_NS,Term],Full_URL),!.
  907
  908expand_iri(_M,NS_URL,NSList,Full_URL):- 
  909  atomic(NS_URL),
  910  NS_URL \= literal(_),
  911  \+ sub_atom(NS_URL,_,_,_,':'),
  912  member(([]=Long_NS),NSList),
  913  concat_atom([Long_NS,NS_URL],Full_URL),!.
  914
  915expand_iri(_M,IRI,_NSList,IRI):- atomic(IRI).

 literal(?Lit)

true if Lit is an rdf literal literal(_). % TODO

  921literal(literal(_)).			% TODO
  922expand_literal(M,literal(type(Type,Val)),NSList,literal(type(ExpType,Val))) :-
  923  expand_datatype(M,Type,NSList,ExpType),!.
  924expand_literal(_M,literal(Literal),_NSList,literal(Literal)).
  925
  926propertyExpression(E) :- objectPropertyExpression(E) ; dataPropertyExpression(E).
  927
  928expand_propertyExpressions(_M,[],_NSList,[]) :- !.
  929expand_propertyExpressions(M,[CE|T],NSList,[ExpCE|ExpT]) :-
  930  expand_propertyExpression(M,CE,NSList,ExpCE),
  931  expand_propertyExpressions(M,T,NSList,ExpT).
  932  
  933% expand_propertyExpression(M,E,NSList,ExpE):- expand_objectPropertyExpression(M,E,NSList,ExpE) ; expand_dataPropertyExpression(M,E,NSList,ExpE). % TODO: support for datatype to implement
  934expand_propertyExpression(M,inverseOf(OP),NSList,inverseOf(ExpOP)) :- !,
  935  expand_objectProperty(M,OP,NSList,ExpOP).
  936  %add_expressivity(M,i).
  937expand_propertyExpression(M,E,NSList,ExpE) :- expand_objectProperty(M,E,NSList,ExpE).

 objectPropertyExpression(?OPE)

true if OPE is an ObjectPropertyExpression ObjectPropertyExpression := ObjectProperty | InverseObjectProperty

  942objectPropertyExpression(E) :- objectProperty(E) ; inverseObjectProperty(E).
  943% expand_objectPropertyExpression(M,E,NSList,ExpE) :- expand_objectProperty(M,E,NSList,ExpE) ; expand_inverseObjectProperty(M,E,NSList,ExpE).
  944expand_objectPropertyExpression(M,inverseOf(OP),NSList,inverseOf(ExpOP)) :- !,expand_objectProperty(M,OP,NSList,ExpOP).
  945  %add_expressivity(M,i).
  946expand_objectPropertyExpression(M,E,NSList,ExpE) :- expand_objectProperty(M,E,NSList,ExpE).
  947
  948% give benefit of doubt; e.g. rdfs:label
  949% in the OWL2 spec we have DataProperty := IRI
  950% here dataProperty/1 is an asserted fact
  951objectPropertyExpression(E) :- nonvar(E),iri(E).
  952
  953objectPropertyExpressionOrChain(propertyChain(PL)) :- forall(member(P,PL),objectPropertyExpression(P)).
  954objectPropertyExpressionOrChain(PE) :- objectPropertyExpression(PE).
  955expand_objectPropertyExpressionOrChain(M,propertyChain(PL),NSList,propertyChain(ExpPL)):- !,
  956  expand_propertyExpressions(M,PL,NSList,ExpPL).
  957  %add_expressivity(M,r).
  958expand_objectPropertyExpressionOrChain(M,P,NSList,ExpP):-
  959  expand_objectPropertyExpression(M,P,NSList,ExpP).
  960
  961
  962
  963inverseObjectProperty(inverseOf(OP)) :- objectProperty(OP).
  964expand_inverseObjectProperty(M,inverseOf(OP),NSList,inverseOf(ExpOP)) :- expand_objectProperty(M,OP,NSList,ExpOP).
  965  %add_expressivity(M,i).
  966
  967expand_dataPropertyExpressions(M,DPEs,NSList,ExpDPEs) :- expand_dataPropertyExpression(M,DPEs,NSList,ExpDPEs).
  968
  969dataPropertyExpression(E) :- dataProperty(E).
  970expand_dataPropertyExpression(M,E,NSList,ExpE) :- expand_dataProperty(M,E,NSList,ExpE).
  971
  972dataPropertyExpression(DPEs) :-
  973	(   is_list(DPEs)
  974	->  forall(member(DPE,DPEs),
  975		   dataPropertyExpression(DPE))
  976	;   dataPropertyExpression(DPEs)).
  977
  978expand_dataPropertyExpression(_M,[],_NSList,[]) :- !.
  979expand_dataPropertyExpression(M,[DPE|T],NSList,[ExpDPE|ExpT]) :-
  980  expand_dataPropertyExpression(M,DPE,NSList,ExpDPE),
  981  expand_dataPropertyExpression(M,T,NSList,ExpT).
  982
  983% give benefit of doubt; e.g. rdfs:label
  984% in the OWL2 spec we have DataProperty := IRI
  985% here dataProperty/1 is an asserted fact
  986dataPropertyExpression(E) :- nonvar(E),iri(E).
  987
  988%already declared as entity
  989%datatype(IRI) :- iri(IRI).
  990expand_datatype(M,DT,NSList,ExpDT) :- 
  991  expand_iri(M,DT,NSList,ExpDT),
  992  builtin_datatype(ExpDT).
  993
  994expand_dataRanges(_M,[],_NSList,[]) :- !.
  995expand_dataRanges(M,[H|T],NSList,[ExpH|ExpT]) :-
  996  expand_dataRange(M,H,NSList,ExpH),
  997  expand_dataRanges(M,T,NSList,ExpT).

 dataRange(+DR) is semidet

 1000dataRange(DR) :-
 1001    (datatype(DR) ;
 1002    dataIntersectionOf(DR );
 1003    dataUnionOf(DR) ;
 1004    dataComplementOf(DR) ;
 1005    dataOneOf(DR) ;
 1006    datatypeRestriction(DR)),!.
 1007expand_dataRange(M,intersectionOf(DRs),NSList,intersectionOf(ExpDRs)) :- !,
 1008  expand_dataRanges(M,DRs,NSList,ExpDRs).
 1009expand_dataRange(M,unionOf(DRs),NSList,unionOf(ExpDRs)) :- !,
 1010	expand_dataRanges(M,DRs,NSList,ExpDRs).
 1011expand_dataRange(M,complementOf(DR),NSList,complementOf(ExpDR)) :- !,
 1012	expand_dataRange(M,DR,NSList,ExpDR).
 1013expand_dataRange(M,oneOf(DRs),NSList,oneOf(ExpDRs)) :- !,
 1014	expand_dataRanges(M,DRs,NSList,ExpDRs).
 1015expand_dataRange(M,datatypeRestriction(DR,FacetValues),NSList,datatypeRestriction(DRs,FacetValues)):- !,
 1016	expand_datatype(M,DR,NSList,DRs),
 1017	FacetValues=[_|_].
 1018expand_dataRange(M,literal(DR),NSList,ExpDR):- !,
 1019  expand_literal(M,literal(DR),NSList,ExpDR).
 1020expand_dataRange(M,DR,NSList,ExpDR) :-
 1021  expand_datatype(M,DR,NSList,ExpDR),
 1022  ( M:addKBName -> add_kb_atoms(M,datatype,[ExpDR]) ; true ).

 classExpression(+CE) is semidet

true if CE is a class expression term, as defined in OWL2

Example: classExpression(intersectionOf([car,someValuesFrom(hasColor,blue)])))

Union of:

class/1 | objectIntersectionOf/1 | objectUnionOf/1 | objectComplementOf/1 | objectOneOf/1 | objectSomeValuesFrom/1 | objectAllValuesFrom/1 | objectHasValue/1 | objectHasSelf/1 | objectMinCardinality/1 | objectMaxCardinality/1 | objectExactCardinality/1 | dataSomeValuesFrom/1 | dataAllValuesFrom/1 | dataHasValue/1 | dataMinCardinality/1 | dataMaxCardinality/1 | dataExactCardinality/1

 1040expand_classExpressions(_M,[],_NSList,[]) :- !.
 1041expand_classExpressions(M,[CE|T],NSList,[ExpCE|ExpT]) :-
 1042  expand_classExpression(M,CE,NSList,ExpCE),
 1043  expand_classExpressions(M,T,NSList,ExpT).
 1044
 1045classExpression(CE):-
 1046        (iri(CE) ;               % NOTE: added to allow cases where class is not imported
 1047    class(CE) ;
 1048    objectIntersectionOf(CE) ; objectUnionOf(CE) ; objectComplementOf(CE) ; objectOneOf(CE) ;
 1049    objectSomeValuesFrom(CE) ; objectAllValuesFrom(CE) ; objectHasValue(CE) ; objectHasSelf(CE) ;
 1050    objectMinCardinality(CE) ; objectMaxCardinality(CE) ; objectExactCardinality(CE) ;
 1051    dataSomeValuesFrom(CE) ; dataAllValuesFrom(CE) ; dataHasValue(CE) ;
 1052    dataMinCardinality(CE) ; dataMaxCardinality(CE) ; dataExactCardinality(CE)),!.
 1053/*
 1054expand_classExpression(M,CE,NSList,ExpCE):-			 % TODO: add management datatype
 1055    (expand_class(M,CE,NSList,ExpCE) ;               % NOTE: added to allow cases where class is not imported
 1056    expand_objectIntersectionOf(M,CE,NSList,ExpCE) ; expand_objectUnionOf(M,CE,NSList,ExpCE) ; expand_objectComplementOf(M,CE,NSList,ExpCE) ; expand_objectOneOf(M,CE,NSList,ExpCE) ;
 1057    expand_objectSomeValuesFrom(M,CE,NSList,ExpCE) ; expand_objectAllValuesFrom(M,CE,NSList,ExpCE) ; expand_objectHasValue(M,CE,NSList,ExpCE) ; expand_objectHasSelf(M,CE,NSList,ExpCE) ;
 1058    expand_objectMinCardinality(M,CE,NSList,ExpCE) ; expand_objectMaxCardinality(M,CE,NSList,ExpCE) ; expand_objectExactCardinality(M,CE,NSList,ExpCE) ;
 1059    expand_dataSomeValuesFrom(M,CE,NSList,ExpCE) ; expand_dataAllValuesFrom(M,CE,NSList,ExpCE) ; expand_dataHasValue(M,CE,NSList,ExpCE) ;
 1060    expand_dataMinCardinality(M,CE,NSList,ExpCE) ; expand_dataMaxCardinality(M,CE,NSList,ExpCE) ; expand_dataExactCardinality(M,CE,NSList,ExpCE)),
 1061    ( M:addKBName -> add_kb_atoms(M,class,[ExpCE]) ; true ).
 1062*/
 1063expand_classExpression(M,intersectionOf(CEs),NSList,intersectionOf(ExpCEs)):- !,
 1064  expand_classExpressions(M,CEs,NSList,ExpCEs),
 1065  ( M:addKBName -> add_kb_atoms(M,class,[intersectionOf(ExpCEs)]) ; true ).
 1066expand_classExpression(M,unionOf(CEs),NSList,unionOf(ExpCEs)) :- !,
 1067  expand_classExpressions(M,CEs,NSList,ExpCEs),
 1068  ( M:addKBName -> add_kb_atoms(M,class,[unionOf(ExpCEs)]) ; true ).
 1069  %add_rule(M,or_rule),
 1070  %add_expressivity(M,a).
 1071expand_classExpression(M,complementOf(CE),NSList,complementOf(ExpCE)) :- !,
 1072  expand_classExpression(M,CE,NSList,ExpCE),
 1073  ( M:addKBName -> add_kb_atoms(M,class,[complementOf(ExpCE)]) ; true ).
 1074  %add_expressivity(M,a).
 1075expand_classExpression(M,oneOf(Is),NSList,oneOf(ExpIs)) :- !,  % TODO check in trill
 1076  expand_individuals(M,Is,NSList,ExpIs),
 1077  ( M:addKBName -> add_kb_atoms(M,class,[oneOf(ExpIs)]) ; true ).
 1078  %add_rule(M,o_rule),
 1079  %add_expressivity(M,o).
 1080expand_classExpression(M,someValuesFrom(OPE,CE),NSList,someValuesFrom(ExpOPE,ExpCE)) :- !,
 1081  expand_objectPropertyExpression(M,OPE,NSList,ExpOPE),
 1082  expand_classExpression(M,CE,NSList,ExpCE),
 1083  ( M:addKBName -> add_kb_atoms(M,class,[someValuesFrom(ExpOPE,ExpCE)]) ; true ).
 1084  %add_rule(M,exists_rule).
 1085expand_classExpression(M,allValuesFrom(OPE,CE),NSList,allValuesFrom(ExpOPE,ExpCE)) :- !,
 1086	expand_objectPropertyExpression(M,OPE,NSList,ExpOPE),
 1087	expand_classExpression(M,CE,NSList,ExpCE),
 1088    ( M:addKBName -> add_kb_atoms(M,class,[allValuesFrom(ExpOPE,ExpCE)]) ; true ).
 1089  %add_rule(M,forall_rule),
 1090  %add_expressivity(M,a).
 1091expand_classExpression(M,hasValue(OPE,I),NSList,hasValue(ExpOPE,ExpI)) :- !,  % TODO: add in trill
 1092	expand_objectPropertyExpression(M,OPE,NSList,ExpOPE),
 1093	expand_individual(M,I,NSList,ExpI),
 1094    ( M:addKBName -> add_kb_atoms(M,class,[hasValue(ExpOPE,ExpI)]) ; true ).
 1095expand_classExpression(M,hasSelf(OPE),NSList,hasSelf(ExpOPE)) :- !,  % TODO: add in trill
 1096	expand_objectPropertyExpression(M,OPE,NSList,ExpOPE),
 1097    ( M:addKBName -> add_kb_atoms(M,class,[hasSelf(ExpOPE)]) ; true ).
 1098expand_classExpression(M,minCardinality(C,OPE,CE),NSList,minCardinality(C,ExpOPE,ExpCE)):- !,
 1099	number(C),
 1100	C>=0,
 1101	expand_objectPropertyExpression(M,OPE,NSList,ExpOPE),
 1102	expand_classExpression(M,CE,NSList,ExpCE),
 1103    ( M:addKBName -> add_kb_atoms(M,class,[minCardinality(C,ExpOPE,ExpCE)]) ; true ).
 1104  %add_rule(M,min_rule),
 1105  %add_expressivity(M,q).
 1106expand_classExpression(M,minCardinality(C,OPE),NSList,minCardinality(C,ExpOPE)):- !,
 1107	number(C),
 1108	C>=0,
 1109	expand_objectPropertyExpression(M,OPE,NSList,ExpOPE),
 1110    ( M:addKBName -> add_kb_atoms(M,class,[minCardinality(C,ExpOPE)]) ; true ).
 1111  %add_rule(M,min_rule),
 1112  %add_expressivity(M,n).
 1113expand_classExpression(M,maxCardinality(C,OPE,CE),NSList,maxCardinality(C,ExpOPE,ExpCE)):- !,
 1114	number(C),
 1115	C>=0,
 1116	expand_objectPropertyExpression(M,OPE,NSList,ExpOPE),
 1117	expand_classExpression(M,CE,NSList,ExpCE),
 1118    ( M:addKBName -> add_kb_atoms(M,class,[maxCardinality(C,ExpOPE,ExpCE)]) ; true ).
 1119  %add_rule(M,max_rule),
 1120  %add_expressivity(M,q).
 1121expand_classExpression(M,maxCardinality(C,OPE),NSList,maxCardinality(C,ExpOPE)):- !,
 1122	number(C),
 1123	C>=0,
 1124	expand_objectPropertyExpression(M,OPE,NSList,ExpOPE),
 1125    ( M:addKBName -> add_kb_atoms(M,class,[maxCardinality(C,ExpOPE)]) ; true ).
 1126  %add_rule(M,max_rule),
 1127  %add_expressivity(M,n).
 1128expand_classExpression(M,exactCardinality(C,OPE,CE),NSList,exactCardinality(C,ExpOPE,ExpCE)):- !,
 1129	number(C),
 1130	C>=0,
 1131	expand_objectPropertyExpression(M,OPE,NSList,ExpOPE),
 1132	expand_classExpression(M,CE,NSList,ExpCE),
 1133    ( M:addKBName -> add_kb_atoms(M,class,[exactCardinality(C,ExpOPE,ExpCE)]) ; true ).
 1134  %add_rule(M,min_rule),add_rule(M,max_rule),
 1135  %add_expressivity(M,q).
 1136expand_classExpression(M,exactCardinality(C,OPE),NSList,exactCardinality(C,ExpOPE)):- !,
 1137	number(C),
 1138	C>=0,
 1139	expand_objectPropertyExpression(M,OPE,NSList,ExpOPE),
 1140    ( M:addKBName -> add_kb_atoms(M,class,[exactCardinality(C,ExpOPE)]) ; true ).
 1141  %add_rule(M,min_rule),add_rule(M,max_rule),
 1142  %add_expressivity(M,n).
 1143expand_classExpression(M,CE,NSList,ExpCE):-
 1144    expand_class(M,CE,NSList,ExpCE),
 1145    ( M:addKBName -> add_kb_atoms(M,class,[ExpCE]) ; true ).