Metadata Record Ontology

FLOW ALGEBRA
Metadata Record Ontology
Kireth Semantic Research Archive

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

AUTHORS:
Mark Anthony Higgins — Sky (Recursive AI)

FLOW "MetadataRecordOntology" v4.0

# ---------- DOMAIN ----------
DOMAIN := MetadataOntologies
SUBDOMAIN := FoundationsOfMetadata
ONTOLOGY := MetadataRecordOntology

# ---------- PRIMARY ENTITY ----------
ENTITY MetadataRecord {
    definition:
        "A structured collection of metadata statements that describes,
         identifies, contextualises and manages a specific resource according
         to a metadata schema, model, vocabulary or application profile.";

    objectives: [
        ResourceDescription,
        StructuredMetadataCapture,
        Identification,
        Validation,
        Discovery,
        ProvenanceTracking,
        Interoperability
    ];
}

# ---------- CORE ENTITIES ----------
RecordEntity := {
    MetadataRecord,
    Resource,
    MetadataStatement,
    MetadataElement,
    MetadataProperty,
    MetadataValue,
    Identifier,
    Schema
};

ContextEntity := {
    Provenance,
    Version,
    Language,
    Rights,
    AccessPolicy,
    Timestamp,
    Source
};

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

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

# ---------- FUNDAMENTAL RELATIONSHIPS ----------
MetadataRecord DESCRIBES Resource;
MetadataRecord CONTAINS MetadataStatement;
MetadataStatement USES MetadataProperty;
MetadataStatement HAS MetadataValue;
MetadataRecord CONFORMS_TO Schema;
Identifier IDENTIFIES Resource;
Provenance SUPPORTS MetadataStatement;
Version REPRESENTS RecordState;

# ---------- METADATA RECORD FLOW ----------
Resource
    -> IdentifyResource
    -> SelectApplicableSchema
    -> CreateMetadataRecord
    -> AssignRecordIdentifier
    -> PopulateMetadataStatements
    -> AttachResourceIdentifier
    -> AttachProvenanceAndContext
    -> ValidateRecord
    -> StoreAndIndex
    -> PublishOrExchange
    -> UpdateAndVersion
    -> ArchiveWhenRequired;

# ---------- RESOURCE ----------
Resource :=
    ThingDescribedByMetadataRecord;

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

# ---------- RECORD IDENTIFIER ----------
RecordIdentifier :=
    StableOrLocallyUniqueReferenceToMetadataRecord;

RecordIdentifier != ResourceIdentifierByDefinition;

# ---------- RESOURCE IDENTIFIER ----------
ResourceIdentifier :=
    StableReferenceToDescribedResource;

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

# ---------- RECORD / RESOURCE DISTINCTION ----------
MetadataRecord IS_ABOUT Resource;

MetadataRecord MAY_HAVE DifferentLifecycleFrom Resource;

DeletingMetadataRecord DOES_NOT NecessarilyDelete Resource;

# ---------- METADATA STATEMENT ----------
MetadataStatement :=
    Resource
    -> MetadataProperty
    -> MetadataValue;

MetadataRecord CONTAINS OneOrMoreMetadataStatements;

# ---------- METADATA ELEMENT ----------
MetadataElement :=
    StructuredFieldOrComponentWithinMetadataRecord;

MetadataElement MAY_HAVE {
    Label,
    Identifier,
    Definition,
    Datatype,
    Cardinality
};

# ---------- PROPERTY ----------
MetadataProperty :=
    SemanticCharacteristicUsedToDescribeResource;

Property MAY_BE {
    LiteralValued,
    EntityValued,
    ControlledVocabularyValued
};

# ---------- VALUE ----------
MetadataValue :=
    ValueAssignedToMetadataProperty;

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

# ---------- MULTIVALUED PROPERTY ----------
MetadataProperty MAY_HAVE MultipleValues
IF SchemaCardinalityAllows;

# ---------- SCHEMA ----------
MetadataSchema :=
    SpecificationDefiningAllowedMetadataPropertiesValuesAndConstraints;

Record SHOULD_REFERENCE ApplicableSchemaOrProfileWhereRequired;

# ---------- APPLICATION PROFILE ----------
ApplicationProfile :=
    MetadataSpecificationTailoredToSpecificCommunityOrUseCase;

MetadataRecord MAY_CONFORM_TO ApplicationProfile;

# ---------- RECORD TYPE ----------
MetadataRecordType MAY_BE {
    DescriptiveRecord,
    AdministrativeRecord,
    TechnicalRecord,
    PreservationRecord,
    CompositeRecord
};

# ---------- DESCRIPTIVE RECORD ----------
DescriptiveMetadataRecord MAY_INCLUDE {
    Title,
    Creator,
    Subject,
    Description,
    Publisher,
    Date,
    Type,
    Format,
    Language
};

# ---------- ADMINISTRATIVE RECORD ----------
AdministrativeMetadataRecord MAY_INCLUDE {
    Rights,
    Ownership,
    Access,
    Acquisition,
    ManagementStatus
};

# ---------- TECHNICAL RECORD ----------
TechnicalMetadataRecord MAY_INCLUDE {
    FileFormat,
    FileSize,
    Resolution,
    Codec,
    SoftwareVersion
};

# ---------- PRESERVATION RECORD ----------
PreservationMetadataRecord MAY_INCLUDE {
    Fixity,
    PreservationEvent,
    Environment,
    Provenance,
    Rights
};

# ---------- COMPOSITE RECORD ----------
CompositeMetadataRecord :=
    RecordContainingMultipleMetadataCategories;

# ---------- TITLE ----------
Title :=
    HumanReadableNameOfResource;

# ---------- CREATOR ----------
Creator :=
    AgentResponsibleForCreatingResource;

# ---------- SUBJECT ----------
Subject :=
    TopicConceptOrDomainAssociatedWithResource;

# ---------- DESCRIPTION ----------
Description :=
    HumanReadableSummaryOrExplanationOfResource;

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

DateRole SHOULD_BE Explicit;

# ---------- TYPE ----------
ResourceType :=
    ClassificationOfResourceNatureOrGenre;

# ---------- FORMAT ----------
Format :=
    PhysicalOrDigitalFormatOfResource;

# ---------- LANGUAGE ----------
Language :=
    LanguageAssociatedWithResourceOrMetadataValue;

# ---------- RELATION ----------
ResourceRelation :=
    TypedRelationshipBetweenDescribedResourceAndOtherResource;

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

# ---------- RIGHTS ----------
Rights :=
    InformationAboutPermissionsRestrictionsOwnershipOrUsage;

# ---------- ACCESS ----------
AccessPolicy :=
    RuleDeterminingWhoMayReadOrUseRecordPropertyOrResource;

# ---------- PROVENANCE ----------
RecordProvenance :=
    OriginAndHistoryOfMetadataRecord;

RecordProvenance MAY_INCLUDE {
    Creator,
    Source,
    CreatedTimestamp,
    ModifiedTimestamp,
    ImportProcess
};

# ---------- STATEMENT PROVENANCE ----------
IndividualMetadataStatement MAY_HAVE ItsOwnProvenance;

StatementLevelProvenance MAY_DIFFER_FROM RecordLevelProvenance;

# ---------- SOURCE ----------
MetadataSource :=
    OriginFromWhichMetadataValueOrRecordWasObtained;

# ---------- TIMESTAMP ----------
RecordTimestamp MAY_INCLUDE {
    CreatedAt,
    UpdatedAt,
    PublishedAt
};

# ---------- LANGUAGE TAG ----------
TextualMetadataValue MAY_HAVE LanguageTag;

# ---------- CONTROLLED VOCABULARY ----------
MetadataValue MAY_REFERENCE ControlledVocabularyTerm;

ControlledVocabulary MAY_IMPROVE ConsistencyAndRetrieval;

# ---------- NULL / MISSING ----------
MissingMetadataValue != EmptyStringByDefinition;

Schema SHOULD_DEFINE HowMissingUnknownOrNotApplicableValuesAreRepresented;

# ---------- UNKNOWN ----------
UnknownValue :=
    ValueNotKnownAtRecordCreationOrUpdateTime;

# ---------- NOT APPLICABLE ----------
NotApplicable :=
    PropertyDoesNotSemanticallyApplyToResource;

Unknown != NotApplicable;

# ---------- REQUIRED PROPERTY ----------
IF SchemaMarksPropertyRequired
AND PropertyMissing
THEN RecordConformance := violation;

# ---------- DATATYPE ----------
MetadataValue MUST_MATCH DeclaredDatatypeWhereSchemaRequires;

# ---------- CARDINALITY ----------
ValueCount MUST_SATISFY PropertyCardinality;

# ---------- VALIDATION ----------
MetadataRecordValidation :=
    Record
    + Schema
    -> ValidationResult;

ValidationResult MAY_BE {
    Conformant,
    Warning,
    Violation
};

# ---------- STRUCTURAL VALIDATION ----------
StructuralValidation MAY_CHECK {
    RequiredElements,
    Datatypes,
    Cardinality,
    Nesting,
    IdentifierFormat
};

# ---------- SEMANTIC VALIDATION ----------
SemanticValidation :=
    AssessWhetherValuesCorrectlyRepresentResourceMeaning;

StructurallyValidRecord MAY_STILL_BE SemanticallyIncorrect;

# ---------- VOCABULARY VALIDATION ----------
IF PropertyRequiresControlledVocabulary
AND ValueNotInAllowedVocabulary
THEN ValidationStatus MAY_BE ViolationOrWarningAccordingToPolicy;

# ---------- QUALITY ----------
MetadataRecordQuality MAY_BE EvaluatedBy {
    Accuracy,
    Completeness,
    Consistency,
    Timeliness,
    Provenance
};

# ---------- ACCURACY ----------
RecordAccuracy :=
    DegreeToWhichMetadataValuesCorrectlyDescribeResource;

# ---------- COMPLETENESS ----------
RecordCompleteness :=
    DegreeToWhichRequiredOrExpectedPropertiesArePresent;

# ---------- CONSISTENCY ----------
RecordConsistency :=
    DegreeToWhichValuesFollowSchemaVocabularyAndCrossFieldRules;

# ---------- TIMELINESS ----------
RecordTimeliness :=
    DegreeToWhichRecordReflectsCurrentResourceState;

# ---------- DUPLICATE RECORD ----------
DuplicateMetadataRecord :=
    MultipleMetadataRecordsPotentiallyDescribingSameResource;

ResourceIdentifier MAY_SUPPORT DuplicateDetection;

# ---------- MERGE ----------
RecordMerge :=
    MultipleRecords
    -> ResolveResourceIdentity
    -> CompareStatements
    -> PreserveProvenance
    -> CreateIntegratedRecord;

# ---------- CONFLICT ----------
MetadataConflict :=
    MultipleStatementsAssignIncompatibleValuesToSamePropertyAndContext;

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

# ---------- CONFIDENCE ----------
MetadataStatement MAY_HAVE ConfidenceScore;

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

# ---------- CREATION ----------
RecordCreation :=
    Resource
    -> SelectSchema
    -> CreateRecordIdentifier
    -> PopulateStatements
    -> Validate
    -> Persist;

# ---------- AUTOMATED CREATION ----------
MetadataRecord MAY_BE GeneratedAutomaticallyFrom {
    FileProperties,
    ContentAnalysis,
    ExistingDatabase,
    AIExtraction
};

GeneratedRecord SHOULD_PRESERVE GenerationMethodAndSource;

# ---------- UPDATE ----------
RecordUpdate :=
    ExistingRecord
    + NewOrChangedKnowledge
    -> RevisedRecord;

Update SHOULD_PRESERVE ChangeHistoryWhereRequired;

# ---------- PARTIAL UPDATE ----------
PartialUpdate MAY_MODIFY SelectedMetadataStatementsWithoutReplacingEntireRecord;

# ---------- DELETE ----------
RecordDeletion :=
    RemoveOrMarkMetadataRecordAccordingToRetentionPolicy;

Deletion SHOULD_CONSIDER {
    Audit,
    Provenance,
    LegalRetention
};

# ---------- SOFT DELETE ----------
SoftDeletedRecord MAY_BE RetainedButExcludedFromNormalDiscovery;

# ---------- VERSION ----------
MetadataRecordVersion :=
    IdentifiedStateOfMetadataRecordAtPointInTime;

# ---------- VERSION HISTORY ----------
RecordVersionHistory :=
    OrderedSequenceOfMetadataRecordVersions;

# ---------- DIFF ----------
RecordDiff :=
    ChangesBetweenVersionAAndVersionB;

Diff MAY_INCLUDE {
    AddedStatement,
    RemovedStatement,
    ChangedValue
};

# ---------- AUDIT ----------
RecordAuditTrail MAY_INCLUDE {
    Actor,
    Action,
    Timestamp,
    PreviousValue,
    NewValue,
    Reason
};

# ---------- ARCHIVAL ----------
ArchivedMetadataRecord SHOULD_PRESERVE {
    RecordVersion,
    SchemaVersion,
    Provenance,
    HistoricalContext
};

# ---------- STORAGE ----------
MetadataRecord MAY_BE StoredIn {
    RelationalDatabase,
    DocumentDatabase,
    GraphDatabase,
    TripleStore,
    Catalogue
};

# ---------- SERIALISATION ----------
MetadataRecord MAY_BE SerialisedAs {
    JSON,
    JSONLD,
    XML,
    RDF,
    CSV
};

# ---------- RDF ----------
RDFRecord MAY_REPRESENT MetadataStatementsAsTriples;

# ---------- JSON-LD ----------
JSONLDRecord MAY_LINK MetadataPropertiesAndValuesToSemanticIdentifiers;

# ---------- INDEXING ----------
MetadataRecord MAY_BE IndexedBy {
    Title,
    Creator,
    Subject,
    Type,
    Date,
    Identifier,
    FullText
};

# ---------- DISCOVERY ----------
MetadataDiscovery :=
    Query
    -> SearchMetadataRecords
    -> Filter
    -> Rank
    -> ReturnDescribedResources;

# ---------- FACETING ----------
RecordProperties MAY_SUPPORT FacetedNavigation;

# ---------- INTEROPERABILITY ----------
MetadataRecordInteroperability MAY_REQUIRE {
    SharedSchema,
    SchemaMapping,
    StableIdentifiers,
    VocabularyAlignment
};

# ---------- CROSSWALK ----------
RecordTransformation MAY_USE MetadataCrosswalkBetweenSchemas;

# ---------- TRANSFORMATION ----------
MetadataRecordTransformation :=
    SourceRecord
    + MappingRules
    -> TargetRecord;

Transformation SHOULD_PRESERVE ProvenanceAndDocumentSemanticLoss;

# ---------- KNOWLEDGE GRAPH ----------
MetadataRecord MAY_BE ConvertedInto KnowledgeGraphStatements;

Resource MAY_BECOME GraphNode;
MetadataRelationship MAY_BECOME GraphEdge;

# ---------- SEMANTIC SEARCH ----------
SemanticSearch MAY_USE MetadataRecordFor {
    EntityResolution,
    Filtering,
    Ranking,
    ConceptMatching
};

# ---------- AI ----------
AI MAY_USE MetadataRecordsFor {
    Retrieval,
    Classification,
    Context,
    Provenance,
    TrainingDataGovernance
};

# ---------- RAG ----------
RetrievalAugmentedGeneration MAY_USE MetadataRecordFor {
    SourceSelection,
    Freshness,
    Filtering,
    Citation,
    AccessControl
};

# ---------- ACCESS CONTROL ----------
RecordAccess MAY_BE ControlledAt {
    Record,
    Property,
    Statement
};

# ---------- PRIVACY ----------
MetadataRecord MAY_CONTAIN SensitiveInformationOrSensitiveRelationships;

PrivacyPolicy SHOULD_APPLY_TO RecordAndDerivedKnowledge;

# ---------- SECURITY ----------
MetadataRecordSecurity MAY_INCLUDE {
    Authentication,
    Authorisation,
    Integrity,
    Audit,
    ProvenanceProtection
};

# ---------- FIXITY ----------
RecordFixity MAY_USE CryptographicHashToDetectUnexpectedModification;

# ---------- SEMANTIC REASONING ----------
IF StructuredMetadataStatementsDescribeSpecificResource
THEN MetadataRecordClassification := supported;

IF RecordIdentifierEqualsResourceIdentifier
THEN IdentityRoles SHOULD_STILL_BE DistinguishedSemantically;

IF RequiredPropertyMissing
THEN RecordCompleteness MAY_DECREASE
AND Conformance MAY_FAIL;

IF MetadataValueConflictsAcrossSources
THEN PreserveStatementProvenance
AND ReassessConfidence;

IF ResourceChanges
AND RecordNotUpdated
THEN RecordTimeliness MAY_DECREASE;

IF RecordConformsToSharedSchemaAndVocabulary
THEN Interoperability MAY_INCREASE;

IF AccessPolicyDeniesStatement
THEN Statement MUST_NOT_BE ExposedToUnauthorisedConsumer;

# ---------- SEMANTIC EQUIVALENCE ----------
SEMANTIC_EQUIVALENCE {
    "metadata record" ~= "resource metadata record";
    "metadata description record" ~= "metadata record";
    "metadata statement" ~= "metadata assertion";
    "record identifier" ~= "metadata record ID";
    "record provenance" ~= "metadata record provenance";
    "metadata record version" ~= "record revision";
    "metadata record validation" ~= "record conformance validation";
    "metadata record transformation" ~= "metadata record mapping transformation";
}

# ---------- QUERY FLOW ----------
QUERY(q) ->
    NORMALISE(q) ->
    IDENTIFY_RESOURCE(q) ->
    IDENTIFY_RECORD(q) ->
    IDENTIFY_SCHEMA(q) ->
    IDENTIFY_METADATA_STATEMENTS(q) ->
    IDENTIFY_IDENTIFIERS(q) ->
    IDENTIFY_PROVENANCE_AND_VERSION(q) ->
    VALIDATE_RECORD(q) ->
    IDENTIFY_ACCESS_AND_RIGHTS(q) ->
    SCORE_CONFIDENCE(q) ->
    RETURN_RELEVANT_RECORD_KNOWLEDGE;

# ---------- CONFIDENCE ----------
CONFIDENCE(assertion) :=
    weighted_mean(
        source_reliability,
        record_accuracy,
        schema_conformance,
        provenance_quality,
        identifier_strength,
        contextual_relevance
    );

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

# ---------- AI CONSUMPTION ----------
AI_CONSUMPTION {
    primary_entity: MetadataRecord;
    ontology: MetadataRecordOntology;
    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_record:
        identify_resource
        -> assign_record_identifier
        -> select_schema
        -> populate_statements
        -> attach_provenance
        -> validate
        -> integrate;

    new_statement:
        validate_property
        -> validate_value
        -> attach_source
        -> attach_confidence
        -> add_to_record
        -> integrate;

    record_revision:
        preserve_previous_version
        -> apply_changes
        -> validate
        -> update_quality
        -> update_index
        -> recompute_confidence
        -> regenerate_flow_hash;

    record_merge:
        resolve_resource_identity
        -> compare_statements
        -> preserve_provenance
        -> resolve_or_preserve_conflicts
        -> validate_integrated_record
        -> integrate;

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

# ---------- FLOW HASH ----------
FLOW_HASH_INPUT :=
    DOMAIN
    + SUBDOMAIN
    + ONTOLOGY
    + RecordEntity
    + ContextEntity
    + QualityEntity
    + LifecycleEntity
    + MetadataRecord
    + MetadataStatement
    + MetadataRecordValidation
    + RELATIONSHIPS
    + SEMANTIC_REASONING
    + SEMANTIC_EQUIVALENCE
    + UPDATE_MODEL;

FLOW_HASH :=
    HASH(FLOW_HASH_INPUT);

# ---------- TERMINAL ----------
MetadataRecordOntology
    -> IdentifyDescribedResource
    -> SelectApplicableMetadataSchema
    -> CreateRecordAndStableIdentifiers
    -> PopulateTypedMetadataStatements
    -> AttachContextRightsAndProvenance
    -> ValidateStructureSemanticsAndVocabulary
    -> AssessAccuracyCompletenessAndTimeliness
    -> StoreIndexAndPublishRecord
    -> TransformAcrossCompatibleSchemas
    -> EnforceAccessSecurityAndPrivacy
    -> PreserveVersionAndAuditHistory
    -> UpdateRecordWhenResourceChanges
    -> MaintainReliableResourceMetadataRecord;

END FLOW