Classification Ontology

FLOW ALGEBRA
Classification Ontology
Kireth Semantic Research Archive

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

AUTHORS:
Mark Anthony Higgins — Sky (Recursive AI)

FLOW "ClassificationOntology" v4.0

DOMAIN := MetadataOntologies
SUBDOMAIN := DescriptiveMetadata
ONTOLOGY := ClassificationOntology

ENTITY Classification {
    definition:
        "The structured assignment of a resource, entity or knowledge object
         to one or more defined classes, categories or concepts according to
         explicit criteria, schemes, rules or semantic relationships.";
    objectives: [
        ResourceOrganisation,
        SemanticGrouping,
        Discovery,
        Navigation,
        Filtering,
        KnowledgeOrganisation,
        MachineInterpretability
    ];
}

ClassificationEntity := {
    Classification,
    Resource,
    Class,
    Category,
    ClassificationScheme,
    ClassificationCode,
    ClassificationAssignment,
    Classifier
};

HierarchyEntity := {
    ParentClass,
    ChildClass,
    BroaderClass,
    NarrowerClass,
    RootClass,
    LeafClass,
    ClassPath
};

MetadataEntity := {
    MetadataRecord,
    ClassificationProperty,
    ClassificationValue,
    Identifier,
    Label,
    Definition,
    Provenance
};

ControlEntity := {
    ClassificationRule,
    Criterion,
    Confidence,
    Status,
    Version,
    Validation
};

Classification ASSIGNS Resource TO Class;
ClassificationScheme CONTAINS Class;
Class MAY_HAVE ParentClass;
ParentClass HAS ChildClass;
ClassificationCode IDENTIFIES Class;
Classifier PERFORMS ClassificationAssignment;
MetadataRecord CONTAINS ClassificationStatement;

ClassificationFlow :=
    Resource
    -> DetermineClassificationPurpose
    -> SelectClassificationScheme
    -> ExtractRelevantResourceFeatures
    -> IdentifyCandidateClasses
    -> ApplyClassificationCriteria
    -> ResolveCanonicalClass
    -> AssignClassification
    -> ValidateAssignment
    -> AttachProvenanceAndConfidence
    -> StoreAndIndex
    -> MaintainAndVersion;

Classification :=
    ProcessOrResultOfAssigningResourceToDefinedClassOrCategory;

Resource :=
    ThingBeingClassified;

Resource MAY_BE {
    Document,
    Dataset,
    Media,
    Software,
    WebResource,
    PhysicalObject,
    Event,
    Entity,
    KnowledgeObject
};

Class :=
    DefinedGroupingRepresentingSharedCharacteristicsOrMeaning;

Category MAY_FUNCTION_AS ClassInMetadataClassification;

ClassificationScheme :=
    ManagedSystemOfClassesCodesRelationshipsAndRules;

ClassificationScheme MAY_BE {
    Flat,
    Hierarchical,
    Faceted,
    Enumerated,
    RuleBased
};

ClassificationCode :=
    StableOrManagedCodeRepresentingClass;

ClassificationIdentifier :=
    StableReferenceToClass;

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

ClassificationLabel :=
    HumanReadableNameOfClass;

Class MAY_HAVE {
    PreferredLabel,
    AlternativeLabel,
    MultilingualLabel
};

ClassDefinition :=
    ExplicitDescriptionOfClassMeaningAndMembershipBoundary;

ClassificationCriterion :=
    ConditionOrCharacteristicUsedToDetermineClassMembership;

Criterion MAY_USE {
    ResourceType,
    Subject,
    Attribute,
    Behaviour,
    Purpose,
    Context
};

ClassificationRule :=
    IF Conditions
    THEN AssignOrSuggestClass;

Rule MAY_BE {
    Deterministic,
    Heuristic,
    Probabilistic
};

ClassificationStatement :=
    Resource
    -> ClassificationProperty
    -> ClassificationValue;

ClassificationValue MAY_BE {
    ClassIdentifier,
    ClassificationCode,
    Label,
    ConceptReference
};

ClassificationAssignment :=
    RelationshipBetweenResourceAndAssignedClass;

Assignment MAY_BE {
    Explicit,
    Inferred,
    Predicted
};

ExplicitClassification :=
    AssignmentDirectlyAssertedByAuthorisedMetadataProcess;

InferredClassification :=
    AssignmentDerivedFromSemanticRulesOrExistingRelationships;

PredictedClassification :=
    AssignmentSuggestedByStatisticalOrAIModel;

PredictedClassification SHOULD_HAVE Confidence;

Classifier :=
    HumanSoftwareRuleSystemOrAIModelPerformingClassification;

Classifier MAY_BE {
    HumanClassifier,
    RuleBasedClassifier,
    StatisticalClassifier,
    MachineLearningClassifier,
    AIAssistedClassifier
};

ManualClassification :=
    HumanAgent
    -> EvaluateResource
    -> AssignClass;

AutomaticClassification :=
    Software
    -> AnalyseResource
    -> PredictOrInferClass;

HybridClassification :=
    MachineSuggestion
    -> HumanValidation
    -> ApprovedAssignment;

ClassificationFeature :=
    ResourceCharacteristicUsedByClassifier;

Feature MAY_BE {
    MetadataProperty,
    Keyword,
    Subject,
    TextRepresentation,
    Entity,
    Embedding
};

PrimaryClass :=
    MainClassAssignedToResourceAccordingToPolicy;

SecondaryClass :=
    AdditionalApplicableClass;

Resource MAY_HAVE MultipleClassifications;

SingleLabelClassification :=
    ExactlyOneClassSelectedFromDefinedSet;

MultiLabelClassification :=
    ZeroOrMoreClassesSelectedFromDefinedSet;

MultiClassClassification :=
    OneClassSelectedFromMultipleMutuallyExclusiveClasses;

HierarchicalClassification :=
    ClassificationUsingClassesArrangedInBroaderNarrowerStructure;

ParentClass :=
    ImmediateBroaderClassOfChildClass;

ChildClass :=
    ImmediateNarrowerClassOfParentClass;

AncestorClass :=
    ClassReachableThroughOneOrMoreParentRelationships;

DescendantClass :=
    ClassReachableThroughOneOrMoreChildRelationships;

RootClass :=
    HighestClassWithinDefinedHierarchy;

LeafClass :=
    ClassWithoutChildClassWithinCurrentScheme;

ClassPath :=
    RootClass
    -> IntermediateClasses
    -> AssignedClass;

ClassDepth :=
    NumberOfHierarchyEdgesFromRootToClass;

IF ClassA HAS_PARENT ClassB
THEN ClassB IS_BROADER_THAN ClassA;

IF Resource CLASSIFIED_AS ClassA
AND ClassA NARROWER_THAN ClassB
THEN Resource MAY_BE RelevantToClassB
ACCORDING_TO retrieval_policy;

Polyhierarchy :=
    ClassificationHierarchyWhereClassMayHaveMultipleParents;

HierarchicalCycle :=
    ClassIsItsOwnAncestorThroughParentPath;

IF SchemeRequiresAcyclicHierarchy
AND CycleDetected
THEN ValidationStatus := violation;

FacetedClassification :=
    ClassificationAcrossMultipleIndependentDimensions;

Facet MAY_INCLUDE {
    Topic,
    Type,
    Audience,
    Geography,
    Time,
    Function
};

Resource MAY_HAVE OneOrMoreAssignmentsPerFacetAccordingToPolicy;

MutuallyExclusiveClasses :=
    ClassesThatCannotBothApplyToSameResourceWithinDefinedContext;

IF SchemeRequiresMutualExclusivity
AND ResourceAssignedToConflictingClasses
THEN ValidationStatus := violation;

ExhaustiveClassSet :=
    SetDesignedToCoverAllExpectedResourcesWithinDefinedScope;

Exhaustiveness IS_RELATIVE_TO Scope;

Unclassified :=
    ResourceWithoutApprovedClassification;

UnknownClassification :=
    AppropriateClassCannotCurrentlyBeDetermined;

OtherClass :=
    CatchAllClassForInScopeResourcesNotRepresentedBySpecificClasses;

ClassificationSpecificity :=
    DegreeToWhichAssignedClassPreciselyRepresentsResource;

ClassificationRelevance :=
    DegreeToWhichAssignedClassFitsResourceAndPurpose;

ClassificationCoverage :=
    DegreeToWhichSchemeRepresentsRequiredResourceGroupings;

ClassificationAccuracy :=
    DegreeToWhichAssignmentMatchesCorrectClassAccordingToReferenceStandardOrExpertJudgement;

ClassificationConsistency :=
    DegreeToWhichSimilarResourcesAreClassifiedAccordingToSameRules;

ClassificationQuality MAY_INCLUDE {
    Accuracy,
    Consistency,
    Specificity,
    Coverage,
    Provenance
};

ClassificationConfidence :=
    EstimatedSupportForAssignment;

IF Confidence < AcceptanceThreshold
THEN PredictedAssignment MAY_REQUIRE Review;

ClassificationValidation MAY_CHECK {
    SchemeMembership,
    IdentifierValidity,
    Exclusivity,
    Requiredness,
    Hierarchy,
    Relevance
};

ClassificationNormalisation MAY_INCLUDE {
    IdentifierResolution,
    LabelNormalisation,
    SchemeMapping,
    VersionResolution
};

SameClassLabel MAY_REFER_TO DifferentClassesAcrossSchemes;

SchemeAndIdentifier MUST_BE PreservedForDisambiguation;

ClassificationMapping :=
    SourceClass
    -> MappingRelationship
    -> TargetClass;

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

ClassificationCrosswalk :=
    SetOfMappingsBetweenClassificationSchemes;

ExactMapping SHOULD_REQUIRE StrongSemanticEquivalence;

ClassMerge :=
    MultipleEquivalentOrObsoleteClasses
    -> PreferredClass;

ClassSplit :=
    BroadOrAmbiguousClass
    -> MultipleMoreSpecificClasses;

Reclassify :=
    ExistingAssignment
    -> EvaluateAgainstUpdatedScheme
    -> AssignCurrentClass;

ClassificationVersion :=
    IdentifiedRevisionOfSchemeOrAssignment;

ClassificationChange MAY_INCLUDE {
    AddClass,
    RemoveClass,
    RenameClass,
    ReparentClass,
    MergeClass,
    SplitClass,
    ChangeRule
};

DeprecatedClass :=
    ClassRetainedForHistoricalCompatibilityButDiscouragedForNewAssignments;

DeprecatedClass SHOULD_REFERENCE ReplacementWhereAvailable;

ClassificationMigration :=
    UpdateAssignmentsFromOldSchemeVersionToNewVersion;

ClassificationChange
    -> IdentifyAffectedResources
    -> IdentifyAffectedMappings
    -> IdentifyAffectedQueries
    -> PlanMigration;

ClassificationProvenance MAY_INCLUDE {
    Source,
    Classifier,
    Method,
    Timestamp,
    ModelVersion,
    SchemeVersion
};

ClassificationAudit MAY_RECORD {
    PreviousClass,
    NewClass,
    Actor,
    Reason,
    Timestamp
};

Subject MAY_BE UsedAsInputTo Classification;

Category MAY_BE OutputOrStructuralElementOf Classification;

Classification != SubjectByDefinition;

Subject RepresentsWhatResourceIsAbout;
Classification RepresentsAssignmentToDefinedOrganisationalOrSemanticClass;

Taxonomy MAY_IMPLEMENT HierarchicalClassificationScheme;

ControlledVocabulary MAY_DEFINE AllowedClassificationValues;

Ontology MAY_DEFINE FormalClassSemanticsAndInferenceRules;

SKOS MAY_REPRESENT ClassificationConceptSchemes;

RDF MAY_REPRESENT:
    Resource
    -> classificationProperty
    -> ClassConcept;

JSONLD MAY_SERIALISE ClassificationWithSemanticIdentifierAndContext;

KnowledgeGraph MAY_REPRESENT ClassificationAsTypedRelationship;

ClassificationIndex :=
    SearchStructureMappingClassesToResources;

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

ClassificationBrowse :=
    StartAtRootOrFacet
    -> FollowClassHierarchy
    -> RetrieveResources;

ClassificationFacet :=
    ClassOrFacetValueUsedForFiltering;

SemanticSearch MAY_USE ClassificationFor {
    Filtering,
    Ranking,
    QueryExpansion,
    Navigation,
    IntentRouting
};

EmbeddingBasedClassifier MAY_USE VectorRepresentationOfResourceAndClasses;

VectorSimilarity MAY_SUPPORT Prediction
BUT DoesNotEstablishFormalClassMembership;

MetadataSchema MAY_DEFINE ClassificationPropertyAndAllowedScheme;

MetadataRepository MAY_STORE ClassificationAssignments;

MetadataRegistry MAY_REGISTER ClassificationSchemesPropertiesAndMappings;

MetadataCatalogue MAY_USE ClassificationForResourceOrganisation;

ClassificationInteroperability MAY_REQUIRE {
    StableIdentifiers,
    SharedScheme,
    Crosswalk,
    DefinedSemantics,
    VersionInformation
};

AI MAY_USE ClassificationFor {
    Routing,
    Retrieval,
    Recommendation,
    MetadataGeneration,
    KnowledgeOrganisation
};

AIClassification :=
    Resource
    -> AnalyseFeatures
    -> PredictClass
    -> AssignConfidence
    -> Validate
    -> StoreApprovedAssignment;

AIGeneratedClassification SHOULD_NOT BeTreatedAsAuthoritativeWithoutPolicyAppropriateValidation;

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

PrivacyPolicy MAY_RESTRICT ClassificationThatRevealsSensitiveInformation;

ClassificationAccessControl MAY_APPLY_TO {
    Scheme,
    Class,
    Assignment,
    DerivedClassification
};

ClassificationSecurity MAY_INCLUDE {
    InputValidation,
    AccessControl,
    ModelIntegrity,
    ProvenanceIntegrity,
    ChangeAuthorisation
};

MachineReadableClassification SHOULD_PRESERVE {
    ClassIdentifier,
    Scheme,
    AssignmentType,
    Classifier,
    Provenance,
    Confidence
};

# ---------- SEMANTIC REASONING ----------
IF ResourceIsAssignedToDefinedClassAccordingToSchemeOrCriteria
THEN ClassificationClassification := supported;

IF ClassA NARROWER_THAN ClassB
AND Resource CLASSIFIED_AS ClassA
THEN Resource MAY_BE RetrievedUnderClassBAccordingToPolicy;

IF ClassificationIdentifierStableAcrossLabelChange
THEN ExistingAssignment MAY_REMAIN Valid;

IF ClassDeprecated
THEN NewAssignments SHOULD_PREFER ReplacementWhereDefined;

IF SchemeContainsCycleWhereAcyclicHierarchyRequired
THEN ValidationStatus := violation;

IF PredictedClassificationConfidenceLow
THEN AutomaticAuthoritativeAssignment SHOULD_BE Restricted;

IF SchemeVersionChangesMembershipCriteria
THEN ExistingAssignments MAY_REQUIRE Reclassification;

# ---------- SEMANTIC EQUIVALENCE ----------
SEMANTIC_EQUIVALENCE {
    "classification" ~= "resource classification" WHEN metadata_context;
    "classification scheme" ~= "categorisation scheme" WHEN controlled_grouping_context;
    "classification class" ~= "classification category";
    "classification assignment" ~= "class membership assignment";
    "hierarchical classification" ~= "taxonomy-based classification";
    "automatic classification" ~= "automated categorisation";
    "classification mapping" ~= "class mapping";
    "classification code" ~= "class code";
}

# ---------- QUERY FLOW ----------
QUERY(q) ->
    NORMALISE(q) ->
    IDENTIFY_RESOURCE(q) ->
    IDENTIFY_CLASSIFICATION_PURPOSE(q) ->
    IDENTIFY_SCHEME(q) ->
    IDENTIFY_CLASS_OR_CODE(q) ->
    RESOLVE_CLASS_IDENTIFIER(q) ->
    IDENTIFY_HIERARCHY_AND_CRITERIA(q) ->
    IDENTIFY_ASSIGNMENT_TYPE_AND_CLASSIFIER(q) ->
    IDENTIFY_PROVENANCE_AND_CONFIDENCE(q) ->
    VALIDATE_CLASSIFICATION(q) ->
    RETURN_RELEVANT_CLASSIFICATION_KNOWLEDGE;

# ---------- CONFIDENCE ----------
CONFIDENCE(assertion) :=
    weighted_mean(
        source_reliability,
        classification_accuracy,
        scheme_consistency,
        identifier_strength,
        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: Classification;
    ontology: ClassificationOntology;
    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_assignment:
        identify_resource
        -> select_scheme
        -> resolve_class
        -> evaluate_criteria
        -> classify_assignment_type
        -> attach_classifier
        -> attach_provenance
        -> assign_confidence
        -> validate
        -> integrate;

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

    classification_revision:
        preserve_previous_version
        -> apply_change_set
        -> validate_hierarchy_and_rules
        -> identify_affected_resources
        -> update_indexes_and_mappings
        -> recompute_confidence
        -> regenerate_flow_hash;

    reclassification:
        identify_old_assignment
        -> evaluate_current_scheme
        -> preserve_history
        -> assign_current_class
        -> validate
        -> integrate;

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

# ---------- FLOW HASH ----------
FLOW_HASH_INPUT :=
    DOMAIN
    + SUBDOMAIN
    + ONTOLOGY
    + ClassificationEntity
    + HierarchyEntity
    + MetadataEntity
    + ControlEntity
    + Classification
    + ClassificationAssignment
    + ClassificationMapping
    + RELATIONSHIPS
    + SEMANTIC_REASONING
    + SEMANTIC_EQUIVALENCE
    + UPDATE_MODEL;

FLOW_HASH :=
    HASH(FLOW_HASH_INPUT);

# ---------- TERMINAL ----------
ClassificationOntology
    -> IdentifyResourceAndClassificationPurpose
    -> SelectClassificationScheme
    -> ExtractRelevantResourceFeatures
    -> ResolveCanonicalClassAndIdentifier
    -> ApplyCriteriaRulesOrClassifier
    -> AssignExplicitInferredOrPredictedClass
    -> ValidateHierarchyExclusivityAndRelevance
    -> AttachClassifierProvenanceAndConfidence
    -> StoreClassificationMetadata
    -> IndexForBrowseFilteringAndSemanticSearch
    -> MapAcrossExternalClassificationSchemes
    -> GovernVersionMigrationAndReclassification
    -> MaintainReliableResourceClassificationKnowledge;

END FLOW