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

 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

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

 class(?IRI)

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

  119axiompred(class/1).
  120axiom_arguments(class,[iri]).
  121
  122expand_class(M,C,NSList,ExpC) :- 
  123  expand_iri(M,C,NSList,ExpC),
  124  \+ builtin_datatype(ExpC).
  125
  126valid_axiom(class(A)) :- subsumed_by([A],[iri]).
  127expand_axiom(M,class(A),NSList,class(A_full_URL)) :- 
  128  expand_iri(M,A,NSList,A_full_URL),
  129  ( 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).

  135axiompred(datatype/1).
  136axiom_arguments(datatype,[iri]).
  137valid_axiom(datatype(A)) :- subsumed_by([A],[iri]).
  138expand_axiom(M,datatype(A),NSList,datatype(A_full_URL)) :- 
  139  expand_iri(M,A,NSList,A_full_URL),
  140  \+ name(A_full_URL,[95, 58, 68, 101, 115, 99, 114, 105, 112, 116, 105, 111, 110|_]),
  141  ( 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

  147:- meta_predicate property(:).  148
  149property(M:A) :- M:dataProperty(A).
  150property(M:A) :- M:objectProperty(A).
  151property(M:A) :- M:annotationProperty(A).
  152axiom_arguments(property,[iri]).
  153valid_axiom(property(A)) :- subsumed_by([A],[iri]).

 objectProperty(?IRI)

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

  159axiompred(objectProperty/1).
  160axiom_arguments(objectProperty,[iri]).
  161
  162expand_objectProperty(M,P,NSList,ExpP) :- 
  163  expand_iri(M,P,NSList,ExpP),
  164  ( M:addKBName -> add_kb_atoms(M,objectProperty,[ExpP]) ; true ).
  165
  166valid_axiom(objectProperty(A)) :- subsumed_by([A],[iri]).
  167expand_axiom(M,objectProperty(A),NSList,objectProperty(A_full_URL)) :- 
  168  expand_iri(M,A,NSList,A_full_URL),
  169  ( 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).

  175axiompred(dataProperty/1).
  176axiom_arguments(dataProperty,[iri]).
  177
  178expand_dataProperty(M,P,NSList,ExpP) :- 
  179  expand_iri(M,P,NSList,ExpP),
  180  ( M:addKBName -> add_kb_atoms(M,dataProperty,[ExpP]) ; true).
  181
  182
  183valid_axiom(dataProperty(A)) :- subsumed_by([A],[iri]).
  184expand_axiom(M,dataProperty(A),NSList,dataProperty(A_full_URL)) :- 
  185  expand_iri(M,A,NSList,A_full_URL),
  186  ( 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).

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

 individual(:IRI)

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

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

  251axiompred(namedIndividual/1).
  252axiom_arguments(namedIndividual,[iri]).
  253valid_axiom(namedIndividual(A)) :- subsumed_by([A],[iri]).
  254expand_axiom(M,namedIndividual(A),NSList,namedIndividual(A_full_URL)) :- 
  255  expand_iri(M,A,NSList,A_full_URL),
  256  ( 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).

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

 construct(:IRI)

See also

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

  272:- meta_predicate costruct(:).  273
  274construct(M:A) :- trillo:axiom(M:A).
  275construct(M:A) :- annotation(M:A).
  276construct(M:A) :- M:ontology(A).
  277axiom_arguments(construct,[iri]).
  278valid_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

  283:- multifile trillo:axiom/1.  284
  285trillo:axiom(M:A) :- classAxiom(M:A).
  286trillo:axiom(M:A) :- propertyAxiom(M:A).
  287trillo:axiom(M:hasKey(A,B)) :- M:hasKey(A,B).
  288trillo:axiom(M:A) :- fact(M:A).
  289trillo:axiom(M:A) :- declarationAxiom(M:A).
  290%axiom(annotation(A,B,C)) :-
  291%	annotation(A,B,C). % CJM-treat annotations as axioms
  292axiom_arguments(axiom,[axiom]).
  293valid_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

  298:- meta_predicate classAxiom(:).  299
  300classAxiom(M:equivalentClasses(A)) :- M:equivalentClasses(A).
  301classAxiom(M:disjointClasses(A)) :- M:disjointClasses(A).
  302classAxiom(M:subClassOf(A, B)) :- M:subClassOf(A, B).
  303classAxiom(M:disjointUnion(A, B)) :- M:disjointUnion(A, B).
  304axiom_arguments(classAxiom,[axiom]).
  305valid_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).

  314axiompred(subClassOf/2).
  315axiom_arguments(subClassOf,[classExpression, classExpression]).
  316valid_axiom(subClassOf(A, B)) :- subsumed_by([A, B],[classExpression, classExpression]).
  317expand_axiom(M,subClassOf(A,B),NSList,subClassOf(A_full_URL,B_full_URL)) :- 
  318  expand_classExpression(M,A,NSList,A_full_URL),
  319  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).

  326axiompred(equivalentClasses/1).
  327axiom_arguments(equivalentClasses,[set(classExpression)]).
  328valid_axiom(equivalentClasses(A)) :- subsumed_by([A],[set(classExpression)]).
  329expand_axiom(M,equivalentClasses(A),NSList,equivalentClasses(A_full_URL)) :- 
  330  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).

  336axiompred(disjointClasses/1).
  337axiom_arguments(disjointClasses,[set(classExpression)]).
  338valid_axiom(disjointClasses(A)) :- subsumed_by([A],[set(classExpression)]).
  339expand_axiom(M,disjointClasses(A),NSList,disjointClasses(A_full_URL)) :- 
  340  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).

  346axiompred(disjointUnion/2).
  347axiom_arguments(disjointUnion,[classExpression,set(classExpression)]).
  348valid_axiom(disjointUnion(A,B)) :- subsumed_by([A,B],[classExpression,set(classExpression)]).
  349expand_axiom(M,disjointUnion(A,B),NSList,disjointUnion(A_full_URL,B_full_URL)) :- 
  350  expand_classExpression(M,A,NSList,A_full_URL),
  351  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

  357:- meta_predicate propertyAxiom(:).  358
  359propertyAxiom(M:symmetricProperty(A)) :- M:symmetricProperty(A).
  360propertyAxiom(M:inverseFunctionalProperty(A)) :- M:inverseFunctionalProperty(A).
  361propertyAxiom(M:transitiveProperty(A)) :- M:transitiveProperty(A).
  362propertyAxiom(M:asymmetricProperty(A)) :- M:asymmetricProperty(A).
  363propertyAxiom(M:subPropertyOf(A, B)) :- M:subPropertyOf(A, B).
  364propertyAxiom(M:functionalProperty(A)) :- M:functionalProperty(A).
  365propertyAxiom(M:irreflexiveProperty(A)) :- M:irreflexiveProperty(A).
  366propertyAxiom(M:disjointProperties(A)) :- M:disjointProperties(A).
  367propertyAxiom(M:propertyDomain(A, B)) :- M:propertyDomain(A, B).
  368propertyAxiom(M:reflexiveProperty(A)) :- M:reflexiveProperty(A).
  369propertyAxiom(M:propertyRange(A, B)) :- M:propertyRange(A, B).
  370propertyAxiom(M:equivalentProperties(A)) :- M:equivalentProperties(A).
  371propertyAxiom(M:inverseProperties(A, B)) :- M:inverseProperties(A, B).
  372axiom_arguments(propertyAxiom,[axiom]).
  373valid_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).

  381axiompred(subPropertyOf/2).
  382axiom_arguments(subPropertyOf,[propertyExpression, objectPropertyExpression]).
  383valid_axiom(subPropertyOf(A, B)) :- subsumed_by([A, B],[propertyExpression, objectPropertyExpression]).
  384%expand_axiom(M,subPropertyOf(A,B),NSList,subPropertyOf(A_full_URL,B_full_URL)) :- %TODO: fix for data properties
  385%  expand_propertyExpression(M,A,NSList,A_full_URL),
  386%  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

  390subObjectPropertyOf(A, B) :- get_module(M),M:subPropertyOf(A, B),subsumed_by([A, B],[objectPropertyExpressionOrChain, objectPropertyExpression]).
  391axiom_arguments(subObjectPropertyOf,[objectPropertyExpressionOrChain, objectPropertyExpression]).
  392valid_axiom(subObjectPropertyOf(A, B)) :- subsumed_by([A, B],[objectPropertyExpressionOrChain, objectPropertyExpression]).
  393expand_axiom(M,subPropertyOf(A,B),NSList,subPropertyOf(A_full_URL,B_full_URL)) :- 
  394  expand_objectPropertyExpressionOrChain(M,A,NSList,A_full_URL),
  395  expand_objectPropertyExpression(M,B,NSList,B_full_URL).
  396  %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.

  400subDataPropertyOf(A, B) :- get_module(M),M:subPropertyOf(A, B),subsumed_by([A, B],[dataPropertyExpression, dataPropertyExpression]).
  401axiom_arguments(subDataPropertyOf,[dataPropertyExpression, dataPropertyExpression]).
  402valid_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

  406subAnnotationPropertyOf(A, B) :- get_module(M),M:subPropertyOf(A, B),subsumed_by([A, B],[annotationProperty, annotationProperty]).
  407axiom_arguments(subAnnotationPropertyOf,[annotationProperty, annotationProperty]).
  408valid_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).

  415axiompred(equivalentProperties/1).
  416axiom_arguments(equivalentProperties,[set(propertyExpression)]).
  417valid_axiom(equivalentProperties(A)) :- subsumed_by([A],[set(propertyExpression)]).
  418expand_axiom(M,equivalentProperties(A),NSList,equivalentProperties(A_full_URL)) :- 
  419  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

  423equivalentObjectProperties(A) :- get_module(M),M:equivalentProperties(A),subsumed_by([A],[set(objectPropertyExpression)]).
  424axiom_arguments(equivalentObjectProperties,[set(objectPropertyExpression)]).
  425valid_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

  429equivalentDataProperties(A) :- get_module(M),M:equivalentProperties(A),subsumed_by([A],[set(dataPropertyExpression)]).
  430axiom_arguments(equivalentDataProperties,[set(dataPropertyExpression)]).
  431valid_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).

  438axiompred(disjointProperties/1).
  439axiom_arguments(disjointProperties,[set(propertyExpression)]).
  440valid_axiom(disjointProperties(A)) :- subsumed_by([A],[set(propertyExpression)]).
  441expand_axiom(M,disjointProperties(A),NSList,disjointProperties(A_full_URL)) :- 
  442  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.

  446disjointObjectProperties(A) :- get_module(M),M:disjointProperties(A),subsumed_by([A],[set(objectPropertyExpression)]).
  447axiom_arguments(disjointObjectProperties,[set(objectPropertyExpression)]).
  448valid_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.

  452disjointDataProperties(A) :- get_module(M),M:disjointProperties(A),subsumed_by([A],[set(dataPropertyExpression)]).
  453axiom_arguments(disjointDataProperties,[set(dataPropertyExpression)]).
  454valid_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).

  464axiompred(inverseProperties/2).
  465axiom_arguments(inverseProperties,[objectPropertyExpression, objectPropertyExpression]).
  466valid_axiom(inverseProperties(A, B)) :- subsumed_by([A, B],[objectPropertyExpression, objectPropertyExpression]).
  467expand_axiom(M,inverseProperties(A,B),NSList,inverseProperties(A_full_URL,B_full_URL)) :- 
  468  expand_objectPropertyExpression(M,A,NSList,A_full_URL),
  469  expand_objectPropertyExpression(M,B,NSList,B_full_URL).
  470  %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)

  477%:- thread_local(propertyDomain/2).
  478
  479axiompred(propertyDomain/2).
  480axiom_arguments(propertyDomain,[propertyExpression, classExpression]).
  481valid_axiom(propertyDomain(A, B)) :- subsumed_by([A, B],[propertyExpression, classExpression]).
  482expand_axiom(M,propertyDomain(A,B),NSList,propertyDomain(A_full_URL,B_full_URL)) :- 
  483  expand_propertyExpression(M,A,NSList,A_full_URL),
  484  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

  488objectPropertyDomain(A, B) :- get_module(M),M:propertyDomain(A, B),subsumed_by([A, B],[objectPropertyExpression, classExpression]).
  489axiom_arguments(objectPropertyDomain,[objectPropertyExpression, classExpression]).
  490valid_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

  494dataPropertyDomain(A, B) :- get_module(M),M:propertyDomain(A, B),subsumed_by([A, B],[dataPropertyExpression, classExpression]).
  495axiom_arguments(dataPropertyDomain,[dataPropertyExpression, classExpression]).
  496valid_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

  500annotationPropertyDomain(A, B) :- get_module(M),M:propertyDomain(A, B),subsumed_by([A, B],[annotationProperty, iri]).
  501axiom_arguments(annotationPropertyDomain,[annotationProperty, iri]).
  502valid_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).

  509axiompred(propertyRange/2).
  510axiom_arguments(propertyRange,[propertyExpression, classExpression]).
  511valid_axiom(propertyRange(A, B)) :- subsumed_by([A, B],[propertyExpression, classExpression]).
  512expand_axiom(M,propertyRange(A,B),NSList,propertyRange(A_full_URL,B_full_URL)) :- 
  513  expand_iri(M,B,NSList,Datatype),
  514  builtin_datatype(Datatype),!,
  515  expand_dataRange(M,B,NSList,B_full_URL),
  516  expand_dataPropertyExpression(M,A,NSList,A_full_URL).
  517expand_axiom(M,propertyRange(A,B),NSList,propertyRange(A_full_URL,B_full_URL)) :- 
  518  expand_propertyExpression(M,A,NSList,A_full_URL),
  519  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

  523objectPropertyRange(A, B) :- propertyRange(A, B),subsumed_by([A, B],[objectPropertyExpression, classExpression]).
  524axiom_arguments(objectPropertyRange,[objectPropertyExpression, classExpression]).
  525valid_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

  529dataPropertyRange(A, B) :- get_module(M),M:propertyRange(A, B),subsumed_by([A, B],[dataPropertyExpression, dataRange]).
  530axiom_arguments(dataPropertyRange,[objectPropertyExpression, dataRange]).
  531valid_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

  535annotationPropertyRange(A, B) :- get_module(M),M:propertyRange(A, B),subsumed_by([A, B],[annotationProperty, iri]).
  536axiom_arguments(annotationPropertyRange,[annotationProperty, iri]).
  537valid_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).

  544axiompred(functionalProperty/1).
  545axiom_arguments(functionalProperty,[propertyExpression]).
  546valid_axiom(functionalProperty(A)) :- subsumed_by([A],[propertyExpression]).
  547expand_axiom(M,functionalProperty(A),NSList,functionalProperty(A_full_URL)) :- 
  548  expand_propertyExpression(M,A,NSList,A_full_URL).
  549  %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

  553functionalObjectProperty(A) :- get_module(M),M:functionalProperty(A),subsumed_by([A],[objectPropertyExpression]).
  554axiom_arguments(functionalObjectProperty,[objectPropertyExpression]).
  555valid_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

  559functionalDataProperty(A) :- get_module(M),M:functionalProperty(A),subsumed_by([A],[dataPropertyExpression]).
  560axiom_arguments(functionalDataProperty,[dataPropertyExpression]).
  561valid_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).

  567axiompred(inverseFunctionalProperty/1).
  568axiom_arguments(inverseFunctionalProperty,[objectPropertyExpression]).
  569valid_axiom(inverseFunctionalProperty(A)) :- subsumed_by([A],[objectPropertyExpression]).
  570expand_axiom(M,inverseFunctionalProperty(A),NSList,inverseFunctionalProperty(A_full_URL)) :- 
  571  expand_objectPropertyExpression(M,A,NSList,A_full_URL).
  572  %add_expressivity(M,i),
  573  %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).

  579axiompred(reflexiveProperty/1).
  580axiom_arguments(reflexiveProperty,[objectPropertyExpression]).
  581valid_axiom(reflexiveProperty(A)) :- subsumed_by([A],[objectPropertyExpression]).
  582expand_axiom(M,reflexiveProperty(A),NSList,reflexiveProperty(A_full_URL)) :- 
  583  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).

  589axiompred(irreflexiveProperty/1).
  590axiom_arguments(irreflexiveProperty,[objectPropertyExpression]).
  591valid_axiom(irreflexiveProperty(A)) :- subsumed_by([A],[objectPropertyExpression]).
  592expand_axiom(M,irreflexiveProperty(A),NSList,irreflexiveProperty(A_full_URL)) :- 
  593  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).

  599axiompred(symmetricProperty/1).
  600axiom_arguments(symmetricProperty,[objectPropertyExpression]).
  601valid_axiom(symmetricProperty(A)) :- subsumed_by([A],[objectPropertyExpression]).
  602expand_axiom(M,symmetricProperty(A),NSList,symmetricProperty(A_full_URL)) :- 
  603  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).

  609axiompred(asymmetricProperty/1).
  610axiom_arguments(asymmetricProperty,[objectPropertyExpression]).
  611valid_axiom(asymmetricProperty(A)) :- subsumed_by([A],[objectPropertyExpression]).
  612expand_axiom(M,asymmetricProperty(A),NSList,asymmetricProperty(A_full_URL)) :- 
  613  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).

  619axiompred(transitiveProperty/1).
  620axiom_arguments(transitiveProperty,[objectPropertyExpression]).
  621valid_axiom(transitiveProperty(A)) :- subsumed_by([A],[objectPropertyExpression]).
  622expand_axiom(M,transitiveProperty(A),NSList,transitiveProperty(A_full_URL)) :- 
  623  expand_objectPropertyExpression(M,A,NSList,A_full_URL).
  624  %add_rule(M,forall_plus_rule),
  625  %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).

  631axiompred(hasKey/2).
  632axiom_arguments(hasKey,[classExpression,propertyExpression]).
  633valid_axiom(hasKey(CE,PE)) :- subsumed_by([CE,PE],[classExpression,propertyExpression]).
  634expand_axiom(M,hasKey(A,B),NSList,hasKey(A_full_URL,B_full_URL)) :- 
  635  expand_classExpression(M,A,NSList,A_full_URL),
  636  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

  643:- meta_predicate fact(:).  644
  645fact(M:annotationAssertion(A, B, C)) :- M:annotationAssertion(A, B, C).
  646fact(M:differentIndividuals(A)) :- M:differentIndividuals(A).
  647fact(M:negativePropertyAssertion(A, B, C)) :- M:negativePropertyAssertion(A, B, C).
  648fact(M:propertyAssertion(A, B, C)) :- M:propertyAssertion(A, B, C).
  649fact(M:sameIndividual(A)) :- M:sameIndividual(A).
  650fact(M:classAssertion(A, B)) :- M:classAssertion(A, B).
  651axiom_arguments(fact,[axiom]).
  652valid_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).

  659axiompred(sameIndividual/1).
  660axiom_arguments(sameIndividual,[set(individual)]).
  661valid_axiom(sameIndividual(A)) :- subsumed_by([A],[set(individual)]).
  662expand_axiom(M,sameIndividual(A),NSList,sameIndividual(A_full_URL)) :- 
  663  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).

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

 lpIndividuals(?Individuals:set(Individual))

A set of individuals from logic programming part. lpIndividuals( a1 ... an ) the individuals from facts in the logic part :- thread_local(lpIndividuals/1).

  679axiompred(lpIndividuals/1).
  680axiom_arguments(lpIndividuals,[set(individual)]).
  681valid_axiom(lpIndividuals(A)) :- subsumed_by([A],[set(individual)]).
  682expand_axiom(M,lpIndividuals(A),NSList,lpIndividuals(A_full_URL)) :- 
  683  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).

  689axiompred(classAssertion/2).
  690axiom_arguments(classAssertion,[classExpression, individual]).
  691valid_axiom(classAssertion(A, B)) :- subsumed_by([A, B],[classExpression, individual]).
  692expand_axiom(M,classAssertion(A,B),NSList,B_full_URL) :- 
  693  expand_iri(M,A,NSList,'http://www.w3.org/2000/01/rdf-schema#Datatype'),!,
  694  ( expand_axiom(M,datatype(B),NSList,B_full_URL) -> true ; B_full_URL='none' ).
  695expand_axiom(M,classAssertion(A,B),NSList,classAssertion(A_full_URL,B_full_URL)) :- 
  696  expand_classExpression(M,A,NSList,A_full_URL),
  697  expand_individual(M,B,NSList,B_full_URL).

 lpClassAssertion(?ClassExpression)

  700axiompred(lpClassAssertion/1).
  701axiom_arguments(lpClassAssertion,[classExpression]).
  702valid_axiom(lpClassAssertion(A)) :- subsumed_by([A],[classExpression]).
  703expand_axiom(M,lpClassAssertion(A),NSList,lpClassAssertion(A_full_URL)) :- 
  704	expand_classExpression(M,A,NSList,A_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).

  711axiompred(propertyAssertion/3).
  712axiom_arguments(propertyAssertion,[propertyExpression, individual, individual]).
  713valid_axiom(propertyAssertion(A, B, C)) :- subsumed_by([A, B, C],[propertyExpression, individual, individual]).
  714expand_axiom(M,propertyAssertion(A,B,C),NSList,propertyAssertion(IRI,B_full_URL,C_full_URL)) :- 
  715  expand_iri(M,A,NSList,IRI),
  716  ( IRI='http://www.w3.org/2000/01/rdf-schema#label' ; IRI='http://www.w3.org/2000/01/rdf-schema#comment' ),!,
  717  expand_iri(M,B,NSList,B_full_URL),
  718  ( expand_iri(M,C,NSList,C_full_URL) ; expand_literal(M,C,NSList,C_full_URL) ), !.
  719expand_axiom(M,propertyAssertion(A,B,C),NSList,propertyAssertion(A_full_URL,B_full_URL,C_full_URL)) :- 
  720  expand_individual(M,C,NSList,C_full_URL),!,
  721  expand_individual(M,B,NSList,B_full_URL),
  722  expand_objectPropertyExpression(M,A,NSList,A_full_URL).
  723expand_axiom(M,propertyAssertion(A,B,C),NSList,propertyAssertion(A_full_URL,B_full_URL,C_full_URL)) :- 
  724  expand_literal(M,C,NSList,C_full_URL),
  725  expand_individual(M,B,NSList,B_full_URL),
  726  expand_dataPropertyExpression(M,A,NSList,A_full_URL).

 lpPropertyAssertion(?PropertyExpression)

  729axiompred(lpPropertyAssertion/1).
  730axiom_arguments(lpPropertyAssertion,[propertyExpression]).
  731valid_axiom(lpPropertyAssertion(A)) :- subsumed_by([A],[propertyExpression]).
  732expand_axiom(M,lpPropertyAssertion(A),NSList,lpPropertyAssertion(A_full_URL)) :- 
  733	expand_objectPropertyExpression(M,A,NSList,A_full_URL).
  734expand_axiom(M,lpPropertyAssertion(A),NSList,lpPropertyAssertion(A_full_URL)) :- 
  735	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

  740objectPropertyAssertion(A, B, C) :- get_module(M),M:propertyAssertion(A, B, C),subsumed_by([A, B, C],[objectPropertyExpression, individual, individual]).
  741axiom_arguments(objectPropertyAssertion,[objectPropertyExpression, individual, individual]).
  742valid_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

  746dataPropertyAssertion(A, B, C) :- get_module(M),M:propertyAssertion(A, B, C),subsumed_by([A, B, C],[dataPropertyExpression, individual, literal]).
  747axiom_arguments(dataPropertyAssertion,[objectPropertyExpression, individual, literal]).
  748valid_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).

  755axiompred(negativePropertyAssertion/3).
  756axiom_arguments(negativePropertyAssertion,[propertyExpression, individual, individual]).
  757valid_axiom(negativePropertyAssertion(A, B, C)) :- subsumed_by([A, B, C],[propertyExpression, individual, individual]).
  758expand_axiom(M,negativePropertyAssertion(A,B,C),NSList,negativePropertyAssertion(A_full_URL,B_full_URL,C_full_URL)) :- 
  759  expand_individual(M,C,NSList,C_full_URL),!,
  760  expand_individual(M,B,NSList,B_full_URL),
  761  expand_objectPropertyExpression(M,A,NSList,A_full_URL).
  762expand_axiom(M,negativePropertyAssertion(A,B,C),NSList,negativePropertyAssertion(A_full_URL,B_full_URL,C_full_URL)) :- 
  763  expand_literal(M,C,NSList,C_full_URL),
  764  expand_individual(M,B,NSList,B_full_URL),
  765  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

  769negativeObjectPropertyAssertion(A, B, C) :- get_module(M),M:negativePropertyAssertion(A, B, C),subsumed_by([A, B, C],[objectPropertyExpression, individual, individual]).
  770axiom_arguments(negativeObjectPropertyAssertion,[objectPropertyExpression, individual, individual]).
  771valid_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

  775negativeDataPropertyAssertion(A, B, C) :- get_module(M),M:negativePropertyAssertion(A, B, C),subsumed_by([A, B, C],[dataPropertyExpression, individual, literal]).
  776axiom_arguments(negativeDataPropertyAssertion,[dataPropertyExpression, individual, literal]).
  777valid_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).

  783axiompred(annotationAssertion/3).
  784axiom_arguments(annotationAssertion,[annotationProperty, annotationSubject, annotationValue]).
  785valid_axiom(annotationAssertion(A, B, C)) :- subsumed_by([A, B, C],[annotationProperty, annotationSubject, annotationValue]).
  786annotationSubject(_).
  787annotationValue(_).
  788expand_axiom(M,annotationAssertion(A,B,C),NSList,annotationAssertion(A_full_URL,B_full_URL,C_full_URL)) :-
  789  expand_annotationProperty(M,A,NSList,A_full_URL),
  790  expand_annotationSubject(M,B,NSList,B_full_URL),
  791  expand_annotationValue(M,C,NSList,C_full_URL).

 annotation(:IRI, ?AnnotationProperty, ?AnnotationValue)

See also

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

  798axiompred(annotation/3).
  799
  800annotation(M:annotationAnnotation(A, B, C)) :- M:annotationAnnotation(M:A, B, C).
  801annotation(M:axiomAnnotation(A, B, C)) :- M:axiomAnnotation(M:A, B, C).
  802axiom_arguments(annotation,[iri,annotationProperty,annotationValue]).
  803valid_axiom(annotation(A,B,C)) :- subsumed_by([A,B,C],[iri,annotationProperty,annotationValue]).
  804expand_axiom(M,annotationAnnotation(A,B,C),NSList,annotationAnnotation(A_full_URL,B_full_URL,C_full_URL)) :- 
  805  expand_iri(M,A,NSList,A_full_URL),
  806  expand_annotationProperty(M,B,NSList,B_full_URL),
  807  expand_annotationValue(M,C,NSList,C_full_URL),
  808  ( M:addKBName -> add_kb_atoms(M,annotationProperty,[A_full_URL]) ; true ).

 ontologyAnnotation(?Ontology, ?AnnotationProperty, ?AnnotationValue)

  811ontologyAnnotation(M:Ontology,AP,AV) :-
  812	M:annotation(Ontology,AP,AV),
  813	M:ontology(Ontology).
  814axiom_arguments(ontologyAnnotation,[ontology, annotationProperty, annotationValue]).
  815valid_axiom(ontologyAnnotation(A, B, C)) :- subsumed_by([A, B, C],[ontology, annotationProperty, annotationValue]).

 axiomAnnotation(?Axiom, ?AnnotationProperty, ?AnnotationValue)

  818axiomAnnotation(M:Axiom,AP,AV) :-
  819	M:annotation(Axiom,AP,AV),
  820	M:axiom(Axiom).
  821axiom_arguments(axiomAnnotation,[axiom, annotationProperty, annotationValue]).
  822valid_axiom(axiomAnnotation(A, B, C)) :- subsumed_by([A, B, C],[axiom, annotationProperty, annotationValue]).

 annotationAnnotation(?Annotation, ?AnnotationProperty, ?AnnotationValue)

  825annotationAnnotation(M:Annotation,AP,AV) :-
  826	M:annotation(Annotation,AP,AV),
  827	annotation(M:Annotation).
  828axiom_arguments(annotationAnnotation,[annotation, annotationProperty, annotationValue]).
  829valid_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).

  835expand_ontology(M,A,NSList,A_full_URL) :-
  836  expand_iri(M,A,NSList,A_full_URL).
  837
  838axiompred(ontology/1).
  839axiom_arguments(ontology,[iri]).
  840valid_axiom(ontology(A)) :- subsumed_by([A],[iri]).
  841expand_axiom(M,ontology(A),NSList,ontology(A_full_URL)) :- 
  842  expand_iri(M,A,NSList,A_full_URL).

 ontologyDirective(:OntologyIRI, ?IRI)

See also

- ontologyImport/2, ontologyAxiom/2

  846:- meta_predicate ontologyDirective(:,?).  847
  848ontologyDirective(M:A, B) :- M:ontologyImport(A, B).
  849ontologyDirective(M:A, B) :- M:ontologyAxiom(A, B).
  850ontologyDirective(M:A, B) :- M:ontologyVersionInfo(A, B).
  851axiom_arguments(ontologyDirective,[ontology, iri]).
  852valid_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).

  864axiompred(ontologyAxiom/2).
  865axiom_arguments(ontologyAxiom,[ontology, axiom]).
  866valid_axiom(ontologyAxiom(A, B)) :- subsumed_by([A, B],[ontology, axiom]).
  867expand_axiom(M,ontologyAxiom(A,B),NSList,ontology(A_full_URL,B_full_URL)) :- 
  868  expand_ontology(M,A,NSList,A_full_URL),
  869  expand_axiom(M,B,NSList,B_full_URL).

 ontologyImport(?Ontology, ?IRI)

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

  875axiompred(ontologyImport/2).
  876axiom_arguments(ontologyImport,[ontology, iri]).
  877valid_axiom(ontologyImport(A, B)) :- subsumed_by([A, B],[ontology, iri]).
  878expand_axiom(M,ontologyImport(A,B),NSList,ontology(A_full_URL,B)) :- 
  879  expand_iri(M,A,NSList,A_full_URL),
  880  M:consult(B).

 ontologyVersionInfo(?Ontology, ?IRI)

:- thread_local(ontologyVersionInfo/2).

  885axiompred(ontologyVersionInfo/2).
  886axiom_arguments(ontologyVersionInfo,[ontology, iri]).
  887valid_axiom(ontologyVersionInfo(A, B)) :- subsumed_by([A, B],[ontology, iri]).
  888
  889/****************************************
  890  RESTRICTIONS ON AXIOMS
  891  ****************************************/
  892
  893% 11.1
  894% 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.
  895% (The property hierarchy relation ->* is the reflexive-transitive closure of ->)
  896%simpleObjectPropertyExpresion(OPE) :-
  897%        objectPropertyExpression(OPE),
  898
  899
  900/****************************************
  901  EXPRESSIONS
  902  ****************************************/
  903
  904subsumed_by(X,_) :- var(X),!.
  905subsumed_by([],[]) :- !.
  906subsumed_by([I|IL],[T|TL]) :-
  907	!,
  908	subsumed_by(I,T),
  909	subsumed_by(IL,TL).
  910subsumed_by(L,set(T)):-
  911        !,
  912        forall(member(I,L),
  913               subsumed_by(I,T)).
  914subsumed_by(I,T):-
  915        !,
  916	G=..[T,I],
  917	get_module(M),
  918	M:G.

 iri(?IRI)

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

  923iri(IRI) :- atomic(IRI).	%
  924expand_iri(_M,NS_URL,NSList,Full_URL):-
  925  atomic(NS_URL),
  926  NS_URL \= literal(_),
  927  uri_split(NS_URL,Short_NS,Term, ':'),
  928  member((Short_NS=Long_NS),NSList),
  929  concat_atom([Long_NS,Term],Full_URL),!.
  930
  931expand_iri(_M,NS_URL,NSList,Full_URL):- 
  932  atomic(NS_URL),
  933  NS_URL \= literal(_),
  934  \+ sub_atom(NS_URL,_,_,_,':'),
  935  member(([]=Long_NS),NSList),
  936  concat_atom([Long_NS,NS_URL],Full_URL),!.
  937
  938expand_iri(_M,IRI,_NSList,IRI):- atomic(IRI).

 literal(?Lit)

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

  944literal(literal(_)).			% TODO
  945expand_literal(M,literal(type(Type,Val)),NSList,literal(type(ExpType,Val))) :-
  946  expand_datatype(M,Type,NSList,ExpType),!.
  947expand_literal(_M,literal(Literal),_NSList,literal(Literal)).
  948
  949propertyExpression(E) :- objectPropertyExpression(E) ; dataPropertyExpression(E).
  950
  951expand_propertyExpressions(_M,[],_NSList,[]) :- !.
  952expand_propertyExpressions(M,[CE|T],NSList,[ExpCE|ExpT]) :-
  953  expand_propertyExpression(M,CE,NSList,ExpCE),
  954  expand_propertyExpressions(M,T,NSList,ExpT).
  955  
  956% expand_propertyExpression(M,E,NSList,ExpE):- expand_objectPropertyExpression(M,E,NSList,ExpE) ; expand_dataPropertyExpression(M,E,NSList,ExpE). % TODO: support for datatype to implement
  957expand_propertyExpression(M,inverseOf(OP),NSList,inverseOf(ExpOP)) :- !,
  958  expand_objectProperty(M,OP,NSList,ExpOP).
  959  %add_expressivity(M,i).
  960expand_propertyExpression(M,E,NSList,ExpE) :- expand_objectProperty(M,E,NSList,ExpE).

 objectPropertyExpression(?OPE)

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

  965objectPropertyExpression(E) :- objectProperty(E) ; inverseObjectProperty(E).
  966% expand_objectPropertyExpression(M,E,NSList,ExpE) :- expand_objectProperty(M,E,NSList,ExpE) ; expand_inverseObjectProperty(M,E,NSList,ExpE).
  967expand_objectPropertyExpression(M,inverseOf(OP),NSList,inverseOf(ExpOP)) :- !,expand_objectProperty(M,OP,NSList,ExpOP).
  968  %add_expressivity(M,i).
  969expand_objectPropertyExpression(M,E,NSList,ExpE) :- expand_objectProperty(M,E,NSList,ExpE).
  970
  971% give benefit of doubt; e.g. rdfs:label
  972% in the OWL2 spec we have DataProperty := IRI
  973% here dataProperty/1 is an asserted fact
  974objectPropertyExpression(E) :- nonvar(E),iri(E).
  975
  976objectPropertyExpressionOrChain(propertyChain(PL)) :- forall(member(P,PL),objectPropertyExpression(P)).
  977objectPropertyExpressionOrChain(PE) :- objectPropertyExpression(PE).
  978expand_objectPropertyExpressionOrChain(M,propertyChain(PL),NSList,propertyChain(ExpPL)):- !,
  979  expand_propertyExpressions(M,PL,NSList,ExpPL).
  980  %add_expressivity(M,r).
  981expand_objectPropertyExpressionOrChain(M,P,NSList,ExpP):-
  982  expand_objectPropertyExpression(M,P,NSList,ExpP).
  983
  984
  985
  986inverseObjectProperty(inverseOf(OP)) :- objectProperty(OP).
  987expand_inverseObjectProperty(M,inverseOf(OP),NSList,inverseOf(ExpOP)) :- expand_objectProperty(M,OP,NSList,ExpOP).
  988  %add_expressivity(M,i).
  989
  990expand_dataPropertyExpressions(M,DPEs,NSList,ExpDPEs) :- expand_dataPropertyExpression(M,DPEs,NSList,ExpDPEs).
  991
  992dataPropertyExpression(E) :- dataProperty(E).
  993expand_dataPropertyExpression(M,E,NSList,ExpE) :- expand_dataProperty(M,E,NSList,ExpE).
  994
  995dataPropertyExpression(DPEs) :-
  996	(   is_list(DPEs)
  997	->  forall(member(DPE,DPEs),
  998		   dataPropertyExpression(DPE))
  999	;   dataPropertyExpression(DPEs)).
 1000
 1001expand_dataPropertyExpression(_M,[],_NSList,[]) :- !.
 1002expand_dataPropertyExpression(M,[DPE|T],NSList,[ExpDPE|ExpT]) :-
 1003  expand_dataPropertyExpression(M,DPE,NSList,ExpDPE),
 1004  expand_dataPropertyExpression(M,T,NSList,ExpT).
 1005
 1006% give benefit of doubt; e.g. rdfs:label
 1007% in the OWL2 spec we have DataProperty := IRI
 1008% here dataProperty/1 is an asserted fact
 1009dataPropertyExpression(E) :- nonvar(E),iri(E).
 1010
 1011%already declared as entity
 1012%datatype(IRI) :- iri(IRI).
 1013expand_datatype(M,DT,NSList,ExpDT) :- 
 1014  expand_iri(M,DT,NSList,ExpDT),
 1015  builtin_datatype(ExpDT).
 1016
 1017expand_dataRanges(_M,[],_NSList,[]) :- !.
 1018expand_dataRanges(M,[H|T],NSList,[ExpH|ExpT]) :-
 1019  expand_dataRange(M,H,NSList,ExpH),
 1020  expand_dataRanges(M,T,NSList,ExpT).

 dataRange(+DR) is semidet

 1023dataRange(DR) :-
 1024    (datatype(DR) ;
 1025    dataIntersectionOf(DR );
 1026    dataUnionOf(DR) ;
 1027    dataComplementOf(DR) ;
 1028    dataOneOf(DR) ;
 1029    datatypeRestriction(DR)),!.
 1030expand_dataRange(M,intersectionOf(DRs),NSList,intersectionOf(ExpDRs)) :- !,
 1031  expand_dataRanges(M,DRs,NSList,ExpDRs).
 1032expand_dataRange(M,unionOf(DRs),NSList,unionOf(ExpDRs)) :- !,
 1033	expand_dataRanges(M,DRs,NSList,ExpDRs).
 1034expand_dataRange(M,complementOf(DR),NSList,complementOf(ExpDR)) :- !,
 1035	expand_dataRange(M,DR,NSList,ExpDR).
 1036expand_dataRange(M,oneOf(DRs),NSList,oneOf(ExpDRs)) :- !,
 1037	expand_dataRanges(M,DRs,NSList,ExpDRs).
 1038expand_dataRange(M,datatypeRestriction(DR,FacetValues),NSList,datatypeRestriction(DRs,FacetValues)):- !,
 1039	expand_datatype(M,DR,NSList,DRs),
 1040	FacetValues=[_|_].
 1041expand_dataRange(M,literal(DR),NSList,ExpDR):- !,
 1042  expand_literal(M,literal(DR),NSList,ExpDR).
 1043expand_dataRange(M,DR,NSList,ExpDR) :-
 1044  expand_datatype(M,DR,NSList,ExpDR),
 1045  ( 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

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