RDF Abstract Syntax

Editors:

Jonathan Borden jonathan@openhealth.org

Pat Hayes phayes@ai.uwf.edu

Drew McDermott drew.mcdermott@yale.edu

This version: June 11, 2001

Latest version

Previous version: June 10, 2001

Introduction

This document defines an Abstract Syntax or Infoset for RDF [1]. RDF Statements are commonly refered to as triples of {predicate,subject,object}. In practice it is useful to group triples into sets of statements termed: Bundles.

This document has no official status.

Bundle

A Bundle is represented by an QName. A bundle is a list (ordered bag) of Statement triples <predicate,subject,object>. For each bundle the statement quadruple: <predicate,subject,object,context> is equivalent to the triple <predicate,subject,object>.

Statement

A Statement is represented by the 4-tuple: <predicate,subject,object,bundle> or consider a Bundle a list of Statements represented as triples <predicate,subject,object>

atom

An atom represents either an XML QName, according to XML Namespaces, or a variable matching the EBNF:

atom := (QName | quantifiedVariable| rowVariable | Statement)

quantifiedVariable := ('?' Name) Name as defined in XML 1.0

rowVariable := ('@' Name)

predicate

A predicate is a QName.

subject

A subject is an atom.

object

An object is an atom. Note that literal strings may be represented by the data: URI scheme.

bundle

A bundle is represented by a QName

Purpose of the Bundle

The bundle allows separation of statements into lists which can be asserted as a group. Bundles allow 'coloring' of subgraphs. The document from which a set of statements arises forms a bundle (represented by its URI). Bundles can 'contain' other bundles.

Abstract Syntax

There exists a set called QNames
There exists a set called QuantifiedVariables
There exists a set called RowVariables
There exists a set called AtomicNames where for all a in AtomicNames => (a in QNames) or (a in quantifiedVariables) or (a in rowVariables)
for all atomicName(x) <=> x in AtomicNames
There exists a set called Predicates where for all p in Predicates => atomicName(p)
There exists a set called Subjects where for all s in Subjects => atomicName(s)
There exists a set called Objects where for all o in Objects => atomicName(o)
There exists a set called Bundles where for all b in Bundles => atomicName(c)
There exists a set of Statements := {<predicate,subject,object,bundle>}

Examples:

The statement:

(not (says jon (color sky blue))

is represented by the Expression:

[not [says jon [color sky blue]]]

The Squish [2] query: (dc:creator, foo, ?x)(foaf:mbox, ?x, mailto:jonathan@openhealth.org)

is represented as:

<dc:creator,foo,?x,ctx-query>
<foaf:mbox,?x,mailto:jonathan@openhealth.org,ctx-query>

S Expressions

An s-expression :

(or a b c d)

may be represented in XML

<or rdf:parseType="daml:list">
 <a/>
 <b/>
 <c/>
 <d/>
</or>

In triple form:

[or a [etc b [etc c [etc d nil]]]]

abbreviated as:

[or a b c d]

Expressions

Expressions are collections of statements within a common context. An expression is a subgraph. The root or top level expression within a particular context are those statements which are not referred as the subject or object of any other statement within the context.

Is there a formal expression of this?