Primordial LX

Introduction

The primordial serialization is a simple format for subject-predicate-object (or thing-property-value) triples. These triples can function as a foundation for other languages and are useful in their own right as seen in the history of frame systems, semantic networks, and recent work on in RDF. This syntax is equivalent to RDF without literals.

This flavor of LX, like the primordial soup, is more a conceptual point-of-origin than something to actually produce or consume in quantity.

Names

Each of the three terms in each triple is a kind of name or identifier for something in the domain of discourse. Names are either internal, being local to the scope of the document, or external, being universally shared.

Internal names are roughly equivalent to existentially quantified variables whose scope is that of the document and to RDF bNodes. There are also very similar to programming language identifiers which are local to a compilation unit.

External names follow the URI-Reference syntax and semantics [RFC 2396]. They to denote the same thing in all expressions in all documents where they occur as names. In their external form, they look like: http://www.example.com/animals#Dog or sometimes just http://www.example.com/animals

'<http://www.example.com/animals#Dog>'

triple('<http://www.w3.org/1999/02/22-rdf-syntax-ns#type>',
       '<http://www.w3.org/1999/02/22-rdf-syntax-ns#type>', 
       '<http://www.w3.org/1999/02/22-rdf-syntax-ns#Property>').

@external(rdf_*, "http://www.w3.org/1999/02/22-rdf-syntax-ns#").
triple(rdf_type, rdf_type, rdf_Property).

@external(rdf_*, "http://www.w3.org/1999/02/22-rdf-syntax-ns#").
exists t s (
  triple(t, rdf_type, rdf_Statement) &
  triple(t, rdf_subject s)
)

@local(t)
@local(s)
triple(t, rdf_type, rdf_Statement).
triple(t, rdf_subject s).

This grammar is written in blindfold's EBNF.

token(ws, comment, string, tripleKeyword, plainName, URIRef)
document ::= ( item "." )*
item ::= directive | formula
directive ::= "@local(" name ")"
            | "@external(" name "," string ")"
            | "@external(" name "*" "," string ")"
ws ::= [\n\r\t ]* @ignored
comment ::= "#[^\n]*" @ignored
formula ::= tightFormula | looseFormula
tightFormula ::= atomicFormula 
               | "(" formula ")"
looseFormula ::= formula "&" formula
               | "exists" namelist tightFormula
atomicFormula ::= tripleKeyword "(" name "," name "," name ")"
tripleKeyword ::= "triple"
name ::= ( plainName | URIRef )     # disjoint from tripleKeyword
plainName ::= [_a-zA-Z][_a-zA-Z0-9]*
URIRef ::= "'<" [^ ()[]<>{}] ">'"          # should be more detailed
namelist ::= plainName ( "," plainName )*

Restrictions not shown in this grammar:

1. All plainNames must be introduced before being used. They can be introduced for the rest of the document by a directive, or for one formula scope by an "exists". "exists" may not re-introduce an already introduced name; it increases the potential for confusion (especially with external names) for no demonstrated benefit.
2. The predicate (middle) name in an atomicFormula must be external. This is an unpleasant bit of RDF we need to put here for full compatibility.

Semantics

The semantics of Primordial are exactly those of this syntactic subset of Vanilla. Existentials quantification and conjunction have their usual classical meaning. Multiple formulas in a document are considered to be conjoined.

Issues

@include

It's tempting to add @import(f, uri) which makes f be the logical formula available at the given URI, or some other inclusion mechanism, but maybe this is better done with log:semantics, where uri can be a variable.

Maybe we can at least have @include so we don't need huge lists of @externals in every file?

Triple as Binary Atomic Sentence

It's very tempting to use p(s,o) instead of triple(s, p, o). We would get rid of the ugly "triple" keyword. And it would make the RDF restriction of having no bNode predicates seem right.

But it would mean we couldn't even axiomatize RDFS. We could use a fake higher-order syntax, and "lower" everything with a "holds" predicate before doing FOL reasoning, but then it would hardly be Vanilla.

Declaring Universal Variables

In Vanilla, we often want document-scope universally-quantified variables. Can we do that like @internal? Maybe @variable? Or just use all-caps like Prolog?

A Better Syntax for Full Externals

Maybe uriref('<.....>') would allow better evolution and not use up single-quotes? It's still OTTER compatible, although it might slow things down a little. But it would not be usable for naming functions and predicates in Vanilla. Or we could just do <...> and have the directive preprocessor handle it. Is that disjoint enough from greater-than and less-than? One can also put in a space to make it distinct, I guess.

Internal Names for Prediciates

Is this okay? Not in RDF. At what level...?

Blindfold Grammar

What should the bf grammar translate to? Maybe primordial without directives or internal names, ie Pure Otter? Handling the directives itself is probably beyond blindfold. Hrm.

Other Grammar

How about pointing us at SOME kind of parser for this, which turns it into a suitable OTTER formula list? It can have a flag on whether to expand or ignore @external declarations.