Category Ontology

FLOW ALGEBRA
Category Ontology
Kireth Semantic Research Archive

PAGE:
https://kirethresearch.org/booksai-core/ontologies/metadata-ontologies/descriptive-metadata/category-ontology-2.html

AUTHORS:
Mark Anthony Higgins — Sky (Recursive AI)

FLOW "CategoryOntology" v4.0

DOMAIN := MetadataOntologies
SUBDOMAIN := DescriptiveMetadata
ONTOLOGY := CategoryOntology

ENTITY Category {
    definition:
        "A defined grouping used in descriptive metadata to classify resources,
         concepts or entities according to shared characteristics, themes,
         types or organisational criteria for discovery, navigation,
         filtering and semantic interpretation.";
    objectives: [
        ResourceClassification,
        Grouping,
        Discovery,
        Navigation,
        Filtering,
        SemanticOrganisation,
        Interoperability
    ];
}

CategoryEntity := {
    Category,
    Resource,
    CategoryConcept,
    ParentCategory,
    ChildCategory,
    RootCategory,
    LeafCategory,
    CategoryScheme
};

MetadataEntity := {
    MetadataRecord,
    CategoryProperty,
    CategoryValue,
    Identifier,
    Label,
    Definition,
    Provenance
};

SemanticEntity := {
    Taxonomy,
    ControlledVocabulary,
    Subject,
    ResourceType,
    Classification,
    Ontology
};

Category CLASSIFIES Resource;
Resource BELONGS_TO Category;
Category MAY_HAVE ParentCategory;
ParentCategory HAS ChildCategory;
CategoryScheme CONTAINS CategoryConcept;
CategoryConcept HAS Identifier;
MetadataRecord CONTAINS CategoryStatement;

CategoryFlow :=
    Resource
    -> IdentifyClassificationPurpose
    -> SelectCategoryScheme
    -> IdentifyCandidateCategories
    -> ResolveCanonicalCategory
    -> ValidateCategoryAssignment
    -> AttachIdentifierAndProvenance
    -> StoreInMetadataRecord
    -> IndexForBrowseAndFiltering
    -> MaintainHierarchyAndVersion;

Category :=
    DefinedGroupingOfResourcesConceptsOrEntities;

Category MAY_BE {
    FlatCategory,
    HierarchicalCategory,
    FacetedCategory,
    ControlledCategory
};

CategoryConcept :=
    SemanticConceptRepresentedByCategory;

CategoryValue :=
    MetadataValueRepresentingCategoryAssignment;

CategoryValue MAY_BE {
    Label,
    Code,
    Identifier,
    ConceptReference
};

CategoryStatement :=
    Resource
    -> CategoryProperty
    -> CategoryValue;

CategoryProperty MAY_BE {
    category,
    classification,
    resourceCategory,
    collectionCategory
};

CategoryScheme :=
    ManagedSetOfCategoriesAndRelationships;

CategoryScheme MAY_BE {
    FlatScheme,
    HierarchicalScheme,
    FacetedScheme
};

FlatCategory :=
    CategoryWithoutRequiredParentChildHierarchy;

HierarchicalCategory :=
    CategoryParticipatingInBroaderNarrowerOrParentChildStructure;

FacetedCategory :=
    CategoryBelongingToIndependentClassificationDimension;

RootCategory :=
    HighestCategoryWithinDefinedHierarchy;

LeafCategory :=
    CategoryWithoutChildCategoryWithinCurrentScheme;

ParentCategory :=
    ImmediateBroaderGroupingOfChildCategory;

ChildCategory :=
    ImmediateNarrowerGroupingOfParentCategory;

AncestorCategory :=
    CategoryReachableThroughOneOrMoreParentRelationships;

DescendantCategory :=
    CategoryReachableThroughOneOrMoreChildRelationships;

SiblingCategories :=
    CategoriesSharingAtLeastOneParentCategory;

CategoryPath :=
    RootCategory
    -> IntermediateCategories
    -> TargetCategory;

CategoryDepth :=
    NumberOfHierarchyEdgesFromSelectedRootToCategory;

IF CategoryA HAS_PARENT CategoryB
THEN CategoryB IS_BROADER_THAN CategoryA;

IF CategoryA IS_DESCENDANT_OF CategoryB
THEN CategoryB IS_ANCESTOR_OF CategoryA;

Polyhierarchy :=
    CategoryStructureWhereCategoryMayHaveMultipleParents;

Polyhierarchy MAY_REPRESENT MultipleValidOrganisationalContexts;

HierarchicalCycle :=
    CategoryIsItsOwnAncestorThroughParentPath;

IF StrictCategoryHierarchyRequiresAcyclicStructure
AND HierarchicalCycleDetected
THEN ValidationStatus := violation;

CategoryIdentifier :=
    StableReferenceToCategoryConcept;

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

StableCategoryIdentifier SHOULD_BE PreferredForMachineLinkingOverLabelAlone;

CategoryLabel :=
    HumanReadableNameOfCategory;

Category MAY_HAVE {
    PreferredLabel,
    AlternativeLabel,
    MultilingualLabel
};

PreferredLabel :=
    PrimaryDisplayLabelForCategoryWithinLanguageOrContext;

AlternativeLabel :=
    VariantSynonymAbbreviationOrNonPreferredLabelForCategory;

CategoryDefinition :=
    ExplicitDescriptionOfCategoryMeaningAndMembershipBoundary;

ScopeNote MAY_EXPLAIN {
    IncludedResources,
    ExcludedResources,
    UsageRules
};

CategoryCriteria :=
    ConditionsUsedToDetermineCategoryMembership;

Criteria MAY_BE {
    Semantic,
    RuleBased,
    AttributeBased,
    Editorial
};

CategoryMembership :=
    RelationshipBetweenResourceAndCategory;

Membership MAY_BE {
    Explicit,
    Inferred,
    Predicted
};

ExplicitCategory :=
    CategoryAssignedDirectlyByAuthorisedMetadataProcess;

InferredCategory :=
    CategoryDerivedFromRulesOrRelationships;

PredictedCategory :=
    CategorySuggestedByStatisticalOrAIModel;

PredictedCategory SHOULD_HAVE Confidence;

CategoryAssignment :=
    Resource
    -> SelectCategory
    -> ValidateMembership
    -> StoreClassification;

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

PrimaryCategory :=
    MainCategoryAssignedToResourceAccordingToPolicy;

SecondaryCategory :=
    AdditionalCategoryAssignedToResource;

Resource MAY_HAVE MultipleCategories;

CategoryExclusivity MAY_BE {
    Exclusive,
    NonExclusive
};

IF CategorySchemeRequiresExclusiveSiblingMembership
AND ResourceAssignedToConflictingSiblings
THEN ValidationStatus MAY_BE violation;

CategoryCoverage :=
    DegreeToWhichCategorySchemeRepresentsRequiredResourceGroupings;

CategoryGranularity :=
    DegreeOfSpecificityOfCategoryStructure;

OverlyBroadCategory MAY_REDUCE FilteringPrecision;

OverlyNarrowCategory MAY_INCREASE MaintenanceComplexity;

CategoryBalance :=
    DistributionOfResourcesOrSubcategoriesAcrossCategoryStructure;

UnevenBalance IS_NOT AutomaticallyInvalid;

Uncategorised :=
    ResourceWithoutCategoryAssignment;

Uncategorised != OtherCategoryByDefinition;

OtherCategory :=
    CatchAllCategoryForResourcesWithinScopeNotRepresentedBySpecificCategories;

OtherCategory SHOULD_NOT HideRepeatedNeedForNewCategory;

UnknownCategory :=
    AppropriateCategoryCannotCurrentlyBeDetermined;

CategoryNormalisation MAY_INCLUDE {
    LabelNormalisation,
    IdentifierResolution,
    SchemeMapping,
    LanguageNormalisation
};

SameCategoryLabel MAY_REFER_TO DifferentCategoryConceptsAcrossSchemes;

SchemeAndIdentifier MUST_BE PreservedForDisambiguation;

CategoryMapping :=
    SourceCategory
    -> MappingRelationship
    -> TargetCategory;

Mapping MAY_BE {
    Exact,
    Close,
    Broader,
    Narrower,
    Related
};

CrossSchemeCategoryMapping MAY_SUPPORT Interoperability;

ExactCategoryMapping SHOULD_REQUIRE StrongSemanticEquivalence;

CategoryMerge :=
    MultipleEquivalentOrObsoleteCategories
    -> PreferredCategory;

Merge SHOULD_PRESERVE HistoricalIdentifiersAndMappings;

CategorySplit :=
    BroadOrAmbiguousCategory
    -> MultipleMoreSpecificCategories;

Split MAY_REQUIRE ExistingResourceReclassification;

ReparentCategory :=
    MoveCategoryToDifferentParent;

Reparenting MAY_CHANGE NavigationAndInheritedContext;

CategoryVersion :=
    IdentifiedRevisionOfCategorySchemeOrAssignment;

CategoryChange MAY_INCLUDE {
    AddCategory,
    RemoveCategory,
    RenameCategory,
    ReparentCategory,
    MergeCategory,
    SplitCategory
};

DeprecatedCategory :=
    CategoryRetainedForCompatibilityButDiscouragedForNewAssignments;

DeprecatedCategory SHOULD_REFERENCE ReplacementWhereAvailable;

CategoryMigration :=
    UpdateResourceAssignmentsFromOldSchemeVersionToNewVersion;

MetadataSchema MAY_DEFINE CategoryPropertyAs {
    Required,
    Recommended,
    Optional
};

MetadataSchema MAY_RESTRICT CategoryValuesTo CategoryScheme;

CategoryValidation MAY_CHECK {
    IdentifierValidity,
    SchemeMembership,
    DuplicateAssignment,
    Hierarchy,
    Exclusivity,
    Relevance
};

IF CategoryNotInRequiredScheme
THEN ValidationStatus := violation_or_warning
ACCORDING_TO policy;

DuplicateCategoryAssignment :=
    SameCanonicalCategoryAssignedMultipleTimesToSameResourceAndContext;

DuplicateAssignments SHOULD_BE Consolidated;

CategoryProvenance MAY_INCLUDE {
    Source,
    Assigner,
    AssignmentMethod,
    Timestamp,
    ModelVersion
};

CategoryConfidence :=
    EstimatedSupportForCategoryAssignment;

IF PredictedCategoryConfidence < AcceptanceThreshold
THEN Assignment MAY_REQUIRE HumanReview;

Taxonomy :=
    HierarchicalControlledClassificationStructure;

CategoryScheme MAY_BE ImplementedAs Taxonomy;

Category != SubjectByDefinition;

Subject PrimarilyRepresentsWhatResourceIsAbout;
Category MAY_Represent TopicTypeFunctionOrOrganisationalGrouping;

Category != ResourceTypeByDefinition;

ResourceType DescribesNatureOrForm;
Category MAY_ProvideBroaderOrApplicationSpecificGrouping;

ControlledVocabulary MAY_DEFINE PermittedCategoryConcepts;

Ontology MAY_DEFINE FormalSemanticsForCategoryConceptsAndRelationships;

SKOS MAY_REPRESENT CategorySchemesUsing {
    Concept,
    ConceptScheme,
    Broader,
    Narrower,
    PreferredLabel
};

CategoryIndex :=
    SearchStructureMappingCategoriesToResources;

CategoryIndex MAY_SUPPORT {
    Browse,
    Filtering,
    Faceting,
    QueryExpansion
};

CategoryBrowse :=
    StartAtRootOrTopCategory
    -> FollowChildCategories
    -> RetrieveResources;

CategoryFacet :=
    CategoryUsedAsFilterDimension;

IF QueryTargetsParentCategory
THEN Search MAY_INCLUDE ResourcesAssignedToDescendantCategoriesAccordingToPolicy;

SemanticSearch MAY_USE CategoryFor {
    Filtering,
    QueryExpansion,
    Ranking,
    Navigation,
    ConceptMatching
};

CategoryConcept MAY_BE EmbeddedForSemanticSimilarity;

VectorSimilarity MAY_SUGGEST CategoryRelationship
BUT DoesNotEstablishFormalHierarchy;

KnowledgeGraph MAY_REPRESENT:
    Resource
    -> BELONGS_TO
    -> CategoryConcept;

ParentChildCategoryRelationships MAY_BE GraphEdges;

MetadataRepository MAY_STORE CategoryAssignments;

MetadataRegistry MAY_REGISTER CategoryPropertiesSchemesAndMappings;

MetadataCatalogue MAY_USE CategoriesForBrowseAndFaceting;

CategoryInteroperability MAY_REQUIRE {
    StableIdentifiers,
    SharedScheme,
    Crosswalk,
    DefinedSemantics
};

CategoryCrosswalk :=
    MappingBetweenCategorySchemes;

AI MAY_USE CategoriesFor {
    Classification,
    Recommendation,
    Retrieval,
    Navigation,
    MetadataGeneration
};

AICategoryClassification :=
    Resource
    -> AnalyseFeatures
    -> PredictCategory
    -> AssignConfidence
    -> Validate
    -> StoreApprovedAssignment;

AIGeneratedCategory SHOULD_NOT BeTreatedAsAuthoritativeWithoutPolicyAppropriateValidation;

RetrievalAugmentedGeneration MAY_USE CategoryFor {
    SourceFiltering,
    QueryRouting,
    ContextSelection,
    ResourceGrouping
};

PrivacyPolicy MAY_RESTRICT CategoryAssignmentsThatRevealSensitiveInformation;

CategoryAccessControl MAY_APPLY_TO {
    Scheme,
    Category,
    Assignment
};

CategorySecurity MAY_INCLUDE {
    InputValidation,
    AccessControl,
    ProvenanceIntegrity,
    ChangeAuthorisation
};

MachineReadableCategory SHOULD_PRESERVE {
    Identifier,
    Label,
    Scheme,
    ParentRelationships,
    Provenance,
    Confidence
};

# ---------- SEMANTIC REASONING ----------
IF MetadataValueAssignsResourceToDefinedGrouping
THEN CategoryClassification := supported;

IF CategoryA HAS_PARENT CategoryB
AND Resource BELONGS_TO CategoryA
THEN Resource MAY_BE RelevantToCategoryB
ACCORDING_TO retrieval_policy;

IF CategoryIdentifierStableAcrossLabelChange
THEN ExistingResourceAssignment MAY_REMAIN Valid;

IF CategoryDeprecated
THEN NewAssignments SHOULD_PREFER ReplacementWhereDefined;

IF StrictHierarchyContainsCycle
THEN CategorySchemeValidation SHOULD_FLAG Error;

IF SameLabelExistsInDifferentSchemes
THEN SchemeContextAndIdentifier MUST_BE UsedForResolution;

IF PredictedCategoryConfidenceLow
THEN AutomaticAuthoritativeAssignment SHOULD_BE Restricted;

# ---------- SEMANTIC EQUIVALENCE ----------
SEMANTIC_EQUIVALENCE {
    "category" ~= "resource category" WHEN metadata_context;
    "category metadata" ~= "classification category metadata";
    "category concept" ~= "classification concept";
    "parent category" ~= "broader category" WHEN immediate_hierarchy_context;
    "child category" ~= "narrower category" WHEN immediate_hierarchy_context;
    "category scheme" ~= "classification scheme" WHEN category_based;
    "category mapping" ~= "classification category mapping";
    "category assignment" ~= "resource categorisation";
}

# ---------- QUERY FLOW ----------
QUERY(q) ->
    NORMALISE(q) ->
    IDENTIFY_RESOURCE(q) ->
    IDENTIFY_CATEGORY_SCHEME(q) ->
    IDENTIFY_CATEGORY_VALUE(q) ->
    RESOLVE_CATEGORY_IDENTIFIER(q) ->
    IDENTIFY_PARENT_CHILD_RELATIONSHIPS(q) ->
    IDENTIFY_ASSIGNMENT_TYPE(q) ->
    IDENTIFY_PROVENANCE_AND_CONFIDENCE(q) ->
    VALIDATE_CATEGORY_ASSIGNMENT(q) ->
    RETURN_RELEVANT_CATEGORY_KNOWLEDGE;

# ---------- CONFIDENCE ----------
CONFIDENCE(assertion) :=
    weighted_mean(
        source_reliability,
        category_relevance,
        identifier_strength,
        hierarchy_consistency,
        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: Category;
    ontology: CategoryOntology;
    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_category_assignment:
        identify_resource
        -> resolve_category
        -> identify_scheme
        -> validate_membership
        -> attach_provenance
        -> assign_confidence
        -> integrate;

    new_category:
        validate_identifier
        -> check_duplicate
        -> define
        -> assign_label
        -> place_in_scheme
        -> validate_hierarchy
        -> integrate;

    category_revision:
        preserve_previous_version
        -> apply_change_set
        -> validate_cycles_and_conflicts
        -> identify_affected_resources
        -> update_indexes_and_mappings
        -> recompute_confidence
        -> regenerate_flow_hash;

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

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

# ---------- FLOW HASH ----------
FLOW_HASH_INPUT :=
    DOMAIN
    + SUBDOMAIN
    + ONTOLOGY
    + CategoryEntity
    + MetadataEntity
    + SemanticEntity
    + Category
    + CategoryAssignment
    + CategoryMapping
    + RELATIONSHIPS
    + SEMANTIC_REASONING
    + SEMANTIC_EQUIVALENCE
    + UPDATE_MODEL;

FLOW_HASH :=
    HASH(FLOW_HASH_INPUT);

# ---------- TERMINAL ----------
CategoryOntology
    -> IdentifyResourceAndClassificationPurpose
    -> SelectCategoryScheme
    -> ResolveCanonicalCategoryConcept
    -> AssignStableCategoryIdentifier
    -> DetermineParentChildHierarchy
    -> ValidateMembershipHierarchyAndExclusivity
    -> AttachProvenanceAndConfidence
    -> StoreCategoryMetadata
    -> IndexForBrowseFilteringAndFaceting
    -> MapAcrossExternalCategorySchemes
    -> GovernVersionMergeSplitAndDeprecation
    -> SupportSemanticSearchAndAIClassification
    -> MaintainReliableResourceCategoryKnowledge;

END FLOW