Metadata Ontology

FLOW ALGEBRA
Metadata Ontology
Kireth Semantic Research Archive

PAGE:
https://kirethresearch.org/booksai-core/ontologies/metadata-ontologies/foundations-of-metadata/metadata-ontology.html

AUTHORS:
Mark Anthony Higgins — Sky (Recursive AI)

FLOW "MetadataOntology" v4.0

DOMAIN := MetadataOntologies
SUBDOMAIN := FoundationsOfMetadata
ONTOLOGY := MetadataOntology

ENTITY Metadata {
    definition:
        "Structured or semi-structured information that describes, identifies,
         contextualises, manages, relates, preserves or enables discovery and
         interpretation of a resource, dataset, document, entity or knowledge object.";
    objectives: [
        ResourceDescription,
        Identification,
        Discovery,
        Contextualisation,
        Management,
        Interoperability,
        Preservation
    ];
}

MetadataEntity := {
    Metadata,
    Resource,
    MetadataRecord,
    MetadataElement,
    MetadataProperty,
    MetadataValue,
    Identifier,
    MetadataSchema
};

MetadataCategory := {
    DescriptiveMetadata,
    StructuralMetadata,
    AdministrativeMetadata,
    TechnicalMetadata,
    PreservationMetadata,
    ProvenanceMetadata
};

LifecycleEntity := {
    Creation,
    Validation,
    Publication,
    Maintenance,
    Versioning,
    Archival
};

QualityEntity := {
    Accuracy,
    Completeness,
    Consistency,
    Timeliness,
    ProvenanceQuality
};

Metadata DESCRIBES Resource;
MetadataRecord DESCRIBES Resource;
MetadataRecord CONTAINS MetadataElement;
MetadataElement USES MetadataProperty;
MetadataProperty HAS MetadataValue;
MetadataSchema DEFINES MetadataProperty;
Identifier IDENTIFIES Resource;
ProvenanceMetadata RECORDS ResourceHistory;

MetadataFlow :=
    Resource
    -> IdentifyResource
    -> DetermineMetadataPurpose
    -> SelectMetadataSchema
    -> CreateMetadataRecord
    -> PopulateMetadataElements
    -> AssignStableIdentifier
    -> AttachProvenance
    -> ValidateMetadata
    -> StoreAndIndex
    -> PublishOrExchange
    -> MaintainAndVersion;

Resource :=
    ThingDescribedByMetadata;

Resource MAY_BE {
    Document,
    Dataset,
    Image,
    Audio,
    Video,
    Software,
    WebResource,
    PhysicalObject,
    Event,
    KnowledgeEntity
};

MetadataRecord :=
    StructuredCollectionOfMetadataStatementsAboutResource;

MetadataRecord SHOULD_REFERENCE ResourceThroughStableIdentifierWherePossible;

MetadataElement :=
    DefinedUnitWithinMetadataRecord;

MetadataElement MAY_HAVE {
    Name,
    Definition,
    Datatype,
    Cardinality,
    Obligation,
    Value
};

MetadataProperty :=
    SemanticCharacteristicUsedToDescribeResource;

MetadataProperty MAY_CONNECT:
    Resource -> LiteralValue
OR
    Resource -> RelatedEntity;

MetadataValue :=
    ValueAssignedToMetadataProperty;

MetadataValue MAY_BE {
    Text,
    Number,
    Date,
    Boolean,
    Identifier,
    ControlledTerm,
    EntityReference
};

MetadataStatement :=
    Resource
    -> MetadataProperty
    -> MetadataValue;

Identifier :=
    ReferenceUsedToDistinguishResource;

Identifier MAY_BE {
    URI,
    IRI,
    DOI,
    ISBN,
    UUID,
    InternalIdentifier
};

PersistentIdentifier :=
    IdentifierDesignedToRemainStableAcrossLocationOrSystemChange;

PersistentIdentifier SUPPORTS LongTermResourceLinking;

DescriptiveMetadata :=
    MetadataSupportingDiscoveryIdentificationSelectionAndUnderstanding;

DescriptiveMetadata MAY_INCLUDE {
    Title,
    Creator,
    Subject,
    Description,
    Keyword,
    Language
};

StructuralMetadata :=
    MetadataDescribingOrganisationAndRelationshipsAmongResourceComponents;

StructuralMetadata MAY_INCLUDE {
    Sequence,
    Hierarchy,
    PageOrder,
    FileRelationship,
    CollectionMembership
};

AdministrativeMetadata :=
    MetadataSupportingResourceManagementAndGovernance;

AdministrativeMetadata MAY_INCLUDE {
    Ownership,
    Rights,
    Access,
    Acquisition,
    LifecycleStatus
};

TechnicalMetadata :=
    MetadataDescribingTechnicalCharacteristicsOfResource;

TechnicalMetadata MAY_INCLUDE {
    FileFormat,
    FileSize,
    Resolution,
    Codec,
    SoftwareVersion,
    HardwareRequirement
};

PreservationMetadata :=
    MetadataSupportingLongTermAccessIntegrityAuthenticityAndInterpretability;

PreservationMetadata MAY_INCLUDE {
    Fixity,
    PreservationEvent,
    Environment,
    Rights,
    Provenance
};

ProvenanceMetadata :=
    MetadataRecordingOriginDerivationOwnershipAndChangeHistory;

ProvenanceMetadata MAY_INCLUDE {
    Source,
    Creator,
    Timestamp,
    Transformation,
    Custody,
    Version
};

Title := HumanReadableNameOfResource;

Creator :=
    AgentResponsibleForCreatingResource;

Agent MAY_BE {
    Person,
    Organisation,
    SoftwareSystem
};

Contributor :=
    AgentContributingToResourceWithoutBeingPrimaryCreator;

Subject :=
    TopicConceptOrDomainAssociatedWithResource;

Subject MAY_REFERENCE {
    Keyword,
    ControlledVocabularyTerm,
    OntologyConcept
};

Description :=
    HumanReadableSummaryOrExplanationOfResource;

Publisher :=
    AgentResponsibleForMakingResourceAvailable;

MetadataDate MAY_HAVE Role {
    Created,
    Modified,
    Published,
    Issued,
    Valid,
    Accessed
};

DateRole MUST_BE ExplicitWhereAmbiguityIsPossible;

ResourceType :=
    CategoryDescribingNatureOrGenreOfResource;

Format :=
    PhysicalOrDigitalManifestationFormatOfResource;

Language :=
    LanguageOfResourceOrMetadataContent;

Language SHOULD_USE StandardLanguageIdentifierWhereApplicable;

ResourceRelation :=
    TypedRelationshipBetweenResources;

Relation MAY_INCLUDE {
    IsPartOf,
    HasPart,
    IsVersionOf,
    IsDerivedFrom,
    References,
    Requires
};

Coverage :=
    SpatialTemporalOrJurisdictionalScopeOfResource;

Rights :=
    InformationAboutPermissionsRestrictionsOwnershipOrUsageConditions;

Licence :=
    FormalTermsGoverningPermittedResourceUse;

AccessCondition :=
    RuleOrStatusDeterminingWhoMayAccessResourceOrMetadata;

MetadataSchema :=
    SpecificationOfMetadataElementsSemanticsAndConstraints;

MetadataSchema MAY_DEFINE {
    ElementNames,
    Definitions,
    Datatypes,
    Cardinality,
    Requiredness,
    ControlledValues
};

MetadataElementSet :=
    DefinedCollectionOfMetadataPropertiesOrElements;

ApplicationProfile :=
    MetadataSpecificationTailoredToSpecificApplicationCommunityOrDomain;

ApplicationProfile MAY_REUSE TermsFromMultipleSchemas;

MetadataCardinality :=
    NumberOfValuesAllowedOrRequiredForElement;

Cardinality MAY_BE {
    ZeroOrOne,
    ExactlyOne,
    ZeroOrMany,
    OneOrMany
};

MetadataObligation MAY_BE {
    Required,
    Recommended,
    Optional
};

MetadataDatatype :=
    ExpectedValueTypeForMetadataProperty;

Datatype MAY_INCLUDE {
    String,
    Integer,
    Decimal,
    Boolean,
    Date,
    URI
};

ControlledVocabulary :=
    ManagedSetOfPermittedTermsOrValues;

ControlledVocabulary MAY_IMPROVE {
    Consistency,
    Retrieval,
    Interoperability
};

Taxonomy :=
    HierarchicalOrganisationOfMetadataTermsOrConcepts;

Thesaurus :=
    ControlledVocabularyWithSemanticRelations;

Thesaurus MAY_INCLUDE {
    PreferredTerm,
    AlternativeTerm,
    BroaderTerm,
    NarrowerTerm,
    RelatedTerm
};

Ontology MAY_DEFINE RichSemanticMeaningForMetadataPropertiesAndValues;

MetadataOntology MAY_CONNECT MetadataStructuresToDomainOntologies;

MetadataClassification :=
    AssignResourceToDefinedCategoryConceptOrType;

Classification MAY_BE {
    Manual,
    RuleBased,
    Automated,
    AIAssisted
};

Keyword :=
    TermAssociatedWithResourceForDiscovery;

Tag :=
    LightweightLabelAssociatedWithResource;

Tag != FormalOntologyConceptUnlessExplicitlyMapped;

MetadataSyntax :=
    StructuralEncodingUsedToRepresentMetadata;

Syntax MAY_BE {
    JSON,
    JSONLD,
    XML,
    RDF,
    CSV,
    HTMLMarkup
};

MetadataSemantics :=
    MeaningOfMetadataPropertiesAndValues;

SharedSyntax WITHOUT SharedSemantics DOES_NOT_GUARANTEE SemanticInteroperability;

Metadata MAY_BE RepresentedAs RDFTriples;

RDFMetadataStatement :=
    Resource
    -> Property
    -> Value;

JSONLD MAY_SERIALISE LinkedSemanticMetadataUsingJSONCompatibleStructure;

XML MAY_SERIALISE MetadataAccordingToDefinedSchema;

StructuredData :=
    MachineReadableMetadataWithExplicitFieldsAndSemantics;

MetadataInteroperability :=
    AbilityOfSystemsToExchangeAndInterpretMetadataConsistently;

Interoperability MAY_REQUIRE {
    SharedSchema,
    SemanticMapping,
    StableIdentifiers,
    ControlledVocabulary
};

SyntacticInteroperability :=
    AbilityToExchangeMetadataUsingCompatibleDataStructures;

SemanticInteroperability :=
    AbilityToPreserveMeaningAcrossMetadataExchange;

MetadataCrosswalk :=
    MappingBetweenElementsOfDifferentMetadataSchemas;

Crosswalk MAY_BE {
    Exact,
    Approximate,
    Conditional,
    Lossy
};

MetadataMapping :=
    SourceElementOrValue
    -> TargetElementOrValue;

Mapping SHOULD_DOCUMENT MeaningLossOrTransformationWhereRelevant;

MetadataNormalisation :=
    ConvertMetadataValuesIntoConsistentRepresentation;

Normalisation MAY_INCLUDE {
    DateFormatting,
    NameFormatting,
    IdentifierFormatting,
    VocabularyMapping
};

MetadataValidation :=
    CheckMetadataRecordAgainstSchemaAndQualityRules;

Validation MAY_CHECK {
    RequiredProperty,
    Datatype,
    Cardinality,
    Vocabulary,
    IdentifierFormat
};

MetadataAccuracy :=
    DegreeToWhichMetadataCorrectlyDescribesResource;

MetadataCompleteness :=
    DegreeToWhichRequiredOrExpectedMetadataIsPresent;

MetadataConsistency :=
    DegreeToWhichMetadataUsesCompatibleValuesStructuresAndSemantics;

MetadataTimeliness :=
    DegreeToWhichMetadataReflectsCurrentResourceState;

MetadataQuality :=
    CompositeAssessmentOf {
        Accuracy,
        Completeness,
        Consistency,
        Timeliness,
        ProvenanceQuality
    };

DuplicateMetadataRecord :=
    MultipleRecordsPotentiallyDescribingSameResource;

IdentifierResolution MAY_SUPPORT DuplicateDetection;

MetadataConflict :=
    IncompatibleMetadataValuesForSameResourceAndProperty;

ConflictHandling MAY {
    PreserveProvenance,
    PreferAuthoritativeSource,
    AssignConfidence,
    FlagReview
};

MetadataAssertion MAY_HAVE Confidence;

Confidence MAY_BE_FUNCTION_OF {
    SourceReliability,
    ExtractionMethod,
    Validation,
    Agreement
};

MetadataCreation MAY_BE {
    Manual,
    Automatic,
    SemiAutomatic
};

MetadataExtraction :=
    Resource
    -> InspectContentOrTechnicalProperties
    -> GenerateMetadataValues;

GeneratedMetadata SHOULD_HAVE MethodProvenance;

Metadata MAY_BE EmbeddedWithinResource;

EmbeddedMetadata MAY_INCLUDE {
    FileHeader,
    DocumentProperties,
    HTMLMarkup,
    MediaMetadata
};

Metadata MAY_BE StoredSeparatelyIn {
    Catalogue,
    Database,
    Registry,
    KnowledgeGraph
};

MetadataIndex :=
    SearchStructureBuiltFromMetadataFieldsAndValues;

Index MAY_SUPPORT {
    KeywordSearch,
    Faceting,
    Filtering,
    SemanticSearch
};

ResourceDiscovery :=
    Query
    -> SearchMetadata
    -> Filter
    -> Rank
    -> ReturnResources;

Facet :=
    MetadataDimensionUsedForNavigationOrFiltering;

Facet MAY_INCLUDE {
    Type,
    Subject,
    Creator,
    Date,
    Format
};

MetadataCatalogue :=
    OrganisedCollectionOfMetadataRecords;

MetadataRegistry :=
    ManagedRepositoryOfSchemasElementsVocabulariesOrProfiles;

MetadataLifecycle :=
    Create
    -> Validate
    -> Publish
    -> Use
    -> Maintain
    -> Version
    -> Archive;

MetadataMaintenance :=
    UpdateMetadataWhenResourceOrKnowledgeChanges;

MetadataVersion :=
    IdentifiedRevisionOfRecordSchemaVocabularyOrProfile;

MetadataChangeHistory :=
    OrderedRecordOfMetadataModifications;

ArchivedMetadata SHOULD_PRESERVE HistoricalContextVersionAndProvenance;

Fixity :=
    EvidenceThatDigitalResourceHasNotChangedUnexpectedly;

Fixity MAY_USE CryptographicHash;

Authenticity :=
    ConfidenceThatResourceIsWhatItClaimsToBeAndHasExpectedProvenance;

MetadataGovernance :=
    PoliciesRolesStandardsAndProcessesForManagingMetadata;

Governance MAY_DEFINE {
    Ownership,
    Stewardship,
    QualityRules,
    Access,
    Retention
};

MetadataSteward :=
    AgentResponsibleForMetadataQualityAndGovernance;

MetadataAccessControl MAY_APPLY_TO {
    Record,
    Property,
    Value,
    Collection
};

Metadata MAY_REVEAL SensitiveInformationEvenWithoutUnderlyingContent;

PrivacyPolicy SHOULD_APPLY_TO MetadataAndDerivedRelationships;

MetadataSecurity MAY_INCLUDE {
    Authentication,
    Authorisation,
    Integrity,
    Audit,
    ProvenanceProtection
};

DublinCore MAY_DEFINE GeneralPurposeMetadataElements;

SchemaOrg MAY_PROVIDE StructuredMetadataVocabularyForWebResources;

Metadata MAY_BE IntegratedInto KnowledgeGraph;

MetadataProperty MAY_BECOME GraphAttributeOrTypedRelationship;

SemanticSearch MAY_USE MetadataFor {
    Filtering,
    Ranking,
    EntityResolution,
    ConceptMatching
};

AI MAY_USE MetadataFor {
    Retrieval,
    Classification,
    Context,
    Provenance,
    Governance,
    Explainability
};

RetrievalAugmentedGeneration MAY_USE MetadataFor {
    SourceSelection,
    Filtering,
    Freshness,
    Citation,
    AccessControl
};

MachineReadableMetadata SHOULD_HAVE {
    StableProperties,
    DefinedSemantics,
    ConsistentDatatypes,
    StableIdentifiers
};

# ---------- SEMANTIC REASONING ----------
IF InformationDescribesResourceEntityDatasetOrKnowledgeObject
THEN MetadataClassification := supported;

IF MetadataUsesControlledVocabulary
THEN SemanticConsistency MAY_INCREASE;

IF StableIdentifierExists
THEN CrossSystemResourceLinking MAY_BE MoreReliable;

IF RequiredPropertyMissing
THEN MetadataCompleteness SHOULD_DECREASE;

IF ResourceChanges
AND MetadataRemainsUnchanged
THEN MetadataTimeliness MAY_DECREASE;

IF ConflictingMetadataValuesExist
THEN PreserveProvenance
AND ReassessConfidence;

IF AccessPolicyDeniesMetadataValue
THEN Value MUST_NOT_BE ExposedToUnauthorisedConsumer;

# ---------- SEMANTIC EQUIVALENCE ----------
SEMANTIC_EQUIVALENCE {
    "metadata" ~= "resource descriptive information" WHEN context == resource_description;
    "metadata record" ~= "resource metadata record";
    "metadata element" ~= "metadata field" WHEN schema_context;
    "metadata property" ~= "metadata attribute" WHEN descriptive_context;
    "metadata schema" ~= "metadata specification";
    "metadata crosswalk" ~= "metadata schema mapping";
    "controlled vocabulary" ~= "managed metadata vocabulary";
    "provenance metadata" ~= "origin and history metadata";
}

# ---------- QUERY FLOW ----------
QUERY(q) ->
    NORMALISE(q) ->
    IDENTIFY_RESOURCE(q) ->
    IDENTIFY_METADATA_CATEGORY(q) ->
    IDENTIFY_SCHEMA(q) ->
    IDENTIFY_PROPERTIES_AND_VALUES(q) ->
    IDENTIFY_IDENTIFIER(q) ->
    IDENTIFY_PROVENANCE_RIGHTS_AND_VERSION(q) ->
    VALIDATE_METADATA(q) ->
    APPLY_SEMANTIC_MAPPING(q) ->
    SCORE_CONFIDENCE(q) ->
    RETURN_RELEVANT_METADATA;

# ---------- CONFIDENCE ----------
CONFIDENCE(assertion) :=
    weighted_mean(
        source_reliability,
        metadata_accuracy,
        schema_conformance,
        provenance_quality,
        semantic_consistency,
        contextual_relevance
    );

CONFIDENCE >= 0.90 => HIGH;
CONFIDENCE >= 0.70 AND < 0.90 => MODERATE;
CONFIDENCE < 0.70 => REVIEW;

# ---------- AI CONSUMPTION ----------
AI_CONSUMPTION {
    primary_entity: Metadata;
    ontology: MetadataOntology;
    parse_entities: true;
    parse_relationships: true;
    preserve_relationship_direction: true;
    resolve_semantic_equivalence: true;
    execute_reasoning_rules: true;
    apply_confidence_weighting: true;
    preserve_provenance: true;
}

# ---------- UPDATE MODEL ----------
UPDATE_MODEL {
    new_resource:
        identify
        -> assign_identifier
        -> determine_metadata_requirements
        -> create_record
        -> integrate;

    new_metadata_value:
        validate_property
        -> validate_value
        -> attach_provenance
        -> update_record
        -> integrate;

    schema_revision:
        preserve_previous_version
        -> update_properties_and_constraints
        -> identify_affected_records
        -> validate_migration
        -> regenerate_flow_hash;

    resource_revision:
        identify_changed_resource_state
        -> update_metadata
        -> preserve_history
        -> recompute_quality
        -> recompute_confidence
        -> integrate;

    conflict:
        preserve_provenance
        -> compare_sources
        -> adjust_confidence
        -> flag_review;
}

# ---------- FLOW HASH ----------
FLOW_HASH_INPUT :=
    DOMAIN
    + SUBDOMAIN
    + ONTOLOGY
    + MetadataEntity
    + MetadataCategory
    + LifecycleEntity
    + QualityEntity
    + MetadataSchema
    + MetadataValidation
    + MetadataInteroperability
    + RELATIONSHIPS
    + SEMANTIC_REASONING
    + SEMANTIC_EQUIVALENCE
    + UPDATE_MODEL;

FLOW_HASH :=
    HASH(FLOW_HASH_INPUT);

# ---------- TERMINAL ----------
MetadataOntology
    -> IdentifyDescribedResource
    -> DetermineMetadataPurposeAndCategory
    -> SelectSchemaAndVocabulary
    -> CreateStructuredMetadataRecord
    -> AssignPropertiesValuesAndStableIdentifiers
    -> AttachProvenanceRightsAndContext
    -> ValidateAccuracyCompletenessAndConsistency
    -> MapAcrossSchemasAndSemanticModels
    -> IndexForDiscoveryAndMachineUse
    -> EnforceGovernanceSecurityAndAccess
    -> MaintainVersionsAndChangeHistory
    -> PreserveInteroperabilityAndInterpretability
    -> MaintainReliableMetadataKnowledge;

END FLOW