Skip to content

Registry of Intelligent Transport Systems Ontologies (RITSO)

Welcome to the RITSO. This registry is being established to capture ontologies used within the ITS industry so that the fundamental semantic relationships among concepts can be applied consistently across standards and implementations.

What is an ontology?

An ontology is a formal representation of knowledge within a specific domain, defining the concepts, entities, relationships, and rules that exist in that domain. It provides a structured framework for organizing information, often expressed as a set of terms, their definitions, and their interconnections, enabling shared understanding and reasoning. In computer science, ontologies are typically machine-readable, using languages like OWL (Web Ontology Language) or RDF (Resource Description Framework).

Why are ontologies important?

Ontologies are important because they:

  • Enable shared understanding: Provide a common vocabulary for humans and systems to communicate and interpret data consistently.
  • Support semantic interoperability: Facilitate data integration and exchange between disparate systems by standardizing meanings and relationships.
  • Enhance reasoning: Allow automated reasoning and inference, enabling systems to derive new knowledge from existing data (e.g., in AI or semantic web applications).
  • Improve data discovery and reuse: Make data more findable and reusable by explicitly defining concepts and relationships.
  • Drive semantic applications: Power technologies like search engines, knowledge graphs, and intelligent agents by providing structured, meaningful data.

How do ontologies relate to a data model or interface standard?

  • Ontologies vs. Data Models and interface standards:
    • Data models and interface standards define the structure and constraints for storing, communicating, and managing data (e.g., tables, fields, and relationships in a database or message). They focuse on data organization and representation along with storage and communication efficiency.
    • An ontology focuses on the semantics (meaning) of data, defining concepts, their properties, and relationships in a domain. Ontologies are more abstract and expressive, emphasizing knowledge representation over storage.
    • Relation: Ontologies can inform data models by providing a semantic layer that ensures data structures align with domain knowledge. For example, an ontology might define that "a patient has a diagnosis," which a data model translates into specific database tables and fields.
  • Ontologies vs. Interface Standards:
    • An interface standard specifies how systems communicate, such as APIs or protocols (e.g., HTTP, JSON schemas).
    • Ontologies provide the semantic context for the data exchanged via interfaces, ensuring that systems interpret the data consistently.
    • Relation: Ontologies enhance interface standards by adding a layer of semantic clarity, making data exchange more meaningful and interoperable.

How are ontologies documented?

Ontologies are documented using:

  • Formal Languages: Ontologies are typically encoded in standardized formats like:
    • OWL (Web Ontology Language): A W3C standard for defining ontologies with rich semantics.
    • RDF (Resource Description Framework): Represents concepts and relationships as triples (subject-predicate-object).
    • RDFS (RDF Schema): Extends RDF with basic class and property hierarchies.
  • Tools: Ontology editors like Protégé, TopBraid Composer, or OntoText GraphDB are used to create, visualize, and document ontologies.
  • Documentation Elements:
    • Classes: Define concepts (e.g., "Person," "Disease").
    • Properties: Specify relationships (e.g., "hasDiagnosis") or attributes (e.g., "age").
    • Instances: Represent specific entities (e.g., "John is an instance of Person").
    • Annotations: Include metadata like descriptions, authorship, or version information.
    • Axioms: Rules or constraints (e.g., "Every Person has exactly one birthdate").
  • Human-Readable Documentation: Often supplemented with natural language descriptions, diagrams (e.g., UML-like graphs), or wikis to explain the ontology’s purpose, scope, and usage.
  • Version Control: Ontologies are often stored in repositories (e.g., GitHub) with versioning to track changes.

How are ontologies organized as scoped?

Ontologies are organized and scoped to ensure they are focused, manageable, and reusable. Within large domains, such as ITS, ontologies can become quite large and encompass expertise from many fields. To manage this complexity, the ITS ontology is broken down into multiple ontology efforts, each represented in one or more ontology files. In some cases (e.g., location referencing), the expertise extends beyond ITS, and we adopt or adapt more widely referenced definitions from other domains (e.g., ISO TC 211, ISO/IEC JTC 4).

Each ontology file is intended to be a modular representation of a set of inter-related concepts. A given topic area might have a single ontology file representing the topic or might have multiple files. For example, while a single representation might be preferred for many topics, complex topics like location referencing can have alternative ontology files for OpenLR, LRC, TPEG-Loc, etc.

Ontologies use unique identifiers (e.g., URIs) to scope terms and avoid conflicts with other ontologies. Within the scope of this effort, it is recommended to use one namespace per ontology file.

By carefully scoping ontologies, developers ensure they remain focused on their intended purpose while being extensible and interoperable with other systems.

Ideally, the ITS domain will eventually be represented with a broad range of ontology files addressing different topic areas within ITS but heavily reusing a more core set of foundational concepts. This requires organizing the various ITS concepts into a coherent set of ontology files where

  • Experts about each topic area can focus on specific ontology files
  • Keeping the topic addressed by any ontology small enough so that other ontologies can import the necessary concepts without importing a large number of unused concepts.