Abstract Ontology

FLOW ALGEBRA
Abstract Ontology
Kireth Semantic Research Archive

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

AUTHORS:
Mark Anthony Higgins — Sky (Recursive AI)

FLOW "AbstractOntology" v4.0

DOMAIN := MetadataOntologies
SUBDOMAIN := DescriptiveMetadata
ONTOLOGY := AbstractOntology

ENTITY Abstract {
    definition:
        "A concise descriptive metadata representation that summarises the
         principal content, purpose, scope, methods, findings or significance
         of a resource to support discovery, selection, understanding and
         machine interpretation.";
    objectives: [
        ContentSummarisation,
        ResourceDiscovery,
        Selection,
        Understanding,
        SemanticRetrieval,
        Indexing,
        MachineInterpretability
    ];
}

AbstractEntity := {
    Abstract,
    Resource,
    AbstractValue,
    AuthorAbstract,
    StructuredAbstract,
    UnstructuredAbstract,
    GeneratedAbstract,
    TranslatedAbstract
};

MetadataEntity := {
    MetadataRecord,
    AbstractProperty,
    Language,
    Identifier,
    Provenance,
    Confidence,
    Version
};

ContentEntity := {
    Purpose,
    Scope,
    Method,
    Result,
    Conclusion,
    Finding,
    Context
};

Abstract SUMMARISES Resource;
MetadataRecord CONTAINS AbstractStatement;
Abstract MAY_DESCRIBE Purpose;
Abstract MAY_DESCRIBE Method;
Abstract MAY_DESCRIBE Result;
Abstract MAY_DESCRIBE Conclusion;
Abstract HAS Language;
Provenance SUPPORTS AbstractStatement;

AbstractFlow :=
    Resource
    -> IdentifyResource
    -> DetermineAbstractPurpose
    -> IdentifySalientContent
    -> SelectAbstractType
    -> ComposeOrExtractAbstract
    -> ValidateAgainstResource
    -> AssignLanguage
    -> AttachIdentifierAndProvenance
    -> StoreInMetadataRecord
    -> IndexForDiscovery
    -> MaintainAndVersion;

Resource :=
    ThingSummarisedByAbstract;

Resource MAY_BE {
    Article,
    Report,
    Book,
    Chapter,
    Dataset,
    Thesis,
    ResearchOutput,
    WebResource,
    TechnicalDocument
};

Abstract :=
    ConciseRepresentationOfMainResourceContent;

AbstractValue :=
    TextualOrStructuredContentOfAbstract;

AbstractStatement :=
    Resource
    -> AbstractProperty
    -> AbstractValue;

AbstractProperty MAY_BE {
    abstract,
    summary,
    structuredAbstract,
    authorAbstract
};

AuthorAbstract :=
    AbstractCreatedByResourceAuthorOrAuthoringTeam;

PublisherAbstract :=
    AbstractProvidedByPublisherOrDistributor;

MetadataAgentAbstract :=
    AbstractCreatedByMetadataProfessionalOrCurator;

GeneratedAbstract :=
    AbstractProducedAutomaticallyBySoftwareOrAI;

GeneratedAbstract SHOULD_HAVE {
    GenerationMethod,
    Provenance,
    ValidationStatus,
    Confidence
};

UnstructuredAbstract :=
    ContinuousNarrativeSummaryWithoutExplicitSectionLabels;

StructuredAbstract :=
    AbstractDividedIntoDefinedSemanticSections;

StructuredAbstract MAY_INCLUDE {
    Background,
    Objective,
    Method,
    Results,
    Conclusion
};

SectionSet MAY_VARY_BY DomainAndPublicationConvention;

Purpose :=
    StatementOfWhyResourceOrWorkExistsOrWasConducted;

Scope :=
    BoundaryOfTopicsPopulationDataPeriodOrCoverageAddressed;

Method :=
    DescriptionOfApproachProcedureDesignOrTechnique;

Result :=
    ReportedOutcomeProducedByWork;

Finding :=
    InterpretedObservationOrResultReportedByResource;

Conclusion :=
    ClosingInterpretationOrImplicationReportedByResource;

Abstract SHOULD_NOT IntroduceClaimsUnsupportedByResource;

AbstractAccuracy :=
    DegreeToWhichAbstractFaithfullyRepresentsResource;

AbstractCompleteness :=
    DegreeToWhichRequiredPrincipalAspectsAreRepresented;

AbstractConciseness :=
    DegreeToWhichAbstractCommunicatesEssentialMeaningWithoutUnnecessaryDetail;

AbstractClarity :=
    DegreeToWhichAbstractIsUnderstandableAndUnambiguous;

AbstractRelevance :=
    DegreeToWhichAbstractFocusesOnPrincipalResourceContent;

AbstractQuality MAY_INCLUDE {
    Accuracy,
    Completeness,
    Conciseness,
    Clarity,
    Relevance,
    Provenance
};

AbstractLength :=
    NumberOfCharactersWordsTokensOrOtherDefinedUnits;

MetadataSchema MAY_DEFINE AbstractLengthConstraint;

LengthConstraint SHOULD_NOT ForceMaterialDistortionOfMeaning;

AbstractLanguage :=
    LanguageInWhichAbstractIsExpressed;

AbstractLanguage MAY_DIFFER_FROM ResourceLanguage;

MultilingualResource MAY_HAVE MultipleAbstractsInDifferentLanguages;

TranslatedAbstract :=
    AbstractTranslatedIntoAnotherLanguage;

TranslatedAbstract SHOULD_REFERENCE SourceAbstractOrResourceWherePossible;

Translation SHOULD_PRESERVE MeaningAndReportedClaims;

AbstractSource :=
    OriginFromWhichAbstractWasObtained;

Source MAY_BE {
    Resource,
    Author,
    Publisher,
    Repository,
    MetadataAgent,
    AIModel
};

AbstractProvenance MAY_INCLUDE {
    Source,
    Creator,
    CreationMethod,
    Timestamp,
    ModelVersion
};

AbstractIdentifier MAY_BE AssignedWhenAbstractIsManagedAsIndependentMetadataObject;

AbstractVersion :=
    IdentifiedRevisionOfAbstract;

AbstractHistory MAY_PRESERVE PreviousVersionsWhereRequired;

AbstractChange MAY_INCLUDE {
    Correction,
    Shortening,
    Expansion,
    Translation,
    Replacement
};

ExtractiveAbstract :=
    AbstractConstructedPrimarilyFromSelectedSourcePassages;

AbstractiveAbstract :=
    NewlyGeneratedTextRepresentingSourceMeaning;

AutomaticSummarisation :=
    ResourceContent
    -> IdentifySalientInformation
    -> GenerateCondensedRepresentation;

ExtractiveSummarisation MAY_REDUCE GenerativeHallucinationRisk
BUT MAY_HAVE CoherenceLimitations;

AbstractiveSummarisation MAY_IMPROVE Readability
BUT MAY_INTRODUCE UnsupportedClaims;

AIGeneratedAbstract :=
    GeneratedAbstractProducedByAIModel;

AIGeneratedAbstract SHOULD_BE ValidatedAgainstSourceAccordingToUseAndRisk;

UnsupportedClaim :=
    StatementInAbstractNotAdequatelySupportedByResource;

IF UnsupportedClaimDetected
THEN AbstractAccuracy SHOULD_DECREASE
AND ValidationReview SHOULD_BE Triggered;

OmittedCriticalInformation MAY_REDUCE AbstractCompleteness;

ContradictoryAbstract :=
    AbstractContainingClaimInconsistentWithVerifiedResourceContent;

ContradictoryAbstract SHOULD_NOT_BE TreatedAsAuthoritativeWithoutCorrection;

AbstractValidation MAY_CHECK {
    Requiredness,
    Datatype,
    Language,
    Length,
    ResourceConsistency,
    UnsafeMarkup
};

IF SchemaRequiresAbstract
AND AbstractMissing
THEN ValidationStatus := violation;

IF AbstractEmpty
THEN Completeness SHOULD_DECREASE;

AbstractNormalisation MAY_INCLUDE {
    UnicodeNormalisation,
    WhitespaceNormalisation,
    LanguageTagNormalisation
};

OriginalDisplayText SHOULD_BE PreservedWhereRequired;

StructuredAbstractValidation MAY_CHECK RequiredSectionsAccordingToProfile;

Abstract MAY_CONTAIN MarkupAccordingToMetadataSyntax;

UnsafeMarkup SHOULD_BE SanitisedOrRejectedAccordingToPolicy;

AbstractIndex :=
    SearchIndexBuiltFromAbstractText;

AbstractIndex MAY_SUPPORT {
    FullTextSearch,
    KeywordSearch,
    SemanticSearch,
    EntitySearch
};

Abstract MAY_BE HighValueTextFor ResourceRetrieval;

QueryTerms MAY_MATCH AbstractContent;

Abstract MAY_BE ConvertedTo Embedding;

AbstractEmbedding MAY_SUPPORT SemanticSimilaritySearch;

VectorSimilarity != FactualEquivalence;

KeywordExtraction MAY_USE AbstractAsInput;

SubjectClassification MAY_USE AbstractAsEvidence;

NamedEntityRecognition MAY_EXTRACT EntitiesFromAbstract;

ExtractedEntity SHOULD_BE DistinguishedFrom ExplicitlyCuratedMetadata;

TopicModel MAY_USE AbstractToInfer CandidateTopics;

CandidateTopic SHOULD_HAVE Confidence;

SemanticSearch MAY_USE AbstractFor {
    QueryMatching,
    Ranking,
    ConceptExtraction,
    ResourceSelection
};

KnowledgeGraph MAY_LINK AbstractTo Resource;

EntitiesAndConceptsMentionedInAbstract MAY_BE LinkedToGraphWhenResolved;

Title IDENTIFIES Resource;
Abstract SUMMARISES Resource;

Description MAY_BE BroaderMetadataCategoryContainingAbstract;

Abstract != FullDescriptionByDefinition;

Abstract SHOULD_BE MoreCondensedThanFullResourceContent;

MetadataSchema MAY_DEFINE AbstractPropertyAndConstraints;

DublinCore MAY_REPRESENT AbstractUsing descriptionOrMoreSpecificProfileProperty;

SchemaOrg MAY_REPRESENT AbstractUsing abstractOrDescriptionWhereSupportedByTypeAndVocabulary;

RDF MAY_REPRESENT:
    Resource
    -> abstractProperty
    -> AbstractLiteral;

JSONLD MAY_SERIALISE AbstractWithLanguageAndSemanticContext;

MetadataRepository MAY_STORE AbstractMetadata;

MetadataRegistry MAY_REGISTER AbstractPropertiesAndProfiles;

MetadataCatalogue MAY_DISPLAY AbstractForResourceSelection;

AbstractInteroperability MAY_REQUIRE {
    SharedPropertySemantics,
    LanguageTags,
    ResourceIdentifiers,
    SchemaMapping
};

AbstractCrosswalk :=
    MappingBetweenAbstractOrDescriptionPropertiesAcrossSchemas;

Mapping SHOULD_PRESERVE AbstractRoleWherePossible;

AccessControl MAY_RESTRICT AbstractIndependentlyOfResource;

Abstract MAY_CONTAIN SensitiveOrConfidentialInformation;

PrivacyPolicy SHOULD_APPLY_TO AbstractContent;

AbstractSecurity MAY_INCLUDE {
    InputValidation,
    OutputEscaping,
    AccessControl,
    ProvenanceIntegrity
};

AI MAY_USE AbstractFor {
    Retrieval,
    Classification,
    Summarisation,
    EntityExtraction,
    QuestionAnswering
};

RetrievalAugmentedGeneration MAY_USE AbstractFor {
    SourceDiscovery,
    Ranking,
    ContextSelection,
    PreliminaryEvidence
};

AbstractAlone MAY_BE InsufficientForHighPrecisionClaimVerification;

MachineReadableAbstract SHOULD_PRESERVE {
    AbstractType,
    Language,
    ResourceIdentifier,
    Provenance,
    Confidence,
    Version
};

# ---------- SEMANTIC REASONING ----------
IF MetadataValueConciseSummarisesPrincipalResourceContent
THEN AbstractClassification := supported;

IF AbstractHasExplicitSemanticSections
THEN Abstract MAY_BE ClassifiedAs StructuredAbstract;

IF AbstractGeneratedByAI
THEN GenerationProvenance SHOULD_BE Preserved;

IF AbstractContainsUnsupportedClaim
THEN Confidence SHOULD_DECREASE
AND Review SHOULD_BE Triggered;

IF MultipleLanguageAbstractsExist
THEN QueryLanguage MAY_SELECT MatchingAbstract;

IF AbstractContradictsVerifiedResource
THEN ResourceContent SHOULD_TakePrecedenceForFactualValidation;

IF AbstractVersionChanges
THEN SearchIndexAndEmbeddings SHOULD_BE Updated;

# ---------- SEMANTIC EQUIVALENCE ----------
SEMANTIC_EQUIVALENCE {
    "abstract" ~= "resource abstract" WHEN metadata_context;
    "structured abstract" ~= "sectioned abstract";
    "unstructured abstract" ~= "narrative abstract";
    "author abstract" ~= "author-provided abstract";
    "generated abstract" ~= "automatically generated abstract";
    "translated abstract" ~= "abstract translation";
    "abstract metadata" ~= "summary metadata" WHEN concise_formal_summary_context;
    "abstract version" ~= "abstract revision";
}

# ---------- QUERY FLOW ----------
QUERY(q) ->
    NORMALISE(q) ->
    IDENTIFY_RESOURCE(q) ->
    IDENTIFY_ABSTRACT(q) ->
    IDENTIFY_ABSTRACT_TYPE(q) ->
    IDENTIFY_LANGUAGE(q) ->
    IDENTIFY_PURPOSE_METHOD_RESULTS_AND_CONCLUSION(q) ->
    IDENTIFY_SOURCE_AND_PROVENANCE(q) ->
    VALIDATE_ABSTRACT_AGAINST_RESOURCE(q) ->
    SCORE_CONFIDENCE(q) ->
    RETURN_RELEVANT_ABSTRACT_KNOWLEDGE;

# ---------- CONFIDENCE ----------
CONFIDENCE(assertion) :=
    weighted_mean(
        source_reliability,
        abstract_accuracy,
        resource_consistency,
        provenance_quality,
        validation_evidence,
        contextual_relevance
    );

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

# ---------- AI CONSUMPTION ----------
AI_CONSUMPTION {
    primary_entity: Abstract;
    ontology: AbstractOntology;
    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_abstract:
        identify_resource
        -> classify_abstract_type
        -> attach_language
        -> attach_source
        -> attach_provenance
        -> validate_against_resource
        -> assign_confidence
        -> integrate;

    abstract_revision:
        preserve_previous_version
        -> apply_changes
        -> validate_resource_consistency
        -> update_index_and_embedding
        -> recompute_confidence
        -> regenerate_flow_hash;

    generated_abstract:
        record_generation_method
        -> identify_source_resource
        -> validate_supported_claims
        -> assign_confidence
        -> human_review_if_required
        -> integrate;

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

# ---------- FLOW HASH ----------
FLOW_HASH_INPUT :=
    DOMAIN
    + SUBDOMAIN
    + ONTOLOGY
    + AbstractEntity
    + MetadataEntity
    + ContentEntity
    + Abstract
    + AbstractValidation
    + AbstractQuality
    + RELATIONSHIPS
    + SEMANTIC_REASONING
    + SEMANTIC_EQUIVALENCE
    + UPDATE_MODEL;

FLOW_HASH :=
    HASH(FLOW_HASH_INPUT);

# ---------- TERMINAL ----------
AbstractOntology
    -> IdentifySummarisedResource
    -> DetermineAbstractPurposeAndType
    -> ExtractPrincipalContent
    -> RepresentPurposeScopeMethodsResultsAndConclusions
    -> PreserveLanguageAndDisplayText
    -> AttachResourceIdentifierSourceAndProvenance
    -> ValidateAccuracyCompletenessAndUnsupportedClaims
    -> StoreAndVersionAbstractMetadata
    -> IndexForFullTextAndSemanticRetrieval
    -> ExtractCandidateEntitiesSubjectsAndKeywords
    -> EnforcePrivacySecurityAndAccess
    -> SupportAIAndMachineConsumption
    -> MaintainReliableResourceSummaryKnowledge;

END FLOW