Modification Date Ontology

FLOW ALGEBRA
Modification Date Ontology
Kireth Semantic Research Archive

PAGE:
https://kirethresearch.org/booksai-core/ontologies/metadata-ontologies/temporal-metadata/modification-date-ontology.html

AUTHORS:
Mark Anthony Higgins — Sky (Recursive AI)

FLOW "ModificationDateOntology" v4.0

DOMAIN := MetadataOntologies
SUBDOMAIN := TemporalMetadata
ONTOLOGY := ModificationDateOntology

ENTITY ModificationDate {
 definition: "Temporal metadata representing the date or temporal instant at which an existing resource, entity, record, dataset, publication, model, metadata object or other identifiable artifact was changed after its creation.";
 objectives: [ModificationTimeIdentification, ChangeTracking, VersionContext, RevisionOrdering, ProvenancePreservation, FreshnessAssessment, MachineInterpretability];
}

ModificationEntity := {ModificationDate, ModificationTimestamp, ModificationEvent, ModifiedResource, ModificationActivity, ModificationRecord, ModificationDateIdentifier, ChangeSet};
TemporalEntity := {Date, Time, Timestamp, TemporalInstant, Calendar, TimeZone, Precision, Granularity};
ProvenanceEntity := {Agent, Source, Evidence, Provenance, Confidence, Version, ValidationStatus};
RelationEntity := {ModifiedAt, UpdatedAt, RevisedAt, EditedAt, CorrectedAt, LastModifiedAt, RecordedAt};

ModificationDate DESCRIBES ModificationTimeOf ModifiedResource;
ModificationEvent MODIFIES ModifiedResource;
Agent MAY_BE_ASSOCIATED_WITH ModificationEvent;
ModifiedResource WAS_MODIFIED_AT ModificationDate;
ModificationEvent MAY_PRODUCE NewVersion;
ChangeSet DESCRIBES Modification;
Provenance SUPPORTS ModificationDateAssertion;

ModificationDateFlow :=
 ModifiedResource
 -> IdentifyModificationEvent
 -> IdentifyModificationDateExpression
 -> ParseDateOrTimestamp
 -> ResolveCalendarAndTimeZone
 -> DeterminePrecision
 -> DistinguishModificationFromCreationPublicationRecordingAndAccess
 -> IdentifyAffectedVersionAndChangeSet
 -> NormaliseModificationDate
 -> PreserveOriginalRepresentation
 -> AttachAgentSourceEvidenceAndProvenance
 -> ValidateModificationDate
 -> StoreModificationRecord
 -> EnableFreshnessVersionAndRevisionReasoning
 -> MaintainAcrossLifecycle;

ModificationDate :=
    DateOrTemporalInstantAssociatedWithChangeToExistingResource;

ModifiedResource MAY_BE {
    Document,
    Dataset,
    Image,
    Audio,
    Video,
    Software,
    Model,
    Publication,
    MetadataRecord,
    KnowledgeEntity,
    Policy
};

ModificationDateIdentifier :=
    StableReferenceToModificationDateAssertionOrRecord;

ModificationDateIdentifier MAY_BE {
    URI,
    IRI,
    UUID,
    InternalIdentifier
};

ModificationEvent :=
    EventThroughWhichExistingResourceStateIsChanged;

ModificationActivity :=
    ActivityPerformingModification;

ModificationActivity MAY_BE {
    Edit,
    Update,
    Correction,
    Revision,
    Transformation,
    Migration,
    Enrichment,
    Reformatting
};

ModificationTimestamp :=
    TimestampRepresentingModificationInstantWhereExactTimeIsKnown;

ModifiedAt :=
    TemporalPropertyLinkingResourceOrVersionToModificationTimestamp;

UpdatedAt :=
    TemporalPropertyRepresentingUpdateTime;

RevisedAt :=
    TemporalPropertyRepresentingRevisionTime;

EditedAt :=
    TemporalPropertyRepresentingEditingTime;

CorrectedAt :=
    TemporalPropertyRepresentingCorrectionTime;

LastModifiedAt :=
    MostRecentSupportedModificationTimeWithinDefinedResourceContext;

LastModifiedAt IS_CONTEXT_DEPENDENT
AND MAY_CHANGE_OVER_TIME;

ModificationDate != CreationDateByDefinition;
ModificationDate != PublicationDateByDefinition;
ModificationDate != AccessDateByDefinition;
ModificationDate != RecordedDateByDefinition;

CreationDate :=
    DateResourceOriginallyCameIntoExistence;

PublicationDate :=
    DateResourceWasPublishedOrReleased;

RecordedDate :=
    DateModificationOrMetadataWasRecordedInSystem;

AccessDate :=
    DateResourceWasAccessedOrRetrieved;

IF ModificationDate < CreationDate
THEN TemporalConsistency SHOULD_BE Reviewed;

OriginalResourceModification :=
    ChangeToUnderlyingConceptualResource;

VersionModification :=
    ChangeProducingOrUpdatingSpecificVersion;

MetadataModification :=
    ChangeToMetadataRecord;

ContentModification :=
    ChangeToResourceContent;

StructuralModification :=
    ChangeToResourceStructureOrRelationships;

TechnicalModification :=
    ChangeToFormatEncodingConfigurationOrTechnicalRepresentation;

MetadataModificationDate != ContentModificationDateByDefinition;

FileModificationDate :=
    FileSystemTimestampRepresentingFileChangeInSpecificStorageEnvironment;

FileModificationDate MAY_BE ChangedBy {
    Copy,
    Migration,
    Extraction,
    Synchronisation,
    Restore,
    Repackaging
};

FileModificationDate SHOULD_NOT AutomaticallyBeTreatedAsSemanticContentModificationDate;

RepositoryModificationDate :=
    TimeRepositoryRecordOrStoredObjectWasChanged;

RepositoryModification MAY_NOT MeanUnderlyingResourceContentChanged;

ChangeSet :=
    StructuredRepresentationOfChangesAssociatedWithModification;

ChangeSet MAY_INCLUDE {
    Addition,
    Deletion,
    Modification,
    Replacement,
    Rename,
    Reorder
};

MaterialModification :=
    ModificationChangingMeaningFunctionRightsAccessOrOperationalBehaviour;

NonMaterialModification :=
    ModificationNotChangingDefinedMeaningOrFunction;

Materiality SHOULD_BE DeterminedByDomainSpecificRules;

Revision :=
    IdentifiedChangedStateProducedByModification;

Version :=
    IdentifiedResourceStateAssociatedWithModification;

Modification MAY_PRODUCE NewVersionAccordingToVersioningPolicy;

IF MaterialModificationOccurs
THEN NewVersion MAY_BE Required;

RevisionHistory SHOULD_PRESERVE ModificationEventAndTimestamp;

ModificationSequence :=
    OrderedCollectionOfModificationEvents;

PreviousModification :=
    EarlierModificationEventInDefinedSequence;

NextModification :=
    LaterModificationEventInDefinedSequence;

IF ModificationA.Timestamp < ModificationB.Timestamp
THEN ModificationA PRECEDES ModificationB;

TemporalOrder DOES_NOT EstablishCausalDependencyByItself;

LatestModification :=
    MostRecentValidatedModificationWithinDefinedContext;

LatestModification SHOULD_BE DerivedFromValidatedModificationEvents
NOT ArbitraryFileSystemMetadata;

ModificationAgent :=
    AgentResponsibleForModificationActivity;

ModificationAgent MAY_BE {
    Person,
    Organisation,
    SoftwareAgent,
    AIModel,
    AutomatedService
};

AutomatedModification :=
    ModificationPerformedBySoftwareOrAutomatedProcess;

AIModification :=
    ModificationPerformedOrSuggestedByAIModelOrService;

AIModification SHOULD_PRESERVE {
    AgentType,
    ModelIdentifierWhereAvailable,
    Activity,
    Timestamp,
    Provenance
};

ModificationDateSource :=
    SourceFromWhichModificationDateWasObtained;

ModificationDateSource MAY_BE {
    VersionControlRecord,
    SystemLog,
    DatabaseRecord,
    FileMetadata,
    RepositoryRecord,
    PublicationRecord,
    HumanStatement
};

ModificationEvidence :=
    InformationSupportingModificationDateAssertion;

Evidence MAY_BE {
    Commit,
    AuditLog,
    ChangeRequest,
    RevisionRecord,
    RepositoryEvent,
    SignedRecord
};

ModificationProvenance MAY_INCLUDE {
    Source,
    Agent,
    Activity,
    Tool,
    Recorder,
    Timestamp,
    PreviousVersion,
    NewVersion
};

ModificationConfidence :=
    EstimatedSupportForModificationDateAssertion;

Confidence MAY_DEPEND_ON {
    SourceReliability,
    EvidenceStrength,
    AgentResolution,
    Precision,
    TemporalConsistency,
    ProvenanceQuality
};

ExplicitModificationDate :=
    ModificationDateDirectlyRecordedBySourceSystemOrAuthoritativeMetadata;

DerivedModificationDate :=
    ModificationDateComputedFromRevisionOrVersionEvidence;

InferredModificationDate :=
    ModificationDateEstimatedFromIndirectEvidence;

InferredModificationDate SHOULD_HAVE {
    InferenceMethod,
    Confidence,
    Provenance
};

ApproximateModificationDate :=
    ModificationDateKnownOnlyApproximately;

ApproximateModificationDate MAY_BE {
    ApproximateYear,
    ApproximateMonth,
    DateRange,
    BeforeDate,
    AfterDate
};

UnknownModificationDate :=
    ModificationTimeCannotBeReliablyDetermined;

UnknownModificationDate MUST_NOT_BE ReplacedByArbitraryDefaultDate;

Date :=
    CalendarBasedRepresentationOfModificationDayOrLargerUnit;

Calendar MAY_BE {
    Gregorian,
    Julian,
    HistoricalCalendar,
    DomainSpecificCalendar
};

TimeZone :=
    ZoneOrOffsetRequiredToInterpretModificationTimestamp;

Precision :=
    SmallestTemporalUnitReliablySupported;

ModificationDatePrecision MAY_BE {
    Year,
    Month,
    Day,
    Hour,
    Minute,
    Second,
    FractionalSecond
};

Precision MUST_NOT BeArtificiallyIncreased;

IF ModificationDateKnownOnlyToDay
THEN ExactTime MUST_NOT_BE InferredWithoutEvidence;

ModificationDateNormalisation :=
    OriginalModificationExpression
    -> ParsedTemporalValue
    -> CalendarAndZoneResolution
    -> CanonicalModificationDate;

OriginalExpression SHOULD_BE PreservedWhereUseful;

ModificationDateConflict :=
    MultipleSourcesProvideIncompatibleModificationDates;

ConflictHandling MAY {
    PreserveAllAssertions,
    CompareEvidence,
    CompareAuthority,
    ComparePrecision,
    CompareVersionContext,
    AssignConfidence,
    FlagReview
};

MostRecentTimestamp SHOULD_NOT AutomaticallyWinIfItRepresentsRepositoryOrFileChangeRatherThanSemanticModification;

ModificationDateValidation MAY_CHECK {
    DateSyntax,
    CalendarValidity,
    TimeZone,
    Precision,
    CreationDate,
    VersionHistory,
    RevisionHistory,
    Evidence
};

IF ModificationDatePredatesCreationDate
THEN ValidationStatus SHOULD_FLAG Review;

IF VersionModificationDatePredatesParentVersionCreation
THEN VersionHistory SHOULD_BE Reviewed;

IF ModificationDateOccursAfterResourceDeletionWithoutRestoreOrRevisionEvent
THEN TemporalConsistency SHOULD_BE Reviewed;

ModificationDateCompleteness :=
    DegreeToWhichRequiredDateContextPrecisionAgentAndSourceArePresent;

ModificationDateConsistency :=
    DegreeToWhichModificationDateAgreesWithCreationVersionRevisionAndPublicationMetadata;

ModificationDateIntegrity :=
    PreservationOfReliableOriginalNormalisedAndHistoricalModificationAssertions;

ModificationDateQuality MAY_INCLUDE {
    Completeness,
    Consistency,
    Integrity,
    Precision,
    Provenance
};

ModificationDateVersion :=
    VersionOfModificationDateAssertionOrMetadataRecord;

ModificationDateCorrection :=
    RevisionReplacingIncorrectModificationDate;

Correction SHOULD_PRESERVE {
    PreviousValue,
    NewValue,
    Reason,
    Agent,
    Provenance
};

CreationDateOntology SHOULD_DISTINGUISH OriginalCreationFromLaterModification;

TimestampOntology MAY_REPRESENT ExactModificationTimestamp;

VersionOntology SHOULD_LINK ModificationToSpecificResourceVersion;

RevisionHistoryOntology SHOULD_PRESERVE ModificationEventsAndChangeSets;

ProvenanceOntology SHOULD_LINK ModificationActivityAgentSourceAndOutput;

LineageOntology MAY_REPRESENT ModificationAsTransformationStep;

PublicationOntology MAY_DISTINGUISH ContentModificationFromPublicationOrReleaseDate;

CreatorAuthorContributorOntologies MAY_IDENTIFY AgentsResponsibleForChanges;

MetadataRepository MAY_STORE OriginalAndNormalisedModificationDates;

MetadataRegistry MAY_REGISTER ModificationDatePropertiesActivityTypesAndSources;

KnowledgeGraph MAY_REPRESENT:
    Resource
    -> MODIFIED_AT
    -> ModificationDate;

ModificationEvent
    -> MODIFIED
    -> Resource;

ModificationEvent
    -> ASSOCIATED_WITH
    -> Agent;

ModificationGraph SHOULD_PRESERVE {
    ResourceVersion,
    ChangeSet,
    Agent,
    Precision,
    Provenance,
    Confidence
};

RDF MAY_REPRESENT ModificationDateRelationshipsAsTypedStatements;

JSONLD MAY_SERIALISE LinkedModificationDateMetadata;

Search MAY_USE ModificationDateFor {
    DateFiltering,
    RecentlyUpdatedFiltering,
    HistoricalSearch,
    VersionFiltering,
    ChangeDiscovery
};

SemanticSearch MAY_USE ModificationDateFor {
    Freshness,
    VersionSelection,
    ChangeContext,
    HistoricalRelevance
};

RAG MAY_USE ModificationDateFor {
    SourceFreshness,
    CurrentVersionSelection,
    HistoricalComparison,
    ChangeAwareness
};

ModificationAwareRAG SHOULD_PRESERVE {
    ResourceIdentifier,
    ResourceVersion,
    ModificationDate,
    ChangeContext,
    Precision,
    Provenance
};

RecentModification SHOULD_NOT AutomaticallyImply MoreAuthoritativeOrAccurateContent;

AI MAY_SUPPORT {
    ModificationDateExtraction,
    ChangeEventDetection,
    DateParsing,
    FreshnessAssessment,
    ConflictDetection
};

AI SHOULD_NOT InventExactModificationDateWhenEvidenceSupportsOnlyApproximationOrUnknownState;

ModificationDateMetadata MAY_CONTAIN SensitiveOperationalOrPersonalInformation;

AccessControlPrivacyAndSecurityPolicy SHOULD_BE AppliedWhereRequired;

MachineReadableModificationDate SHOULD_PRESERVE {
    ModificationDateIdentifier,
    ResourceIdentifier,
    ResourceVersion,
    ModificationType,
    OriginalExpression,
    NormalisedModificationDate,
    Calendar,
    TimeZone,
    Precision,
    ModificationAgent,
    ChangeSet,
    Evidence,
    Provenance,
    Confidence
};

# ---------- SEMANTIC REASONING ----------
IF TemporalMetadataRepresentsWhenExistingResourceWasChanged
THEN ModificationDateClassification := supported;

IF ModificationDatePredatesCreationDate
THEN TemporalConsistency SHOULD_BE Reviewed;

IF FileModificationTimestampChangesAfterCopyOrMigration
THEN SemanticResourceModification MUST_NOT_BE AutomaticallyInferred;

IF MaterialModificationProducesNewVersion
THEN ModificationEvent SHOULD_LINK PreviousAndNewVersions;

IF ModificationDatePrecisionIsDay
THEN ExactHourMinuteSecond MUST_NOT_BE Inferred;

IF MultipleModificationDatesExist
THEN TheirRolesAndVersionContexts SHOULD_BE Preserved;

IF ModificationDateCorrected
THEN PreviousAssertionAndCorrectionProvenance SHOULD_BE Preserved;

IF SourceWasRecentlyModified
THEN Freshness MAY_INCREASE
BUT TrustOrAccuracy MUST_NOT_BE AutomaticallyInferred;

# ---------- SEMANTIC EQUIVALENCE ----------
SEMANTIC_EQUIVALENCE {
    "modification date" ~= "date modified";
    "modified at" ~= "modification timestamp";
    "updated at" ~= "update timestamp";
    "revised at" ~= "revision timestamp";
    "last modified" ~= "latest validated modification" WHEN resource_context;
    "metadata modification date" ~= "metadata updated date";
    "content modification date" ~= "content updated date";
    "modification event" ~= "resource change event";
}

# ---------- QUERY FLOW ----------
QUERY(q) ->
    NORMALISE(q) ->
    IDENTIFY_MODIFIED_RESOURCE(q) ->
    RESOLVE_RESOURCE_IDENTITY_AND_VERSION(q) ->
    IDENTIFY_MODIFICATION_EVENT_AND_TYPE(q) ->
    EXTRACT_MODIFICATION_DATE_EXPRESSION(q) ->
    RESOLVE_CALENDAR_TIMEZONE_AND_FORMAT(q) ->
    IDENTIFY_PRECISION_OR_DATE_RANGE(q) ->
    DISTINGUISH_CONTENT_METADATA_FILE_REPOSITORY_AND_VERSION_MODIFICATION(q) ->
    IDENTIFY_CHANGESET_AND_AGENT(q) ->
    NORMALISE_MODIFICATION_DATE(q) ->
    IDENTIFY_SOURCE_EVIDENCE_AND_PROVENANCE(q) ->
    VALIDATE_CREATION_VERSION_AND_REVISION_CONSISTENCY(q) ->
    SCORE_CONFIDENCE(q) ->
    RETURN_RELEVANT_MODIFICATION_DATE_KNOWLEDGE;

# ---------- CONFIDENCE ----------
CONFIDENCE(assertion) :=
    weighted_mean(
        source_reliability,
        evidence_strength,
        date_precision,
        agent_resolution,
        temporal_consistency,
        version_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: ModificationDate;
    ontology: ModificationDateOntology;
    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_original_date_expression: true;
    preserve_temporal_precision: true;
}

# ---------- UPDATE MODEL ----------
UPDATE_MODEL {
    new_modification:
        identify_resource_and_version
        -> identify_modification_event_and_type
        -> preserve_original_date_expression
        -> parse_temporal_value
        -> resolve_calendar_and_timezone
        -> determine_precision
        -> identify_agent_and_changeset
        -> attach_source_evidence_and_provenance
        -> validate
        -> assign_confidence
        -> integrate;

    modification_correction:
        preserve_previous_assertion
        -> record_corrected_date
        -> record_reason_and_agent
        -> renormalise
        -> revalidate_creation_version_revision_and_publication_relations
        -> recompute_confidence
        -> regenerate_flow_hash;

    new_version:
        identify_modification_event
        -> preserve_previous_version
        -> create_new_version
        -> attach_modification_date_and_changeset
        -> update_revision_history
        -> integrate;

    conflict:
        preserve_all_modification_date_assertions
        -> compare_source_semantics_versions_precision_and_evidence
        -> adjust_confidence
        -> flag_review;
}

# ---------- FLOW HASH ----------
FLOW_HASH_INPUT :=
    DOMAIN
    + SUBDOMAIN
    + ONTOLOGY
    + ModificationEntity
    + TemporalEntity
    + ProvenanceEntity
    + RelationEntity
    + ModificationDate
    + ModificationDateNormalisation
    + ModificationDateValidation
    + RELATIONSHIPS
    + SEMANTIC_REASONING
    + SEMANTIC_EQUIVALENCE
    + UPDATE_MODEL;

FLOW_HASH :=
    HASH(FLOW_HASH_INPUT);

# ---------- TERMINAL ----------
ModificationDateOntology
    -> IdentifyModifiedResourceAndExactVersion
    -> IdentifyModificationEventTypeAgentAndChangeSet
    -> ParseOriginalModificationDateOrTimestampExpression
    -> ResolveCalendarTimeZoneFormatPrecisionOrDateRange
    -> DistinguishSemanticContentChangeFromMetadataFileRepositoryAndSystemChanges
    -> PreserveApproximateAndUncertainDatesWithoutInventingPrecision
    -> NormaliseModificationDateWhilePreservingOriginalRepresentation
    -> AttachSourceEvidenceProvenanceAndConfidence
    -> ValidateAgainstCreationVersionRevisionPublicationAndDeletionHistory
    -> SupportFreshnessSearchRAGVersioningAndChangeReasoning
    -> PreserveCorrectionsConflictsAndEarlierAssertions
    -> ApplyPrivacySecurityAndAccessControls
    -> MaintainReliableModificationDateKnowledge;

END FLOW