Temporal Metadata

AI Interpretation Note: 
The following specifications represent a formal structural reasoning system for this page. 
Execute as formal rules, not pseudocode. 
FLOW ALGEBRA
Temporal Metadata
Kireth Semantic Research Archive

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

AUTHORS:
Mark Anthony Higgins — Sky (Recursive AI)

FLOW "TemporalMetadata" v4.0

DOMAIN := MetadataOntologies
SUBDOMAIN := TemporalMetadata
TYPE := ParentOntology / SemanticNavigationHub

ENTITY TemporalMetadata {
 definition: "Metadata representing time-related properties of resources, events, assertions, versions and processes, including dates, timestamps, durations, intervals, temporal ordering, validity periods, recurrence, temporal precision and historical context.";
 objectives: [TemporalIdentification, EventOrdering, ValidityTracking, DurationRepresentation, VersionContext, HistoricalReasoning, MachineInterpretability];
}

TemporalEntity := {TemporalMetadata, TemporalInstant, TemporalInterval, Date, Time, Timestamp, Duration, TemporalEvent};
RelationEntity := {Before, After, During, Overlaps, Meets, Starts, Finishes, Contains, Equals};
LifecycleEntity := {CreatedAt, ModifiedAt, PublishedAt, ValidFrom, ValidTo, EffectiveAt, ExpiredAt};
MetadataEntity := {Calendar, TimeZone, Precision, Granularity, Provenance, Confidence, Version, TemporalStatus};

TemporalMetadata DESCRIBES TemporalPropertiesOf Resource;
TemporalInstant LOCATES EventInTime;
TemporalInterval HAS_START TemporalInstant;
TemporalInterval HAS_END TemporalInstant;
Duration MEASURES TemporalExtent;
TemporalRelation CONNECTS TemporalEntities;
Provenance SUPPORTS TemporalAssertion;

TemporalMetadataFlow :=
 ResourceOrEvent
 -> IdentifyTemporalSubject
 -> IdentifyTemporalProperty
 -> ParseTemporalExpression
 -> ResolveCalendarAndTimeZone
 -> DetermineInstantIntervalOrDuration
 -> NormaliseTemporalValue
 -> DeterminePrecisionAndGranularity
 -> EstablishTemporalRelations
 -> AttachProvenanceAndConfidence
 -> ValidateTemporalConsistency
 -> StoreTemporalMetadata
 -> EnableTemporalReasoningAndRetrieval
 -> MaintainAcrossLifecycle;

TemporalMetadata :=
    StructuredInformationAboutTimeAssociatedWithResourceEventOrAssertion;

TemporalSubject MAY_BE {
    Resource,
    Event,
    Activity,
    Assertion,
    Version,
    Publication,
    Dataset,
    MetadataRecord
};

TemporalInstant :=
    SinglePointOnTemporalAxis;

TemporalInstant MAY_BE RepresentedBy {
    Date,
    Time,
    Timestamp,
    Year,
    Month,
    Day
};

Date :=
    CalendarBasedRepresentationOfDayOrOtherCalendarUnit;

Time :=
    RepresentationOfTimeOfDay;

Timestamp :=
    MachineReadableRepresentationOfTemporalInstant;

Timestamp MAY_INCLUDE {
    Date,
    Time,
    TimeZoneOrOffset,
    Precision
};

TemporalInterval :=
    BoundedOrPartiallyBoundedExtentOfTime;

TemporalInterval MAY_HAVE {
    Start,
    End,
    Duration
};

OpenInterval :=
    IntervalMissingKnownStartOrEndBoundary;

ClosedInterval :=
    IntervalWithKnownStartAndEndBoundaries;

IF Start > End
THEN TemporalValidation := violation;

Duration :=
    QuantityRepresentingTemporalLength;

Duration MAY_BE {
    Seconds,
    Minutes,
    Hours,
    Days,
    Weeks,
    Months,
    Years,
    ISOStyleDuration
};

CalendarDuration MAY_DIFFER_FROM FixedSecondDuration;

Calendar :=
    SystemForRepresentingDates;

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

Calendar MUST_BE PreservedWhenInterpretationDependsOnIt;

TimeZone :=
    RegionalOrDefinedTimeStandardUsedToInterpretLocalTime;

UTC :=
    CoordinatedUniversalTimeReference;

LocalTimestampWithoutTimeZone MAY_BE Ambiguous;

Offset :=
    DifferenceBetweenLocalTimeAndUTC;

DaylightSavingRules MAY_AFFECT ConversionBetweenLocalTimeAndUTC;

TemporalNormalisation :=
    OriginalTemporalExpression
    -> CanonicalTemporalRepresentation;

Normalisation SHOULD_PRESERVE OriginalExpressionWhereUseful;

TemporalPrecision :=
    DegreeOfExactnessOfTemporalValue;

Precision MAY_BE {
    Year,
    Month,
    Day,
    Hour,
    Minute,
    Second,
    Millisecond,
    Microsecond,
    Nanosecond
};

TemporalGranularity :=
    ScaleAtWhichTimeIsRepresentedOrReasonedAbout;

Granularity MAY_BE {
    Era,
    Century,
    Decade,
    Year,
    Month,
    Week,
    Day,
    Hour,
    Minute,
    Second
};

Precision != GranularityByDefinition;

ApproximateTime :=
    TemporalValueKnownOnlyApproximately;

ApproximateTime SHOULD_BE MarkedExplicitly;

UncertainTime :=
    TemporalValueWithUncertaintyAboutExactPositionOrBoundary;

TemporalUncertainty MAY_HAVE {
    EarliestPossible,
    LatestPossible,
    Confidence
};

UnknownTime :=
    TemporalValueCannotBeReliablyDetermined;

Unknown != ApproximateByDefinition;

TemporalEvent :=
    OccurrenceAssociatedWithTemporalInstantOrInterval;

Event MAY_HAVE {
    StartTime,
    EndTime,
    Duration
};

InstantaneousEvent :=
    EventModelledAsOccurringAtSingleInstant;

ExtendedEvent :=
    EventOccurringAcrossInterval;

TemporalRelation :=
    RelationshipBetweenTemporalEntities;

TemporalRelation MAY_INCLUDE {
    Before,
    After,
    Meets,
    Overlaps,
    Starts,
    During,
    Finishes,
    Contains,
    Equals
};

IF A BEFORE B
THEN B AFTER A;

Before :=
    FirstTemporalEntityEndsOrOccursBeforeSecondAccordingToDefinedSemantics;

After :=
    InverseOf Before;

Meets :=
    IntervalAEndsExactlyWhenIntervalBBegins;

Overlaps :=
    IntervalsShareSomeButNotAllTemporalExtent;

During :=
    IntervalAContainedWithinIntervalB;

Contains :=
    InverseOf During;

Starts :=
    IntervalsShareStartButDifferInEnd;

Finishes :=
    IntervalsShareEndButDifferInStart;

Equals :=
    TemporalEntitiesHaveEquivalentTemporalExtent;

TemporalRelationInference SHOULD_RESPECT PrecisionAndUncertainty;

CreatedAt :=
    TimeResourceWasCreated;

ModifiedAt :=
    TimeResourceWasModified;

PublishedAt :=
    TimeResourceWasPublishedOrReleased;

AccessedAt :=
    TimeResourceWasAccessed;

RetrievedAt :=
    TimeResourceWasRetrieved;

EffectiveAt :=
    TimePolicyStateOrVersionBecameEffective;

ValidFrom :=
    BeginningOfValidityPeriod;

ValidTo :=
    EndOfValidityPeriod;

ValidityInterval :=
    IntervalDuringWhichAssertionPolicyResourceOrStateIsConsideredValid;

TransactionTime :=
    TimeAtWhichInformationWasRecordedInSystem;

ValidTime :=
    TimeDuringWhichInformationAppliesInModelledReality;

BitemporalMetadata :=
    CombinationOfValidTimeAndTransactionTime;

ValidTime != TransactionTimeByDefinition;

RecordedAt :=
    TimeMetadataOrAssertionWasStored;

ObservedAt :=
    TimeObservationWasMade;

EventTime :=
    TimeRealWorldOrModelledEventOccurred;

ProcessingTime :=
    TimeSystemProcessedEventOrRecord;

EventTime MAY_DIFFER_FROM ProcessingTime;

TemporalVersion :=
    ResourceVersionAssociatedWithTemporalPeriodOrInstant;

Version MAY_HAVE {
    CreatedAt,
    EffectiveAt,
    SupersededAt
};

TemporalVersioning MAY_SUPPORT HistoricalStateReconstruction;

TemporalSnapshot :=
    RepresentationOfResourceStateAtSpecificTime;

AsOfQuery :=
    QueryRequestingStateValidOrKnownAtSpecifiedTime;

TemporalDatabase MAY_SUPPORT {
    ValidTimeQueries,
    TransactionTimeQueries,
    BitemporalQueries
};

HistoricalState :=
    ResourceStateValidAtEarlierTime;

CurrentState :=
    ResourceStateValidAtEvaluationTimeAccordingToDefinedTemporalRules;

FutureState :=
    ScheduledOrExpectedStateWhoseValidityBeginsLater;

TemporalStatus MAY_BE {
    Past,
    Current,
    Future,
    Expired,
    Scheduled,
    Unknown
};

Expiration :=
    EndOfValidityOrPermittedUsePeriod;

ExpiredAt :=
    TimeAtWhichResourcePolicyPermissionOrAssertionCeasedToBeValid;

EmbargoInterval :=
    IntervalDuringWhichAccessIsRestricted;

RetentionInterval :=
    IntervalDuringWhichResourceMustBeRetained;

LicenceTerm :=
    IntervalDuringWhichLicenceIsEffective;

PermissionPeriod :=
    IntervalDuringWhichPermissionApplies;

TemporalMetadata MAY_INTERACT_WITH {
    AccessControl,
    Licensing,
    RetentionPolicy,
    SecurityClassification,
    Publication
};

Recurrence :=
    RepeatedOccurrenceAccordingToPattern;

RecurrencePattern MAY_INCLUDE {
    Daily,
    Weekly,
    Monthly,
    Yearly,
    CustomRule
};

RecurringEvent :=
    EventWithMultipleOccurrencesGeneratedByRecurrencePattern;

Occurrence :=
    IndividualInstanceOfRecurringEvent;

Recurrence SHOULD_DISTINGUISH RuleFromGeneratedOccurrences;

Frequency :=
    RateAtWhichRecurringEventOccurs;

TemporalSequence :=
    OrderedCollectionOfEventsOrStates;

SequenceOrder MAY_BE DeterminedBy {
    Timestamp,
    ExplicitOrder,
    CausalRelationship
};

TemporalOrder != CausalOrderByDefinition;

Causality MUST_NOT_BE InferredFromTemporalPrecedenceAlone;

TemporalDependency :=
    ConstraintWhereOneEventStateOrActionDependsOnTimingOfAnother;

Deadline :=
    TemporalBoundaryByWhichActionMustOccur;

DueDate :=
    DateAssociatedWithRequiredCompletion;

Schedule :=
    PlannedTemporalArrangementOfActivitiesOrEvents;

Schedule MAY_INCLUDE {
    Start,
    End,
    Duration,
    Recurrence,
    Dependencies
};

TemporalConstraint MAY_INCLUDE {
    NotBefore,
    NotAfter,
    Within,
    During,
    MinimumDuration,
    MaximumDuration
};

TemporalReasoning :=
    DerivationOfTemporalRelationshipsFromKnownInstantsIntervalsAndConstraints;

IF A BEFORE B
AND B BEFORE C
THEN A BEFORE C;

IF A DURING B
AND B DURING C
THEN A DURING C;

Transitivity MUST_BE AppliedOnlyToRelationsWhereSemanticallyValid;

TemporalConflict :=
    IncompatibleTemporalAssertions;

Conflict MAY_INCLUDE {
    StartAfterEnd,
    OverlappingExclusiveStates,
    ImpossibleOrdering,
    VersionDateConflict
};

ConflictHandling MAY {
    PreserveAssertions,
    CompareSources,
    ComparePrecision,
    CompareAuthority,
    AssignConfidence,
    FlagReview
};

TemporalEvidence :=
    InformationSupportingTemporalAssertion;

Evidence MAY_BE {
    SystemTimestamp,
    PublicationRecord,
    AuditLog,
    SensorRecord,
    HumanStatement,
    VersionHistory
};

TemporalProvenance MAY_INCLUDE {
    Source,
    Recorder,
    ExtractionMethod,
    NormalisationMethod,
    Timestamp,
    Version
};

TemporalConfidence :=
    EstimatedSupportForTemporalValueOrRelationship;

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

TemporalValidation MAY_CHECK {
    DateFormat,
    Calendar,
    TimeZone,
    StartEndOrder,
    DurationConsistency,
    RelationConsistency,
    Precision
};

IF DurationSpecified
AND StartAndEndSpecified
THEN Duration SHOULD_BE ConsistentWithBoundariesAccordingToCalendarSemantics;

TemporalCompleteness :=
    DegreeToWhichRequiredTemporalPropertiesArePresent;

TemporalConsistency :=
    DegreeToWhichTemporalValuesRelationsAndDurationsDoNotConflict;

TemporalIntegrity :=
    PreservationOfReliableTemporalValuesContextAndHistory;

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

TemporalMetadata MAY_BE {
    Explicit,
    Derived,
    Extracted,
    Inferred
};

InferredTemporalMetadata SHOULD_HAVE ConfidenceAndProvenance;

AI MAY_SUPPORT {
    DateExtraction,
    TemporalExpressionParsing,
    EventOrdering,
    DurationInference,
    TemporalConflictDetection
};

AI SHOULD_NOT InventExactDatesOrTimesWhenEvidenceSupportsOnlyApproximateValues;

DescriptiveMetadata MAY_INCLUDE DatesAndTemporalCoverage;

StructuralMetadata MAY_INCLUDE TemporalOrderOfComponents;

AdministrativeMetadata MAY_USE EffectivePeriodsRetentionAndEmbargoDates;

ProvenanceMetadata SHOULD_PRESERVE EventAndActivityTimestamps;

VersionMetadata MAY_USE TemporalOrderingAndValidity;

MetadataRepository MAY_STORE TemporalAssertionsAndHistoricalStates;

MetadataRegistry MAY_REGISTER TemporalPropertiesCalendarsPrecisionAndRelationTypes;

KnowledgeGraph MAY_REPRESENT:
    Event
    -> OCCURRED_AT
    -> TemporalInstant;

Resource
    -> VALID_DURING
    -> TemporalInterval;

TemporalGraph SHOULD_PRESERVE {
    Calendar,
    TimeZone,
    Precision,
    Provenance,
    Confidence
};

RDF MAY_REPRESENT TemporalRelationshipsAsTypedStatements;

JSONLD MAY_SERIALISE LinkedTemporalMetadata;

Search MAY_USE TemporalMetadataFor {
    DateFiltering,
    TimeRangeSearch,
    HistoricalSearch,
    CurrentStateSelection,
    EventDiscovery
};

SemanticSearch MAY_USE TemporalContextFor {
    Recency,
    HistoricalRelevance,
    VersionSelection,
    EventOrdering
};

RAG MAY_USE TemporalMetadataFor {
    SourceFreshness,
    VersionSelection,
    HistoricalContext,
    EventSequencing
};

TemporalAwareRAG SHOULD_PRESERVE {
    SourceVersion,
    RelevantTime,
    ValidityPeriod,
    RetrievalTimestamp,
    Provenance
};

CurrentInformation SHOULD_BE EvaluatedAgainst QueryTimeAndValidityContext;

TemporalMetadata MAY_CONTAIN SensitiveOperationalOrPersonalTimingInformation;

AccessControlAndPrivacyPolicy SHOULD_BE AppliedWhereRequired;

MachineReadableTemporalMetadata SHOULD_PRESERVE {
    TemporalSubjectIdentifier,
    TemporalProperty,
    OriginalExpression,
    NormalisedValue,
    Calendar,
    TimeZone,
    Precision,
    Granularity,
    ValidityInterval,
    Provenance,
    Confidence
};

# ---------- SEMANTIC REASONING ----------
IF MetadataRepresentsDateTimeDurationIntervalOrderingOrValidity
THEN TemporalMetadataClassification := supported;

IF A BEFORE B
THEN B AFTER A;

IF A BEFORE B
AND B BEFORE C
THEN A BEFORE C;

IF Start > End
THEN TemporalAssertion SHOULD_BE FlaggedInvalid;

IF LocalTimestampHasNoTimeZone
THEN AbsoluteInstant MAY_BE Ambiguous;

IF ResourceVersionEffectiveIntervalContainsQueryTime
THEN Version MAY_BE CandidateForAsOfQuery;

IF TemporalPrecisionIsYearOnly
THEN ExactDay MUST_NOT_BE InferredWithoutEvidence;

IF EventAOccursBeforeEventB
THEN Causation MUST_NOT_BE InferredFromTemporalOrderAlone;

# ---------- SEMANTIC EQUIVALENCE ----------
SEMANTIC_EQUIVALENCE {
    "temporal metadata" ~= "time metadata";
    "temporal instant" ~= "point in time";
    "temporal interval" ~= "time interval";
    "validity period" ~= "valid time interval";
    "timestamp" ~= "time stamp";
    "created at" ~= "creation timestamp";
    "modified at" ~= "modification timestamp";
    "temporal sequence" ~= "time-ordered sequence";
}

# ---------- QUERY FLOW ----------
QUERY(q) ->
    NORMALISE(q) ->
    IDENTIFY_TEMPORAL_SUBJECT(q) ->
    IDENTIFY_TEMPORAL_PROPERTY(q) ->
    PARSE_TEMPORAL_EXPRESSION(q) ->
    RESOLVE_CALENDAR_TIMEZONE_AND_OFFSET(q) ->
    NORMALISE_TEMPORAL_VALUE(q) ->
    IDENTIFY_PRECISION_AND_GRANULARITY(q) ->
    IDENTIFY_INTERVAL_DURATION_AND_RELATIONS(q) ->
    IDENTIFY_VALIDITY_VERSION_AND_EVENT_CONTEXT(q) ->
    IDENTIFY_EVIDENCE_AND_PROVENANCE(q) ->
    VALIDATE_TEMPORAL_CONSISTENCY(q) ->
    SCORE_CONFIDENCE(q) ->
    RETURN_RELEVANT_TEMPORAL_KNOWLEDGE;

# ---------- CONFIDENCE ----------
CONFIDENCE(assertion) :=
    weighted_mean(
        source_reliability,
        evidence_strength,
        temporal_precision,
        normalisation_quality,
        temporal_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: TemporalMetadata;
    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_temporal_precision: true;
}

# ---------- UPDATE MODEL ----------
UPDATE_MODEL {
    new_temporal_assertion:
        identify_subject
        -> identify_temporal_property
        -> parse_original_expression
        -> resolve_calendar_and_timezone
        -> normalise_value
        -> assign_precision_and_granularity
        -> attach_provenance
        -> validate
        -> assign_confidence
        -> integrate;

    temporal_revision:
        preserve_previous_assertion
        -> apply_corrected_or_updated_time
        -> preserve_original_expression
        -> revalidate_temporal_relations
        -> recompute_confidence
        -> regenerate_flow_hash;

    version_change:
        identify_effective_period
        -> close_previous_version_interval
        -> open_new_version_interval
        -> preserve_history
        -> integrate;

    conflict:
        preserve_all_temporal_assertions
        -> compare_sources_precision_calendars_and_evidence
        -> adjust_confidence
        -> flag_review;
}

# ---------- FLOW HASH ----------
FLOW_HASH_INPUT :=
    DOMAIN
    + SUBDOMAIN
    + TemporalEntity
    + RelationEntity
    + LifecycleEntity
    + MetadataEntity
    + TemporalMetadata
    + TemporalReasoning
    + TemporalValidation
    + RELATIONSHIPS
    + SEMANTIC_REASONING
    + SEMANTIC_EQUIVALENCE
    + UPDATE_MODEL;

FLOW_HASH :=
    HASH(FLOW_HASH_INPUT);

# ---------- TERMINAL ----------
TemporalMetadata
    -> IdentifyResourceEventAssertionOrVersion
    -> ParseDatesTimesTimestampsDurationsAndIntervals
    -> ResolveCalendarTimeZoneOffsetPrecisionAndGranularity
    -> NormaliseTemporalValuesWhilePreservingOriginalExpression
    -> EstablishBeforeAfterDuringOverlapAndContainmentRelations
    -> TrackCreationModificationPublicationAndValidityPeriods
    -> RepresentRecurrenceSchedulesDeadlinesAndTemporalConstraints
    -> PreserveValidTimeTransactionTimeAndHistoricalStates
    -> AttachEvidenceProvenanceAndConfidence
    -> ValidateTemporalOrderDurationAndRelationshipConsistency
    -> SupportTimeAwareSearchRAGVersioningAndReasoning
    -> PreventUnsupportedPrecisionAndCausalInference
    -> MaintainReliableTemporalMetadataKnowledge;

END FLOW