RDF (Resource Description
Framework)
RDFS (Resource Description
Framework Schema)
Tópicos Especiais em Engenharia de Software I (Introdução à Engenharia de Ontologias)
Curso: Engenharia de Computação Prof. Maria das Graças da Silva Teixeira DECOM / CEUNES / UFES
Semestre: 2011.2
Considerações
RDF é uma recomendação do W3C para padronizar a
definição e utilização de metadados (título, autor, data de criação, ...) de descrição de recursos da web.
É uma linguagem para representar informações sobre recursos da
Web;
É adequado para representar dados e proporciona uma
forma simples de expressar afirmações sobre os recursos;
Tenta trazer interoperabilidade ante a multiplicidade de
formatos incompatíveis existentes na web;
A linguagem XML é utilizada para representar os
Considerações
RDF também pode ser usada para representar informações
sobre coisas que podem ser identificadas na WEB, mesmo que elas não possam ser recuperadas diretamente na WEB.
Exemplos: informações sobre itens disponíveis para compras
on-line, ou a descrição das preferências de um usuário da Web.
Conceito Fundamental: Tripla
Componentes: Sujeito – predicado/propriedade – objeto;
Sujeito: recurso, coisas, tais como pessoas e páginas Web – aquilo
do qual se quer falar;
Predicado: atributo (propriedades) ou aspecto do recurso, tais como
“is sister of”, “is author of” – descrevem relacionamentos entre os recursos;
Objeto: valor do atributo ou objeto da relação, pode ser um URI ou
um literal;
Formatos possíveis:
Grafo;
Conceito Fundamental: Tripla
Exemplo: A página http://www.ceunes.ufes.br/prof/mariateixeiraé mantida por Maria das Graças
mantidaPor(http://www.ceunes.ufes.br/prof/mariateixeira, Maria das Graças)
http://www.ceunes.ufes.br/prof/mariateixeira
sujeito
objeto mantidaPor (predicado)
Tem-se um RECURSO, uma PROPRIEDADE desse recurso e um VALOR para essa propriedade.
Maria das Graças
Conceito Fundamental: Tripla
Em RDF, o sujeito e o objeto podem mudar de posição,
dependendo da tripla.
Exemplo:
mantidaPor(http://www.ceunes.ufes.br/prof/mariateixeira, Maria das Graças) cargo(Maria das Graças, professora assistente)
OBS.: Apenas URIs podem passar por tal processo, pois literais podem ser apenas Objetos.
Conceitos Básicos
RDF se utiliza dos seguintes conceitos:
Grafo de Modelo de Dados; Vocabulário baseado em URIs; Tipos de Dados;
Literais;
Sintaxe de Serialização XML; Expressão de Fatos Simples; Vinculação.
Grafo de Modelo de Dados
O grafo é um resultado visual do conjunto de triplas da
expressão RDF que está se desenvolvendo para representar um determinado modelo de dados;
Cada tripla representa uma ligação nó-aresta-nó; Exemplo: Texto sobre Eric Miller.
Existe uma Pessoa identificada por
http://www.w3.org/People/EM/contact#me, cujo nome é Eric Miller, cujo email é [email protected] e cujo título é Doutor.
Grafo de Modelo de Dados
Grafo de Modelo de Dados
Notação em tripla do grafo exemplo. <http://www.w3.org/People/EM/contact#me> <http://www.w3.org/1999/02/22-rdf-syntax-ns#type> <http://www.w3.org/2000/10/swap/pim/contact#Person>. <http://www.w3.org/People/EM/contact#me> <http://www.w3.org/2000/10/swap/pim/contact#fullName> "Eric Miller". <http://www.w3.org/People/EM/contact#me> <http://www.w3.org/2000/10/swap/pim/contact#mailbox> "mailto:[email protected]". <http://www.w3.org/People/EM/contact#me> <http://www.w3.org/2000/10/swap/pim/contact#personalTitle>
Grafo de Modelo de Dados
Notação em XML do grafo exemplo. <?xml version="1.0"?> <rdf:RDF xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#" xmlns:contact="http://www.w3.org/2000/10/swap/pim/contact#"> <contact:Person rdf:about="http://www.w3.org/People/EM/contact#me"> <contact:fullName>Eric Miller</contact:fullName> <contact:mailbox rdf:resource="mailto:[email protected]"/> <contact:personalTitle>Dr.</contact:personalTitle> </contact:Person> </rdf:RDF>
Vocabulário baseado em URIs
Cada nó do grafo RDF pode ser uma URI, um literal ou
estar em branco (não sendo identificado);
Os predicados são identificados por URIs e também podem
ser nós do grafo;
Uma URI ou literal usada como um nó identifica o que
aquele nó representa;
Uma URI usada como predicado identifica um
relacionamento entre as coisas representadas pelos nós que ele conecta;
Tipos de Dados
São usados em RDF para representação de valores, tais
como números (inteiros, reais), datas;
Consiste de um espaço léxico, um espaço de valores e um
mapeamento léxico-para-valor;
É identificado por uma, ou mais, URI;
Por recomendação do W3C espera-se que os tipos de
dados definidos no XMLSchema sejam utilizados;
O RDF não provê nenhum mecanimos para definição de
novos dataypes. Os datatypes do XML Schema provêem um framework extensível adequado para definição de novos datatypes para uso em RDF.
Tipos de Dados
Exemplo: O mapeamento léxico-para-valor do tipo de dado
xsd:boolean do XMLSchema, onde cada membro do espaço de valores (T, F)possui duas representações léxicas é como:
Espaço de valores {T, F}
Espaço léxico {“0”, “1”, “true”, “false”} Mapeamento léxico-para-valores {<“true”, T>, <“1”,T>,
Literais
São usados para identificar valores como números e datas
por meio de uma representação léxica;
Qualquer coisa representada como uma literal também
pode ser representada através de uma URI, mas literais são mais intuitivas;
Podem ser objeto em uma declaração RDF, mas não sujeito
ou predicado;
Podem ser:
Simples (plain) – strings combinadas com tags opcionais da linguagem;
Typed (tipados) - strings combinadas com alguma URI de tipo de dados. Exemplo: <xsd:boolean, “true”>
Literais
Exemplo:Typed Literal Lexical-to-Value
Mapping Value <xsd:boolean, "true"> <"true", T> T
<xsd:boolean, "1"> <"1", T> T <xsd:boolean, "false"> <"false", F> F <xsd:boolean, "0"> <"0", F> F
Sintaxe de serialização de XML
Existe uma forma recomendada de serialização de RDF em
XML de forma a facilitar a troca de modelos RDF entre aplicações;
Expressão de Fatos Simples
Indicam um relacionamento entre duas entidades;
Podem ser representados como um tripla RDF na qual o
predicado nomeia o relacionamento e o sujeito e o objeto as duas entidades;
São como uma linha numa tabela relacional, onde as
colunas são o sujeito e o objeto, e o nome da tabela representa o predicado;
Também podem ser vistos como um predicado com dois
Expressão de Fatos Simples
Exemplo:mantidaPor(http://www.ceunes.ufes.br/prof/mariateixeira, Maria das Graças)
mantidaPor
Sujeito Objeto
http://www.ceunes.ufes.br/prof/mariateixeira Maria das Graças
Expressão de Fatos Simples
Tanto bancos de dados relacionais, como lógica de 1ª.
Ordem permitem relações ou predicados com mais de duas entidades;
Para representar algo assim em RDF é preciso decompor a
tripla RDF;
Uma forma simples de fazer essa decomposição é
introduzir um nó em branco no grafo correspondente à linha (BD), e uma nova tripla para cada célula da linha;
O sujeito da tripla é o nó em branco, o predicado é dado
pelo nome da coluna, o objeto corresponde ao valor da célula.
Expressão de Fatos Simples
Exemplo:Vinculação
Uma expressão RDF A é dita que vincula outra expressão
RDF B se todo possível estado das coisas do mundo que tornam A verdadeiro também tornam B verdadeiro;
Ou seja, se a verdade de A é presumida ou demonstrada,
Sintaxe RDF/XML
Sintaxe recomendada pelo W3C. Outro exemplo de notação:
N3;
De acordo com RDF/XML, um documento RDF é uma lista de
descrições de recursos em XML;
Cada descrição corresponde a um recurso (sujeito) e contém
as propriedades que o definem;
Cada descrição é representada por um elemento XML do tipo
<rdf:Description>, com um dos seguintes atributos: <rdf:about>ou <rdf:ID> ou anônimo. Tal atributo indica o sujeito da tripla;
Os valores das propriedades podem conter literais, outros
recursos (URI) ou uma descrição de outro recurso.
Sintaxe RDF/XML
Descrição de propriedade com valor contendo literal: <rdf:Description rdf:about=
"http://www.ceunes.ufes.br/prof/mariateixeira"> <mantidaPor>Maria das Graças</mantidaPor>
</rdf:Description>
Descrição de propriedade com valor contendo outro
recurso: <rdf:Description rdf:about= "http://www.ceunes.ufes.br/prof/mariateixeira "> <mantidaPor rdf:resource= "mailto:[email protected]"/> </rdf:Description>
Sintaxe RDF/XML
<rdf:Description rdf:about= "http://www.ceunes.ufes.br/prof/mariateixeira"> <mantidaPor> <rdf:Description rdf:about="mailto:[email protected]"> <TrabalhaCom rdf:resource="mailto:[email protected]"/> </rdf:Description> </mantidaPor> </rdf:Description>Descrição de propriedade com valor contendo outra
descrição:
Sintaxe RDF/XML – Tags/Atributos
rdf:RDF – Dentro de um documento XML identifica obloco de declarações RDF.
A tag de abertura pode conter as declarações de namespaces;
rdf:Description – Dentro do bloco rdf:RDF, identifica
a declaração de um recurso.
rdf:about – Utilizada como atributo da tag de abertura
de rdf:Description, identifica a URIref do sujeito a ser tratado, caso esse já exista;
Propriedades – Aninhados entre os tags de rdf:Description,
descrevem cada propriedade e o objeto correspondente.
No caso do objeto ser um recurso, será identificado na própria tag
Sintaxe RDF/XML – Tags/Atributos
rdf:ID – Indica a criação de um Fragment Identifier no
documento RDF sendo construído.
Exemplo: Supor que se esteja criando o documento RDF
armazenado em http://www.example.com/2002/04/products(URI base). <?xml version="1.0"?> <rdf:RDF xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#" xmlns:exterms="http://www.example.com/terms/"> <rdf:Description rdf:ID="item10245"> <exterms:model>Overnighter</exterms:model> <exterms:sleeps>2</exterms:sleeps> <exterms:weight>2.4</exterms:weight> <exterms:packedSize>784</exterms:packedSize> </rdf:Description>
...other product descriptions... </rdf:RDF>
Fragment Identifier: item10245
URIref equivalente: http://www.example.com/2002/04/products#item10245
Sintaxe RDF/XML – Tags/Atributos
rdf:type – Propriedade que indica que um
recurso é instância de um outro recurso.
Valor/Objeto – recurso que representa uma categoria/classe; Sujeito – instância da categoria/classe;
Exemplo: <?xml version="1.0"?> <rdf:RDF xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#" xmlns:exterms="http://www.example.com/terms/" xml:base="http://www.example.com/2002/04/products"> <rdf:Description rdf:ID="item10245"> <rdf:type rdf:resource="http://www.example.com/terms/Tent"/> <exterms:model>Overnighter</exterms:model> <exterms:sleeps>2</exterms:sleeps> <exterms:weight>2.4</exterms:weight> <exterms:packedSize>784</exterms:packedSize> </rdf:Description>
Sintaxe RDF/XML – Tags/Atributos
rdf:type.Exemplo (notação alternativa, simplificada):
<?xml version="1.0"?> <rdf:RDF xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#" xmlns:exterms="http://www.example.com/terms/" xml:base="http://www.example.com/2002/04/products"> <exterms:Tent rdf:ID="item10245"> <exterms:model>Overnighter</exterms:model> <exterms:sleeps>2</exterms:sleeps> <exterms:weight>2.4</exterms:weight> <exterms:packedSize>784</exterms:packedSize> </exterms:Tent>
...other product descriptions... </rdf:RDF>
Sintaxe RDF/XML – XML base
A URI base do documento RDF é a URI do documento que contém as afirmações em RDF;
A URI base pode ser explicitamente indicada no documento, através do atributo xml:base, nos namespaces do documento;
Exemplo: <?xml version="1.0"?> <rdf:RDF xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#" xmlns:exterms="http://www.example.com/terms/" xml:base="http://www.example.com/2002/04/products"> <rdf:Description rdf:ID="item10245"> <exterms:model>Overnighter</exterms:model> <exterms:sleeps>2</exterms:sleeps> <exterms:weight >2.4</exterms:weight> <exterms:packedSize >784</exterms:packedSize> </rdf:Description>
...other product descriptions... </rdf:RDF>
URI Reference
RDF é baseada na ideia de identificar coisas (qualquer
componente da tripla) usando identificadores Web (URI);
Uma URI reference (ou URIref) é uma URI junto com um
fragment identifier opcional no final;
Exemplo: a URI reference
http://www.example.org/index.html#section2 consiste na URI
http://www.example.org/index.htmle (separado pelo caracter “#”) do fragment identifier Section2.
RDF URIrefs podem conter caracteres Unicode, permitindo
que muitas linguagens sejam refletidas em URIrefs.
URI Reference
URIrefs podem ser utilizados para identificar:
Indivíduos, por ex., Eric Miller, identificado por
http://www.w3.org/People/EM/contact#me
Tipos das coisas, por ex., Person, identificado por
http://www.w3.org/2000/10/swap/pim/contact#Person
Propriedades das coisas, por ex., mailbox, identificado por
http://www.w3.org/2000/10/swap/pim/contact#mailbox
Valores das propriedades, por ex., mailto:[email protected], que é um
valor para a propriedade mailbox.
RDF também utiliza caracteres strings, tal como "Eric Miller", e valores de outros dataypes, tal como inteiros e datas, como valores de propriedades.
Qualified Name
A notação de tripla completa requer que a URIref seja escrita completamente dentro dos brackets, o que pode resultar em linhas muito longas em um documento RDF/XML;
Por conveniência, foi estabelecida uma forma abreviada de se
referenciar a um XML Qualified Name (QName), através da abreviação de URIref;
QName prefix: uma abreviação para um URI namespace; Exemplo:
Seja o QName prefix - foo – associado ao namespace do URI
http://example.org/somewhere/;
Então foo:bar é uma abreviação para o URIref
Qualified Name
Alguns QName prefix comuns:
QName Prefix URI Namespace
rdf: http://www.w3.org/1999/02/22-rdf-syntax-ns# rdfs: http://www.w3.org/2000/01/rdf-schema# dc: http://purl.org/dc/elements/1.1/ owl: http://www.w3.org/2002/07/owl# ex: http://www.example.org xsd: http://www.w3.org/2001/XMLSchema#
Qualified Name
Exemplo: <?xml version=“1.0”?> <rdf:RDF xmlns:rdf = “http://www.w3.org/1999/02/22-rdf-syntax-ns#” xmlns:contact = “http://www.w3.org/2000/10/swap/pim/contact”> <rdf:Descriptionrdf:about=“http://www.w3.org/People/EM/contact#me”> <rdf:type rdf:resource=contact:Person />
<contact:fullName>Eric Miller</contact:fullName> <contact:mailbox rdf:resource = “mailto:[email protected]” /> <contact:PersonalTitle>Dr.</contact:PersonalTitle> </rdf:Description>
Recursos Anônimos / Blank Nodes
Algumas informações são mais complexas de seremrepresentadas, e requerem alguma estruturação. Por exemplo:
exstaff:85740 exterms:address "1501 Grant Avenue, Bedford, Massachusetts 01730" .
Supor que o endereço deva ser representado de forma estruturada (rua, cidade, ...) ao invés de como uma string.
Informação estruturada pode ser representada em RDF
considerando a coisa a ser descrita (por exemplo, o
endereço) como um recurso, e então construindo comandos sobre aquele novo recurso.
Recursos Anônimos / Blank Nodes
Exemplo (grafo):Recursos Anônimos / Blank Nodes
Exemplo (formato de triplas):exstaff:85740 exterms:address exaddressid:85740 . exaddressid:85740 exterms:street "1501 Grant Avenue" . exaddressid:85740 exterms:city "Bedford" .
exaddressid:85740 exterms:state "Massachusetts" . exaddressid:85740 exterms:postalCode "01730" . Esta forma de representar uma informação estruturada pode envolver a
geração de várias URIrefs intermediárias (tal como exaddressid:85740) para representar conceitos agregados.
Tais conceitos podem nunca ser referenciados diretamente de fora do documento RDF original, não requerendo assim um identificador universal. Para resolver tal situação pode-se trabalhar com um recurso anônimo (um
blank node no grafo), que pode ser representado, mas não requer um URI.
Recursos Anônimos / Blank Nodes
Exemplo (grafo):Recursos Anônimos / Blank Nodes
Exemplo (formato de triplas):
exstaff:85740 exterms:address ??? .
??? exterms:street "1501 Grant Avenue" . ??? exterms:city "Bedford" .
??? exterms:state "Massachusetts" . ??? exterms:postalCode "01730" .
Considerando que um grafo RDF pode ter mais de um blank node, para representar informações mais complexas, é necessário ter uma forma de identificar um recurso anônimo (destacado no código acima como “???”).
Identificação de blank node: _:name
Recursos Anônimos / Blank Nodes
Exemplo (formato de triplas):
exstaff:85740 exterms:address _:johnaddress . _:johnaddress exterms:street "1501 Grant Avenue" . _:johnaddress exterms:city "Bedford" .
_:johnaddress exterms:state "Massachusetts" . _:johnaddress exterms:postalCode "01730" .
Literais
Além de URIs, o objeto de uma tripla RDF pode ser também
um valor constante (literal);
Tipos de literais:
Plain (simples / não-tipados) – composto apenas por
caracteres. O literal é interpretado como string, mesmo se contiver números ou datas.
Exemplo: _:johnaddress exterms:city "Bedford" . Typed (tipados) – Capacita a interpretação do tipo de
dado representado pelo literal, isto é, que o valor seja associado a um datatype.
Exemplo: exstaff:85740 exterms:age "27"^^xsd:integer.
Literais
Os datatypes comumente interpretados em um documento RDF são aqueles do XML Schema Datatype;
Formas de representação de uma literal tipada (com exemplo): Em um grafo:
Literais
Formas de representação de uma literal tipada (com exemplo, cont): Representação de tripla:
<http://www.example.org/staffid/85740> <http://www.example.org/terms/age>
"27"^^<http://www.w3.org/2001/XMLSchema#integer> .
Usando Qname prefix:
exstaff:85740 exterms:age "27"^^xsd:integer .
Notação XML/RDF:
<?xml version=“1.0”?>
<rdf:RDF xmlns:rdf = “http://www.w3.org/1999/02/22-rdf-syntax-ns#” xmlns:exterms = “http://www.example.org/terms”>
<rdf:Description rdf:about=“http://www.example.org/staffid/85740”> <exterms:age
rdf:datatype=“http://www.w3.org/2011/XMLSchema#integer”>27</exterms:age> </rdf:Description>
</rdf:RDF>
Outras capacidades RDF/XML
-Containers
Às vezes é necessário trabalhar ou declarar fatos sobre um
conjunto de entidades. RDF/XML oferece um vocabulário de recursos para tal. Tais recursos são chamados
containers;
Um container é um recurso que contém objetos,
denominados membros;
Outras capacidades RDF/XML
-Containers
Tipos pré-definidos:
rdf:Bag– representa um grupo de recursos / literais,
possivelmente com membros duplicados, onde não é relevante a ordem dos membros;
rdf:Seq– representa um grupo de recursos / literais, possivelmente com membros duplicados, onde a ordem dos membros é relevante;
rdf:Alt– representa um grupo de recursos / literiis que são alternativas (tipicamente para um único valor de uma propriedade).
Outras capacidades RDF/XML
-Containers
Para descrever um recurso como sendo um container, o recurso é
colocado como tendo uma propriedade rdf:type, cujo valor é um dos tipos rdf:Bag, rdf:Seq, rdf:Alt;
O recurso do container (que pode ser um blank node ou um recurso
com URIref) denota o grupo como um todo;
Os membros do container podem ser descritos definindo-se uma
propriedade membership container para cada membro, com o recurso do container como sujeito e o membro como objeto;
As propriedades membership container tem nomes no formato rdf:_n,
onde n é um inteiro maior do que zero;
Recursos container também podem ter outras propriedades que
Outras capacidades RDF/XML
-Containers
Outras capacidades RDF/XML
-Containers
Exemplo: <?xml version="1.0"?> <rdf:RDF xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#" xmlns:s="http://example.org/students/vocab#"><rdf:Description rdf:about="http://example.org/courses/6.001"> <s:students>
<rdf:Bag>
<rdf:li rdf:resource="http://example.org/students/Amy"/> <rdf:li rdf:resource="http://example.org/students/Mohamed"/> <rdf:li rdf:resource="http://example.org/students/Johann"/> <rdf:li rdf:resource="http://example.org/students/Mary"/> <rdf:li rdf:resource="http://example.org/students/Phuong"/> </rdf:Bag>
</s:students> </rdf:Description> </rdf:RDF>
Outras capacidades RDF/XML
-Collections
Uma limitação dos containers é não poder fechá-los, isto é,
indicar que outros membros não existem;
Um Collection em RDF é um grupo de entidades
representadas como uma estrutura de listas no grafo RDF;
A estrutura é montada usando o vocabulário de Collection,
que consiste em:
O tipo lista – rdf:List
A propriedade primeiro – rdf:First A propriedade resto – rdf:Rest O recurso nulo – rdf:Nil
Outras capacidades RDF/XML
-Collections
Outras capacidades RDF/XML
-Collections
Exemplo: <?xml version="1.0"?> <rdf:RDF xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#" xmlns:s="http://example.org/students/vocab#"> <rdf:Description rdf:about="http://example.org/courses/6.001"> <s:students rdf:nodeID="sch1"/> </rdf:Description> <rdf:Description rdf:nodeID="sch1"> <rdf:first rdf:resource="http://example.org/students/Amy"/> <rdf:rest rdf:nodeID="sch2"/> </rdf:Description> <rdf:Description rdf:nodeID="sch2"> <rdf:first rdf:resource="http://example.org/students/Mohamed"/> <rdf:rest rdf:nodeID="sch3"/> </rdf:Description> <rdf:Description rdf:nodeID="sch3"> <rdf:first rdf:resource="http://example.org/students/Johann"/> <rdf:rest rdf:resource="http://www.w3.org/1999/02/22-rdf-syntax-ns#nil"/> </rdf:Description> </rdf:RDF>Outras capacidades RDF/XML
-Collections
Exemplo (usando notação simplificada): <?xml version="1.0"?>
<rdf:RDF xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#" xmlns:s="http://example.org/students/vocab#">
<rdf:Description rdf:about="http://example.org/courses/6.001"> <s:students rdf:parseType="Collection">
<rdf:Description rdf:about="http://example.org/students/Amy"/> <rdf:Description rdf:about="http://example.org/students/Mohamed"/> <rdf:Description rdf:about="http://example.org/students/Johann"/> </s:students> </rdf:Description> </rdf:RDF>
Outras capacidades RDF/XML
-Reification
Aplicações RDF algumas vezes precisam descrever outras
afirmações RDF usando RDF, para registrar informação, por exemplo, sobre quem fez o comando,quando ele foi feito, etc;
RDF provê um vocabulário próprio para descrever
afirmações RDF. Uma descrição de afirmação é denominada uma reificação da afirmação;
Sintaxe:
rdf:Statement– indica que a afirmação é sobre outra afirmação; rdf:subject– indica o sujeito da afirmação;
rdf:predicate– indica o predicado da afirmação; rdf:object– indica o objeto da afirmação.
Outras capacidades RDF/XML
-Reification
Seja a tripla:
exproducts:item10245 exterms:weight "2.4"^^xsd:decimal . Uma descrição da afirmação (uma reificação), usando uma
URIref (neste caso exproducts:triple12345):
exproducts:triple12345 rdf:type rdf:Statement.
exproducts:triple12345 rdf:subject exproducts:item10245. exproducts:triple12345 rdf:predicate exterms:weight. exproducts:triple12345 rdf:object "2.4"^^xsd:decimal.
Uma vez descrita a afirmação dessa forma, informações
adicionais a tais triplas podem ser feitas, como por exemplo:
Outras capacidades RDF/XML
-Reification
Prosseguindo no exemplo: a afirmação original, junto com a reificação e a identificação do criador, forma o grafo RDF abaixo.
RDFS (RDF Schema)
Introduz primitivas básicas que permitem falar de classe,
subclasse, domínio e restrições de valores das propriedades, em contexto da web;
Permitem aos desenvolvedores definir um vocabulário
básico para dados RDF e especificar o tipo de objeto aos quais se aplicam tais atributos;
Proporciona um mecanismo de tipagem básica para
modelos RDF, utilizando termos definidos, tais como: Class, subPropertyOf, subClassOf;
Os objetos RDF podem ser definidos como instâncias de
RDFS (RDF Schema)
Provê um conjunto de recursos e propriedades: Com significado bem definido;
Utilizado para descrever classes e propriedades de uma
aplicação;
Forma um vocabulário reservado (de RDF Schema)
estendendo o vocabulário RDF.
RDFS (RDF Schema)
rdfs:Resource– Todas as coisas descritas por RDF são recursos, e portanto instâncias da classe rdfs:Resource.
É a classe raiz de todas as outras (suas subclasses); http://www.w3.org/TR/rdf-schema/#ch_resource
rdfs:Class– É a classe dos recursos que são classes RDF.
http://www.w3.org/TR/rdf-schema/#ch_class
rdfs:Literal– Classe dos valores literais para propriedades, tais como strings e números inteiros.
É uma instância de rdfs:Class, e portanto uma subclasse de rdfs:Resource;
RDFS (RDF Schema)
rdfs:Property– É a classe das propriedades herdadas de RDF.
Instância de rdfs:Class;
rdfs:subClassOf– Usada para declarar que todas as
instâncias de uma classe são instâncias de outra classe.
Instância de rdfs:Property; É uma propriedade transitiva;
RDFS (RDF Schema)
Definição de classe.Sujeito: identificação de classe; Predicado: rdf:type;
Objeto: rdfs:Class;
Exemplo: xml:base ex
Tripla: ex:MotorVehicle rdf:type rdfs:Class RDF/XML:
<?xml version=“1.0”?>
<rdf:RDF xmlns:rdf=“http://www.w3.org/1999/02/22-rdf-syntax-ns#”> <rdf:Description rdf:ID=“MotorVehicle”>
<rdf:type rdf:resource=“http://www.w3.org/2000/01/rdf-schema#Class”/> </rdf:Description>
RDFS (RDF Schema)
Definição de subclasse.Sujeito: identificação da subclasse; Predicado: rdfs:subClassOf; Objeto: identificação da superclasse;
Exemplo: xml:base ex
Tripla: ex:Van rdf:type rdfs:Class
ex:Van rdfs:subClassOf ex:MotorVehicle
RDFS (RDF Schema)
Exemplo:RDFS (RDF Schema)
<rdf:RDF xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#" xmlns:rdfs="http://www.w3.org/2000/01/rdf-schema#" xml:base="http://example.org/schemas/vehicles"> <rdf:Description rdf:ID="MotorVehicle"> <rdf:type rdf:resource="http://www.w3.org/2000/01/rdf-schema#Class"/> </rdf:Description> <rdf:Description rdf:ID="PassengerVehicle"> <rdf:type rdf:resource="http://www.w3.org/2000/01/rdf-schema#Class"/> <rdfs:subClassOf rdf:resource="#MotorVehicle"/> </rdf:Description> <rdf:Description rdf:ID="Truck"> <rdf:type rdf:resource="http://www.w3.org/2000/01/rdf-schema#Class"/> <rdfs:subClassOf rdf:resource="#MotorVehicle"/> </rdf:Description> <rdf:Description rdf:ID="Van"> <rdf:type rdf:resource="http://www.w3.org/2000/01/rdf-schema#Class"/> <rdfs:subClassOf rdf:resource="#MotorVehicle"/> </rdf:Description> <rdf:Description rdf:ID="MiniVan"> <rdf:type rdf:resource="http://www.w3.org/2000/01/rdf-schema#Class"/> <rdfs:subClassOf rdf:resource="#Van"/> <rdfs:subClassOf rdf:resource="#PassengerVehicle"/> </rdf:Description> </rdf:RDF>RDFS (RDF Schema)
Definição de instância de classe.Sujeito: recurso identificando a instância da classe; Predicado: rdfs:type;
RDFS (RDF Schema)
Exemplo: xml:base exTripla: ex:companyCar rdf:type ex:MotorVehicle RDF/XML: <rdf:RDF xmlns:rdf=“http://www.w3.org/1999/02/22-rdf-syntax-ns#” xmlns:ex=“http://example.org/schemas/vehicles”> <rdf:Description rdf:ID=“companyCar”> <rdf:type rdf:resource=“http://example.org/schemas/vechicles#MotorVehicle”/> </rdf:Description> </rdf:RDF> Formatos alternativos: <rdf:type rdf:resource=“ex:#MotorVehicle”/> <rdf:type rdf:resource=“#MotorVehicle”/>
RDFS (RDF Schema)
Definição de propriedade.Sujeito: recurso identificando o nome da propriedade; Predicado: rdfs:type;
Objeto: rdf:property;
Exemplo:
RDFS (RDF Schema)
Definição de domínio de uma propriedade. Sujeito: recurso identificando o nome da propriedade; Predicado: rdfs:domain;
Objeto: recurso identificando o nome de uma classe;
Exemplo:
ex:Book rdf:type rdfs:Class ex:author rdf:type rdf:Property ex:author rdfs:domain ex:Book
RDFS (RDF Schema)
Definição de range (contradomínio) de uma propriedade. Sujeito: recurso identificando o nome da propriedade;
Predicado: rdfs:range;
Objeto: recurso identificando o nome de uma classe ou o nome de um XSD dataype;
Exemplo:
ex:Person rdf:type rdfs:Class ex:author rdf:type rdf:Property ex:author rdfs:range ex:Person ex:age rdf:type rdf:Property ex:age rdfs:range xsd:integer xsd:integer rdf:type rdfs:Datatype
RDFS (RDF Schema)
Exemplo: <rdf:Description rdf:ID="registeredTo"> <rdf:type rdf:resource="http://www.w3.org/1999/02/22-rdf-syntax-ns#Property"/> <rdfs:domain rdf:resource="#MotorVehicle"/> <rdfs:range rdf:resource="#Person"/> </rdf:Description> <rdf:Description rdf:ID="rearSeatLegRoom"> <rdf:type rdf:resource="http://www.w3.org/1999/02/22-rdf-syntax-ns#Property"/> <rdfs:domain rdf:resource="#PassengerVehicle"/><rdfs:range rdf:resource="http://www.w3.org/2001/XMLSchema#integer"/> </rdf:Description>
<rdf:Description rdf:ID="Person">
<rdf:type rdf:resource="http://www.w3.org/2000/01/rdf-schema#Class"/> </rdf:Description>
<rdf:Description rdf:about="http://www.w3.org/2001/XMLSchema#integer"> <rdf:type rdf:resource="http://www.w3.org/2000/01/rdf-schema#Datatype"/> </rdf:Description>
RDFS (RDF Schema)
Exemplo (formato alternativo):<rdf:Property rdf:ID="registeredTo"> <rdfs:domain rdf:resource="#MotorVehicle"/> <rdfs:range rdf:resource="#Person"/> </rdf:Property> <rdf:Property rdf:ID="rearSeatLegRoom"> <rdfs:domain rdf:resource="#PassengerVehicle"/> <rdfs:range rdf:resource="&xsd;integer"/> </rdf:Property> <rdfs:Class rdf:ID="Person"/> <rdfs:Datatype rdf:about="&xsd;integer"/>
RDFS (RDF Schema)
Definição de sub-propriedade.Sujeito: recurso identificando o nome da sub-propriedade; Predicado: rdfs:subPropertyOf;
Objeto: recurso identificando o nome da super-propriedade;
Exemplo:
ex:driver rdf:type rdf:Property
ex:primaryDriver rdf:type rdf:Property ex:primaryDriver rdfs:subPropertyOf ex:driver <rdf:Property rdf:ID="driver"> <rdfs:domain rdf:resource="#MotorVehicle"/> </rdf:Property> <rdf:Property rdf:ID="primaryDriver"> <rdfs:subPropertyOf rdf:resource="#driver"/> </rdf:Property>
RDFS (RDF Schema)
Exemplo, dois formatos XML/RDF:<rdf:Property rdf:ID="driver"> <rdfs:domain rdf:resource="#MotorVehicle"/> </rdf:Property> <rdf:Property rdf:ID="primaryDriver"> <rdfs:subPropertyOf rdf:resource="#driver"/> </rdf:Property> <rdf:Description rdf:ID="driver">
<rdf:type rdf:resource= "http://www.w3.org/1999/02/22-rdf-syntax-ns#Property"/>
<rdfs:domain rdf:resource="#MotorVehicle"/> </rdf:Description>
<rdf:Description rdf:ID="primaryDriver">
<rdf:type rdf:resource= "http://www.w3.org/1999/02/22-rdf-syntax-ns#Property"/>
RDFS (RDF Schema)
Definição de instância de propriedade.
Sujeito: recurso identificando uma instância de alguma classe; Predicado: nome da propriedade;
Objeto: recurso identificando uma instância de alguma classe, ou literal indicando o valor da propriedade;
Exemplo:
ex:JohnSmithsCar ex:registeredTo ex:85740
RDFS (RDF Schema)
Exemplo, formato 1 em XML/RDF: <rdf:RDF xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#" xmlns:ex="http://example.org/schemas/vehicles#" xml:base="http://example.org/things"> <ex:PassengerVehicle rdf:ID="johnSmithsCar"> <ex:registeredTo rdf:resource="http://www.example.org/staffid/85740"/> <ex:rearSeatLegRoom rdf:datatype="&xsd;integer">127</ex:rearSeatLegRoom> <ex:primaryDriver rdf:resource="http://www.example.org/staffid/85740"/> </ex:PassengerVehicle> </rdf:RDF>RDFS (RDF Schema)
Exemplo, formato 2 em XML/RDF: <rdf:RDF xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#" xmlns:ex="http://example.org/schemas/vehicles"> <rdf:Description rdf:ID="johnSmithsCar"> <rdf:type rdf:resource="http://example.org/schemas/vehicles#PassengerVehicle"/> <ex:registeredTo rdf:resource="http://www.example.org/staffid/85740"/> <ex:rearSeatLegRoom rdf:datatype="http://www.w3.org/2001/XMLSchema#integer"> 127</ex:rearSeatLegRoom> <ex:primaryDriver rdf:resource="http://www.example.org/staffid/85740"/> </rdf:Description> </rdf:RDF>RDFS (RDF Schema)
Pode ser vista como uma linguagem para descrever
conhecimento muito simples;
Porém existe muito tipo de conhecimento que não pode ser
expresso em tal linguagem.
Exemplo: afirmar que cada livro tem um único título e pelo menos um autor; afirmar que um livro tem que ter capa dura ou capa “normal”;
Para expressar o conhecimento necessário ao
desenvolvimento de uma web semântica se faz necessário desenvolver uma linguagem mais expressiva, o que é feito na próxima camada: Vocabulário para Ontologia.
Referências Bibliográficas
BREITMAN, K. Web semântica – a internet do Futuro. LTC, 2005. ISBN 85-216-1466-7. Capítulo 4 – Como representar? Linguagens para representação de Ontologias.
WWW Consortium – RDF e RDFS –http://www.w3.org/rdf e http://www.w3.org/TR/rdf-schema/
Destaque para: http://www.w3.org/TR/rdf-primer/e
http://www.w3.org/TR/2004/REC-rdf-concepts-20040210/
Seminário: Semantic Web Applications. Disponível em: http://www.tecweb.inf.puc-rio.br/semweb/space/RDF
STAAB, S., STUDER, R. (editors). Handbook on Ontology. Springer, 2009. Part 1 – Ontology Representation Languages – Resource Description Framework.
