Owl Guide Resticted

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

Struttura delle ontologie
1.Spazio dei Nomi
Un 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 Base
Classi Semplici ed Individuals
L'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" />

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 rdf:ID="hasColor">
<rdfs:subPropertyOf rdf:resource="#hasWineDescriptor" />
<rdfs:range rdf:resource="#WineColor" />
...

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.

<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" />

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" />

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" />

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 rdf:ID="producesWine">
<owl:inverseOf rdf:resource="#hasMaker" />

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" />

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.

<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
Per tutti i vini, se hanno delle aziende produttrici, tutti i produttori sono delle
allValuesFrom
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 Mapping
Equivalenza 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: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 Complesse
Operazioni di Insieme
Da 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:Class rdf:about="#Burgundy" />
<owl:Class rdf:about="#WhiteWine" />
</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: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: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 Disgiunte
La 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.

Owl Guide Resticted

Recomendados

Recomendados

Más contenido relacionado

Destacado

Destacado (20)

Más de Sebastiano Merlino (eTr)

Más de Sebastiano Merlino (eTr) (20)

Owl Guide Resticted