OWL Guide //Restricted!Liberamente estratto e sintetizzato da OWL Web Ontology Language Guide (http://www.w3.org/TR/owl-guide/)

Struttura delle ontologie1.Spazio dei NomiUn componente iniziale standard di una ontologia include un insieme di dichiarazioni dello spazio dei nomi XML racchiuse in una etichetta iniziale del tipo rdf:RDF. Questo fornisce un mezzo per interpretare in maniera non ambigua gli identificatori e rendere il resto della presentazione dell'ontologia molto più leggibile. Una tipica ontologia OWL comincia con una dichiarazione dello spazio dei nomi molto simile alla seguente.

<rdf:RDF xmlns ="http://www.w3.org/TR/2004/REC-owl-guide-20040210/wine#" xmlns:vin ="http://www.w3.org/TR/2004/REC-owl-guide-20040210/wine#" xml:base ="http://www.w3.org/TR/2004/REC-owl-guide-20040210/wine#" xmlns:food="http://www.w3.org/TR/2004/REC-owl-guide-20040210/food#" xmlns:owl ="http://www.w3.org/2002/07/owl#" xmlns:rdf ="http://www.w3.org/1999/02/22-rdf-syntax-ns#" xmlns:rdfs="http://www.w3.org/2000/01/rdf-schema#" xmlns:xsd ="http://www.w3.org/2001/XMLSchema#">

Come aiuto per la scrittura di indirizzi web troppo lunghi, può essere utile fornire un insieme di definizioni di entità in una dichiarazione del tipo di documento (DOCTYPE) che precede le definizioni dell'ontologia. I valori degli attributi possono essere scritti nella loro forma completa espansa, per esempio "http://www.w3.org/TR/2004/REC-owl-guide-20040210/wine#merlot". Oppure, alternativamente, possono essere definite delle abbreviazioni mediante una definizione con il costrutto ENTITY, ad esempio:

<!DOCTYPE rdf:RDF [ <!ENTITY vin "http://www.w3.org/TR/2004/REC-owl-guide-20040210/wine#" > <!ENTITY food "http://www.w3.org/TR/2004/REC-owl-guide-20040210/food#" > ]>

Dopo questa coppia di dichiarazioni di ENTITY, possiamo scrivere il valore "&vin;merlot" e questo verrà considerato automaticamente con la sua estensione "http://www.w3.org/TR/2004/REC-owl-guide-20040210/wine#merlot".

2.Intestazione dell'Ontologia

Una volta che gli spazi dei nomi sono stati dichiarati, normalmente includiamo una collezione di affermazioni riguardanti l'ontologie e raggruppate sotto una etichetta owl:Ontology. Queste etichette svolgono compiti critici molto comuni quali i commenti, il controllo della versione e l'inclusione di altre ontologie.

<owl:Ontology rdf:about=""> <rdfs:comment>An example OWL ontology</rdfs:comment> <owl:priorVersion rdf:resource="http://www.w3.org/TR/2003/PR-owl-guide-20031215/wine"/> <owl:imports rdf:resource="http://www.w3.org/TR/2004/REC-owl-guide-20040210/food"/> <rdfs:label>Wine Ontology</rdfs:label> ...

L'elemento owl:Ontology è il posto dove è possibile conservare la maggior parte delle meta-informazioni OWL per il documento. L'attributo rdf:about fornisce invece un nome o un riferimento per l'ontologia. Quando il valore di questo attributo e nullo (""), ovvero il caso standard,

il nome dell'ontologia è l'identificatore di base dell'elemento owl:Ontology.

rdfs:comment fornisce l'ovvia capacità di cui si ha bisogno per commentare una ontologia.

owl:priorVersion è una etichetta standard che può essere usata per fornire un collegamento per il sistema di controllo di versione che viene utilizzato con le ontologie.

owl:imports fornisce un meccanismo di stile di inclusione. Importare un'altra ontologia implica l'importazione dell'intero insieme di asserzioni fornito da quella ontologia, all'interno dell'ontologia corrente. Da notare che owl:imports non sempre può avere successo. Da notare inoltre che per usare il vocabolario OWL non è necessario importare l'ontologia owl.rdf. Infatti una importazione di questo tipo non è assolutamente raccomandata.Le proprietà che sono usate come annotazioni devono essere dichiarate utilizzando la owl:AnnotationProperty. Per esempio

<owl:AnnotationProperty rdf:about="&dc;creator" />

Includiamo inoltre una etichetta rdfs:label per supportare la specifica del linguaggio naturale per la nostra ontologia. La definizione dell'intestazione dell'ontologia è chiusa con la seguente etichetta.

</owl:Ontology>

Questo preludio è seguito dalle definizioni di sorta che costituiscono l'ontologia ed è chiuso definitivamente da una altra etichetta del tipo

</rdf:RDF>

Elementi di BaseClassi Semplici ed IndividualsL'individual come suggerisce il nome rappresenta un individuo. Generalmente si preferisce ragionare sulle classe a cui appartiene un individuo. Chiamiamo l'insieme degli individui che sono membri di una classe come l'estensione di quella classe. Ogni individuo nel mondo di OWL è un membro della classe owl:Thing. Per questo motivo ogni nuova classe definita dall'utente sarà implicitamente una sottoclasse della owl:Thing. OWL permette anche la definizione della classe vuota, owl:Nothing. Definiamo ora 3 classi Radice:

<owl:Class rdf:ID="Winery"/> <owl:Class rdf:ID="Region"/> <owl:Class rdf:ID="ConsumableThing"/>

Da notare che per ora abbiamo solo detto che esistono classi a cui sono stati dati questi nomi, mediante la sintassi 'rdf:ID='. La sintassi rdf:ID="Region" è usata per introdurre un nome come parte della sua definizione. All'interno di questo documento, potremmo ora riferirci alla classe Region usando il termine #Region, ad esempio scrivendo rdf:resource="#Region". Altre ontologie possono invece riferirvisi usando la sua forma completa, "http://www.w3.org/TR/2004/REC-owl-guide-20040210/wine#Region". Il costruttore fondamentale per definire la tassonomia delle classi è rdfs:subClassOf. Esso mette in relazione una classe specifica con una più generica. Se X è una sottoclasse di Y, allora ogni istanza di X è anche una istanza di Y. La relazione rdfs:subClassOf è inoltre una relazione transitiva. Se X è una sottoclasse di Y e Y è una sottoclasse di Z, allora X è anche una sottoclasse di Z.

<owl:Class rdf:ID="PotableLiquid"> <rdfs:subClassOf rdf:resource="#ConsumableThing" />

...</owl:Class>

Definiamo PotableLiquid (liquido potabile) come una sottoclasse di ConsumableThing.

La definizione di una classe è suddivisa in due parti:un nome introduttivo od un riferimento ed una serie di restrizioni. Ognuna delle espressioni che sono contenute all'interno della definizione della classe, restringono le proprietà che possono essere applicate alle istanze della classe definita. Le Istanze della Classe appartengono all'intersezione delle restrizioni su di essa.

<owl:Class rdf:ID="Wine"> <rdfs:subClassOf rdf:resource="&food;PotableLiquid"/> <rdfs:label xml:lang="en">wine</rdfs:label> <rdfs:label xml:lang="fr">vin</rdfs:label> ... </owl:Class>

<owl:Class rdf:ID="Pasta"> <rdfs:subClassOf rdf:resource="#EdibleThing" /> ...</owl:Class>

L'etichetta rdfs:label fornisce un nome opzionale leggibile da parte dell'utente umano per le classi appena definite. L'attributo "lang" fornisce il supporto per diverse lingue. L'attributo "lang" fornisce il supporto per diverse lingue. Una etichetta è in realtà come un commento e non contribuisce all'interpretazione logica dell'ontologia. La nostra definizione del vino è ancora molto incompleta ma abbiamo comunque già abbastanza informazioni per creare e ragionare su alcuni degli individui che appartengono alla classe. In aggiunta alle classi, noi vogliamo essere in grado di descrivere anche i loro membri. Normalmente pensiamo ai membri come degli individui nel nostro universo delle cose. Un individuo è introdotto principalmente dichiarando la sua appartenenza ad una classe. <Region rdf:ID="CentralCoastRegion" />

Da notare che il seguente esempio ha esattamente lo stesso significato del precedente.

<owl:Thing rdf:ID="CentralCoastRegion" />

<owl:Thing rdf:about="#CentralCoastRegion"> <rdf:type rdf:resource="#Region"/> </owl:Thing>

rdf:type è una proprietà RDF che lega un individuo ad una classe a cui appartiene.

I tipi d'uva (Grapes) sono definiti nell'ontologia food:

<owl:Class rdf:ID="Grape"> ...</owl:Class>

E poi, nell'ontologia dei vini abbiamo anche:

<owl:Class rdf:ID="WineGrape"> <rdfs:subClassOf rdf:resource="&food;Grape" /></owl:Class>

<WineGrape rdf:ID="CabernetSauvignonGrape" />

CabernetSauvignonGrape è da considerarsi come un individuo in quanto denota una singola varietà di uva.

Una classe è da considerarsi semplicemente come un nome e una collezione di proprietà che descrivono un insieme di individui. Gli Individui sono i membri di questi insiemi. Per questo motivo le classi devono corrispondere ad insiemi di cose che naturalmente compaiono nel dominio di un discorso e gli individui devono invece corrispondere proprio a quelle entità che possono essere raggruppate in queste classi. In alcuni contesti, qualcosa che può essere considerata ovviamente come una classe, può invece essere considerata come una istanza di qualche altra cosa. E' veramente facile confondere la relazione istanza-di (instance-of) con quella di sottoclasse. Per esempio può sembrare arbitraria la scelta di rappresentare CabernetSauvignonGrape come un individuo di una istanza di Grape, piuttosto che una sottoclasse di Grape. Questa non è del tutto una scelta arbitraria. La classe Grape denota l'insieme di tutte le varietà di uva (grape varietals), e tuttavia ogni sottoclasse di Grape deve rappresentare un sottoinsieme di queste varietà. Per questo motivo quindi, CabernetSauvignonGrape deve essere considerato una istanza di (istance of) Grape (Uva) e non una sua sottoclasse. Esso infatti non descrive un sottoinsieme delle varietà di Grape (Uva) bensì è una varietà di uva. In generale è importante che lo sviluppo di una ontologia deve essere fermamente guidato dall'uso che se ne intende fare.

Proprietà Semplici

Le Proprietà ci permettono di asserire fatti generali riguardo i membri delle classi e di asserire fatti specifici riguardo gli individui. Una proprietà è una relazione binaria. Possono essere distinti due tipi di proprietà:

• datatype properties, relazioni tra le istanze appartenenti alle classi e elementi RDF literals o tipi di dati XML Schema

• object properties, relazioni tra istanze di due classi.

Quando definiamo una proprietà, ci sono molti modi di restringere una relazione. Possono essere specificati il dominio e l'intervallo (range). La proprietà può essere definita come una specializzazione di una proprietà esistente (sottoproprietà).

<owl:ObjectProperty rdf:ID="madeFromGrape"> <rdfs:domain rdf:resource="#Wine"/> <rdfs:range rdf:resource="#WineGrape"/> </owl:ObjectProperty>

<owl:ObjectProperty rdf:ID="course"> <rdfs:domain rdf:resource="#Meal" /> <rdfs:range rdf:resource="#MealCourse" /></owl:ObjectProperty>

La proprietà madeFromGrape ha il dominio della classe Wine e un intervallo riferito a WineGrape. Ciò significa che crea una relazione tra istanze della classe Wine e istanze della classe WineGrape. Domini multipli indicano invece che il dominio della proprietà è dato dall'intersezione delle classi identificate ( e la stessa cosa vale anche per l'intervallo). Allo stesso modo, la proprietà course(portata) lega un Meal(pasto) ad un MealCourse (tipo di portata).

In OWL, un intervallo può essere usato per ricavare un tipo di dato. Per esempio, se viene detto:

<owl:Thing rdf:ID="LindemansBin65Chardonnay"> <madeFromGrape rdf:resource="#ChardonnayGrape" /></owl:Thing>

Noi possiamo asserire che LindemansBin65Chardonnay è un vino poichè il dominio di madeFromGrape è un vino(Wine). Le proprietà, come le classi, possono essere arrangiate in una gerarchia.

<owl:Class rdf:ID="WineDescriptor" />

<owl:Class rdf:ID="WineColor"> <rdfs:subClassOf rdf:resource="#WineDescriptor" /> ...</owl:Class>

<owl:ObjectProperty rdf:ID="hasWineDescriptor"> <rdfs:domain rdf:resource="#Wine" /> <rdfs:range rdf:resource="#WineDescriptor" /></owl:ObjectProperty>

<owl:ObjectProperty rdf:ID="hasColor"> <rdfs:subPropertyOf rdf:resource="#hasWineDescriptor" /> <rdfs:range rdf:resource="#WineColor" /> ...</owl:ObjectProperty>

hasColor è una sottoproprietà della proprietà hasWineDescriptor, con il suo intervallo circoscritto al WineColor. La relazione rdfs:subPropertyOf in questo caso indica che ogni cosaeDescriptor, con il suo intervallo circoscritto al WineColor. La relazione rdfs:subPropertyOf in questo caso indica che ogni cosa con una proprietà del tipo hasColor avente valore X ha anche una proprietà hasWineDescriptor che assume il valore X.E' ora possibile espandere la definizione di Wine per includere la nozione che un vino è fatto da almeno una WineGrape.

<owl:Class rdf:ID="Wine"> <rdfs:subClassOf rdf:resource="&food;PotableLiquid"/> <rdfs:subClassOf> <owl:Restriction> <owl:onProperty rdf:resource="#madeFromGrape"/> <owl:minCardinality rdf:datatype="&xsd;nonNegativeInteger">1</owl:minCardinality> </owl:Restriction> </rdfs:subClassOf> ... </owl:Class>

La restrizione sulla sottoclassedefinisce una classe senza nome che rappresenta l'insieme delle cose con almeno una proprietà madeFromGrape. Chiamiamo questo tipo classi anonime. Includere questa restrizione nel corpo della definizione della classe Wine vuol dire che le cose che sono vini, sono anche membri della classe anonima. Ciò significa che ogni individuo della classe Wine deve partecipare almeno ad una relazione di tipo madeFromGrape. OWL usa la maggior parte degli XML Schema datatypes predefiniti.

<owl:Class rdf:ID="VintageYear" />

<owl:DatatypeProperty rdf:ID="yearValue"> <rdfs:domain rdf:resource="#VintageYear" /> <rdfs:range rdf:resource="&xsd;positiveInteger"/></owl:DatatypeProperty>

La proprietà yearValue relaziona il VintageYear ad un valore positivo intero.

<Region rdf:ID="SantaCruzMountainsRegion"> <locatedIn rdf:resource="#CaliforniaRegion" /></Region>

<Winery rdf:ID="SantaCruzMountainVineyard" />

<CabernetSauvignon rdf:ID="SantaCruzMountainVineyardCabernetSauvignon" > <locatedIn rdf:resource="#SantaCruzMountainsRegion"/> <hasMaker rdf:resource="#SantaCruzMountainVineyard" /> </CabernetSauvignon>

Questa definizione è ancora incompleta. Le proprietà dei tipi di dato possono essere aggiunte agli individui in maniera molto simile. Sotto viene riportata una istanza di VintageYear che viene collegata ad uno specifico valore di tipo &xsd:positiveInteger.

<VintageYear rdf:ID="Year1998"> <yearValue rdf:datatype="&xsd;positiveInteger">1998</yearValue></VintageYear>

Caratteristiche delle Proprietà

E' possibile specificare le caratteristiche di una proprietà, che forniscono un meccanismo molto potente per agevolare dei ragionamenti su una proprietà.Se una proprietà P è specificata come proprietà transitiva, allora per ogni X,Y e Z si ha logicamente:

P(x,y) e P(y,z) implicano P(x,z)La proprietà locatedIn è transitiva.

<owl:ObjectProperty rdf:ID="locatedIn"> <rdf:type rdf:resource="&owl;TransitiveProperty" /> <rdfs:domain rdf:resource="&owl;Thing" /> <rdfs:range rdf:resource="#Region" /></owl:ObjectProperty>

Se una proprietà P viene definita simmetrica, allora per ogni x e y abbiamo: P(x,y) se e solo se P(y,x)

La proprietà adjacentRegion(regione adiacente) è simmetrica

<owl:ObjectProperty rdf:ID="adjacentRegion"> <rdf:type rdf:resource="&owl;SymmetricProperty" /> <rdfs:domain rdf:resource="#Region" /> <rdfs:range rdf:resource="#Region" /></owl:ObjectProperty>

Se una proprietà P viene definita come funzionale, allora per tutte le x, y e z: P(x,y) e P(x,z) implicano che y = z

La proprietà hasVintageYear è una proprietà funzionale.

<owl:Class rdf:ID="VintageYear" />

<owl:ObjectProperty rdf:ID="hasVintageYear"> <rdf:type rdf:resource="&owl;FunctionalProperty" /> <rdfs:domain rdf:resource="#Vintage" /> <rdfs:range rdf:resource="#VintageYear" /></owl:ObjectProperty>

Se una proprietà P1, viene definita come la proprietà owl:inverseOf (inversa di) P2, allora per tutte le x e y abbiamo:

P1(x,y) se e solo se P2(y,x)Da notare che la sintassi della proprietà owl:inverseOf prende un nome di una proprietà come argomento. A se e solo se B significa (A implica B) e (B implica A).

<owl:ObjectProperty rdf:ID="hasMaker"> <rdf:type rdf:resource="&owl;FunctionalProperty" /></owl:ObjectProperty> <owl:ObjectProperty rdf:ID="producesWine"> <owl:inverseOf rdf:resource="#hasMaker" /></owl:ObjectProperty>

Gli individui appartenenti alla classe Wine hanno dei produttori, che nella definizione della classe Wine sono ristretti agli individui della classe Winery(Azienda Vinicola). Allora ogni Winery(Azienda Vinicola) produce l'insieme dei vini che la identificano come un'azienda produttrice. Se una proprietà P, viene definita come una Proprietà Funzionale Inversa, allora per tutte le x, y e z abbiamo:

P(y,x) e P(z,x) implica y = z Da notare che la proprietà producesWine(produce vino) nella sezione precedente è una funzionale inversa. La ragione di questa decisione è che l'inversa di una proprietà funzionale deve necessariamente essere una proprietà funzionale inversa.<owl:ObjectProperty rdf:ID="hasMaker" /> <owl:ObjectProperty rdf:ID="producesWine"> <rdf:type rdf:resource="&owl;InverseFunctionalProperty" /> <owl:inverseOf rdf:resource="#hasMaker" /></owl:ObjectProperty>

Restrizioni sulle proprietà

In aggiunta alle caratteristiche specificate sulle proprietà, è possibile limitare ulteriormente l'intervallo dei valori che può assumere una proprietà in specifici contesti, in differenti maniere. Otteniamo questo mediante le property restrictions (restrizioni sulle proprietà). Le differenti forme descritte di seguito, possono essere usate solo all'interno del contesto di un costrutto definito owl:Restriction. Il costrutto owl:onProperty indica la proprietà restrittiva. I meccanismi allValuesFrom e someValuesFrom sono locali ovvero si applicano solo alla classe in cui sono definiti.La restrizione owl:allValuesFrom richiede che per ogni istanza della classe che ha delle istanze della specifica proprietà, i valori della proprietà devono essere tutti membri appartenenti alla classe indicata nella clausola della owl:allValuesFrom.

<owl:Class rdf:ID="Wine"> <rdfs:subClassOf rdf:resource="&food;PotableLiquid" /> ... <rdfs:subClassOf> <owl:Restriction> <owl:onProperty rdf:resource="#hasMaker" /> <owl:allValuesFrom rdf:resource="#Winery" /> </owl:Restriction> </rdfs:subClassOf> ...</owl:Class>

Il produttore di un Wine(vino) deve essere una Winery(Azienda Vinicola). La restrizione allValuesFrom è imposta solo sulla proprietà hasMaker(ha un produttore) di questa classe Wine(vino). La proprietà owl:someValuesFrom è simile. Se rimpiazzassimo la proprietà owl:allValuesFrom con la owl:someValuesFrom nell'esempio sopra, significherebbe che almeno uno individuo delle proprietà hasMaker(ha un produttore) di un Wine deve indicare un

individuo che deve appartenere alla classe Winery(Azienda Vinicola).

La differenza tra queste due formulazioni è la differenza che sussiste tra i due quantificatori universale ed esistenziale.

Relazione Implicazioni

allValuesFromPer tutti i vini, se hanno delle aziende produttrici, tutti i produttori sono delle aziende vinicole.

someValuesFrom Per tutti i vini, essi hanno almeno un produttore che è un'azienda vinicola.

La prima formulazione non richiede che un vino debba avere un produttore; dice solo che se ne ha uno o più, devono essere tutti delle aziende vinicole. La seconda formulazione invece richiede che ci sia almeno un produttore che sia una azienda vinicola ma possono anche esserci altri produttori che non siano aziende vinicole. L'elemento owl:cardinality permette di specificare esattamente il numero di elementi in una relazione. Per esempio, specifichiamo la classe Vintage(annata) come una classe che ha esattamente un VintageYear (Anno di invecchiamento).

<owl:Class rdf:ID="Vintage"> <rdfs:subClassOf> <owl:Restriction> <owl:onProperty rdf:resource="#hasVintageYear"/> <owl:cardinality rdf:datatype="&xsd;nonNegativeInteger">1</owl:cardinality> </owl:Restriction> </rdfs:subClassOf></owl:Class>

Il costrutto hasValue ci permette di specificare delle classi sulla base dell'esistenza di particolari valori della proprietà. Tuttavia, un individuo sarà un membro di tale classe se almeno uno dei valori della sua proprietà è uguale a quello assunto dalla clausola hasValue.

<owl:Class rdf:ID="Burgundy"> ... <rdfs:subClassOf> <owl:Restriction> <owl:onProperty rdf:resource="#hasSugar" /> <owl:hasValue rdf:resource="#Dry" /> </owl:Restriction> </rdfs:subClassOf></owl:Class>

Qui dichiariamo che tutti i vini di tipo Burgundy sono secchi. Ciò significa che le loro proprietà hasSugar(hanno grado zucchero) devono avere almeno un valore che è uguale a Dry(Secco).

Ontology MappingEquivalenza tra Classi e ProprietàFrequentemente risulta utile il fatto di essere in grado di indicare che una particolare classe o una proprietà in una ontologia sia equivalente ad una classe o ad una proprietà in una seconda ontologia.

<owl:Class rdf:ID="Wine"> <owl:equivalentClass rdf:resource="&vin;Wine"/></owl:Class>

La proprietà owl:equivalentClass è usata per indicare che due classi hanno precisamente le stesse istanze.

owl:Class rdf:ID="TexasThings">

<owl:equivalentClass> <owl:Restriction> <owl:onProperty rdf:resource="#locatedIn" /> <owl:someValuesFrom rdf:resource="#TexasRegion" /> </owl:Restriction> </owl:equivalentClass></owl:Class>

Le TexasThings(oggetti Texani) sono esattamente quelle cose che si trovano nella regione del Texas. In questo caso, la differenza tra l'uso della owl:equivalentClass e della rdfs:subClassOf consiste nella differenza tra una condizione necessaria e una condizione necessaria e sufficiente. Con il subClassOf, le cose che si trovano in Texas non sono necessariamente TexasThings(oggetti Texani). Ma, usando invece owl:equivalentClass, se qualcosa si trova in Texas, allora deve necessariamente essere inclusa all'interno della classe di TexasThings(oggetti Texani). Per collegare fra loro le proprietà in maniera simile usiamo invece la proprietà owl:equivalentProperty.

Identità tra Individui

Il costrutto sameAs dichiara invece che sono identici i due individui a cui fa riferimento. Un esempio potrebbe essere: <Wine rdf:ID="MikesFavoriteWine"> <owl:sameAs rdf:resource="#StGenevieveTexasWhite" /> </Wine> ¬

Questo esempio non ha una grande utilità.Un uso più tipico della proprietà sameAs potrebbe invece essere quello di uguagliare tra loro individui definiti in differenti documenti, durante la parte di unificazione delle due ontologie.

Questo mette in risalto un punto importante. OWL non ha una assunzione di nome unico (unique name assumption). Significa quindi che se due nomi sono differenti, non è detto che debbano riferirsi a differenti individui.

Individui Differenti

Questo meccanismo fornisce l'effetto opposto del sameAs.

<WineSugar rdf:ID="Dry" />

<WineSugar rdf:ID="Sweet"> <owl:differentFrom rdf:resource="#Dry"/> </WineSugar>

<WineSugar rdf:ID="OffDry"> <owl:differentFrom rdf:resource="#Dry"/> <owl:differentFrom rdf:resource="#Sweet"/> </WineSugar>

Questo è uno dei modi per asserire che questi tre valori sono mutuamente distinti tra loro. Esiste un altro meccanismo più conveniente per la definizione di un insieme di individui mutuamente distinti. Il seguente esempio afferma che Red(rosso), White(bianco) e Rose(rosato) sono distinti a coppie.

<owl:AllDifferent> <owl:distinctMembers rdf:parseType="Collection"> <vin:WineColor rdf:about="#Red" /> <vin:WineColor rdf:about="#White" /> <vin:WineColor rdf:about="#Rose" /> </owl:distinctMembers>

</owl:AllDifferent>

Da notare che il costrutto owl:distinctMembers può essere usato solamente in combinazione con il costrutto owl:AllDifferent.

Classi ComplesseOperazioni di InsiemeDa ricordare che le estensioni di una classe OWL class sono degli insiemi composti dagli individui che sono membri di quella classe. OWL fornisce i mezzi per manipolare le estensioni di una classe usando gli operatori base di insieme.

<owl:Class rdf:ID="WhiteWine"> <owl:intersectionOf rdf:parseType="Collection"> <owl:Class rdf:about="#Wine" /> <owl:Restriction> <owl:onProperty rdf:resource="#hasColor" /> <owl:hasValue rdf:resource="#White" /> </owl:Restriction> </owl:intersectionOf></owl:Class>

La costruzione effettuata nell'esempio precedente stabilisce che il WhiteWine(Vino Bianco) è esattamente l'intersezione della classe Wine(Vino) con l'insieme delle cose che sono di colore bianco. Ciò significa che se qualcosa è bianco ed è un vino, allora è necessariamente una istanza della classe WhiteWine(Vino Bianco). Senza questo tipo di definizione noi possiamo sapere solo che i vini bianchi sono vini e bianchi, ma non il viceversa.(Si noti che 'rdf:parseType="Collection"' è un elemento sintattico necessario.)

<owl:Class rdf:ID="WhiteBurgundy"> <owl:intersectionOf rdf:parseType="Collection"> <owl:Class rdf:about="#Burgundy" /> <owl:Class rdf:about="#WhiteWine" /> </owl:intersectionOf> </owl:Class>

Infine, la classe WhiteBurgundy è esattamente l'intersezione dei vini e dei Burgundies.

Il seguente esempio mostra l'uso del costrutto unionOf. E' usato esattamente nello stesso modo del costrutto intersectionOf:

<owl:Class rdf:ID="Fruit"> <owl:unionOf rdf:parseType="Collection"> <owl:Class rdf:about="#SweetFruit" /> <owl:Class rdf:about="#NonSweetFruit" /> </owl:unionOf></owl:Class>

La classe Fruit(Frutta) include entrambe le estensioni della classe SweetFruit(Frutta Dolce) e della classe NonSweetFruit(Frutta non dolce).

Il costrutto complementOf seleziona tutti gli individui del dominio di interesse che non appartengono ad una certa classe. Solitamente questo si riferisce ad un insieme veramente grande di individui:

<owl:Class rdf:ID="ConsumableThing" />

<owl:Class rdf:ID="NonConsumableThing"> <owl:complementOf rdf:resource="#ConsumableThing" /> </owl:Class>

La classe delle NonConsumableThing(cose non commestibili) include tra i suoi membri tutti gli individui che non appartengono all'estensione delle ConsumableThing(cose commestibili).

E' letteralmente l'insieme di differenza tra la classe owl:Thing e la classe ConsumableThing.

Tuttavia, un tipico modo di uso del complementOf è in combinazione con altri operatori di insieme:

<owl:Class rdf:ID="NonFrenchWine"> <owl:intersectionOf rdf:parseType="Collection"> <owl:Class rdf:about="#Wine"/> <owl:Class> <owl:complementOf> <owl:Restriction> <owl:onProperty rdf:resource="#locatedIn" /> <owl:hasValue rdf:resource="#FrenchRegion" /> </owl:Restriction> </owl:complementOf> </owl:Class> </owl:intersectionOf></owl:Class>

Questo definisce la classe NonFrenchWine come l'intersezione della classe Wine con l'insieme di tutte le cose che non sono collocate in Francia.

Classi Enumerate

OWL fornisce i mezzi per specificare una classe mediante l'enumerazione diretta dei suoi membri. Questo si ottiene mediante il costrutto oneOf. Da notare che questa definizione specifica completamente l'estensione della classe in modo che nessun altro individuo possa essere dichiarato come appartenente alla classe.

Il seguente esempio definisce una classe WineColor(Colore del Vino) i cui membri sono gli individui White(Bianco), Rose(Rosato) e Red(Rosso).

<owl:Class rdf:ID="WineColor"> <rdfs:subClassOf rdf:resource="#WineDescriptor"/> <owl:oneOf rdf:parseType="Collection"> <owl:Thing rdf:about="#White"/> <owl:Thing rdf:about="#Rose"/> <owl:Thing rdf:about="#Red"/> </owl:oneOf></owl:Class>

La prima cosa che deve essere messa in evidenza a questo punto, è che nessun altro individuo può essere un valido WineColor poichè la classe è stata definita mediante l'enumerazione. Avremmo anche potuto usare dei riferimenti usando una classe specifica, come ad esempio <WineColor rdf:about="#White" />, solo se la classe WineColor è già stata specificata.

Classi DisgiunteLa disgiunzione di un insieme di classi può essere espressa usando il costrutto owl:disjointWith. Esso garantisce che un individuo che è membro di una classe non può essere contemporaneamente una istanza di un'altra specifica classe:

<owl:Class rdf:ID="Pasta"> <rdfs:subClassOf rdf:resource="#EdibleThing"/> <owl:disjointWith rdf:resource="#Meat"/> <owl:disjointWith rdf:resource="#Fowl"/> <owl:disjointWith rdf:resource="#Seafood"/> <owl:disjointWith rdf:resource="#Dessert"/> <owl:disjointWith rdf:resource="#Fruit"/></owl:Class>

L'esempio precedente della Pasta, dimostra l'uso di classi disgiunte multiple. Da notare che in questo caso si afferma che la Pasta è disgiunta da tutte queste altre classi. Non afferma, ad esempio, che la Meat(Carne) e la Fruit(Frutta) sono disgiunte.