RDF applications often need to describe a statement without asserting it universally, then qualify a review, policy, or domain claim by the context in which it applies. The Inferal Scoped Statements Ontology distinguishes exact RDF quad targets, reusable groups of targets, applicability resources, and the values claimed within those scopes. It supports publishers and consumers that need to exchange, validate, and interpret context-dependent claims without collapsing target identity, applicability, and claim meaning into one relation. A scope can be supplied by any domain vocabulary, including range and versioning vocabularies, but this ontology does not define range or version semantics.

This is an unofficial 0.1 Editor's Draft maintained in the Inferal ontology repository. It is written as a ReSpec source document so it can later be exported as static HTML if the ontology is advanced toward a formal publication process.

Feedback should be sent to contact@inferal.com.

This specification defines three conformance classes: scoped statements data graph, claim consumer, and claim producer.

A scoped statements data graph is an RDF graph that uses the terms defined in this specification consistently with the normative requirements below, including the validation expectations in . Machine-readable SHACL artifacts MAY be used to test those requirements, but this specification is the self-contained normative description of the 0.1 validation surface.

A claim producer is software or an authoring process that emits quad targets, quad groups, and scoped claims. A conforming producer MUST emit enough target, scope, and claim-value information for a consumer to identify the target and applicability context.

A claim consumer is software that reads scoped claims. A conforming consumer MUST NOT treat this ontology alone as defining whether an arbitrary scope applies. Scope interpretation comes from the vocabulary or application contract that defines the scope resource. A consumer MUST NOT treat this ontology alone as defining the meaning of every ss:claimValue; those meanings come from application vocabularies, policy vocabularies, or domain-specific ontologies.

Introduction And Audience

A named graph can identify where RDF is stored, and an RDF reifier can identify a triple, but neither construct by itself says that a review, policy classification, vulnerability status, or replacement decision applies only in some separately modeled context. Encoding all three concerns in one application-specific predicate makes it difficult to compare claims, reuse scopes, or validate that producers supplied the complete target.

This specification is for RDF publishers that describe context-dependent claims, vocabulary authors that define reusable applicability or claim-value resources, validators that check the structural exchange contract, and consumers that select or explain claims. It gives those actors a shared target-and-claim model while leaving domain-specific scope evaluation and conflict resolution to the vocabularies and policies that own them.

Competency Questions

A conforming graph and the relevant scope vocabulary are intended to support the following questions:

1. Which RDF subject, predicate, object, and optional graph identify the exact target of a claim?
2. Which exact quad targets are collected into a target that can be reviewed or selected as a unit?
3. For a scoped claim, what is the target, which resource defines applicability, and what resource represents the claim's meaning?
4. Can a graphless quad target be exposed as an RDF 1.2 reifier without losing the scoped-statements decomposition?
5. Which structural defects can SHACL reject without pretending to evaluate the truth, applicability, or precedence of a claim?

The quad-target, quad-group, claim-pattern, RDF 1.2 bridge, and validation sections answer these questions respectively. Evaluating a particular scope, such as deciding whether a version lies within a version range, requires the semantics and processing contract of the vocabulary that defines that scope.

Conceptual Model

The model separates a target from a claim about that target. A quad target records the RDF terms of one triple or named-graph quad. A quad group names a collection of those targets. Both are kinds of scoped target, so either can be the object of a claim without erasing whether the target is atomic or grouped.

A scoped claim is a separate resource with three independent relations: its claim target, its scope, and its claim value. The target says what the claim concerns; the scope identifies the external applicability context; and the claim value identifies the classification or meaning asserted in that context. None of these relations substitutes for either of the others.

Describing a target does not assert the targeted quad, and making a scoped claim does not prove the target true. Likewise, SHACL conformance does not establish that a scope applies or that a claim value should win over a conflicting value. RDFS domain and range statements can infer target and claim types from property use, but they do not enforce completeness or uniqueness; those closed-world conditions belong to the validation contract.

Target resource identity is also distinct from quad decomposition. The ontology does not declare an OWL key, so two target resources with the same subject, predicate, object, and graph terms are not inferred to be identical. Applications that need canonical target IRIs MUST define a deterministic identity policy outside this vocabulary.

Namespaces

This specification defines the normative vocabulary and behavior for the scoped statements namespace. Domain vocabularies such as SPDX Core can appear in source facts and examples, but this ontology does not import or specialize those vocabularies. Implementations MAY publish equivalent machine-readable RDF, OWL, or SHACL artifacts, but readers do not need repository-local files to understand or implement scoped statements 0.1.

Term Index

Scope And Non-Goals

This ontology identifies RDF facts and attaches scoped claim resources to them. It does not replace RDF reification, RDF-star, named graphs, or nanopublications. It can be used alongside those patterns when a project needs explicit statement targets and reusable applicability scopes.

A ss:ScopedClaim does not, by itself, assert that the targeted quad is true in the data graph. It asserts that the resource in ss:claimValue applies to the target within the scope identified by ss:scope. A claim value such as ex:reviewed, ex:vulnerable, or ex:deprecated gets its operational meaning from the vocabulary that defines that resource.

A ss:QuadTarget is an explicit description of the RDF terms that identify a target statement or quad; it is not declared equivalent to rdf:Statement, RDF 1.2 triple terms, RDF-star quoted triples, named-graph assertions, or nanopublication assertions. Projects MAY derive an rdf:Statement, quoted triple, named graph, or nanopublication view from a quad target when their local model requires one, but this ontology does not require that derived representation and does not infer the targeted assertion from the target resource.

Quad Targets

A ss:QuadTarget identifies one RDF quad by subject, predicate, object, and optional graph term. A quad target MUST have exactly one ss:subjectTerm value and exactly one ss:predicateTerm value. The predicate term MUST be an IRI.

A quad target MUST identify exactly one object form. It MUST have either exactly one ss:objectResourceTerm for an IRI or blank-node object, or exactly one ss:objectLiteralValue for a literal object. It MUST NOT use both object forms.

A literal object value MUST preserve the RDF literal's lexical form, datatype IRI, and language tag when those are present in the source RDF term. A claim producer SHOULD use normal RDF literal syntax in Turtle so the datatype and language tag are carried by the literal itself.

Subject terms and resource object terms MAY be blank nodes. Producers SHOULD avoid blank nodes for long-lived published targets unless the blank-node identity is stable within the dataset where the claim is interpreted.

A quad target MAY have at most one ss:graphTerm. If ss:graphTerm is present, it identifies the named graph whose identity is part of the target and MUST be an IRI or blank node, as permitted for RDF 1.2 graph names [[RDF12-CONCEPTS]]. If it is absent, the target carries no named-graph identity. Absence of ss:graphTerm MUST NOT be treated as a wildcard that matches every named graph.

RDF 1.2 Reifier Bridge

For graph-free targets, a claim producer MAY expose an ss:QuadTarget as an RDF 1.2 reifier by adding an rdf:reifies triple to the same target resource [[RDF12-TURTLE]]. This is an augmentation, not a replacement: the ss:subjectTerm, ss:predicateTerm, and object-form properties remain the conforming scoped-statements representation.

A claim consumer MAY decompose graphless RDF 1.2 reifiers into ss:QuadTarget form when the reified triple term has an IRI, blank-node, or literal object. Literal objects map to ss:objectLiteralValue; IRI and blank-node objects map to ss:objectResourceTerm. Consumers SHOULD NOT synthesize an ss:QuadTarget from a reifier whose triple-term object is itself a triple term unless a later scoped-statements version defines an object form for nested triple terms.

When ss:graphTerm is present, RDF 1.2 reifier augmentation still preserves all data by leaving the IRI or blank-node graph name on the target node. The RDF 1.2 triple term itself has no graph slot, so RDF 1.2 term equality cannot preserve quad identity. A consumer that keys only on the triple term will treat two targets with the same subject, predicate, and object as the same reified triple even when their ss:graphTerm values differ. Consumers that need exact quad identity MUST use the ss:QuadTarget decomposition and ss:graphTerm value.

The module-local SPARQL 1.2 bridge queries are informative examples that use triple-term syntax and functions from SPARQL 1.2 [[SPARQL12-QUERY]].

Quad Groups

A ss:QuadGroup is a named collection of quad targets that can receive a single scoped claim. A quad group MUST have at least one ss:hasQuad relation to a ss:QuadTarget.

Producers SHOULD use quad groups when several RDF facts are reviewed, asserted, deprecated, superseded, or selected as a unit. Producers SHOULD keep each member as an explicit quad target so consumers can audit and render the group without knowing private application state.

The following source facts can be shown compactly with TriG graph-block syntax before they are targeted as explicit quad resources.

Scoped Claims

A ss:ScopedClaim connects a target, an applicability scope, and a claim value. A scoped claim MUST have exactly one ss:claimTarget value, exactly one ss:scope value, and exactly one ss:claimValue value. The target MUST be a ss:ScopedTarget. The scope value MUST be a resource, and its interpretation is supplied by the vocabulary or application contract that defines that resource.

A claim MUST have exactly one ss:claimValue. The claim value MUST be a resource. It SHOULD be an instance of a domain, policy, review, compatibility, or security vocabulary that defines what the claim means.

If two claims overlap on the same target and scope, this ontology does not choose a winner or define conflict resolution. Consumers MUST apply project-specific claim-value semantics, provenance, trust policy, or review workflow rules to interpret overlaps and conflicts.

Claim Patterns

The following examples use scopes from other vocabularies. They are informative patterns: this ontology only requires ss:scope to identify a resource.

Validation Expectations

A conforming scoped statements data graph MUST satisfy the following 0.1 validation requirements:

• Each ss:QuadTarget MUST have exactly one ss:subjectTerm value and exactly one ss:predicateTerm value.
• Each ss:QuadTarget MUST identify exactly one object form: exactly one ss:objectResourceTerm value or exactly one ss:objectLiteralValue value, but not both.
• Each ss:QuadTarget MAY have at most one IRI or blank-node ss:graphTerm value.
• Each ss:QuadGroup MUST have at least one ss:hasQuad relation to a ss:QuadTarget.
• Each ss:ScopedClaim MUST have exactly one ss:claimTarget value, exactly one ss:scope value, and exactly one ss:claimValue value.
• Each ss:claimTarget value MUST be a ss:ScopedTarget.
• Each ss:scope value MUST be a resource.
• Each ss:claimValue value MUST be a resource.

These SHACL constraints apply closed-world checks to resources selected as shape focus nodes; they do not close the RDF vocabulary or change its open-world RDFS and OWL meaning. The generic ss:ScopedTarget extension point intentionally has no standalone property constraints. Concrete ss:QuadTarget and ss:QuadGroup resources receive their respective shapes, and the scoped-claim shape checks that ss:claimTarget identifies a scoped target. A domain vocabulary MAY define another scoped-target subtype with its own structural contract.

SHACL validation does not evaluate scope semantics. Consumers that answer questions such as "does this claim apply at version V?" MUST use the semantics of the vocabulary that defines the scope resource, such as the Inferal Versioning range membership semantics when the scope is a ver:VersionRange.