Provenance Ontology

FLOW ALGEBRA
Provenance Ontology
Kireth Semantic Research Archive

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

AUTHORS:
Mark Anthony Higgins — Sky (Recursive AI)

FLOW "ProvenanceOntology" v4.0

DOMAIN := MetadataOntologies
SUBDOMAIN := ProvenanceMetadata
ONTOLOGY := ProvenanceOntology

ENTITY Provenance {
 definition: "A semantic representation of the origin, derivation, generation, attribution, custody, transformation, version history and evidential lineage of an entity, resource, assertion or metadata object.";
 objectives: [OriginTracking, DerivationTracking, Attribution, ActivityTracking, ChainOfCustody, Reproducibility, TrustAssessment, MachineInterpretability];
}

ProvenanceEntity := {Entity, Activity, Agent, ProvenanceRecord, ProvenanceStatement, ProvenanceEvent, ProvenanceChain, ProvenanceIdentifier};
RelationshipEntity := {WasGeneratedBy, Used, WasDerivedFrom, WasAttributedTo, WasAssociatedWith, WasRevisionOf, HadPrimarySource, WasInformedBy};
EvidenceEntity := {Evidence, Source, Timestamp, Version, AuditRecord, Fixity, Checksum, Confidence};
AgentEntity := {Person, Organisation, SoftwareAgent, AIModel, ResponsibleAgent, Creator, Contributor, Authority};

Entity MAY_BE_GENERATED_BY Activity;
Activity MAY_USE Entity;
Activity MAY_BE_ASSOCIATED_WITH Agent;
Entity MAY_BE_DERIVED_FROM Entity;
Entity MAY_BE_ATTRIBUTED_TO Agent;
Entity MAY_BE_REVISION_OF Entity;
Entity MAY_HAVE_PRIMARY_SOURCE Entity;
Activity MAY_BE_INFORMED_BY Activity;
ProvenanceRecord CONTAINS ProvenanceStatement;

ProvenanceFlow :=
 ProvenanceSubject
 -> IdentifyEntity
 -> IdentifySourceEntities
 -> IdentifyGeneratingUsingOrTransformingActivities
 -> IdentifyAssociatedAgents
 -> RecordTimestampsVersionsAndIdentifiers
 -> BuildDirectedProvenanceRelationships
 -> AttachEvidenceAndConfidence
 -> ValidateProvenanceGraph
 -> StoreProvenanceRecord
 -> EnableTraceabilityReproducibilityAndTrust
 -> MaintainAcrossLifecycle;

Entity := IdentifiableThingWhoseProvenanceCanBeDescribed;
Entity MAY_BE {Document, Dataset, File, Image, Audio, Video, Software, Model, MetadataRecord, Assertion, KnowledgeEntity};

Activity := ProcessActionOrEventThatUsesGeneratesTransformsOrModifiesEntities;
Activity MAY_BE {Creation, Generation, Import, Extraction, Transformation, Validation, Publication, Migration, Modification, Deletion};

Agent := PersonOrganisationSoftwareOrOtherActorAssociatedWithProvenanceActivity;
Agent MAY_BE {Person, Organisation, SoftwareAgent, AIModel, AutomatedService};

ProvenanceRecord := StructuredCollectionOfProvenanceStatements;
ProvenanceStatement := Subject -> ProvenanceRelationship -> Object;
ProvenanceIdentifier := StableReferenceToEntityActivityAgentEventOrProvenanceRecord;
ProvenanceIdentifier MAY_BE {URI, IRI, UUID, InternalIdentifier};

Generation := Activity -> GENERATES -> Entity;
WasGeneratedBy := Entity -> WAS_GENERATED_BY -> Activity;
IF Activity GENERATES Entity THEN Entity WAS_GENERATED_BY Activity;

Usage := Activity -> USES -> Entity;
Used := Activity -> USED -> Entity;

Derivation := DerivedEntity -> WAS_DERIVED_FROM -> SourceEntity;
WasDerivedFrom := RelationshipConnectingDerivedEntityToSourceEntity;
DirectDerivation := ImmediateDerivationFromSource;
AncestorDerivation := TransitiveSourceRelationshipAcrossMultipleDerivationSteps;

IF EntityA WAS_DERIVED_FROM EntityB
AND EntityB WAS_DERIVED_FROM EntityC
THEN EntityA MAY_HAVE AncestorSource EntityC;

DirectDerivation != AncestorDerivation;

Attribution := Entity -> WAS_ATTRIBUTED_TO -> Agent;
WasAttributedTo := RelationshipConnectingEntityToResponsibleOrCreditedAgent;
Association := Activity -> WAS_ASSOCIATED_WITH -> Agent;
WasAssociatedWith := RelationshipConnectingActivityToParticipatingAgent;

Revision := NewEntityVersion -> WAS_REVISION_OF -> PreviousEntityVersion;
WasRevisionOf := RelationshipConnectingRevisionToEarlierVersion;

PrimarySource := SourceHavingDirectOrAuthoritativeRelationshipToEntityAccordingToContext;
HadPrimarySource := Entity -> HAD_PRIMARY_SOURCE -> SourceEntity;
WasInformedBy := Activity -> WAS_INFORMED_BY -> EarlierActivity;

Creator := AgentResponsibleForInitialCreationOfEntity;
Contributor := AgentContributingToEntityOrActivity;
ResponsibleAgent := AgentAccountableForDefinedActivityOrDecision;
Authority := AgentOrSourceHavingRecognisedAuthorityForProvenanceAssertion;

SoftwareAgent := SoftwareSystemPerformingProvenanceRelevantActivity;
AIModel := ModelPerformingGenerationTransformationExtractionOrInference;

AIActivity MAY_RECORD {ModelIdentifier, ModelVersion, Operation, InputEntities, OutputEntities, Timestamp};

Source := OriginEvidenceOrInputAssociatedWithEntityOrAssertion;
SourceEntity := EntityUsedAsOriginInputOrEvidence;
DerivedEntity := EntityProducedFromOneOrMoreSourceEntities;

Transformation := ActivityChangingRepresentationStructureContentOrStateOfEntity;
Transformation MAY_BE {Conversion, Normalisation, Aggregation, Extraction, Translation, Summarisation, Migration};
Transformation SHOULD_PRESERVE {SourceIdentifiers, ActivityIdentifier, ToolOrAgent, ParametersWhereRelevant, Timestamp};

Aggregation := ActivityCombiningMultipleEntitiesIntoDerivedEntity;
Extraction := ActivitySelectingOrDerivingSubsetOrInformationFromSourceEntity;
Translation := TransformationProducingRepresentationInDifferentLanguage;
Summarisation := TransformationProducingCondensedRepresentation;
Migration := TransformationMovingEntityAcrossFormatSystemOrEnvironment;

Lineage := DirectedHistoryOfEntityDerivationsActivitiesAndAgents;
ProvenanceChain := ConnectedSequenceOrGraphOfProvenanceEventsAndRelationships;

ProvenanceEvent := TimeAssociatedOccurrenceAffectingEntityHistory;
ProvenanceEvent MAY_BE {CreationEvent, ImportEvent, TransformationEvent, ValidationEvent, PublicationEvent, MigrationEvent, ModificationEvent, DeletionEvent};

Timestamp := TemporalValueAssociatedWithEntityActivityEventOrStatement;
Timestamp MAY_INCLUDE {CreatedAt, StartedAt, EndedAt, ModifiedAt, RecordedAt};

IF ActivityA.endTime < ActivityB.startTime
THEN ActivityA PRECEDES ActivityB;

TimestampPrecision SHOULD_BE Preserved;

Version := IdentifiedStateOfEntityAtPointInHistory;
VersionIdentifier := IdentifierDistinguishingEntityRevision;
VersionHistory := OrderedOrGraphStructuredCollectionOfEntityVersions;
VersionRelationship MAY_INCLUDE {PreviousVersion, NextVersion, RevisionOf, Supersedes};

ChangeSet := StructuredRepresentationOfDifferencesBetweenVersions;
ChangeSet MAY_INCLUDE {Added, Removed, Modified};

IdentityContinuity := RelationshipIndicatingSameConceptualEntityAcrossVersions;
IdentityContinuity SHOULD_BE DistinguishedFrom DerivationIntoDistinctEntity;

Copy := NewRepresentationPotentiallySharingContentWithSourceEntity;
Copy MAY_HAVE DistinctIdentityAndProvenance;
Derivative := EntityCreatedByTransformingAnotherEntity;

ProvenanceGraph := Entities + Activities + Agents + DirectedTypedRelationships;
GraphNode MAY_BE {Entity, Activity, Agent};
GraphEdge MAY_BE {WAS_GENERATED_BY, USED, WAS_DERIVED_FROM, WAS_ATTRIBUTED_TO, WAS_ASSOCIATED_WITH, WAS_REVISION_OF, HAD_PRIMARY_SOURCE, WAS_INFORMED_BY};

RelationshipDirection MUST_BE Preserved;

ProvenancePath := DirectedPathThroughProvenanceGraph;
SourceTrace := TargetEntity -> FollowBackwardDerivationAndGenerationEdges -> SourceEntities;
ImpactTrace := SourceEntity -> FollowForwardDerivationRelationships -> DescendantEntities;

RootSource := SourceEntityWithoutKnownEarlierDerivationWithinCurrentGraph;
RootSource != AbsoluteOriginalSourceUnlessGraphIsComplete;

ChainOfCustody := SequenceOfAgentsRepositoriesOrSystemsHoldingManagingOrTransferringEntity;
CustodyEvent MAY_BE {Receipt, Transfer, Storage, Release};
CustodyEvent SHOULD_RECORD {FromAgent, ToAgent, Timestamp, Authority, Evidence};

CustodyGap := PeriodOrTransferWithoutAdequateCustodyEvidence;
CustodyGap MAY_DECREASE ProvenanceConfidence;

Evidence := InformationSupportingProvenanceStatement;
Evidence MAY_BE {AuditLog, DigitalSignature, Checksum, SystemRecord, ExternalRecord, HumanAttestation};

Fixity := EvidenceThatDigitalEntityHasNotChangedUnexpectedly;
Checksum := ComputedDigestUsedToVerifyIntegrity;

IF CurrentChecksum != RecordedChecksum
THEN IntegrityMismatch SHOULD_BE Raised;

DigitalSignature MAY_SUPPORT {Integrity, Authentication, NonRepudiation} according_to cryptographic_context;

AuditRecord := ControlledRecordOfProvenanceRelevantAction;
AuditTrail := OrderedCollectionOfAuditRecords;
AuditTrail MAY_SUPPORT ReconstructionOfEntityHistory;

ProvenanceConfidence := EstimatedSupportForProvenanceStatement;
Confidence MAY_BE_FUNCTION_OF {SourceReliability, EvidenceStrength, ChainCompleteness, TemporalConsistency, CrossSourceAgreement};

ProvenanceCompleteness := DegreeToWhichRequiredEntitiesActivitiesAgentsAndRelationshipsAreRecorded;
ProvenanceConsistency := DegreeToWhichStatementsDoNotConflict;
ProvenanceIntegrity := PreservationOfReliableUnalteredProvenanceRecords;
ProvenanceTraceability := AbilityToFollowEntityHistoryToSourcesActivitiesAndAgents;

ProvenanceQuality MAY_INCLUDE {Completeness, Consistency, Integrity, Traceability, EvidenceStrength};

ProvenanceValidation MAY_CHECK {IdentifierValidity, MissingSource, MissingAgent, TemporalConsistency, BrokenDerivation, VersionContinuity, GraphCycles};

IF DerivedEntityRequiresSource AND NoSourceRecorded
THEN ProvenanceCompleteness SHOULD_DECREASE;

IF ActivityUsesEntityCreatedAfterActivityEnded
THEN TemporalConsistency SHOULD_DECREASE;

ProvenanceConflict := MultipleStatementsProvideIncompatibleOriginHistoryAttributionOrVersionInformation;
ConflictHandling MAY {PreserveAllStatements, CompareEvidence, CompareAuthority, RankConfidence, FlagReview};

MetadataProvenance := ProvenanceOfMetadataRecordOrMetadataStatement;
RecordLevelProvenance := ProvenanceAppliedToWholeMetadataRecord;
StatementLevelProvenance := ProvenanceAppliedToIndividualMetadataAssertion;
StatementLevelProvenance MAY_DIFFER_FROM RecordLevelProvenance;

AssertionProvenance := ProvenanceAttachedToSpecificClaimOrKnowledgeAssertion;
AssertionProvenance SHOULD_PRESERVE {Source, ExtractionOrGenerationMethod, Timestamp, Confidence};

DataProvenance := ProvenanceOfDatasetDataElementOrTransformationPipeline;
WorkflowProvenance := ProvenanceOfWorkflowDefinitionOrExecution;
WorkflowRun := ExecutionInstanceOfWorkflow;

PipelineProvenance MAY_RECORD {Inputs, Outputs, ProcessingSteps, SoftwareVersions, Parameters};

Reproducibility := AbilityToRecreateOrVerifyResultUsingRecordedSourcesMethodsParametersAndEnvironment;
Provenance MAY_SUPPORT Reproducibility BUT DoesNotGuaranteeIt;

ScientificProvenance MAY_INCLUDE {DatasetVersion, Instrument, Method, Software, Parameters, Researcher};

ModelProvenance MAY_INCLUDE {TrainingDataReferences, ModelVersion, TrainingProcedure, Evaluation, DeploymentHistory} where available_and_appropriate;

AIOutputProvenance MAY_INCLUDE {Model, InputSourceReferences, RetrievalSources, GenerationTimestamp, Operation} subject_to policy_and_privacy;

RAGProvenance SHOULD_PRESERVE {RetrievedSourceIdentifiers, SourceVersions, RetrievalTimestamp, CitationRelationships};

Search MAY_USE ProvenanceFor {SourceFiltering, AuthorityRanking, VersionSelection, DateFiltering, TrustSignals};
SemanticSearch MAY_RETURN ProvenanceAlongsideResultForExplainability;
RetrievalAugmentedGeneration MAY_USE ProvenanceFor {SourceRanking, Citation, TrustAssessment, Freshness, ConflictResolution};

KnowledgeGraph MAY_ATTACH ProvenanceTo {Nodes, Edges, ReifiedStatements};
KnowledgeGraphStatement := Subject -> Predicate -> Object;
StatementProvenance MAY_IDENTIFY {Source, Extractor, Timestamp, Confidence};

RDF MAY_REPRESENT ProvenanceUsing TypedRelationships;
JSONLD MAY_SERIALISE LinkedProvenanceMetadata;

PROVStyleModel MAY_REPRESENT {Entity, Activity, Agent, Generation, Usage, Derivation, Attribution, Association};

DescriptiveMetadata MAY_HAVE Provenance;
StructuralMetadata MAY_HAVE Provenance;
AdministrativeMetadata MAY_HAVE Provenance;
TechnicalMetadata MAY_HAVE Provenance;
ProvenanceMetadata MAY_CROSSCUT AllMetadataCategories;

MetadataRepository SHOULD_PRESERVE ProvenanceAcross {Import, Transformation, Merge, Export};
MetadataRegistry MAY_REGISTER ProvenancePropertiesEventTypesAndAgentTypes;

TrustAssessment := ProvenanceEvidence + SourceAuthority + Validation -> TrustSignal;
TrustSignal SHOULD_NOT BeTreatedAsAbsoluteTruth;

AccessControl MAY_APPLY_TO ProvenanceMetadata;
Provenance MAY_REVEAL {PersonalInformation, InternalSystems, ConfidentialSources, SecuritySensitiveHistory};
PrivacyAndSecurityPolicy SHOULD_BE AppliedBeforeProvenanceDisclosure;

ProvenanceSecurity MAY_INCLUDE {AccessControl, IntegrityProtection, DigitalSigning, Audit, AppendOnlyStorage};
AppendOnlyProvenanceStore MAY_REDUCE UndetectedHistoryRewriting;

ProvenanceVersion := VersionOfProvenanceRecordOrGraph;
ProvenanceRevision SHOULD_PRESERVE PreviousAssertionsWhereAuditabilityRequires;

MachineReadableProvenance SHOULD_PRESERVE {
 EntityIdentifiers,
 ActivityIdentifiers,
 AgentIdentifiers,
 RelationshipTypes,
 RelationshipDirection,
 Timestamps,
 Versions,
 Evidence,
 Confidence
};

# ---------- SEMANTIC REASONING ----------
IF MetadataDescribesOriginGenerationDerivationAttributionCustodyOrHistory
THEN ProvenanceClassification := supported;

IF Entity WAS_GENERATED_BY Activity
THEN Activity SHOULD_BE RepresentedAsGeneratingEntity;

IF Activity USED SourceEntity
AND GENERATED DerivedEntity
THEN DerivedEntity MAY_BE_DERIVED_FROM SourceEntity according_to activity_semantics;

IF EntityA WAS_DERIVED_FROM EntityB
AND EntityB WAS_DERIVED_FROM EntityC
THEN EntityC MAY_BE AncestorSourceOf EntityA;

IF Entity WAS_ATTRIBUTED_TO Agent
THEN Attribution MUST_NOT AutomaticallyImply LegalOwnership;

IF ChecksumMismatchDetected
THEN EntityIntegrityConfidence SHOULD_DECREASE;

IF ProvenanceChainHasCriticalGap
THEN ProvenanceCompleteness SHOULD_DECREASE;

IF SourceVersionKnown
THEN Derivation SHOULD_REFERENCE ExactSourceVersionWherePossible;

IF AIOutputGeneratedFromRetrievedSources
THEN RetrievedSourceProvenance SHOULD_BE PreservedWhereSupported;

# ---------- SEMANTIC EQUIVALENCE ----------
SEMANTIC_EQUIVALENCE {
 "provenance" ~= "resource provenance" WHEN metadata_context;
 "data lineage" ~= "provenance lineage" WHEN data_context;
 "derivation" ~= "was derived from relationship";
 "generation" ~= "entity generation event";
 "attribution" ~= "was attributed to relationship";
 "chain of custody" ~= "custody history";
 "source trace" ~= "provenance source path";
 "provenance graph" ~= "lineage graph";
}

# ---------- QUERY FLOW ----------
QUERY(q) ->
 NORMALISE(q) ->
 IDENTIFY_PROVENANCE_SUBJECT(q) ->
 RESOLVE_ENTITY_AND_VERSION(q) ->
 IDENTIFY_SOURCE_ENTITIES(q) ->
 IDENTIFY_GENERATING_USING_AND_TRANSFORMING_ACTIVITIES(q) ->
 IDENTIFY_AGENTS_AND_ATTRIBUTION(q) ->
 IDENTIFY_TIMESTAMPS_EVENTS_AND_CUSTODY(q) ->
 TRACE_DERIVATION_AND_VERSION_PATHS(q) ->
 IDENTIFY_EVIDENCE_AND_CONFIDENCE(q) ->
 VALIDATE_PROVENANCE_GRAPH(q) ->
 APPLY_ACCESS_AND_PRIVACY_POLICY(q) ->
 RETURN_RELEVANT_PROVENANCE_KNOWLEDGE;

# ---------- CONFIDENCE ----------
CONFIDENCE(assertion) :=
 weighted_mean(
  source_reliability,
  evidence_strength,
  provenance_completeness,
  temporal_consistency,
  graph_integrity,
  contextual_relevance
 );

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

# ---------- AI CONSUMPTION ----------
AI_CONSUMPTION {
 primary_entity: Provenance;
 ontology: ProvenanceOntology;
 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;
 trace_derivation_paths: true;
}

# ---------- UPDATE MODEL ----------
UPDATE_MODEL {
 new_entity:
  assign_identifier
  -> identify_generation_or_source
  -> attach_version
  -> attach_agent
  -> attach_timestamp
  -> attach_evidence
  -> validate
  -> integrate;

 new_activity:
  assign_activity_identifier
  -> identify_inputs
  -> identify_outputs
  -> identify_agents
  -> record_parameters_and_time
  -> create_provenance_edges
  -> integrate;

 new_derivation:
  validate_source_and_target
  -> preserve_direction
  -> attach_activity_if_known
  -> attach_evidence
  -> assign_confidence
  -> integrate;

 provenance_revision:
  preserve_previous_assertions
  -> add_correct_or_supersede_assertions
  -> maintain_audit_history
  -> revalidate_graph
  -> recompute_confidence
  -> regenerate_flow_hash;

 conflict:
  preserve_all_provenance
  -> compare_sources_and_evidence
  -> adjust_confidence
  -> flag_review;
}

# ---------- FLOW HASH ----------
FLOW_HASH_INPUT :=
 DOMAIN
 + SUBDOMAIN
 + ONTOLOGY
 + ProvenanceEntity
 + RelationshipEntity
 + EvidenceEntity
 + AgentEntity
 + Provenance
 + ProvenanceGraph
 + ProvenanceValidation
 + RELATIONSHIPS
 + SEMANTIC_REASONING
 + SEMANTIC_EQUIVALENCE
 + UPDATE_MODEL;

FLOW_HASH := HASH(FLOW_HASH_INPUT);

# ---------- TERMINAL ----------
ProvenanceOntology
 -> IdentifyEntityAssertionOrMetadataSubject
 -> AssignStableEntityActivityAndAgentIdentifiers
 -> IdentifySourceEntitiesAndPrimarySources
 -> RecordGenerationUsageTransformationAndRevisionActivities
 -> AssociateCreatorsContributorsSoftwareAndAI agents
 -> PreserveTimestampsVersionsCustodyAndChangeEvents
 -> BuildDirectedProvenanceAndDerivationGraph
 -> AttachEvidenceFixityAuditAndConfidence
 -> ValidateTemporalGraphAndLineageConsistency
 -> SupportSourceTraceImpactAnalysisAndReproducibility
 -> PreserveProvenanceForSearchRAGAndKnowledgeGraphs
 -> EnforcePrivacySecurityAndAccessPolicies
 -> MaintainReliableProvenanceKnowledge;

END FLOW