Towards an Effective Extension of Activity Streams

Abstract

Activity Streams is a data format designed to describe activities. Although its specification is written in natural language, its core vocabulary is formally defined in an OWL (Web Ontology Language) ontology. In this work, we propose a set of additional OWL axioms to extend the existing ontology, with the goal of enabling more detailed, precise, and machine-interpretable descriptions of Activity Streams. This enhancement aims to support real-world applications, such as those related to automatic test generation from OWL specifications.

Keywords

activity streams OWL test-driven development software testing

1. Introduction

Activity Streams, as described by Snell and Prodromou (2017a), is a data format for describing activities in a rich, human-friendly, yet machine-processable and extensible manner. It is specified as a JSON-LD serialization (Lanthaler & Gütl, 2012; Sporny et al., 2020) of the Activity Vocabulary (Snell & Prodromou, 2017b). As is common in many specifications, the Activity Vocabulary is defined in a natural language document that enumerates the classes and properties used to represent activities. In addition to this normative specification, a non-normative OWL (Web Ontology Language) ontology (W3C, 2017) is provided to formalize the vocabulary in a machine-interpretable way.

Adopting OWL for specifications is highly desirable, as it enables the reuse of the extensive tools and technologies developed by the Semantic Web community over the years. For instance, reasoning techniques—implemented in tools known as reasoners (Glimm et al., 2014; Sirin et al., 2007)—can be used to automatically detect logical inconsistencies that may be overlooked when specifications are written solely in natural language. Additionally, reasoning engines can infer implicit knowledge from Semantic Web knowledge bases. Finally, OWL classes and properties can be integrated into object-oriented software through Ontology-to-Object-Mapping frameworks, such as the JOPA software suite described by Ledvinka and Křemen (2015).

The more detailed the OWL definitions in the ontology, the more valuable the ontology becomes for software developers, analysts, researchers, and other stakeholders. Indeed, OWL expressive power can be leveraged to define domain entities and their relationships precisely, thereby clarifying their roles and intended use.

However, the current Activity Streams specification does not fully support these capabilities, due to the flat structure of its ontological model. Although several features are described informally in the natural language specification, they are not captured in the accompanying OWL ontology. Consequently, the format exhibits several ambiguities that have surfaced over time, as reflected in the errata currently under discussion (W3C ActivityStreams Working Group, 2025).

In this contribution, we propose an extension of Activity Streams that introduces additional axioms intended to formally capture aspects of the Activity Vocabulary, aimed at identifying and resolving existing ambiguities and inconsistencies.

Naturally, some of the proposed axioms may be disputable, as they necessarily reflect interpretations of natural-language descriptions. However, as shown in Section 4, the resulting reasoning capabilities enable a systematic assessment of the intended semantics of Activity Vocabulary items, by comparing inferred statements against an arbitrarily large collection of test scenarios. Along similar lines, one can generate automated tests in advance for Activity Streams—enabled software, covering an exhaustive range of scenarios in accordance with the test-driven development methodology presented by Beck (2003 - 2003) and illustrated in Section 5.

We adopt the Description Logic syntax (Baader et al., 2003) to represent classes, properties, and expressions, while property assertions are written in infix notation. When inline, property assertions latter may come enclosed in apices. To improve readability, we use distinct font styles for different types of Description Logic terms: Classes, properties , and individuals.

The remainder of the article is organized as follows. Section 2 introduces the main concepts of Activity Streams. Section 3 presents the OWL encoding of the Activity Vocabulary. Section 4 proposes additional axioms for Activity Vocabulary terms and discusses the benefits of adopting them. Section 5 describes a case study on collections management, illustrating the advantages of the proposed extension. Finally, Section 6 concludes the article and outlines potential directions for future research.

2. Activity Streams

This section briefly summarizes the core concepts of the Activity Streams format, as defined by Snell and Prodromou (2017a, 2017b). All Activity Streams entities belong to the namespace https://www.w3.org/ns/activitystreams#, which is assumed to be the default namespace throughout the remainder of this article. The elements of Activity Streams are organized into a class hierarchy rooted in two top-level classes: Object and Link. As reported by Snell and Prodromou (2017a), Object is the primary base type for the Activity Streams vocabulary: all concepts related to the domain of activities are modeled using the Object class, its subclasses, and the properties that connect their instances. In contrast, the class Link, which is disjoint from Object, represents qualified references to Web resources. It is intended for entities outside the Activity Streams domain and allows linking an instance of Object to a Web resource while also providing additional information about how that resource should be fetched and consumed.

The Activity Vocabulary defines several subclasses of Object, which can be grouped into the following categories:

Collections, represented by the class Collection (a subclass of Object), describes a set of objects or links. Its subclass OrderedCollection is intended for collections whose members are “assumed to be strictly ordered.”

The Activity Vocabulary provides two mechanisms for identifying collection members: the items property and collection pages, represented as instances of the class CollectionPage, which is itself a subclass of Collection. Collection pages are intended to facilitate exploration and item lookup in huge collections; in practice, they are simply subsets of a collection.

A collection object refers to its first and last pages using the first and last properties, respectively. In addition, the Activity Vocabulary provides a current property to indicate “the page that contains the most recently updated member items.” However, the notion of “most recently updated items” is underspecified. It is also constrained by the fact that current is functional, hence the set of most recently updated items must fit within a single page. In addition, in light of this functionality, it is unclear how to handle collections whose most recently updated items occur across multiple pages.

Each page links back to its parent collection via the partOf property, and all pages of a collection are chained together in a doubly-linked list via the prev and next properties.

Activities, represented by the class Activity (a subclass of Object), denote actions. The Activity Vocabulary defines—though is not limited to—a set of predefined subclasses of Activity for representing social Web interactions, such as Accept, Follow, and others.

Actors are entities capable of performing activities. The Activity Vocabulary provides five specific actor types: Application, Group, Organization, Person, and Service. Unlike activities, these actor types do not share a common superclass.

Finally, the Activity Vocabulary includes an additional set of predefined objects and links, such as Article and Audio. These are primarily domain-specific entities that are typically distributed among actors through activities.

3. The OWL Ontology for Activity Streams

This section analyses the OWL encoding of Activity Streams, as presented by W3C (2017). The ontology includes all classes and properties defined in the Activity Vocabulary, with the sole exception of the orderedItems property, which we discuss separately.

As customary, the class hierarchy is expressed via subclass axioms. Some classes are further constrained by class restrictions. For example, IntransitiveActivity is defined as a subclass of Activity and is constrained to have no object property. Similarly, OrderedCollection is defined as a subclass of Collection, with the range of the items property restricted to OrderedItems. This, however, diverges from the Activity Vocabulary, which mentions a property orderedItems (not present by Snell and Prodromou (2017a, 2017b)), while the class OrderedItems is not mentioned at all in the vocabulary. In view of this discrepancy, we exclude ordered collections from our analysis until their intended definition is clarified.

Domain and ranges are specified for all properties. In some cases, such as current , properties are also declared functional. For most properties, the range is defined as $Object ⊔ Link$ .

Let us consider the class Link. Its intended semantics can be summarized as follows: when an instance of Link occurs as the object of a property assertion, it is meant to establish—via the same property—a relation between the subject of the assertion and the resource specified by the link via the href property. For instance, consider the following two assertions: “ $activity a c t o r link$ ,” “ $link h r e f webResource$ .” Under this intended semantics, one would expect these assertions to entail the direct statement “ $activity a c t o r webResource$ ’ suggesting an axiom of the form $a c t o r \circ h r e f ⊑ a c t o r$ . Unfortunately, such an axiom is not expressible in OWL, since href is defined as a data-type property. Similar limitations arise for all properties whose range includes Link or its subclasses. For this reason, we do not further investigate the semantics of Link in this article.

4. Additional Axioms From the Activity Vocabulary

As mentioned above, the Activity Vocabulary provides textual descriptions for all Activity Streams classes and properties.

The SABiO methodology (Falbo, 2014) is adopted to elicit and formalize competency questions (Monfardini, 2023) for the Activity Vocabulary (Snell & Prodromou, 2017a, 2017b). The analysis is intentionally restricted to competency questions that can be directly derived from the normative descriptions provided in the Activity Vocabulary. For example, the Notes field associated with the class Create states: “Indicates that the actor has created the object.” This description entails that every instance of Create is required to be related to at least one actor and at least one object.

On the basis of these competency questions, and assuming that the relevant classes and properties had already been identified by W3C (2017), we derived a corresponding set of OWL axioms, forming the reference ontology. For practical reasons, we removed one role-chain axiom from the reference ontology, thus obtaining the operational ontology. The axioms in the operational ontology are detailed in this section. The full set of competency questions, together with both the reference and the operational ontology and the examples discussed throughout the article, are available at Longo et al. (2025).

The conventions adopted for presenting and exemplifying these axioms are outlined next. The proposed axioms are grouped into tables, one for each category of items enumerated in the Activity Vocabulary. Each table is further organized into sections, separated by horizontal lines, each representing a set of axioms. Some sections consist of a single axiom, for example, the first section of Table 1. Others represent multiple axioms using a shorthand: each class and property on the left-hand side is related through the relation symbol shown in the central column ( $⊑$ or $\equiv$ ) to each class and property on the right-hand side. For example, the second section of Table 2 represents the following axioms:

\begin{array}{ll} Add ⊑ \exists (a c t o r) . ⊤, & Announce ⊑ \exists (a c t o r) . ⊤, \\ Add ⊑ \exists (o b j e c t) . ⊤, & Announce ⊑ \exists (o b j e c t) . ⊤, \\ Add ⊑ \exists (t a r g e t) . ⊤, & Announce ⊑ \exists (t a r g e t) . ⊤ . \end{array}

Table 1.
Proposed Additional Axioms for Collections.

$p a r t O f \circ i t e m s$ $⊑$ items

first , current , last $⊑$ ${p a r t O f}^{-}$

prev $\equiv$ ${n e x t}^{-}$

Collection $⊑$ $\forall (f i r s t) . \forall (p r e v) . ⊥, \forall (l a s t) . \forall (n e x t) . ⊥$

Table 2.

Proposed Additional Axioms for Activities.

Accept, Create, Delete, Follow, Ignore,
Join, Leave, Like, Offer, Reject, Remove,	$⊑$	$\exists (a c t o r) . ⊤$ , $\exists (o b j e c t) . ⊤$
Undo, Update, View, Listen, Read, Flag,
Dislike
Add, Announce	$⊑$	$\exists (a c t o r) . ⊤$ , $\exists (o b j e c t) . ⊤$ , $\exists (t a r g e t) . ⊤$
Arrive	$⊑$	$\exists (a c t o r) . ⊤$ , $\exists (l o c a t i o n) . ⊤$
Invite	$⊑$	$\exists (t a r g e t) . ⊤$
Move	$⊑$	$\exists (a c t o r) . ⊤$ , $\exists (o b j e c t) . ⊤$ , $\exists (o r i g i n) . ⊤$
		$\exists (t a r g e t) . ⊤$
Travel	$⊑$	$\exists (a c t o r) . ⊤$ , $\exists (o r i g i n) . ⊤$ , $\exists (t a r g e t) . ⊤$
Question	$⊑$	$\neg (\exists (a n y O f) . ⊤ ⊓ \exists (o n e O f) . ⊤)$

Most of the axioms we propose are existential restrictions of the form:

Class ⊑ \exists (p r o p e r t y) . ⊤ .

(1)

Property ranges are left unspecified (we use the class

⊤

of all OWL individuals), since they are already defined by W3C (2017).

Axioms of the form (1) are not particularly informative for inferring implicit facts about named individuals. For example, when an automated agent processes a Create activity with no actor , it may satisfy the axiom by postulating the existence of some (unnamed) actor related via actor , and nothing more. Nevertheless, such axioms are useful for human readers seeking to understand the intended usage of specific classes, and they can support code-generation tools in determining which fields should be mandatory in the corresponding data structures.

Other axioms have instead concrete consequences in terms of inferred assertions about individuals. Examples illustrating both asserted property statements (solid arrows labeled with the role name) and inferred ones (dashed arrows) are provided throughout the section; see, for instance, Figure 1.

Figure 1.

Page items are items of the parent collection.

In these examples, individuals labeled with c, p, o, and q—possibly followed by a number—should be interpreted as instances of the classes Collection, CollectionPage, Object, and Question, respectively.

In some cases, consistency checking can be used to verify the compliance of items with the Activity Streams format. Such axioms are particularly valuable for developers, as they can be used to create test cases that check whether the objects produced by their applications conform to the model. Examples of inconsistent configurations are provided in Figures 5 to 7.

The proposed axioms are examined next, starting with those related to collections, listed in Table 1.

The axioms in Table 1 derive from the description of collections provided by Snell and Prodromou (2017a, 2017b) and recalled in Section 2. We model collection pages so that the members of a page are also members of its parent collection, as illustrated in Figure 1. Note that pages are themselves instances of Collection, and can, therefore, be nested. The axiom involving items suffices to capture this recursive behavior, as shown in Figure 2.

Figure 2.

Collection pages may be themselves paged.

Naturally, the first , last , and current pages of a collection are parts of the collection itself, as illustrated in Figure 3.

Figure 3.

The first, current, and last pages of a collection are parts of the collection.

The axiom $p r e v \equiv {n e x t}^{-}$ specifies that prev and next are inverse properties, as exemplified in Figure 4.

Figure 4.

prev and next are inverses of each other.

Figure 5.

Non-compliant: The first page of a collection must have no predecessor.

Figure 6.

Non-compliant: The last page of a collection must have no successor.

Figure 7.

Not consistent: Question objects can’t have both anyOf and oneOf .

We also propose axioms enforcing that the first page of a collection has no predecessor and the last page has no successor. Examples of non-compliant configurations violating these axioms are shown in Figures 5 and 6.

Next, we consider the additional axioms proposed for activities, summarized in Table 2.

Most axioms in Table 2 are of the form (1) and follow directly from the descriptions provided in the Notes field in Snell and Prodromou (2017b). For instance, many activities are described by statements of the form “Indicates that the actor is doing something with the object ” (where “doing something” stands for the action performed by the actor), which entails that both actor and object are mandatory for the activity under consideration. This is captured by axioms $A ⊑ \exists (a c t o r) . ⊤$ and $A ⊑ \exists (o b j e c t) . ⊤$ , where $A$ is the activity under consideration. Note that the existential axioms for Invite with respect to the roles actor and object are not stated explicitly, as they are inherited from its declaration as a subclass of Offer by W3C (2017). Axioms for intransitive activity and for other properties (e.g., target ) are derived in an analogous way. The only exception is the axiom concerning Question. This axiom supports automated consistency checking by ensuring that no Question instance may simultaneously contain both anyOf and oneOf . A violating configuration is shown in Figure 7.

Finally, we consider predefined objects and links. Table 3 lists the additional axioms proposed for these items. As noted in Section 2, we introduce a single axiom for the class Link, requiring each instance to have (at least) one value for the href property. Since href is defined as functional, this requirement implies that each Link has exactly one href value. For predefined object and link subclasses, we apply the same methodology adopted for activities.

Table 3.

Proposed Additional Axioms for Predefined Objects and Links.

Link	$⊑$	$\exists (h r e f) . (xsd:anyURI)$
Relationship	$⊑$	$\exists (s u b j e c t) . ⊤$ , $\exists (o b j e c t) . ⊤$
Profile	$⊑$	$\exists (d e s c r i b e) . ⊤$

5. The Case Study of a Collection Manager

We now present a case study focused on collections, illustrating how the additional axioms proposed in Section 4 can be practically applied in particular within the software development process of an application that uses Activity Streams.

Suppose an engineer is tasked with developing a collection management application that supports the following commands:

$a d d I t e m (o, c)$ , which adds the Object o to the collection c;

$a d d P a g e (p, c)$ which adds the Page p to the collection c;

$g e t I t e m s (c)$ , which returns all the expected members of the collection c;

$g e t P a g e s (c)$ , which retrieves all the pages of the collection $c$ .

We assume that the input parameters o, c, and p are Activity Streams items serialized in JSON-LD, as requested by the Activity Streams specifications (Snell & Prodromou, 2017a). In other words, each of them represents a set of triples rooted in a single individual.

In this example, the engineer opts for an object-oriented implementation for efficiency reasons. The axioms proposed in this article enable the automatic generation of classes (in the object-oriented programming sense) corresponding to Activity Streams items.

The engineer then adopts the so-called Test-Driven development methodology, presented by Beck (2003 - 2003), which consists of writing tests in advance and using them to validate the produced software. In our setting, test cases submit a sequence of $a d d I t e m$ and $a d d P a g e$ commands to the software agent and verify that the results of $g e t I t e m s$ and $g e t P a g e s$ match the expected collection members and pages, respectively. However, for any finite sequence of $a d d I t e m$ and $a d d P a g e$ commands, the expected output of $g e t I t e m s$ and $g e t P a g e s$ can be derived automatically using OWL reasoning alone.

Specifically, let $K$ be an OWL ontology constructed as follows: for each command $a d d I t e m (o, c)$ , put o, c, and “ $c i t e m s o$ ” to $K$ ; for each command $a d d P a g e (p, c)$ , add o, c, and “ $p p a r t O f c$ ” to $K$ , this is, captured by axioms. Then, for any collection c, the expected output of $g e t I t e m s (c)$ consists of all individuals $x$ such that “ $c i t e m s x$ ” is either explicitly asserted in—or inferred from— $K$ . Similarly, the expected output of $g e t P a g e s (c)$ consists of all individuals $x$ such that “ $x p a r t O f c$ ” holds, either by assertion or by inference.

By leveraging the proposed Activity Streams extension, the engineer only needs to provide an exhaustive set of usage scenarios to automatically generate tests that verify the application’s compliance with the specification.

Such usage scenarios may also clarify situations that are not explicitly addressed in the Activity Streams specification. An example is shown in Figure 8, which depicts a collection c with two pages, p1 and p2, and three objects, o, o1, and o2. This setup exemplifies the case of an object shared by two different pages: o1 and o2 are members of p1 and p2, respectively, whereas o belongs to both. Reasoning shows that this configuration is fully compliant and yields the expected outputs: specifically, that $g e t I t e m s (c)$ must return the set ${o, o1, o2}$ .

Figure 8.

Two pages sharing an object.

6. Conclusions and Future Works

In this article, we presented a set of additional axioms for the ontology by W3C (2017), aimed at providing a more complete and precise formalization of the Activity Streams format. We argue that these axioms can support both ontology-to-object-oriented code generation and the automated derivation of compliance tests for Activity Streams-based applications. Moreover, a detailed and exhaustive OWL encoding would enable the automatic detection of logical inconsistencies in novel extensions of the format. Nonetheless, several aspects of the specification remain to be formalized.

This work is preliminary and focuses on a limited extension of the Activity Streams core. As a next step, we plan to enrich the ontology by grounding its semantics in foundational ontologies such as UFO (Guizzardi 2005), DOLCE (Gangemi et al., 2002), and BFO (Arp et al., 2015). Such an alignment would provide a more precise semantic characterization of key concepts. For instance, the notion of activity could be endowed with a more rigorous semantics, with clearer ontological distinctions and more specific participant roles. This, in turn, would improve conceptual clarity and facilitate interoperability with other ontologies grounded in the same foundational frameworks.

The notion of Audience, described by Snell and Prodromou (2017b), and the semantics of undoing activities also go beyond what can be captured by merely encoding textual descriptions. Finally, certain concepts require clarification, such as the precise meaning of “owner” in the context of Audience, before they can be formally specified.

Footnotes

Acknowledgments

Daniele Francesco Santamaria acknowledges the Research Program PIAno di inCEntivi per la Ricerca di Ateneo 2020/2022—Linea di Intervento 3 “Starting Grant”—University of Catania.

ORCID iDs

Domenico Cantone

Daniele Francesco Santamaria

Cristiano Longo

Marianna Nicolosi-Asmundo

Funding

The authors received no financial support for the research, authorship and/or publication of this article.

Declaration of Conflicting Interests

The authors declared no potential conflicts of interest with respect to the research, authorship, and/or publication of this article.

References

Arp

Smith

Spear

A. D.

(2015). Building ontologies with basic formal ontology. MIT Press.

Baader

Calvanese

McGuinness

Nardi

Patel-Schneider

(2003). The description logic handbook: Theory, implementation and applications. Cambridge University Press.

Beck

(2003 - 2003). Test-driven development: By example. The Addison-Wesley signature series. Boston: Addison-Wesley.

Falbo

(2014). SABiO: Systematic approach for building ontologies. In CEUR workshop proceedings (vol. 1301). CEUR-WS.org.

Gangemi

Guarino

Masolo

Oltramari

Schneider

(2002). Sweetening ontologies with dolce. In Proceedings of the 13th international conference on knowledge engineering and knowledge management (EKAW 2002), Volume 2473 of Lecture Notes in Computer Science (pp. 166–181). Springer.

Glimm

Horrocks

Motik

Stoilos

Wang

(2014). HermiT: An OWL 2 reasoner. Journal of Automated Reasoning, 53(3), 245–269.

Lanthaler

Gütl

(2012). On using JSON-LD to create evolvable RESTful services. In R. Alarcón, C. Pautasso, & E. Wilde (Eds.), WS-REST (pp. 25–32). ACM. ISBN 978-1-4503-1190-8. http://dblp.uni-trier.de/db/conf/rest/rest2012.html#LanthalerG12

Ledvinka

Křemen

(2015). JOPA: Accessing ontologies in an object-oriented way. In Proceedings of the 17th international conference on enterprise information systems - Volume 1: ICEIS, (pp. 212–221). INSTICC, SciTePress. ISBN 978-989-758-097-0. https://doi.org/10.5220/0005400302120221

Longo

Cantone

Nicolosi Asmundo

Santamaria

D. F.

(2025). Some additional constraints for activity streams. https://www.opendatahacklab.org/as-exh

10.

Monfardini

G. K. Q.

Salamon

J. S.

Barcellos

M. P.

(2023). Use of competency questions in ontology engineering: A survey. In J. P. A. Almeida, J. Borbinha, G. Guizzardi, S. Link, & J. Zdravkovic (Eds.), Conceptual modeling (pp. 45–64). Cham: Springer Nature Switzerland

11.

Sirin

Parsia

Grau

B. C.

Kalyanpur

Katz

(2007). Pellet: A practical OWL-DL reasoner. Web Semantics: Science, Services and Agents on the World Wide Web 5(2), 51–53. https://doi.org/10.1016/j.websem.2007.03.004

12.

Snell

J. M.

Prodromou

(2017a). Activity Streams 2.0. W3C recommendation, W3C. https://www.w3.org/TR/2017/REC-activitystreams-core-20170523/

13.

Snell

J. M.

Prodromou

(2017b). Activity Vocabulary. W3C recommendation, W3C. https://www.w3.org/TR/2020/REC-json-ld11-20200716/

14.

Sporny

Longley

Kellogg

Lanthaler

Champin

P. A.

Lindström

(2020). JSON-LD 1.1—A JSON-based serialization for linked data. W3C recommendation, W3C. https://www.w3.org/TR/2020/REC-json-ld11-20200716/

15.

W3C. (2017). Activity Streams 2.0 OWL. https://www.w3.org/ns/activitystreams-owl

16.

W3C ActivityStreams Working Group. (2025). Errata—Activitystreams. Retrieved from 17 November 2025. https://github.com/w3c/activitystreams/blob/main/ERRATA.md

$p a r t O f \circ i t e m s$	$⊑$	items
first , current , last	$⊑$	${p a r t O f}^{-}$
prev	$\equiv$	${n e x t}^{-}$
Collection	$⊑$	$\forall (f i r s t) . \forall (p r e v) . ⊥, \forall (l a s t) . \forall (n e x t) . ⊥$