OWL 2 Construct Coverage

Ontopoiesis's projection covers the full OWL 2 structural specification. Every axiom, class expression, data range, property expression, and annotation construct from the specification has a corresponding entry in the construct registry.

Each construct is stored as a node in the projection with a kind property you use to query it. The kind strings match the OWL 2 specification names directly, so if you know the OWL 2 name you already know the Cypher kind.

Jump to:

• Entities
• Literals
• Class axioms
• Object property axioms
• Data property axioms
• Keys and datatype definitions
• Assertion axioms
• Annotation axioms
• Class expressions
• Data ranges
• Property expressions
• Ontology structure
• Node and edge properties
• Structural edge roles
• Node identifiers
• What is out of scope
• Querying by construct kind

Entities¶

Named entities with IRI identity. Every entity also produces a Declaration axiom node.

Literals¶

Literal values are a single node kind. All three literal forms from the OWL 2 structural specification share it, distinguished by which properties are set.

Literal node properties:

The string value is val.text regardless of form — no COALESCE across kinds needed.

Class axioms¶

Object property axioms¶

Data property axioms¶

Keys and datatype definitions¶

Assertion axioms¶

Annotation axioms¶

Annotation axioms are full axiom nodes, not metadata attached to other nodes. Axiom-level annotations attach as Annotation children (edge role annotation) of any axiom node.

Class expressions¶

Object property class expressions:

Data property class expressions:

Data ranges¶

Property expressions¶

Ontology structure¶

These construct kinds appear in every projection as document-level structure. They are not axioms and have no standalone representation in OWL document round-trips.

Node and edge properties¶

Every node in the projection carries kind and uid. Named entities also carry iri. Beyond those, several construct types carry additional properties:

Named entities¶

Literals¶

Annotation assertions¶

An AnnotationAssertion has no subject property. Its subject is an edge (role subject) to an IRI node whose text holds the annotated entity's IRI:

MATCH (ax:N {kind: 'AnnotationAssertion'})-[:E {role: 'subject'}]->(s:N)
WHERE s.text = 'http://example.org/MyClass'

To join straight to the labelled entity instead, use the derived annotation_value edge (see derived relations), which connects the entity node directly to the literal.

Ontology and document nodes¶

Edges¶

position is present on every edge and is what serialization round-trips. Query it to recover the order of an ordered field, such as property chain steps:

MATCH (:N {kind: 'ObjectPropertyChain'})
      -[link:E {role: 'operand'}]->(step:N)
RETURN step.iri AS step, link.position AS position
ORDER BY position

Structural edge roles¶

The tables below make constructs.md the single lookup for which edge roles a construct uses in the projection. Roles are the short query-facing names assigned by the parent kind and child position; the canonical source is the Ontoplexis edge-roles reference. Where a role appears more than once (n-ary operands, chain steps), the edges are distinguished by position.

Common class and property axioms¶

Assertions and annotation axioms¶

Expressions and data ranges¶

Ontology structure¶

The Ontology node is the document root. Its children take a role by kind — prefix, import, annotation, or axiom — rather than a single list role. There is no separate OntologyDocument node in the projection.

Node identifiers¶

Every node in the projection carries a uid, assigned in document order (n0, n1, …) on each build. Named entities and leaf values are deduplicated to one node, but the ids are positional and not stable across rebuilds — use iri as the durable identifier for named entities. Migrations get a separate, deterministic id from the scalar_uid / axiom_uid helpers. See The Projection Graph Model.

What is out of scope¶

SWRL rules. SWRL (Semantic Web Rule Language) rules are not part of the OWL 2 structural specification. Ontopoiesis does not represent them. If an ontology document contains SWRL rules, they are not represented in the projection.

Import resolution. owl:imports declarations are faithfully captured as Import nodes, but ontopoiesis build does not fetch imported ontologies or merge their constructs into the projection. Ontopoiesis also does not yet provide a graph-native import model that preserves imported ontologies as distinct structural units with explicit cross-document semantics inside one projection.

OWL Full. The OWL 2 structural specification — and therefore Ontopoiesis — does not cover the RDF-level semantics of OWL Full. Constructs that exist only under OWL Full's RDF semantics have no representation in the projection — this includes metamodeling beyond standard punning and full RDF reification.

Querying by construct kind¶

Every node in the projection carries a kind property. Use it to filter by construct type:

MATCH (n:N {kind: 'SubClassOf'}) RETURN count(*) AS count;
MATCH (n:N {kind: 'ObjectSomeValuesFrom'}) RETURN count(*) AS count;
MATCH (n:N) WHERE n.kind IN ['ObjectMinCardinality', 'ObjectMaxCardinality', 'ObjectExactCardinality']
RETURN n.kind AS kind, count(*) AS count ORDER BY kind;

To see every kind present in a given projection:

MATCH (n:N) RETURN DISTINCT n.kind AS kind ORDER BY kind