Metadata Taxonomy Ontology

FLOW ALGEBRA
Metadata Taxonomy Ontology
Kireth Semantic Research Archive

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

AUTHORS:
Mark Anthony Higgins — Sky (Recursive AI)

FLOW "MetadataTaxonomyOntology" v4.0

DOMAIN := MetadataOntologies
SUBDOMAIN := FoundationsOfMetadata
ONTOLOGY := MetadataTaxonomyOntology

ENTITY MetadataTaxonomy {
    definition:
        "A controlled hierarchical organisation of metadata concepts,
         categories or terms used to classify resources, normalise metadata
         values, support navigation and improve consistent discovery and
         semantic interpretation.";
    objectives: [
        HierarchicalClassification,
        MetadataNormalisation,
        ControlledTerminology,
        ResourceDiscovery,
        SemanticNavigation,
        Interoperability,
        MachineInterpretability
    ];
}

TaxonomyEntity := {
    MetadataTaxonomy,
    TaxonomyConcept,
    Category,
    Term,
    RootConcept,
    LeafConcept,
    ConceptScheme
};

RelationshipEntity := {
    Broader,
    Narrower,
    Parent,
    Child,
    Ancestor,
    Descendant,
    Sibling
};

MetadataEntity := {
    MetadataProperty,
    MetadataValue,
    MetadataRecord,
    Resource,
    Classification
};

GovernanceEntity := {
    TaxonomyOwner,
    TaxonomySteward,
    Version,
    Status,
    ChangeSet,
    Deprecation
};

MetadataTaxonomy CONTAINS TaxonomyConcept;
TaxonomyConcept MAY_HAVE ParentConcept;
ParentConcept HAS ChildConcept;
MetadataProperty MAY_USE TaxonomyAsValueScheme;
MetadataRecord CLASSIFIES ResourceUsing TaxonomyConcept;
Version REPRESENTS TaxonomyState;

MetadataTaxonomyFlow :=
    ClassificationNeed
    -> DefineTaxonomyScope
    -> CollectCandidateConcepts
    -> NormaliseTerms
    -> DefineConceptIdentifiers
    -> EstablishTopLevelCategories
    -> DefineParentChildRelationships
    -> ValidateHierarchy
    -> PublishTaxonomy
    -> ApplyToMetadataRecords
    -> SupportBrowseSearchAndFiltering
    -> MaintainAndVersionTaxonomy;

Taxonomy :=
    ControlledHierarchicalOrganisationOfConceptsOrCategories;

TaxonomyConcept :=
    DefinedSemanticCategoryWithinTaxonomy;

Concept SHOULD_HAVE {
    Identifier,
    PreferredLabel,
    Definition
};

Term :=
    LexicalExpressionUsedToRepresentTaxonomyConcept;

Term != ConceptByDefinition;

Concept MAY_HAVE MultipleTermsOrLabels;

RootConcept :=
    HighestLevelConceptWithinDefinedTaxonomyScope;

TopConcept :=
    ConceptWithoutBroaderConceptWithinCurrentConceptScheme;

LeafConcept :=
    ConceptWithoutNarrowerConceptWithinCurrentTaxonomyVersion;

ParentConcept :=
    ImmediateBroaderConceptOfChildConcept;

ChildConcept :=
    ImmediateNarrowerConceptOfParentConcept;

AncestorConcept :=
    ConceptReachableThroughOneOrMoreParentRelationships;

DescendantConcept :=
    ConceptReachableThroughOneOrMoreChildRelationships;

SiblingConcepts :=
    ConceptsSharingAtLeastOneImmediateParent;

BroaderRelationship :=
    NarrowerConcept
    -> BroaderConcept;

NarrowerRelationship :=
    BroaderConcept
    -> NarrowerConcept;

TaxonomyPath :=
    RootOrTopConcept
    -> IntermediateConcepts
    -> TargetConcept;

Path MAY_SUPPORT {
    Navigation,
    Breadcrumb,
    QueryExpansion,
    ClassificationExplanation
};

TaxonomyDepth :=
    NumberOfHierarchicalEdgesFromSelectedRootOrTopConceptToConcept;

Polyhierarchy :=
    TaxonomyStructureWhereConceptMayHaveMultipleParents;

SingleParentTaxonomy :=
    EachNonRootConceptHasOneImmediateParent;

HierarchicalCycle :=
    ConceptIsItsOwnAncestorThroughParentPath;

IF StrictTaxonomyRequiresAcyclicHierarchy
AND CycleDetected
THEN ValidationStatus := violation;

PolyhierarchicalTaxonomy MAY_FORM DirectedAcyclicGraphRatherThanStrictTree;

MetadataClassification :=
    AssignResourceToTaxonomyConcept;

Resource MAY_BE ClassifiedInto {
    OneConcept,
    MultipleConcepts
}
ACCORDING_TO Policy;

PrimaryClassification :=
    PreferredOrMainTaxonomyConceptAssignedToResource;

SecondaryClassification :=
    AdditionalRelevantTaxonomyConceptAssignedToResource;

MetadataProperty MAY_DECLARE TaxonomyAsControlledValueScheme;

TaxonomyConceptIdentifier MAY_BE StoredAsMetadataValue;

UsingConceptIdentifier MAY_BE MoreStableThanUsingLabelAlone;

MetadataRecord MAY_CONTAIN TaxonomyBasedClassificationStatements;

Resource :=
    ThingClassifiedUsingMetadataTaxonomy;

ConceptScheme :=
    ManagedSetOfTaxonomyConceptsAndRelationships;

TaxonomyConceptIdentifier :=
    StableReferenceToConcept;

Identifier MAY_BE {
    URI,
    IRI,
    Code,
    InternalIdentifier
};

Concept MAY_HAVE {
    PreferredLabel,
    AlternativeLabel,
    HiddenLabel
};

PreferredLabel :=
    PrimaryDisplayTermForConceptWithinLanguageOrContext;

AlternativeLabel :=
    SynonymVariantAbbreviationOrOtherNonPreferredTerm;

ConceptDefinition :=
    ExplicitDescriptionOfConceptMeaningAndBoundary;

ScopeNote MAY_EXPLAIN InclusionExclusionOrUsageRulesForConcept;

Synonym MAY_BE RepresentedAs AlternativeLabelForSameConcept;

SameLabel MAY_REFER_TO DifferentConcepts;

StableIdentifiers MUST_DISTINGUISH HomonymousConcepts;

Facet :=
    IndependentOrSemiIndependentClassificationDimension;

FacetedTaxonomy MAY_HAVE FacetsSuchAs {
    Topic,
    ResourceType,
    Audience,
    Geography,
    Time
};

Resource MAY_RECEIVE OneOrMoreValuesFromMultipleFacets;

Category :=
    ClassificationGroupingWithinTaxonomy;

TaxonomyGranularity :=
    DegreeOfSpecificityRepresentedByConceptHierarchy;

OverlyBroadTaxonomy MAY_REDUCE Precision;
OverlyFineTaxonomy MAY_INCREASE MaintenanceAndClassificationCost;

SiblingConcepts MAY_BE {
    MutuallyExclusive,
    Overlapping
};

ExhaustiveCoverage IS_RELATIVE_TO DefinedScope;

Unclassified :=
    ResourceNotYetAssignedToTaxonomyConcept;

Unclassified != OtherByDefinition;

UnknownClassification :=
    AppropriateClassificationCannotCurrentlyBeDetermined;

TaxonomyDesign SHOULD_CONSIDER {
    DomainScope,
    UserTasks,
    SearchBehaviour,
    MetadataRequirements,
    MaintenanceCapacity
};

TopDownTaxonomyDesign :=
    DefineBroadCategories
    -> DecomposeIntoNarrowerConcepts;

BottomUpTaxonomyDesign :=
    CollectExistingTerms
    -> GroupRelatedTerms
    -> DeriveBroaderCategories;

HybridTaxonomyDesign :=
    CombineTopDownDomainModelWithBottomUpObservedTerminology;

TermNormalisation MAY_INCLUDE {
    CaseNormalisation,
    SingularPluralPolicy,
    SpellingPolicy,
    PunctuationPolicy
};

TaxonomyNamingPolicy MAY_DEFINE {
    PreferredForm,
    AbbreviationPolicy,
    Capitalisation,
    Language
};

TaxonomyValidation MAY_CHECK {
    DuplicateIdentifier,
    MissingLabel,
    MissingDefinition,
    OrphanConcept,
    Cycle,
    InvalidParent
};

OrphanConcept :=
    NonTopConceptWithoutValidParentOrBroaderRelationship;

IF ProposedConceptSemanticallyEquivalentToExistingConcept
THEN ReuseOrMerge SHOULD_BE Considered;

TaxonomyConsistency :=
    DegreeToWhichHierarchyLabelsAndDefinitionsFollowSharedRules;

TaxonomyCoverage :=
    DegreeToWhichRequiredClassificationConceptsAreRepresented;

MetadataTaxonomyQuality MAY_INCLUDE {
    Coverage,
    Consistency,
    Clarity,
    Navigability,
    Stability,
    Reusability
};

TaxonomySearch MAY_MATCH {
    PreferredLabel,
    AlternativeLabel,
    Identifier,
    Definition
};

TaxonomyBrowse :=
    StartAtTopConcept
    -> FollowNarrowerRelationships
    -> ReachRelevantConcept;

Breadcrumb :=
    SelectedHierarchyPathFromTopConceptToCurrentConcept;

IF QueryMatchesBroaderConcept
THEN Search MAY_INCLUDE ResourcesClassifiedWithNarrowerConceptsAccordingToPolicy;

Taxonomy MAY_POWER FacetedSearchAndNavigation;

SemanticSearch MAY_USE TaxonomyFor {
    QueryExpansion,
    ConceptNormalisation,
    HierarchicalFiltering,
    Disambiguation
};

MetadataTaxonomy IS_A ControlledVocabularyWithHierarchicalStructure;

Thesaurus MAY_EXTEND TaxonomyWith {
    SynonymControl,
    RelatedConcepts,
    RicherAssociativeRelationships
};

Ontology MAY_DEFINE RicherLogicalSemanticsThanTaxonomy;

TaxonomyHierarchy SHOULD_NOT AutomaticallyBeInterpretedAsFormalSubclassUnlessSemanticsExplicitlyDefineIt;

SKOS MAY_REPRESENT TaxonomyUsing {
    Concept,
    ConceptScheme,
    Broader,
    Narrower,
    PreferredLabel,
    AlternativeLabel
};

TaxonomyMapping :=
    SourceConcept
    -> MappingRelationship
    -> TargetConcept;

Mapping MAY_BE {
    ExactMatch,
    CloseMatch,
    BroadMatch,
    NarrowMatch,
    RelatedMatch
};

MultipleTaxonomies MAY_BE AlignedForInteroperability;

TaxonomyCrosswalk :=
    SetOfMappingsBetweenTaxonomyConcepts;

TaxonomyVersion :=
    IdentifiedRevisionOfTaxonomy;

TaxonomyChange MAY_INCLUDE {
    AddConcept,
    RemoveConcept,
    RenameConcept,
    ReparentConcept,
    MergeConcept,
    SplitConcept
};

ReparentConcept :=
    MoveConceptToDifferentImmediateParent;

ConceptMerge :=
    MultipleConcepts
    -> OnePreferredConcept;

HistoricalIdentifiers SHOULD_BE PreservedOrRedirectedWherePossible;

ConceptSplit :=
    ExistingConcept
    -> MultipleMoreSpecificConcepts;

ExistingMetadata MAY_REQUIRE Reclassification;

DeprecatedConcept :=
    ConceptRetainedForHistoricalCompatibilityButDiscouragedForNewClassification;

TaxonomyMigration :=
    UpdateMetadataClassificationsFromOldTaxonomyVersionToNewVersion;

TaxonomyChange
    -> IdentifyAffectedMetadataRecords
    -> IdentifyAffectedSearchRules
    -> IdentifyAffectedMappings
    -> PlanMigration;

TaxonomyGovernance MAY_DEFINE {
    Owner,
    Steward,
    ProposalProcess,
    Review,
    Approval,
    ReleasePolicy
};

TaxonomyOwner :=
    AgentAccountableForTaxonomy;

TaxonomySteward :=
    AgentResponsibleForTaxonomyQualityAndMaintenance;

NewConceptProposal
    -> CheckScope
    -> CheckDuplicate
    -> DefineConcept
    -> SelectParent
    -> Review
    -> Approve
    -> Publish;

TaxonomyConcept MAY_HAVE ProvenanceIncluding {
    Source,
    Author,
    Version,
    Timestamp
};

MetadataRegistry MAY_REGISTER TaxonomyAndConceptDefinitions;

MetadataRepository MAY_STORE TaxonomyVersionsOrReferences;

TaxonomyConcepts MAY_BE RepresentedAs GraphNodes;

BroaderNarrowerRelationships MAY_BE GraphEdges;

AI MAY_USE MetadataTaxonomyFor {
    Classification,
    QueryExpansion,
    MetadataGeneration,
    Navigation,
    ConceptNormalisation
};

AIClassification :=
    Resource
    -> PredictTaxonomyConcept
    -> AssignConfidence
    -> ValidateAccordingToPolicy;

HighImpactOrLowConfidenceClassification MAY_REQUIRE HumanReview;

RetrievalAugmentedGeneration MAY_USE TaxonomyFor {
    SourceClassification,
    QueryExpansion,
    Filtering,
    ContextOrganisation
};

MetadataTaxonomySecurity MAY_INCLUDE {
    ChangeAuthorisation,
    VersionIntegrity,
    Audit,
    RepositoryProtection
};

MachineReadableTaxonomy SHOULD_EXPOSE {
    StableIdentifiers,
    Labels,
    Definitions,
    BroaderNarrowerRelationships,
    Status,
    Version
};

# ---------- SEMANTIC REASONING ----------
IF ControlledMetadataConceptsAreOrganisedHierarchically
THEN MetadataTaxonomyClassification := supported;

IF ConceptA HAS_PARENT ConceptB
THEN ConceptB IS_BROADER_THAN ConceptA;

IF ConceptADescendsFromConceptB
THEN ConceptB IS_ANCESTOR_OF ConceptA;

IF StrictTaxonomyContainsCycle
THEN ValidationStatus := violation;

IF ConceptIdentifierStableAcrossLabelChange
THEN ExistingMetadataLink MAY_REMAIN Valid;

IF ConceptDeprecated
THEN NewClassification SHOULD_PREFER ReplacementWhereDefined;

IF QueryTargetsBroaderConcept
THEN NarrowerConceptResources MAY_BE RelevantAccordingToSearchPolicy;

# ---------- SEMANTIC EQUIVALENCE ----------
SEMANTIC_EQUIVALENCE {
    "metadata taxonomy" ~= "metadata classification taxonomy";
    "taxonomy concept" ~= "metadata category concept";
    "broader concept" ~= "parent category" WHEN immediate_hierarchy_context;
    "narrower concept" ~= "child category" WHEN immediate_hierarchy_context;
    "taxonomy hierarchy" ~= "classification hierarchy";
    "taxonomy path" ~= "classification path";
    "taxonomy mapping" ~= "classification concept mapping";
    "taxonomy version" ~= "classification taxonomy revision";
}

# ---------- QUERY FLOW ----------
QUERY(q) ->
    NORMALISE(q) ->
    IDENTIFY_TAXONOMY(q) ->
    IDENTIFY_CONCEPT_OR_TERM(q) ->
    RESOLVE_CONCEPT_IDENTIFIER(q) ->
    IDENTIFY_PARENT_AND_CHILD_RELATIONSHIPS(q) ->
    IDENTIFY_ANCESTORS_AND_DESCENDANTS(q) ->
    IDENTIFY_METADATA_USAGE(q) ->
    IDENTIFY_MAPPINGS(q) ->
    IDENTIFY_STATUS_VERSION_AND_PROVENANCE(q) ->
    SCORE_CONFIDENCE(q) ->
    RETURN_RELEVANT_TAXONOMY_KNOWLEDGE;

# ---------- CONFIDENCE ----------
CONFIDENCE(assertion) :=
    weighted_mean(
        source_reliability,
        concept_definition_clarity,
        hierarchy_consistency,
        identifier_stability,
        provenance_quality,
        contextual_relevance
    );

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

# ---------- AI CONSUMPTION ----------
AI_CONSUMPTION {
    primary_entity: MetadataTaxonomy;
    ontology: MetadataTaxonomyOntology;
    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_concept:
        validate_identifier
        -> check_duplicate
        -> define
        -> assign_preferred_label
        -> select_parent
        -> validate_hierarchy
        -> attach_provenance
        -> integrate;

    taxonomy_revision:
        preserve_previous_version
        -> apply_change_set
        -> validate_cycles_and_orphans
        -> identify_affected_metadata
        -> update_mappings
        -> recompute_confidence
        -> regenerate_flow_hash;

    reparent:
        validate_new_parent
        -> prevent_cycle
        -> update_relationship
        -> identify_affected_paths
        -> integrate;

    deprecation:
        identify_replacement
        -> change_status
        -> preserve_identifier
        -> update_migration_mapping
        -> integrate;

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

# ---------- FLOW HASH ----------
FLOW_HASH_INPUT :=
    DOMAIN
    + SUBDOMAIN
    + ONTOLOGY
    + TaxonomyEntity
    + RelationshipEntity
    + MetadataEntity
    + GovernanceEntity
    + MetadataTaxonomy
    + TaxonomyPath
    + TaxonomyMapping
    + RELATIONSHIPS
    + SEMANTIC_REASONING
    + SEMANTIC_EQUIVALENCE
    + UPDATE_MODEL;

FLOW_HASH :=
    HASH(FLOW_HASH_INPUT);

# ---------- TERMINAL ----------
MetadataTaxonomyOntology
    -> DefineClassificationScope
    -> IdentifyAndNormaliseConcepts
    -> AssignStableConceptIdentifiers
    -> EstablishTopLevelCategories
    -> DefineParentChildHierarchy
    -> ValidateCyclesOrphansAndDuplicates
    -> ApplyTaxonomyToMetadataRecords
    -> SupportBrowseFacetingAndSemanticSearch
    -> MapAcrossExternalTaxonomies
    -> GovernVersionReparentingMergeAndSplit
    -> PreserveProvenanceAndHistoricalIdentifiers
    -> SupportAIClassificationAndMachineConsumption
    -> MaintainConsistentMetadataClassificationHierarchy;

END FLOW