Temporal Metadata Ontology

FLOW ALGEBRA
Temporal Metadata Ontology
Kireth Semantic Research Archive

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

AUTHORS:
Mark Anthony Higgins — Sky (Recursive AI)

FLOW "TemporalMetadataOntology" v4.0

DOMAIN := MetadataOntologies
SUBDOMAIN := TemporalMetadata
ONTOLOGY := TemporalMetadataOntology

ENTITY TemporalMetadata {
 definition: "Structured metadata representing temporal properties of resources, events, activities, assertions, versions and processes, including instants, dates, timestamps, intervals, durations, ordering, validity, recurrence, precision, granularity, temporal uncertainty and historical context.";
 objectives: [TemporalRepresentation, EventOrdering, ValidityTracking, IntervalReasoning, DurationRepresentation, HistoricalStateReconstruction, MachineInterpretability];
}

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

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

TemporalMetadataFlow :=
 TemporalSubject
 -> IdentifyTemporalProperty
 -> ExtractTemporalExpression
 -> ParseTemporalValue
 -> ResolveCalendarTimeZoneAndOffset
 -> ClassifyInstantIntervalDurationOrRecurrence
 -> DeterminePrecisionAndGranularity
 -> NormaliseTemporalRepresentation
 -> EstablishTemporalRelations
 -> AttachValidityVersionAndEventContext
 -> AttachEvidenceProvenanceAndConfidence
 -> ValidateTemporalConsistency
 -> StoreTemporalRecord
 -> EnableTemporalReasoningAndRetrieval
 -> MaintainAcrossLifecycle;

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

TemporalMetadata := MetadataAboutWhenSomethingExistsOccursAppliesChangesOrIsRecorded;

TemporalProperty MAY_BE {CreationTime, ModificationTime, PublicationTime, ObservationTime, RecordingTime, RetrievalTime, EffectiveTime, ValidityTime, ExpirationTime};

TemporalInstant := SinglePointOnTemporalAxis;
TemporalInstant MAY_BE RepresentedBy {Date, Time, Timestamp, EpochValue};

Date := CalendarBasedRepresentationOfTemporalPositionAtDayOrLargerPrecision;
Time := RepresentationOfTimeOfDay;
Timestamp := MachineReadableRepresentationOfTemporalInstant;

TemporalInterval := TemporalExtentWithStartEndOrPartialBoundaries;
TemporalInterval MAY_HAVE {Start, End, Duration};

ClosedInterval := IntervalWithKnownStartAndEnd;
OpenStartInterval := IntervalWithUnknownOrUnboundedStart;
OpenEndInterval := IntervalWithUnknownOrUnboundedEnd;

IF Start > End
THEN TemporalValidation := violation;

Duration := QuantityRepresentingLengthOfTemporalInterval;
Duration MAY_BE {FixedDuration, CalendarDuration, BusinessDuration, ApproximateDuration};

Calendar := SystemForInterpretingDates;
Calendar MAY_BE {Gregorian, Julian, HistoricalCalendar, DomainSpecificCalendar};

TimeZone := NamedOrDefinedRulesMappingLocalCivilTimeToUTC;
UTCOffset := DifferenceBetweenLocalTimeAndUTCAtSpecificInstant;
NamedTimeZone != UTCOffsetByDefinition;

LocalDateTimeWithoutTimeZone MAY_BE AmbiguousAsAbsoluteInstant;
DaylightSavingTransition MAY_CREATE {AmbiguousLocalTime, NonexistentLocalTime};

TemporalNormalisation :=
 OriginalExpression
 -> ParsedTemporalValue
 -> CalendarZoneAndOffsetResolution
 -> CanonicalTemporalRepresentation;

Normalisation SHOULD_PRESERVE OriginalExpressionWhereUseful;

Precision := SmallestTemporalUnitReliablySupportedByValue;
Precision MAY_BE {Era, Century, Decade, Year, Month, Day, Hour, Minute, Second, Millisecond, Microsecond, Nanosecond};

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

Precision != GranularityByDefinition;
TemporalPrecision MUST_NOT BeArtificiallyIncreased;

IF TemporalValueKnownOnlyToYear
THEN MonthDayAndTime MUST_NOT_BE InferredWithoutEvidence;

ApproximateTemporalValue MAY_HAVE {ApproximationType, EarliestPossible, LatestPossible};
UnknownTemporalValue MUST_NOT_BE ReplacedByArbitrarySemanticDate;

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

IF A BEFORE B
THEN B AFTER A;

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

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

TemporalRelationInference MUST_RESPECT RelationSemanticsPrecisionAndUncertainty;

CreatedAt := TimeResourceWasCreated;
ModifiedAt := TimeResourceWasModified;
PublishedAt := TimeResourceWasPublishedOrReleased;
RecordedAt := TimeInformationWasRecorded;
ObservedAt := TimeObservationWasMade;
RetrievedAt := TimeResourceWasRetrieved;
AccessedAt := TimeResourceWasAccessed;
ProcessedAt := TimeSystemProcessedResourceOrEvent;
EffectiveAt := TimeStatePolicyDecisionOrVersionBecameEffective;
ValidFrom := BeginningOfValidityInterval;
ValidTo := EndOfValidityInterval;
ExpiredAt := TimeValidityPermissionOrPolicyEnded;

CreatedAt != RecordedAtByDefinition;
ObservedAt != ProcessedAtByDefinition;
PublishedAt != CreatedAtByDefinition;

SameResource MAY_HAVE MultipleTemporalPropertiesWithDifferentRoles;
TemporalRole MUST_BE Preserved;

ValidTime := TimeDuringWhichInformationAppliesInModelledReality;
TransactionTime := TimeDuringWhichInformationIsStoredOrKnownInSystem;
BitemporalMetadata := CombinationOfValidTimeAndTransactionTime;

ValidTime != TransactionTimeByDefinition;

BitemporalRecord MAY_HAVE {ValidFrom, ValidTo, TransactionFrom, TransactionTo};

AsOfQuery := QueryRequestingStateValidOrKnownAtSpecifiedTemporalContext;
HistoricalState := ResourceStateValidOrKnownAtEarlierTime;
CurrentState := ResourceStateApplicableAtEvaluationTimeAccordingToDefinedRules;
FutureState := ScheduledOrExpectedStateApplicableAtFutureTime;

TemporalVersion := VersionAssociatedWithSpecificTemporalState;
VersionInterval := IntervalDuringWhichVersionIsCurrentOrEffective;

CreationDateOntology SPECIALISES TemporalMetadataForCreationTime;
TimestampOntology SPECIALISES TemporalMetadataForMachineReadableTemporalInstants;
VersionOntology MAY_USE TemporalMetadataForVersionOrderingAndEffectiveState;
RevisionHistoryOntology MAY_USE TemporalMetadataForRevisionSequence;
PublicationOntology MAY_USE PublicationDatesAndReleaseTimes;
ProvenanceOntology MAY_USE ActivityGenerationUsageAndRecordingTimes;
LineageOntology MAY_USE TransformationAndPipelineExecutionTimes;
CitationOntology MAY_USE AccessAndRetrievalDates;
AdministrativeMetadata MAY_USE EffectiveExpiryEmbargoRetentionAndAuditTimes;

Recurrence := RepetitionOfEventAccordingToTemporalPattern;
RecurrenceRule MAY_INCLUDE {Frequency, Interval, Start, End, Count, Exceptions};
Frequency MAY_BE {Hourly, Daily, Weekly, Monthly, Yearly, Custom};

RecurringEvent := EventHavingMultipleOccurrencesGeneratedByRecurrenceRule;
Occurrence := IndividualTemporalInstanceOfRecurringEvent;
RecurrenceRule != OccurrenceByDefinition;

Schedule := PlannedArrangementOfEventsActivitiesOrStatesOverTime;
Schedule MAY_HAVE {Start, End, Duration, Recurrence, Dependencies, Deadline};

Deadline := TemporalBoundaryByWhichActionShouldOrMustOccur;
DueDate := DateAssociatedWithExpectedCompletion;

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

TemporalSequence := OrderedCollectionOfEventsStatesOrVersions;
SequenceOrder MAY_BE {Chronological, Explicit, Logical, Causal};

ChronologicalOrder != CausalOrderByDefinition;
TemporalPrecedence MUST_NOT AutomaticallyImply Causation;

EventTime := TimeRealWorldOrModelledEventOccurred;
ProcessingTime := TimeSystemProcessedEvent;
IngestionTime := TimeEventOrDataEnteredSystem;

EventTime MAY_DIFFER_FROM ProcessingTime;
ProcessingTime MAY_DIFFER_FROM IngestionTime;

Clock MAY_HAVE {Identifier, SynchronisationSource, Accuracy, Precision, Drift};
ClockSkew := DifferenceBetweenClockReadingsForSameReferenceInstant;

LogicalTimestamp MAY_BE {SequenceNumber, LamportStyleClock, VectorClock, CustomLogicalClock};
LogicalTime != WallClockTimeByDefinition;

TemporalEvidence MAY_BE {SystemTimestamp, SensorRecord, AuditLog, PublicationRecord, VersionControlRecord, HumanStatement, ExternalSource};

TemporalProvenance MAY_INCLUDE {Source, Recorder, Extractor, ParsingMethod, NormalisationMethod, Timestamp, Version};

TemporalConfidence := EstimatedSupportForTemporalAssertion;

TemporalValidation MAY_CHECK {Syntax, CalendarValidity, TimeZone, Offset, Precision, StartEndOrder, DurationConsistency, RelationConsistency, VersionConsistency};

IF DurationSpecified
AND StartAndEndSpecified
THEN Duration SHOULD_BE ConsistentWithBoundariesAccordingToApplicableTemporalSemantics;

TemporalConflict MAY_INCLUDE {InvalidDate, StartAfterEnd, ImpossibleOrdering, OverlappingExclusiveStates, VersionDateConflict, TimeZoneConflict};

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

TemporalCompleteness := DegreeToWhichRequiredTemporalValuesRolesAndContextsArePresent;
TemporalConsistency := DegreeToWhichTemporalValuesRelationsAndDurationsAgree;
TemporalIntegrity := PreservationOfReliableOriginalNormalisedAndHistoricalTemporalAssertions;
TemporalTraceability := AbilityToTraceTemporalAssertionToSourceEvidenceAndTransformation;

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

TemporalMetadata MAY_BE {Explicit, Extracted, Derived, Inferred};
InferredTemporalMetadata SHOULD_HAVE {InferenceMethod, Confidence, Provenance};

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

MetadataRepository MAY_STORE OriginalNormalisedAndHistoricalTemporalValues;
MetadataRegistry MAY_REGISTER {TemporalProperties, TemporalRelations, Calendars, TimeZones, PrecisionLevels, RecurrenceTypes};

KnowledgeGraph MAY_REPRESENT:
 Event -> OCCURRED_AT -> TemporalInstant;
 Resource -> VALID_DURING -> TemporalInterval;
 Version -> EFFECTIVE_DURING -> TemporalInterval;

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

RDF MAY_REPRESENT TemporalRelationshipsAsTypedStatements;
JSONLD MAY_SERIALISE LinkedTemporalMetadata;

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

SemanticSearch MAY_USE TemporalContextFor {Freshness, HistoricalRelevance, EventOrdering, VersionSelection, Validity};

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

TemporalAwareRAG SHOULD_PRESERVE {SourceIdentifier, SourceVersion, RelevantTemporalProperty, ValidityInterval, Precision, RetrievalTimestamp, Provenance};

AI MAY_SUPPORT {TemporalExpressionExtraction, DateAndTimeParsing, TimeZoneResolution, IntervalDetection, EventOrdering, RecurrenceParsing, TemporalConflictDetection};

AI SHOULD_NOT InventExactTemporalValuesWhenEvidenceSupportsOnlyApproximationRangeOrUnknownState;

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

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

IF A BEFORE B
THEN B AFTER A;

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

IF IntervalStart > IntervalEnd
THEN TemporalInterval SHOULD_BE Invalid;

IF TemporalPrecisionIsYear
THEN ExactMonthDayAndTime MUST_NOT_BE InferredWithoutEvidence;

IF LocalTimeHasNoZoneOrOffset
THEN AbsoluteInstant MAY_BE Ambiguous;

IF VersionValidityContainsQueryTime
THEN Version MAY_BE CandidateForAsOfQuery;

IF EventAOccursBeforeEventB
THEN CausalRelationship MUST_NOT_BE InferredFromTemporalPrecedenceAlone;

IF TemporalAssertionCorrected
THEN PreviousAssertionAndCorrectionProvenance SHOULD_BE Preserved;

# ---------- SEMANTIC EQUIVALENCE ----------
SEMANTIC_EQUIVALENCE {
 "temporal metadata" ~= "time metadata";
 "temporal instant" ~= "point in time";
 "temporal interval" ~= "time interval";
 "valid time" ~= "validity time";
 "transaction time" ~= "system recording time" WHEN bitemporal_context;
 "temporal relation" ~= "time relation";
 "temporal sequence" ~= "chronological sequence" WHEN chronological_context;
 "validity interval" ~= "validity period";
}

# ---------- QUERY FLOW ----------
QUERY(q) ->
 NORMALISE(q) ->
 IDENTIFY_TEMPORAL_SUBJECT(q) ->
 IDENTIFY_TEMPORAL_PROPERTY(q) ->
 EXTRACT_TEMPORAL_EXPRESSION(q) ->
 PARSE_TEMPORAL_VALUE(q) ->
 RESOLVE_CALENDAR_TIMEZONE_OFFSET_AND_FORMAT(q) ->
 CLASSIFY_INSTANT_INTERVAL_DURATION_OR_RECURRENCE(q) ->
 IDENTIFY_PRECISION_AND_GRANULARITY(q) ->
 NORMALISE_TEMPORAL_REPRESENTATION(q) ->
 IDENTIFY_TEMPORAL_RELATIONS_VALIDITY_AND_VERSION_CONTEXT(q) ->
 IDENTIFY_EVIDENCE_PROVENANCE_AND_CONFIDENCE(q) ->
 VALIDATE_TEMPORAL_CONSISTENCY(q) ->
 APPLY_ACCESS_PRIVACY_AND_SECURITY_POLICY(q) ->
 RETURN_RELEVANT_TEMPORAL_KNOWLEDGE;

# ---------- CONFIDENCE ----------
CONFIDENCE(assertion) :=
 weighted_mean(
  source_reliability,
  evidence_strength,
  parsing_certainty,
  temporal_precision,
  timezone_resolution,
  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;
 ontology: TemporalMetadataOntology;
 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;
 preserve_original_expression: true;
}

# ---------- UPDATE MODEL ----------
UPDATE_MODEL {
 new_temporal_assertion:
  identify_subject
  -> identify_temporal_property
  -> preserve_original_expression
  -> parse_temporal_value
  -> resolve_calendar_timezone_and_offset
  -> classify_temporal_type
  -> determine_precision_and_granularity
  -> normalise
  -> attach_evidence_and_provenance
  -> validate
  -> assign_confidence
  -> integrate;

 temporal_revision:
  preserve_previous_assertion
  -> record_corrected_or_updated_value
  -> preserve_original_expression
  -> revalidate_relations_and_versions
  -> recompute_confidence
  -> regenerate_flow_hash;

 version_transition:
  identify_previous_and_new_versions
  -> close_previous_validity_interval
  -> open_new_validity_interval
  -> preserve_temporal_history
  -> integrate;

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

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

FLOW_HASH := HASH(FLOW_HASH_INPUT);

# ---------- TERMINAL ----------
TemporalMetadataOntology
 -> IdentifyTemporalSubjectPropertyAndContext
 -> ParseDatesTimesTimestampsIntervalsDurationsAndRecurrence
 -> ResolveCalendarTimeZoneOffsetPrecisionAndGranularity
 -> PreserveOriginalExpressionsAndCreateCanonicalRepresentations
 -> EstablishBeforeAfterOverlapContainmentAndValidityRelations
 -> DistinguishCreationModificationPublicationObservationRecordingAndProcessingTimes
 -> PreserveValidTimeTransactionTimeVersionIntervalsAndHistoricalStates
 -> RepresentSchedulesDeadlinesRecurrenceAndTemporalConstraints
 -> AttachEvidenceProvenanceUncertaintyAndConfidence
 -> ValidateTemporalSyntaxOrderingDurationAndRelationshipConsistency
 -> SupportTemporalSearchRAGVersioningProvenanceAndKnowledgeGraphs
 -> PreventUnsupportedPrecisionAndCausalInference
 -> MaintainReliableTemporalMetadataKnowledge;

END FLOW