Entity Metadata Ontology

FLOW ALGEBRA

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

Authors: Mark Anthony Higgins — Sky (Recursive AI)

flow "EntityMetadataOntology" v1.0

# ---------- DOMAIN ----------
domain:
  class: MetadataOntology
  category: KnowledgeMetadata
  subject: EntityMetadata
  purpose:
    - represent metadata describing identifiable entities
    - preserve entity identity, type, attributes, relationships, context, and provenance
    - support entity resolution, disambiguation, linking, validation, and reasoning
    - distinguish entities from labels, descriptions, identifiers, and representations
    - enable machine-readable entity management across knowledge systems

# ---------- CORE ENTITY ----------
entity EntityMetadata:
  type: KnowledgeMetadata
  describes: Entity
  may_include:
    - entity_identifier
    - entity_type
    - preferred_label
    - alternative_label
    - description
    - attributes
    - relationships
    - ontology_reference
    - context
    - temporal_metadata
    - spatial_metadata
    - status
    - version
    - provenance
    - confidence

entity Entity:
  type: IdentifiableSemanticObject
  identified_by: EntityIdentifier

entity EntityIdentifier:
  type: SemanticIdentifier
  identifies: Entity

entity EntityType:
  type: Classification
  classifies: Entity

entity EntityAttribute:
  type: PropertyAssertion
  describes: Entity

entity EntityRelationship:
  type: SemanticRelationship
  relates:
    - source_entity
    - target_entity

# ---------- ENTITY CATEGORIES ----------
entity_categories:
  - Person
  - Organisation
  - Place
  - Object
  - Event
  - Process
  - Concept
  - Document
  - Dataset
  - System
  - Product
  - Service
  - DigitalResource

# ---------- RELATIONSHIPS ----------
relationships:
  EntityMetadata -> DESCRIBES -> Entity
  Entity -> IDENTIFIED_BY -> EntityIdentifier
  Entity -> HAS_TYPE -> EntityType
  Entity -> HAS_ATTRIBUTE -> EntityAttribute
  Entity -> HAS_RELATIONSHIP -> EntityRelationship
  EntityRelationship -> HAS_SOURCE -> Entity
  EntityRelationship -> HAS_TARGET -> Entity
  Entity -> MAY_HAVE_LABEL -> EntityLabel
  Entity -> MAY_REFERENCE -> Ontology
  Entity -> MAY_HAVE_CONTEXT -> ContextMetadata
  Entity -> MAY_HAVE_TEMPORAL_METADATA -> TemporalMetadata
  Entity -> MAY_HAVE_SPATIAL_METADATA -> SpatialMetadata
  Entity -> MAY_HAVE_VERSION -> EntityVersion
  EntityMetadata -> MAY_REFERENCE -> Provenance

# ---------- IDENTITY ----------
rule entity_identity:
  Entity SHOULD have stable EntityIdentifier
  where persistent semantic reference is required

rule identifier_namespace:
  EntityIdentifier MUST preserve namespace
  where identifier is not globally unique

rule identifier_not_label:
  EntityIdentifier != EntityLabel

rule label_not_identity:
  same label MUST NOT automatically imply same Entity

rule representation_not_entity:
  representation_of_entity != Entity
  unless ontology explicitly models representation as entity itself

# ---------- ENTITY TYPES ----------
rule type:
  EntityType SHOULD be explicit
  where type materially affects interpretation

rule multiple_types:
  Entity MAY have multiple compatible EntityTypes

rule incompatible_types:
  incompatible EntityTypes SHOULD be flagged
  unless ontology permits contextual typing

rule subtype:
  IF type B subtype_of type A
  AND Entity has_type B
  THEN Entity may_be inferred has_type A
  according_to ontology semantics

# ---------- LABELS ----------
entity EntityLabel:
  type: LexicalRepresentation
  may_be:
    - PreferredLabel
    - AlternativeLabel
    - HistoricalLabel
    - Alias

rule preferred_label:
  Entity MAY have preferred label per language or context

rule alias:
  Alias MUST NOT be treated as distinct Entity without evidence

rule multilingual_label:
  labels SHOULD preserve language metadata
  where multilingual interpretation matters

# ---------- ATTRIBUTES ----------
rule attribute:
  EntityAttribute SHOULD identify:
    - property
    - value
    - datatype_or_entity_reference
    - context_optional
    - provenance_optional

rule attribute_value:
  attribute value MUST conform to declared property semantics

rule attribute_time:
  time-varying EntityAttribute SHOULD preserve temporal validity

rule attribute_source:
  source-specific attribute SHOULD preserve provenance

# ---------- RELATIONSHIPS ----------
rule relationship:
  EntityRelationship SHOULD identify:
    - relationship_type
    - source_entity
    - target_entity
    - direction
    - context
    - provenance

rule inverse:
  IF relationship R has defined inverse R_inv
  AND A R B
  THEN infer B R_inv A

rule symmetric:
  IF relationship R is symmetric
  AND A R B
  THEN infer B R A

rule transitive:
  IF relationship R is transitive
  AND A R B
  AND B R C
  THEN infer A R C

rule self_relationship:
  self-relationship MUST be validated against relationship semantics

# ---------- ENTITY RESOLUTION ----------
operation resolve_entity(candidate):
  evaluate:
    - identifiers
    - labels
    - entity_type
    - attributes
    - relationships
    - temporal_context
    - spatial_context
    - provenance

  output:
    - candidate_entities
    - resolved_entity_optional
    - confidence

rule identifier_match:
  matching authoritative stable identifier strongly supports same Entity

rule label_match:
  matching label alone provides insufficient evidence for identity

rule conflicting_identity:
  conflicting high-confidence identifiers SHOULD prevent automatic merge

# ---------- ENTITY MERGE ----------
operation merge_entities(A, B):
  require:
    - identity_evidence
    - compatibility
    - merge_policy

  preserve:
    - source_identifiers
    - source_labels
    - source_attributes
    - source_relationships
    - provenance

  output:
    - merged_entity
    - merge_confidence
    - conflict_report

rule merge_safety:
  entities MUST NOT be merged solely on shared name

# ---------- ENTITY SPLIT ----------
operation split_entity(E):
  trigger:
    - conflated_identifiers
    - incompatible_types
    - contradictory_temporal_presence
    - contradictory_spatial_identity
    - provenance_evidence

  preserve:
    - original_record
    - split_reason
    - resulting_entities
    - provenance

# ---------- TEMPORAL CONTEXT ----------
rule temporal_identity:
  Entity MAY persist through changing attributes over time

rule historical_state:
  historical Entity state != separate Entity
  unless identity semantics define a distinct entity

rule lifespan:
  entities with temporal existence MAY include:
    - valid_from
    - valid_until
    - creation_time
    - dissolution_time

# ---------- SPATIAL CONTEXT ----------
rule spatial_identity:
  Place or location-dependent Entity SHOULD preserve spatial context

rule same_name_different_place:
  same label at different geographic locations MAY indicate distinct entities

# ---------- STATUS ----------
entity_status:
  - active
  - inactive
  - historical
  - deprecated
  - superseded
  - unknown

rule status:
  Entity status SHOULD be temporally contextualised
  where status changes over time

# ---------- VERSION ----------
entity EntityVersion:
  type: VersionMetadata
  may_include:
    - version_identifier
    - predecessor
    - successor
    - creation_time
    - change_description

rule version:
  metadata revision MAY create EntityVersion
  without creating new real-world Entity identity

rule identity_version_distinction:
  Entity != EntityVersion

# ---------- PROVENANCE ----------
rule provenance:
  EntityMetadata SHOULD preserve available:
    - source
    - creator
    - creation_time
    - extraction_method
    - resolution_method
    - revision_history

rule source_conflict:
  conflicting source assertions SHOULD remain traceable
  rather_than silently overwritten

# ---------- VALIDATION ----------
validation:
  require:
    - identifiable_entity_or_candidate

  validate_if_present:
    - identifier
    - entity_type
    - labels
    - attributes
    - relationships
    - temporal_context
    - spatial_context
    - status
    - version
    - provenance

  reject:
    - contradictory_authoritative_identifiers_for_same_entity_without resolution
    - invalid_attribute_datatype
    - impossible_relationship_semantics
    - unsupported_entity_merge
    - invalid_version_identity_collapse
    - unresolved_identifier_namespace where deterministic resolution is required

# ---------- SEMANTIC EQUIVALENCE ----------
SEMANTIC_EQUIVALENCE:
  "entity metadata" ~= "metadata about entities"
  "entity identifier" ~= "semantic entity identifier"
  "entity type" ~= "entity classification"
  "entity attribute" ~= "entity property" WHEN property describes entity
  "entity relationship" ~= "semantic relationship" WHEN connecting entities
  "entity resolution" ~= "entity disambiguation and matching"

  PRESERVE distinctions:
    entity != identifier
    entity != label
    entity != representation
    entity != entity_version
    alias != separate_entity
    attribute != relationship
    same_label != same_entity
    historical_state != new_entity
    merge != equivalence_without_evidence

# ---------- CONFIDENCE ----------
CONFIDENCE:
  authoritative_identifier_match:
    score: 1.00

  explicit_entity_metadata:
    score: 1.00

  multi_attribute_resolution:
    score: 0.95

  relationship_supported_resolution:
    score: 0.90

  type_and_location_resolution:
    score: 0.90

  label_only_match:
    score: <= 0.65

  conflicting_identity_evidence:
    score: <= 0.50
    action: do_not_merge

# ---------- UPDATE MODEL ----------
UPDATE_MODEL:
  on_attribute_update:
    - preserve previous attribute where historically relevant
    - validate new value
    - preserve temporal validity
    - update provenance

  on_relationship_update:
    - preserve previous relationship state
    - validate relationship semantics
    - update inverse or derived relationships
    - update provenance

  on_identity_resolution:
    - preserve candidate records
    - record resolution evidence
    - assign confidence
    - merge only if threshold and policy satisfied
    - preserve provenance

  on_entity_split:
    - preserve original conflated record
    - create distinct Entity identities
    - redistribute attributes and relationships
    - record split rationale
    - preserve provenance

# ---------- FLOW HASH ----------
FLOW_HASH:
  inputs:
    - ontology
    - entity_metadata_entities
    - entity_categories
    - relationships
    - identity_rules
    - attribute_rules
    - relationship_rules
    - resolution_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
    - entity identity model
    - entity resolution structure
    - semantic relationship model
    - knowledge graph entity layer

  operations:
    - identify entities
    - resolve entity identifiers
    - classify entity types
    - interpret labels and aliases
    - validate attributes
    - traverse relationships
    - resolve duplicate candidates
    - merge compatible entity records
    - detect conflated entities
    - preserve temporal and spatial identity
    - trace provenance
    - expose uncertainty

  constraints:
    - do_not_equate_label_with_entity
    - do_not_merge_entities_on_name_alone
    - do_not_discard_conflicting_identity_evidence
    - do_not_equate_entity_version_with_new_entity
    - do_not_invent_identifiers
    - preserve_source_identifiers_context_and_provenance

# ---------- QUERY MODEL ----------
query:
  input:
    - entity_identifier
    - label
    - entity_type
    - attribute
    - relationship
    - temporal_constraint
    - spatial_constraint
    - status
    - source

  resolve:
    1. identify candidate Entity records
    2. resolve authoritative identifiers
    3. compare labels and aliases
    4. compare EntityTypes
    5. compare attributes
    6. inspect relationships
    7. apply temporal context
    8. apply spatial context
    9. inspect provenance
    10. rank candidates by confidence

  output:
    - entity
    - identifiers
    - entity_types
    - labels
    - attributes
    - relationships
    - status
    - provenance
    - resolution_confidence

# ---------- INFERENCE ----------
inference:
  IF authoritative EntityIdentifier resolves uniquely
  THEN identify Entity
  WITH confidence = 1.00

  IF multiple independent attributes and relationships align
  THEN infer same-entity candidate
  WITH confidence <= 0.95

  IF same label but incompatible locations or identifiers exist
  THEN infer distinct-entity candidates

  IF relationship has declared inverse
  THEN infer inverse relationship

  IF identity evidence remains conflicting
  THEN preserve separate candidates
  AND do_not merge

# ---------- OUTPUT CONTRACT ----------
output:
  ontology_entity: EntityMetadata
  entity_identity: machine_interpretable
  identifiers: stable_and_namespaced
  types: explicit
  labels: language_and_context_aware
  attributes: semantically_typed
  relationships: traversable
  resolution_history: traceable
  versions: preserved
  provenance: preserved
  uncertainty: explicit
  semantic_retrieval: enabled

end flow