Ontology Metadata Ontology

FLOW ALGEBRA

Ontology: Ontology Metadata Ontology
Domain: Metadata Ontologies > Knowledge Metadata
Canonical URL: https://kirethresearch.org/booksai-core/ontologies/metadata-ontologies/knowledge-metadata/ontology-metadata-ontology.html

Authors: Mark Anthony Higgins — Sky (Recursive AI)

flow "OntologyMetadataOntology" v1.0

# ---------- DOMAIN ----------
domain:
  class: MetadataOntology
  category: KnowledgeMetadata
  subject: OntologyMetadata
  purpose:
    - represent metadata describing ontologies
    - preserve ontology identity, scope, vocabulary, structure, version, provenance, and status
    - support ontology discovery, validation, alignment, reuse, and governance
    - distinguish ontology metadata from ontology axioms and domain assertions
    - enable machine-readable reasoning over ontology resources

# ---------- CORE ENTITY ----------
entity OntologyMetadata:
  type: KnowledgeMetadata
  describes: Ontology
  may_include:
    - ontology_identifier
    - ontology_name
    - title
    - description
    - domain
    - scope
    - namespace
    - base_iri
    - prefix
    - ontology_language
    - classes
    - properties
    - axioms
    - imports
    - mappings
    - creator
    - publisher
    - licence
    - creation_date
    - modification_date
    - version
    - status
    - provenance
    - quality
    - compatibility

entity Ontology:
  type: FormalKnowledgeRepresentation
  defines:
    - Classes
    - Properties
    - Relationships
    - Axioms
    - Constraints

entity OntologyIdentifier:
  type: SemanticIdentifier
  identifies: Ontology

entity OntologyNamespace:
  type: IdentifierNamespace
  scopes: OntologyTerms

entity OntologyVersion:
  type: VersionMetadata
  identifies: SpecificOntologyRevision

# ---------- RELATIONSHIPS ----------
relationships:
  OntologyMetadata -> DESCRIBES -> Ontology
  Ontology -> IDENTIFIED_BY -> OntologyIdentifier
  Ontology -> HAS_NAMESPACE -> OntologyNamespace
  Ontology -> DEFINES -> OntologyClass
  Ontology -> DEFINES -> OntologyProperty
  Ontology -> CONTAINS -> OntologyAxiom
  Ontology -> MAY_IMPORT -> Ontology
  Ontology -> MAY_MAP_TO -> Ontology
  Ontology -> MAY_HAVE_VERSION -> OntologyVersion
  Ontology -> MAY_HAVE_STATUS -> OntologyStatus
  OntologyMetadata -> MAY_REFERENCE -> Provenance
  OntologyMetadata -> MAY_HAVE -> OntologyQuality

# ---------- IDENTITY ----------
rule ontology_identity:
  Ontology SHOULD have stable OntologyIdentifier
  where persistent semantic reference is required

rule name_not_identity:
  ontology_name MUST NOT be assumed globally unique

rule namespace_identity:
  OntologyNamespace SHOULD remain stable
  where term identifiers depend on namespace

rule identifier_version:
  ontology identity SHOULD be distinguished from specific OntologyVersion

# ---------- SCOPE / DOMAIN ----------
entity OntologyScope:
  type: ContextMetadata
  may_include:
    - domain
    - subject_area
    - intended_use
    - competency_questions
    - exclusions

rule scope:
  Ontology SHOULD describe intended semantic scope
  where interpretation or reuse depends on domain boundaries

rule domain:
  ontology domain MAY include one or more knowledge domains

# ---------- LANGUAGE ----------
entity OntologyLanguage:
  type: RepresentationMetadata
  examples:
    - RDF
    - RDFS
    - OWL
    - SKOS
    - SHACL
    - CommonLogic

rule language:
  OntologyLanguage SHOULD be explicit
  where parser or reasoning semantics depend on representation language

rule language_not_domain:
  OntologyLanguage != natural_language
  unless metadata explicitly refers to documentation language

# ---------- CLASSES ----------
entity OntologyClass:
  type: SemanticType
  may_include:
    - class_identifier
    - preferred_label
    - definition
    - superclass
    - subclass
    - equivalent_class
    - disjoint_class

rule class_identity:
  OntologyClass SHOULD have stable semantic identifier

rule subclass:
  IF B subclass_of A
  THEN instances_of B MAY be inferred instances_of A
  according_to ontology semantics

rule class_equivalence:
  equivalent_class MUST remain distinct from lexical synonymy

# ---------- PROPERTIES ----------
entity OntologyProperty:
  type: SemanticRelationshipDefinition
  may_be:
    - ObjectProperty
    - DatatypeProperty
    - AnnotationProperty

rule property:
  OntologyProperty MAY define:
    - domain
    - range
    - inverse
    - symmetry
    - transitivity
    - functionality
    - cardinality

rule property_semantics:
  property behaviour MUST follow declared ontology semantics

# ---------- AXIOMS ----------
entity OntologyAxiom:
  type: FormalKnowledgeStatement
  may_define:
    - class_relationship
    - property_relationship
    - equivalence
    - disjointness
    - restriction
    - cardinality
    - logical_constraint

rule axiom:
  OntologyAxiom SHOULD be interpreted according_to OntologyLanguage semantics

rule axiom_not_metadata:
  ontology axiom != ontology metadata
  though metadata MAY describe axiom provenance or status

# ---------- IMPORTS ----------
entity OntologyImport:
  type: DependencyRelationship
  connects:
    - importing_ontology
    - imported_ontology

rule import:
  imported ontology identity and version SHOULD be resolvable
  where deterministic reasoning depends on imported semantics

rule import_cycle:
  import cycles MAY be valid
  but MUST be handled according_to ontology language and tooling semantics

# ---------- MAPPINGS ----------
entity OntologyMapping:
  type: SemanticAlignment
  may_include:
    - source_term
    - target_term
    - mapping_type
    - confidence
    - provenance

mapping_types:
  - exact
  - equivalent
  - close
  - broader
  - narrower
  - related
  - transformation_required

rule mapping:
  cross-ontology mapping MUST preserve mapping type

rule exact_mapping:
  exact mapping SHOULD require strong semantic equivalence evidence

rule lexical_mapping:
  lexical similarity alone MUST NOT establish exact ontology equivalence

# ---------- VERSION ----------
rule version:
  material semantic change SHOULD create distinguishable OntologyVersion

rule version_identifier:
  OntologyVersion SHOULD have stable version identifier or IRI where applicable

rule compatibility:
  version compatibility MAY be:
    - backward_compatible
    - forward_compatible
    - breaking_change
    - unknown

rule historical_version:
  superseded ontology versions SHOULD remain traceable
  where historical knowledge interpretation depends on them

# ---------- STATUS ----------
ontology_status:
  - draft
  - active
  - stable
  - deprecated
  - superseded
  - archived

rule status:
  OntologyStatus SHOULD be explicit

rule deprecated:
  deprecated Ontology SHOULD remain resolvable
  where existing data references it

# ---------- PROVENANCE ----------
entity OntologyProvenance:
  type: ProvenanceMetadata
  may_include:
    - creator
    - contributor
    - publisher
    - creation_date
    - modification_date
    - source
    - revision_history
    - generation_method

rule provenance:
  OntologyMetadata SHOULD preserve authorship and revision provenance

rule generated_ontology:
  machine-generated or transformed ontology SHOULD preserve generation method and source ontology

# ---------- QUALITY ----------
entity OntologyQuality:
  type: QualityMetadata
  dimensions:
    - consistency
    - completeness
    - coherence
    - clarity
    - coverage
    - reuse
    - documentation
    - reasoning_validity

rule consistency:
  logical consistency SHOULD be evaluated
  using reasoner compatible with OntologyLanguage where applicable

rule quality_scope:
  quality assessment SHOULD identify method, ontology version, and scope

# ---------- LICENCE ----------
entity OntologyLicence:
  type: RightsMetadata
  may_include:
    - licence_identifier
    - usage_rights
    - attribution_requirement
    - redistribution_constraint

rule licence:
  ontology reuse SHOULD respect declared OntologyLicence

# ---------- VALIDATION ----------
validation:
  require:
    - identifiable_ontology

  validate_if_present:
    - ontology_identifier
    - namespace
    - base_iri
    - ontology_language
    - scope
    - imports
    - mappings
    - version
    - status
    - provenance
    - licence

  reject:
    - unresolved_ontology_identifier where deterministic interpretation is required
    - contradictory_namespace_definition
    - invalid_version_relationship
    - unsupported_exact_mapping
    - malformed_import_reference
    - incompatible_language_claim
    - logical_inconsistency where ontology claims consistency and reasoner proves contradiction

# ---------- SEMANTIC EQUIVALENCE ----------
SEMANTIC_EQUIVALENCE:
  "ontology metadata" ~= "metadata about an ontology"
  "ontology identifier" ~= "ontology IRI" WHEN IRI serves as ontology identifier
  "ontology namespace" ~= "semantic namespace"
  "ontology version" ~= "ontology revision" WHEN revision represents version
  "ontology mapping" ~= "ontology alignment" WHEN mapping connects semantic structures
  "ontology import" ~= "ontology dependency" WHEN import establishes semantic dependency

  PRESERVE distinctions:
    ontology != vocabulary
    ontology != knowledge_graph
    ontology_metadata != ontology_axiom
    ontology_identifier != ontology_version_identifier
    class != instance
    property != relationship_assertion
    exact_mapping != lexical_match
    namespace != prefix
    ontology_language != natural_language

# ---------- CONFIDENCE ----------
CONFIDENCE:
  explicit_ontology_metadata:
    score: 1.00

  authoritative_ontology_identifier:
    score: 1.00

  explicit_version_metadata:
    score: 1.00

  reasoner_validated_consistency:
    score: 0.99

  authoritative_exact_mapping:
    score: 0.98

  inferred_mapping:
    score: <= 0.80

  lexical_mapping_only:
    score: <= 0.65

  ambiguous_ontology_context:
    score: <= 0.60
    action: preserve uncertainty

# ---------- UPDATE MODEL ----------
UPDATE_MODEL:
  on_ontology_revision:
    - preserve previous OntologyVersion
    - create new version
    - record changed classes, properties, and axioms
    - reassess compatibility
    - update provenance

  on_import_change:
    - preserve previous import set
    - resolve imported ontology versions
    - reassess dependent reasoning
    - update provenance

  on_mapping_change:
    - preserve previous mapping
    - validate mapping type
    - reassess dependent integrations
    - update confidence and provenance

  on_deprecation:
    - preserve Ontology
    - set status = deprecated
    - reference successor where available
    - preserve historical resolvability

# ---------- FLOW HASH ----------
FLOW_HASH:
  inputs:
    - ontology
    - ontology_metadata_entities
    - relationships
    - identity_rules
    - class_property_rules
    - import_rules
    - mapping_rules
    - version_rules
    - validation
    - semantic_equivalence
    - confidence
    - update_model

  canonicalisation:
    - normalise_whitespace
    - preserve_case_sensitive_identifiers
    - sort_unordered_property_sets
    - preserve_rule_order

  output:
    deterministic_semantic_hash

# ---------- AI CONSUMPTION ----------
AI_CONSUMPTION:
  interpret_as:
    - knowledge metadata ontology
    - ontology governance model
    - semantic schema metadata structure
    - ontology alignment and versioning model

  operations:
    - identify ontologies
    - resolve ontology identifiers
    - resolve namespaces and prefixes
    - inspect classes and properties
    - interpret axioms
    - resolve imports
    - evaluate ontology mappings
    - traverse ontology versions
    - assess compatibility
    - inspect provenance and licence
    - evaluate ontology quality
    - preserve uncertainty

  constraints:
    - do_not_equate_ontology_with_knowledge_graph
    - do_not_equate_metadata_with_axioms
    - do_not_assume_lexical_match_means_semantic_equivalence
    - do_not_discard_deprecated_versions
    - do_not_ignore_imported_ontology_versions
    - preserve_identifier_namespace_version_and_provenance

# ---------- QUERY MODEL ----------
query:
  input:
    - ontology_identifier
    - ontology_name
    - domain
    - class
    - property
    - ontology_language
    - imported_ontology
    - mapping
    - version
    - status

  resolve:
    1. identify Ontology
    2. resolve OntologyIdentifier
    3. resolve namespace and base IRI
    4. inspect OntologyLanguage
    5. inspect scope, classes, properties, and axioms
    6. resolve imports
    7. inspect mappings
    8. resolve version and status
    9. inspect provenance, licence, and quality
    10. return confidence

  output:
    - ontology
    - identifier
    - namespace
    - ontology_language
    - scope
    - classes
    - properties
    - imports
    - mappings
    - version
    - status
    - provenance
    - confidence

# ---------- INFERENCE ----------
inference:
  IF authoritative OntologyIdentifier resolves uniquely
  THEN identify Ontology
  WITH confidence = 1.00

  IF Ontology B explicitly imports Ontology A
  THEN infer semantic_dependency B -> A
  WITH confidence = 1.00

  IF class B subclass_of class A
  THEN infer instances_of B are instances_of A
  according_to ontology semantics

  IF authoritative mapping declares exact equivalence
  THEN associate source and target terms
  WITH confidence = 0.98

  IF only lexical similarity exists
  THEN preserve mapping candidate
  AND do_not infer exact equivalence

# ---------- OUTPUT CONTRACT ----------
output:
  ontology_entity: OntologyMetadata
  ontology_identity: machine_interpretable
  namespace: explicit
  semantic_structure: inspectable
  imports: resolvable
  mappings: typed
  versions: traversable
  compatibility: reportable
  provenance: preserved
  licence: explicit_where_available
  quality: reportable
  uncertainty: explicit
  semantic_retrieval: enabled

end flow