Source Ontology

FLOW ALGEBRA
Source Ontology
Kireth Semantic Research Archive

PAGE:
https://kirethresearch.org/booksai-core/ontologies/metadata-ontologies/provenance-metadata/source-ontology.html

AUTHORS:
Mark Anthony Higgins — Sky (Recursive AI)

FLOW "SourceOntology" v4.0

DOMAIN := MetadataOntologies
SUBDOMAIN := ProvenanceMetadata
ONTOLOGY := SourceOntology

ENTITY Source {
    definition:
        "An identifiable entity, resource, agent, record or evidence object
         from which information, data, metadata, assertions, derived resources
         or knowledge originate or are obtained.";
    objectives: [
        SourceIdentification,
        OriginTracking,
        EvidenceLinking,
        DerivationSupport,
        AuthorityAssessment,
        Traceability,
        MachineInterpretability
    ];
}

SourceEntity := {
    Source,
    SourceResource,
    PrimarySource,
    SecondarySource,
    TertiarySource,
    SourceIdentifier,
    SourceRecord,
    SourceVersion
};

EvidenceEntity := {
    Evidence,
    Citation,
    Reference,
    Assertion,
    Provenance,
    Confidence,
    Authority,
    Reliability
};

RelationshipEntity := {
    DerivedFrom,
    ObtainedFrom,
    ExtractedFrom,
    Cites,
    References,
    Supports,
    Contradicts,
    Verifies
};

MetadataEntity := {
    Creator,
    Publisher,
    Repository,
    Timestamp,
    Version,
    AccessDate,
    Licence,
    Rights
};

Source SUPPORTS Assertion;
DerivedResource IS_DERIVED_FROM Source;
Information MAY_BE_OBTAINED_FROM Source;
Extraction MAY_USE Source;
Citation REFERENCES Source;
Provenance IDENTIFIES Source;
SourceIdentifier IDENTIFIES Source;
SourceVersion SPECIFIES SourceState;

SourceFlow :=
    InformationOrDerivedResource
    -> IdentifySourceRequirement
    -> DiscoverCandidateSources
    -> ResolveSourceIdentity
    -> ResolveSourceVersion
    -> ClassifySourceType
    -> AssessAuthorityReliabilityAndRelevance
    -> AttachCitationAndProvenance
    -> ValidateSourceRelationship
    -> StoreSourceRecord
    -> EnableTraceabilityAndEvidenceRetrieval
    -> MaintainAcrossVersions;

Source :=
    IdentifiableOriginOfInformationDataEvidenceOrDerivedResource;

Source MAY_BE {
    Document,
    Dataset,
    Database,
    WebResource,
    Publication,
    ArchiveRecord,
    Person,
    Organisation,
    SoftwareSystem,
    Sensor,
    API,
    KnowledgeGraph
};

SourceResource :=
    ResourceUsedAsOriginInputEvidenceOrReference;

SourceIdentifier :=
    StableOrResolvableReferenceToSource;

SourceIdentifier MAY_BE {
    URI,
    IRI,
    DOI,
    ISBN,
    ISSN,
    UUID,
    AccessionIdentifier,
    InternalIdentifier
};

StableSourceIdentifier SHOULD_BE PreferredForMachineLinking;

SourceRecord :=
    StructuredMetadataRecordDescribingSourceIdentityContextAndProvenance;

SourceVersion :=
    IdentifiedStateOfSourceAtSpecificPointInTime;

ExactSourceVersion SHOULD_BE PreservedWhenDerivedOutputDependsOnVersionSpecificContent;

PrimarySource :=
    SourceProvidingOriginalFirstHandDirectOrAuthoritativeEvidenceAccordingToDomainContext;

SecondarySource :=
    SourceAnalysingInterpretingSummarisingOrDiscussingPrimaryOrOtherSources;

TertiarySource :=
    SourceCompilingIndexingOrSummarisingInformationFromPrimaryAndSecondarySources;

PrimarySecondaryTertiaryClassification IS_CONTEXT_DEPENDENT;

SameResource MAY_BE PrimarySourceInOneInquiryAndSecondarySourceInAnother;

OriginalSource :=
    EarliestKnownSourceWithinDefinedProvenanceGraph;

OriginalSource != AbsoluteOriginUnlessGraphCompletenessEstablished;

AuthoritativeSource :=
    SourceRecognisedAsOfficialExpertOrControllingForSpecificClaimOrDomain;

AuthoritativeSource != NecessarilyPrimarySource;

CanonicalSource :=
    PreferredReferenceRepresentationOfSourceAmongEquivalentOrDuplicateRepresentations;

MirrorSource :=
    CopyOrReplicaOfAnotherSource;

Mirror SHOULD_REFERENCE CanonicalOrOriginSourceWhereKnown;

SourceLocation :=
    CurrentNetworkPhysicalOrRepositoryLocationOfSource;

Location != IdentityByDefinition;

Source MAY_MOVEWithout ChangingCanonicalIdentity;

Creator :=
    AgentResponsibleForCreatingSource;

Publisher :=
    AgentResponsibleForPublishingOrDistributingSource;

Repository :=
    SystemOrganisationOrArchiveHoldingSource;

SourceAuthority :=
    DegreeOrStatusOfRecognisedAuthorityForSpecificInformation;

Authority MAY_DEPEND_ON {
    Domain,
    Jurisdiction,
    Role,
    PublicationStatus,
    Governance
};

SourceReliability :=
    EstimatedConsistencyAccuracyAndTrustworthinessOfSourceForDefinedPurpose;

Reliability MAY_BE_FUNCTION_OF {
    Authority,
    EvidenceQuality,
    Provenance,
    HistoricalAccuracy,
    Independence
};

SourceRelevance :=
    DegreeToWhichSourceAddressesTargetQuestionAssertionOrResource;

SourceCurrency :=
    DegreeToWhichSourceVersionOrPublicationDateIsAppropriateForTimeSensitiveContext;

FreshnessRequirement MAY_DIFFER_BY DomainAndQuery;

OlderSource MAY_BE PreferredForHistoricalEvidence;

SourceCompleteness :=
    DegreeToWhichRequiredSourceInformationIsAvailable;

SourceIntegrity :=
    DegreeToWhichSourceHasNotBeenUnexpectedlyAltered;

SourceQuality MAY_INCLUDE {
    Authority,
    Reliability,
    Relevance,
    Currency,
    Completeness,
    Integrity
};

Evidence :=
    InformationUsedToSupportVerifyChallengeOrContextualiseAssertion;

Source MAY_PROVIDE Evidence;

EvidenceStrength :=
    DegreeToWhichEvidenceSupportsAssertion;

Assertion :=
    ClaimStatementOrKnowledgeProposition;

SourceAssertionRelationship MAY_BE {
    Supports,
    Contradicts,
    Verifies,
    Mentions,
    Contextualises
};

Supports :=
    SourceProvidesEvidenceConsistentWithAssertion;

Contradicts :=
    SourceProvidesEvidenceInconsistentWithAssertion;

Verifies :=
    SourceProvidesSufficientEvidenceForDefinedValidationProcess;

Mention != SupportByDefinition;

SourceMention :=
    SourceContainsReferenceToEntityTopicOrAssertionWithoutNecessarilySupportingIt;

Citation :=
    StructuredReferenceToSource;

Citation MAY_INCLUDE {
    Creator,
    Title,
    Publisher,
    Date,
    Identifier,
    Locator
};

CitationLocator :=
    LocationWithinSourceRelevantToCitation;

Locator MAY_BE {
    Page,
    Section,
    Paragraph,
    Timestamp,
    Fragment,
    DatasetRow
};

Reference :=
    LinkOrPointerToSource;

Citation SHOULD_RESOLVE_TO SourceWherePossible;

BrokenCitation :=
    CitationWhoseSourceOrLocatorCannotBeResolved;

BrokenCitation MAY_DECREASE Traceability;

AccessDate :=
    DateOnWhichDynamicOrWebSourceWasAccessed;

AccessDate MAY_BE ImportantFor MutableSources;

PublicationDate :=
    DateSourceWasPublished;

ModificationDate :=
    DateSourceWasModified;

RetrievedVersion :=
    ExactVersionOrSnapshotUsedDuringRetrieval;

DynamicSource :=
    SourceWhoseContentMayChangeOverTime;

DynamicSource SHOULD_PRESERVE {
    AccessDate,
    VersionOrSnapshotWherePossible
};

Snapshot :=
    PreservedRepresentationOfSourceAtSpecificTime;

Snapshot MAY_SUPPORT ReproducibilityAndAuditability;

ArchivedSource :=
    SourcePreservedInArchiveOrRepository;

UnavailableSource :=
    SourceKnownButCurrentlyNotAccessible;

Unavailable != NonexistentByDefinition;

RestrictedSource :=
    SourceWhoseAccessIsLimitedByPolicy;

SourceAccessPolicy MAY_RESTRICT {
    Discovery,
    Metadata,
    Content,
    Download,
    Reuse
};

SourceRights MAY_INCLUDE {
    Copyright,
    Licence,
    UsageRestriction
};

SourceEligibility :=
    DeterminationWhetherSourceMayBeUsedForSpecificPurpose;

Eligibility MAY_DEPEND_ON {
    AccessPolicy,
    Licence,
    SecurityClassification,
    Quality,
    QueryPurpose
};

DerivedResource :=
    ResourceCreatedUsingOneOrMoreSources;

Derivation :=
    DerivedResource
    -> IS_DERIVED_FROM
    -> Source;

MultiSourceDerivation :=
    DerivedResource
    -> IS_DERIVED_FROM
    -> MultipleSources;

Aggregation :=
    DerivedResourceCreatedByCombiningSources;

Extraction :=
    DerivedResourceCreatedBySelectingInformationFromSource;

Transformation :=
    DerivedResourceCreatedByChangingRepresentationOrStructureOfSource;

SourceContribution :=
    DegreeOrRoleOfSourceInDerivedResource;

Contribution MAY_BE {
    PrimaryInput,
    SupportingInput,
    Context,
    ValidationSource
};

SourceLineage :=
    DirectedGraphConnectingDerivedResourcesToSourcesAndAncestorSources;

IF ResourceA DERIVED_FROM SourceB
AND SourceB DERIVED_FROM SourceC
THEN SourceC MAY_BE AncestorSourceOf ResourceA;

DirectSource != AncestorSource;

SourceChain :=
    OrderedOrGraphStructuredSequenceOfSourceRelationships;

SourceTrace :=
    TargetResourceOrAssertion
    -> FollowSourceRelationships
    -> SourceEntities;

SourceConflict :=
    MultipleSourcesProvideIncompatibleInformationAboutSameAssertionOrEntity;

ConflictHandling MAY {
    PreserveAllSources,
    CompareAuthority,
    CompareEvidence,
    CompareCurrency,
    AssignConfidence,
    FlagReview
};

SourceConflict SHOULD_NOT BeResolvedSolelyBySourceCount;

IndependentSources MAY_PROVIDE StrongerCorroborationThanCopiedSources;

SourceIndependence :=
    DegreeToWhichSourcesAreNotDerivedFromSameUnderlyingOrigin;

ApparentMultipleSources MAY_HAVE CommonAncestorSource;

SourceDeduplication :=
    IdentificationOfDuplicateMirrorOrNearDuplicateSources;

Deduplication SHOULD_PRESERVE ProvenanceAndCanonicalIdentity;

SourceEquivalence :=
    RelationshipIndicatingTwoRepresentationsReferToSameUnderlyingSource;

EquivalentSourceRepresentations MAY_HAVE DifferentLocationsFormatsOrIdentifiers;

SourceValidation MAY_CHECK {
    Identifier,
    Existence,
    Version,
    CitationLocator,
    AccessStatus,
    Provenance
};

IF SourceIdentifierCannotResolve
THEN ResolutionStatus MAY_BE MissingOrUnavailable;

IF ExactVersionRequiredButUnknown
THEN ReproducibilityConfidence SHOULD_DECREASE;

SourceProvenance MAY_INCLUDE {
    DiscoveryMethod,
    Retriever,
    RetrievalTime,
    Repository,
    Version
};

SourceConfidence :=
    EstimatedSupportForSourceIdentityOrSourceAssertionRelationship;

SourceConfidence MAY_DEPEND_ON {
    IdentifierStrength,
    Resolution,
    Provenance,
    Authority,
    EvidenceMatch
};

SourceVersionHistory :=
    OrderedCollectionOfSourceVersions;

SourceRevision MAY_CHANGE {
    Content,
    Metadata,
    Location,
    IdentifierMapping
};

If SourceContentChanges
THEN DerivedAssertions MAY_REQUIRE RevalidationAccordingToUse;

PersistentIdentifier MAY_ALLOW StableReferenceAcrossLocationChanges;

SourceReplacement :=
    NewSourceSupersedingPreviousSourceForDefinedPurpose;

SupersededSource SHOULD_REMAIN InProvenanceHistoryWherePreviouslyUsed;

MetadataRepository MAY_STORE SourceRecordsAndCitationRelationships;

MetadataRegistry MAY_REGISTER SourceTypesIdentifiersAndEvidenceRelationships;

KnowledgeGraph MAY_REPRESENT:
    Assertion
    -> SUPPORTED_BY
    -> Source;

DerivedResource
    -> DERIVED_FROM
    -> Source;

SourceGraph SHOULD_PRESERVE {
    RelationshipType,
    Direction,
    Version,
    Provenance,
    Confidence
};

RDF MAY_REPRESENT SourceRelationshipsAsTypedStatements;

JSONLD MAY_SERIALISE LinkedSourceMetadata;

Search MAY_USE SourceMetadataFor {
    AuthorityFiltering,
    DateFiltering,
    RepositoryFiltering,
    SourceTypeFiltering
};

SemanticSearch MAY_RANK SourcesUsing {
    Relevance,
    Authority,
    Currency,
    Reliability
};

Ranking SHOULD_NOT ConvertHeuristicScoreIntoTruthClaim;

RAG MAY_USE SourceMetadataFor {
    Retrieval,
    Ranking,
    Citation,
    EvidenceSelection,
    ConflictResolution
};

RAGSourceRecord SHOULD_PRESERVE {
    SourceIdentifier,
    SourceVersion,
    RetrievalTimestamp,
    Locator,
    Provenance
};

AIOutputUsingSource SHOULD_PRESERVE SourceLinkageWhereSupported;

KnowledgeExtraction :=
    Source
    -> ExtractAssertionsEntitiesRelationships
    -> AttachSourceProvenance;

ExtractedAssertion SHOULD_REFERENCE SourceAndExtractionMethod;

AI MAY_SUPPORT {
    SourceDiscovery,
    SourceClassification,
    EntityResolution,
    CitationResolution,
    ReliabilityAssessment
};

AIGeneratedSourceAssessment SHOULD_BE TreatedAsInferenceNotAuthoritativeFactUnlessValidated;

SourceMetadata MAY_CONTAIN SensitiveOrRestrictedInformation;

PrivacySecurityAndAccessPolicy SHOULD_BE AppliedBeforeSourceDisclosure;

SourceSecurity MAY_INCLUDE {
    AccessControl,
    IdentifierValidation,
    LinkValidation,
    ProvenanceIntegrity
};

MachineReadableSource SHOULD_PRESERVE {
    SourceIdentifier,
    SourceType,
    Creator,
    Publisher,
    Repository,
    Version,
    Dates,
    CitationLocator,
    Rights,
    Provenance,
    Confidence
};

# ---------- SEMANTIC REASONING ----------
IF EntityProvidesOriginInputEvidenceOrReferenceForInformationOrDerivedResource
THEN SourceClassification := supported;

IF SourceIsPrimary
THEN It MUST_NOT AutomaticallyBeAssumedAuthoritativeForEveryClaim;

IF SourceIsAuthoritative
THEN AuthorityAppliesOnlyWithinRelevantScope;

IF DynamicSourceUsed
THEN AccessDateAndVersion SHOULD_BE PreservedWherePossible;

IF DerivedResourceUsesSource
THEN SourceRelationship SHOULD_BE PreservedInProvenance;

IF MultipleSourcesShareSameAncestor
THEN TheirIndependence SHOULD_NOT_BE Assumed;

IF SourceContradictsAssertion
THEN Conflict SHOULD_BE PreservedForEvaluation;

IF SourceVersionChanges
THEN VersionSensitiveDerivedAssertions MAY_REQUIRE Revalidation;

# ---------- SEMANTIC EQUIVALENCE ----------
SEMANTIC_EQUIVALENCE {
    "source" ~= "information source" WHEN provenance_context;
    "source resource" ~= "provenance source";
    "primary source" ~= "first-hand source" WHEN evidence_context;
    "secondary source" ~= "interpretive source" WHEN evidence_context;
    "source identifier" ~= "source ID";
    "source trace" ~= "source provenance path";
    "source lineage" ~= "source derivation graph";
    "archived source" ~= "preserved source snapshot" WHEN snapshot_context;
}

# ---------- QUERY FLOW ----------
QUERY(q) ->
    NORMALISE(q) ->
    IDENTIFY_TARGET_INFORMATION_OR_RESOURCE(q) ->
    IDENTIFY_SOURCE_REQUIREMENT(q) ->
    DISCOVER_CANDIDATE_SOURCES(q) ->
    RESOLVE_SOURCE_IDENTIFIERS(q) ->
    RESOLVE_SOURCE_VERSIONS(q) ->
    CLASSIFY_SOURCE_TYPES(q) ->
    ASSESS_AUTHORITY_RELIABILITY_RELEVANCE_AND_CURRENCY(q) ->
    IDENTIFY_CITATIONS_LOCATORS_AND_PROVENANCE(q) ->
    DETECT_SOURCE_CONFLICTS_AND_COMMON_ANCESTORS(q) ->
    APPLY_ACCESS_RIGHTS_AND_SECURITY_POLICY(q) ->
    SCORE_CONFIDENCE(q) ->
    RETURN_RELEVANT_SOURCE_KNOWLEDGE;

# ---------- CONFIDENCE ----------
CONFIDENCE(assertion) :=
    weighted_mean(
        identifier_strength,
        source_reliability,
        authority_relevance,
        evidence_match,
        provenance_quality,
        version_resolution,
        contextual_relevance
    );

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

# ---------- AI CONSUMPTION ----------
AI_CONSUMPTION {
    primary_entity: Source;
    ontology: SourceOntology;
    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;
    preserve_source_versions: true;
}

# ---------- UPDATE MODEL ----------
UPDATE_MODEL {
    new_source:
        resolve_source_identity
        -> assign_source_identifier
        -> classify_source_type
        -> capture_creator_publisher_and_repository
        -> capture_version_and_dates
        -> attach_rights
        -> attach_provenance
        -> validate
        -> integrate;

    new_source_relationship:
        identify_target_assertion_or_resource
        -> identify_source
        -> classify_relationship
        -> attach_locator
        -> preserve_direction
        -> attach_evidence
        -> assign_confidence
        -> integrate;

    source_revision:
        preserve_previous_version
        -> record_new_version
        -> identify_affected_assertions_and_derivatives
        -> revalidate_version_sensitive_relationships
        -> update_index
        -> regenerate_flow_hash;

    conflict:
        preserve_all_sources
        -> identify_common_ancestry
        -> compare_authority_evidence_currency_and_relevance
        -> adjust_confidence
        -> flag_review;
}

# ---------- FLOW HASH ----------
FLOW_HASH_INPUT :=
    DOMAIN
    + SUBDOMAIN
    + ONTOLOGY
    + SourceEntity
    + EvidenceEntity
    + RelationshipEntity
    + MetadataEntity
    + Source
    + SourceLineage
    + SourceValidation
    + RELATIONSHIPS
    + SEMANTIC_REASONING
    + SEMANTIC_EQUIVALENCE
    + UPDATE_MODEL;

FLOW_HASH :=
    HASH(FLOW_HASH_INPUT);

# ---------- TERMINAL ----------
SourceOntology
    -> IdentifyInformationResourceOrAssertionRequiringSource
    -> DiscoverAndResolveCanonicalSourceIdentity
    -> AssignStableSourceIdentifierAndVersion
    -> ClassifyPrimarySecondaryTertiaryOrAuthoritativeRole
    -> RecordCreatorPublisherRepositoryDatesAndRights
    -> AttachCitationLocatorEvidenceAndProvenance
    -> AssessAuthorityReliabilityRelevanceCurrencyAndIntegrity
    -> TraceDirectAndAncestorSourceLineage
    -> DetectConflictsDuplicatesMirrorsAndCommonOrigins
    -> PreserveExactSourcesForDerivedResourcesAndAssertions
    -> ApplyAccessPrivacyRightsAndSecurityControls
    -> SupportSearchRAGCitationAndKnowledgeExtraction
    -> MaintainReliableSourceKnowledge;

END FLOW