Expiry Date Ontology

FLOW ALGEBRA
Expiry Date Ontology
Kireth Semantic Research Archive

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

AUTHORS:
Mark Anthony Higgins — Sky (Recursive AI)

FLOW "ExpiryDateOntology" v4.0

DOMAIN := MetadataOntologies
SUBDOMAIN := TemporalMetadata
ONTOLOGY := ExpiryDateOntology

ENTITY ExpiryDate {
 definition: "Temporal metadata representing the date, timestamp or temporal boundary after which a resource, permission, licence, credential, policy, record, version or other time-limited entity is no longer valid, active, usable, authoritative or permitted according to defined rules.";
 objectives: [ExpiryIdentification, ValidityTracking, LifecycleControl, TemporalReasoning, PolicyEnforcement, ProvenancePreservation, MachineInterpretability];
}

ExpiryEntity := {ExpiryDate, ExpiryTimestamp, ExpiryEvent, ExpiringEntity, ExpiryDateIdentifier, ExpiryRecord, ExpiryStatus, ExpiryRule};
TemporalEntity := {Date, Time, Timestamp, TemporalInstant, TemporalInterval, Duration, Calendar, TimeZone, Precision};
LifecycleEntity := {ValidFrom, ValidTo, EffectiveAt, ExpiresAt, ExpiredAt, RenewalDate, ReviewDate, GracePeriod};
MetadataEntity := {Authority, Source, Evidence, Provenance, Confidence, Version, ValidationStatus, Policy};

ExpiryDate DESCRIBES EndOfValidityOf ExpiringEntity;
ExpiringEntity EXPIRES_AT ExpiryDate;
ExpiryEvent CHANGES ExpiryStatus;
ExpiryRule DETERMINES ExpiryDate;
ValidityInterval ENDS_AT ExpiryDate;
Provenance SUPPORTS ExpiryDateAssertion;

ExpiryDateFlow :=
 ExpiringEntity
 -> IdentifyExpiryRequirement
 -> IdentifyExpiryDateExpressionOrRule
 -> ParseDateTimestampDurationOrCondition
 -> ResolveCalendarAndTimeZone
 -> DeterminePrecision
 -> IdentifyValidityStartAndExpiryBasis
 -> CalculateOrResolveExpiryBoundary
 -> IdentifyRenewalGracePeriodAndExceptions
 -> DetermineCurrentExpiryStatus
 -> PreserveOriginalRepresentation
 -> AttachAuthorityEvidenceAndProvenance
 -> ValidateExpiryDate
 -> StoreExpiryRecord
 -> EnableLifecycleAndPolicyReasoning
 -> MaintainAcrossLifecycle;

ExpiryDate := TemporalBoundaryAtWhichDefinedValidityOrAuthorityEnds;

ExpiringEntity MAY_BE {Licence, Permission, Credential, Certificate, Policy, Contract, Subscription, Resource, Dataset, Version, Offer, Record};

ExpiryDateIdentifier := StableReferenceToExpiryDateAssertionOrRecord;
ExpiryDateIdentifier MAY_BE {URI, IRI, UUID, InternalIdentifier};

ExpiryTimestamp := ExactTimestampAtWhichExpiryOccursWhereKnown;
ExpiresAt := TemporalPropertyLinkingEntityToFutureOrDefinedExpiryBoundary;
ExpiredAt := TemporalPropertyRecordingEffectiveExpiryInstant;

ExpiryEvent := EventTransitioningEntityFromValidOrActiveStateToExpiredState;

ExpiryStatus MAY_BE {NotYetEffective, Active, ExpiringSoon, Expired, Renewed, Suspended, Revoked, Unknown};

ExpiryDate != RevocationDateByDefinition;
ExpiryDate != TerminationDateByDefinition;
ExpiryDate != ReviewDateByDefinition;
ExpiryDate != RenewalDateByDefinition;

Revocation := AuthorisedWithdrawalBeforeOrIndependentOfScheduledExpiry;
Termination := EventEndingValidityAccordingToContractPolicyOrAdministrativeAction;
ReviewDate := DateAtWhichEntityMustBeReviewedWithoutNecessarilyExpiring;
RenewalDate := DateAtWhichRenewalOccursOrMustBeProcessed;

ScheduledExpiry := ExpiryDefinedInAdvanceByDateTimestampOrDuration;
ConditionalExpiry := ExpiryTriggeredByConditionOrEvent;
IndefiniteValidity := ValidityWithoutDefinedExpiryDate;
IndefiniteValidity != PermanentValidityByDefinition;

PermanentValidity := ValidityIntendedNotToExpireUnderNormalRules
BUT MAY_STILL_BE SubjectToRevocationOrSupersession;

ValidityInterval := TemporalIntervalDuringWhichEntityIsValidAccordingToDefinedRules;
ValidityInterval MAY_HAVE {ValidFrom, ValidTo};

ValidFrom := BeginningOfValidityInterval;
ValidTo := EndOfValidityInterval;
ValidTo MAY_EQUAL ExpiryDateAccordingToPolicySemantics;
EffectiveAt := TimeEntityBecomesEffective;

IF ExpiryDate < EffectiveAt
THEN TemporalValidation := violation;

DurationBasedExpiry := StartTime + ValidityDuration -> ExpiryDate;
ValidityDuration MAY_BE {Hours, Days, Weeks, Months, Years, CalendarDuration};

CalendarDuration MUST_BE CalculatedUsingApplicableCalendarSemantics;

EventBasedExpiry := ExpiryCalculatedFromSpecifiedLifecycleEvent;
ExpiryTrigger MAY_BE {Creation, Activation, Publication, Issue, Purchase, LastUse, ContractEnd, CertificationEvent, CustomEvent};

TriggerDate := TemporalValueAssociatedWithExpiryTrigger;

IF TriggerDateUnknown
THEN CalculatedExpiryDate MAY_BE Unknown;

RuleBasedExpiry := ExpiryDeterminedByPolicyOrBusinessRule;
ExpiryRule MAY_INCLUDE {FixedDateRule, DurationRule, EventRule, ConditionalRule, CompositeRule};

CompositeExpiryRule := RuleCombiningMultipleTemporalOrLogicalConditions;
RuleSemantics MUST_BE ExplicitlyDefined;

GracePeriod := PeriodAfterNominalExpiryDuringWhichLimitedUseRenewalOrComplianceMayStillBeAllowed;
GracePeriod MAY_HAVE {Start, End, Duration, AllowedActions};

NominalExpiryDate := ScheduledExpiryBeforeGracePeriodSemantics;
EffectiveExpiryDate := DateAtWhichValidityActuallyEndsAccordingToGraceAndPolicyRules;
NominalExpiryDate MAY_DIFFER_FROM EffectiveExpiryDate;

Renewal := ProcessExtendingOrReplacingValidityBeforeOrAfterExpiryAccordingToPolicy;
Renewal MAY_BE {Automatic, Manual, Conditional};
Renewal MAY_CREATE {NewExpiryDate, NewVersion, NewValidityInterval};

IF RenewalOccurs
THEN PreviousExpiryDate SHOULD_BE PreservedInHistory;

AutoRenewal := RenewalPerformedAutomaticallyWhenConditionsAreSatisfied;
RenewalFailure MAY_ALLOW EntityToExpire;

ExpiryExtension := AuthorisedChangeMovingExpiryBoundaryLater;
ExpiryReduction := AuthorisedChangeMovingExpiryBoundaryEarlier;

ExpiryChange SHOULD_PRESERVE {PreviousExpiryDate, NewExpiryDate, Reason, Authority, Provenance};

ExpiryOverride := AuthorisedRuleChangingNormalExpiryBehaviour;
Override MAY_INCLUDE {LegalHold, AdministrativeExtension, EmergencyExtension, ContractualOverride, RegulatoryOverride};

LegalHold MAY_SUSPEND DispositionAfterExpiry
BUT DoesNotNecessarilyChangeUnderlyingExpiryDate;

RetentionExpiry != PermissionExpiryByDefinition;

Resource MAY_BE ExpiredForUse
BUT StillRetainedForAuditLegalOrHistoricalReasons;

ExpiryDateSource MAY_BE {Contract, Licence, Policy, CredentialRecord, Certificate, SystemRecord, Database, MetadataRecord, HumanStatement};

ExpiryEvidence MAY_BE {ContractTerm, PolicyRule, SystemRecord, Certificate, Approval, AuditRecord};

ExpiryProvenance MAY_INCLUDE {Source, Rule, Calculator, Authority, Recorder, Timestamp, Version};

ExpiryConfidence := EstimatedSupportForExpiryDateAssertionOrCalculation;

ExplicitExpiryDate := ExpiryDateDirectlySpecifiedByAuthoritativeSource;
CalculatedExpiryDate := ExpiryDateComputedFromTriggerAndDuration;
InferredExpiryDate := ExpiryDateEstimatedFromIndirectEvidence;
InferredExpiryDate SHOULD_HAVE {InferenceMethod, Confidence, Provenance};

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

UnknownExpiryDate := ExpiryBoundaryCannotBeReliablyDetermined;
UnknownExpiryDate MUST_NOT_BE ReplacedByArbitraryDefaultDate;

Date := CalendarBasedRepresentationOfExpiryDayOrLargerUnit;
Calendar MAY_BE {Gregorian, Julian, DomainSpecificCalendar};
TimeZone := ZoneOrOffsetRequiredToInterpretExactExpiryTimestamp;

Precision := SmallestTemporalUnitReliablySupported;
ExpiryDatePrecision MAY_BE {Year, Month, Day, Hour, Minute, Second, FractionalSecond};

Precision MUST_NOT BeArtificiallyIncreased;

IF ExpiryDateKnownOnlyToDay
THEN ExactTimeOfDay MUST_NOT_BE InferredWithoutPolicy;

EndOfDaySemantics := RuleDefiningWhetherDateOnlyExpiryOccursAtStartOrEndOfSpecifiedDate;

DateOnlyExpiry MUST_HAVE DefinedBoundarySemanticsWhenExactValidityDecisionDependsOnTime;

InclusiveExpiry := EntityRemainsValidThroughSpecifiedBoundaryAccordingToPolicy;
ExclusiveExpiry := EntityCeasesToBeValidAtSpecifiedBoundary;
BoundaryInclusivity MUST_BE ExplicitWhereMaterial;

ExpiryDateNormalisation :=
 OriginalExpiryExpression
 -> ParsedTemporalValueOrRule
 -> CalendarZoneAndBoundaryResolution
 -> CanonicalExpiryDate;

OriginalExpression SHOULD_BE PreservedWhereUseful;

CurrentTime := EvaluationTimeForExpiryStatus;

IF CurrentTime < EffectiveAt
THEN ExpiryStatus MAY_BE NotYetEffective;

IF EffectiveAt <= CurrentTime
AND CurrentTime < EffectiveExpiryDate
THEN ExpiryStatus MAY_BE Active;

IF CurrentTime >= EffectiveExpiryDate
THEN ExpiryStatus MAY_BE Expired according_to boundary_semantics;

ExpiringSoon := StatusAssignedWhenExpiryFallsWithinDefinedWarningWindow;
WarningWindow := DurationBeforeExpiryUsedForNotificationOrReview;
WarningWindow MAY_BE {Hours, Days, Weeks, Months};
ExpiringSoonThreshold IS_POLICY_DEPENDENT;

ExpiryDateConflict := MultipleSourcesOrRulesProvideIncompatibleExpiryDates;

ConflictHandling MAY {PreserveAllAssertions, CompareAuthority, ComparePolicyPrecedence, CompareRuleVersion, ComparePrecision, AssignConfidence, FlagReview};

EarliestExpiry SHOULD_NOT AutomaticallyWinWithoutDefinedPolicy;
LatestExpiry SHOULD_NOT AutomaticallyWinWithoutDefinedPolicy;

ExpiryDateValidation MAY_CHECK {DateSyntax, CalendarValidity, TimeZone, Precision, EffectiveDate, TriggerDate, Duration, Renewal, GracePeriod, RuleVersion};

IF ExpiryDatePredatesTriggerDateForPositiveDuration
THEN ValidationStatus := violation;

IF GracePeriodEndPredatesNominalExpiry
THEN GracePeriodValidation := violation;

ExpiryDateCompleteness := DegreeToWhichRequiredBoundaryRuleContextAndSourceArePresent;
ExpiryDateConsistency := DegreeToWhichExpiryDateAgreesWithValidityRenewalAndLifecycleMetadata;
ExpiryDateIntegrity := PreservationOfReliableOriginalCalculatedAndHistoricalExpiryAssertions;

ExpiryDateQuality MAY_INCLUDE {Completeness, Consistency, Integrity, Precision, RuleTraceability, Provenance};

ExpiryDateVersion := VersionOfExpiryDateAssertionRuleOrRecord;

ExpiryDateCorrection SHOULD_PRESERVE {PreviousValue, NewValue, Reason, Authority, Provenance};

AccessControlOntology MAY_USE ExpiryDateForTemporaryAccess;
PermissionOntology MAY_USE ExpiryDateForPermissionValidity;
LicensingOntology MAY_USE ExpiryDateForLicenceTerm;
RetentionPolicyOntology MAY_USE ExpiryRelatedDatesForDispositionEligibility;
SecurityClassification MAY_USE ReviewOrExpiryRulesForClassification;
VersionOntology MAY_USE ExpiryOrDeprecationBoundariesForVersions;
TimestampOntology MAY_REPRESENT ExactExpiryTimestamp;
TemporalMetadataOntology PROVIDES GeneralTemporalSemantics;
ProvenanceOntology SHOULD_PRESERVE ExpiryRuleCalculationAndChanges;

MetadataRepository MAY_STORE OriginalCalculatedAndHistoricalExpiryDates;
MetadataRegistry MAY_REGISTER ExpiryPropertiesRulesStatusesAndBoundarySemantics;

KnowledgeGraph MAY_REPRESENT:
 Entity -> EXPIRES_AT -> ExpiryDate;
 ValidityInterval -> ENDS_AT -> ExpiryDate;
 ExpiryRule -> DETERMINES -> ExpiryDate;

ExpiryGraph SHOULD_PRESERVE {EntityVersion, Rule, BoundarySemantics, GracePeriod, Renewal, Provenance, Confidence};

RDF MAY_REPRESENT ExpiryRelationshipsAsTypedStatements;
JSONLD MAY_SERIALISE LinkedExpiryDateMetadata;

Search MAY_USE ExpiryDateFor {ActiveFiltering, ExpiredFiltering, ExpiringSoonFiltering, RenewalDiscovery, HistoricalSearch};

SemanticSearch MAY_USE ExpiryDateFor {ValidityFiltering, CurrentStateSelection, PolicyContext, LifecycleReasoning};

RAG MAY_USE ExpiryDateFor {SourceEligibility, PermissionValidity, LicenceValidity, PolicyValidity, VersionSelection};

ExpiryAwareRAG SHOULD_PRESERVE {EntityIdentifier, EntityVersion, ExpiryDate, ExpiryStatus, BoundarySemantics, EvaluationTime, Provenance};

ExpiredEntity SHOULD_NOT BeTreatedAsCurrentlyValid
UNLESS ApplicablePolicyDefinesContinuedUseOrGrace;

AI MAY_SUPPORT {ExpiryDateExtraction, RuleParsing, DurationCalculation, RenewalDetection, ExpiryConflictDetection};

AI SHOULD_NOT InventExpiryDatesOrAssumeBoundarySemanticsWithoutEvidenceOrPolicy;

MachineReadableExpiryDate SHOULD_PRESERVE {
 ExpiryDateIdentifier,
 EntityIdentifier,
 EntityVersion,
 OriginalExpression,
 NormalisedExpiryDate,
 ExpiryRule,
 TriggerDate,
 ValidityStart,
 GracePeriod,
 RenewalStatus,
 BoundaryInclusivity,
 Calendar,
 TimeZone,
 Precision,
 Authority,
 Evidence,
 Provenance,
 Confidence
};

# ---------- SEMANTIC REASONING ----------
IF TemporalMetadataRepresentsBoundaryAfterWhichEntityIsNoLongerValidActiveUsableOrPermitted
THEN ExpiryDateClassification := supported;

IF CurrentTimePassesEffectiveExpiryBoundary
THEN Entity MAY_BE ClassifiedExpiredAccordingToPolicy;

IF RenewalOccursBeforeExpiry
THEN NewExpiryDate SHOULD_BE CalculatedOrRecorded
AND PreviousExpiryDate SHOULD_BE Preserved;

IF DateOnlyExpiryHasNoBoundarySemantics
THEN ExactExpiryInstant MUST_NOT_BE AssumedWhenMaterial;

IF ExpiryDatePredatesEffectiveDate
THEN TemporalConsistency SHOULD_BE Reviewed;

IF GracePeriodExists
THEN NominalExpiryAndEffectiveEndOfAllowedUse SHOULD_BE Distinguished;

IF EntityIsExpired
THEN RetentionDeletionOrArchival MUST_NOT_BE AutomaticallyInferred;

IF ExpiryDateCorrected
THEN PreviousAssertionAndCorrectionProvenance SHOULD_BE Preserved;

# ---------- SEMANTIC EQUIVALENCE ----------
SEMANTIC_EQUIVALENCE {
 "expiry date" ~= "expiration date";
 "expires at" ~= "expiry timestamp";
 "valid until" ~= "validity end" WHEN validity_context;
 "expiry boundary" ~= "expiration boundary";
 "effective expiry date" ~= "effective expiration date";
 "nominal expiry date" ~= "scheduled expiry date";
 "grace period" ~= "post-expiry grace interval";
 "expiring soon" ~= "near expiry" WHEN warning_context;
}

# ---------- QUERY FLOW ----------
QUERY(q) ->
 NORMALISE(q) ->
 IDENTIFY_EXPIRING_ENTITY(q) ->
 RESOLVE_ENTITY_IDENTITY_AND_VERSION(q) ->
 IDENTIFY_EXPIRY_RULE_OR_EXPRESSION(q) ->
 IDENTIFY_VALIDITY_START_TRIGGER_AND_DURATION(q) ->
 RESOLVE_CALENDAR_TIMEZONE_AND_BOUNDARY_SEMANTICS(q) ->
 IDENTIFY_PRECISION_OR_DATE_RANGE(q) ->
 CALCULATE_OR_NORMALISE_EXPIRY_DATE(q) ->
 IDENTIFY_RENEWAL_GRACE_PERIOD_EXCEPTIONS_AND_OVERRIDES(q) ->
 DETERMINE_EXPIRY_STATUS_AT_EVALUATION_TIME(q) ->
 IDENTIFY_AUTHORITY_EVIDENCE_AND_PROVENANCE(q) ->
 VALIDATE_EXPIRY_CONSISTENCY(q) ->
 SCORE_CONFIDENCE(q) ->
 RETURN_RELEVANT_EXPIRY_DATE_KNOWLEDGE;

# ---------- CONFIDENCE ----------
CONFIDENCE(assertion) :=
 weighted_mean(
  source_reliability,
  authority_strength,
  rule_clarity,
  trigger_resolution,
  date_precision,
  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: ExpiryDate;
 ontology: ExpiryDateOntology;
 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_boundary_semantics: true;
}

# ---------- UPDATE MODEL ----------
UPDATE_MODEL {
 new_expiry_date:
  identify_entity_and_version
  -> identify_expiry_rule_or_expression
  -> preserve_original_expression
  -> identify_validity_start_trigger_and_duration
  -> resolve_calendar_timezone_and_boundary
  -> determine_precision
  -> calculate_or_normalise_expiry
  -> attach_renewal_and_grace_context
  -> attach_authority_evidence_and_provenance
  -> validate
  -> assign_confidence
  -> integrate;

 renewal:
  preserve_previous_expiry
  -> verify_renewal_authority_and_conditions
  -> create_new_validity_interval
  -> assign_new_expiry_date
  -> update_status
  -> preserve_history
  -> integrate;

 expiry_extension_or_reduction:
  preserve_previous_boundary
  -> verify_authority
  -> record_new_boundary_and_reason
  -> revalidate_status_and_dependants
  -> regenerate_flow_hash;

 expiry_event:
  evaluate_current_time
  -> verify_boundary_semantics
  -> update_expiry_status
  -> trigger_policy_defined_actions
  -> preserve_audit_and_provenance;

 conflict:
  preserve_all_expiry_assertions_and_rules
  -> compare_authority_precedence_versions_precision_and_evidence
  -> adjust_confidence
  -> flag_review;
}

# ---------- FLOW HASH ----------
FLOW_HASH_INPUT :=
 DOMAIN
 + SUBDOMAIN
 + ONTOLOGY
 + ExpiryEntity
 + TemporalEntity
 + LifecycleEntity
 + MetadataEntity
 + ExpiryDate
 + ExpiryDateNormalisation
 + ExpiryDateValidation
 + RELATIONSHIPS
 + SEMANTIC_REASONING
 + SEMANTIC_EQUIVALENCE
 + UPDATE_MODEL;

FLOW_HASH := HASH(FLOW_HASH_INPUT);

# ---------- TERMINAL ----------
ExpiryDateOntology
 -> IdentifyExpiringEntityAndExactVersion
 -> ResolveExpiryRuleExpressionTriggerAndValidityStart
 -> ParseDateTimestampDurationOrConditionalBoundary
 -> ResolveCalendarTimeZonePrecisionAndBoundaryInclusivity
 -> CalculateNominalAndEffectiveExpiryDates
 -> DistinguishExpiryFromReviewRenewalRevocationTerminationAndRetention
 -> PreserveGracePeriodsRenewalsExtensionsAndOverrides
 -> DetermineActiveExpiringSoonExpiredOrUnknownStatus
 -> AttachAuthorityEvidenceProvenanceAndConfidence
 -> ValidateExpiryAgainstEffectiveDatesTriggersDurationsAndLifecycleRules
 -> SupportValidityAwareSearchRAGPermissionsLicensingAndGovernance
 -> PreserveCorrectionsConflictsAndHistoricalExpiryAssertions
 -> MaintainReliableExpiryDateKnowledge;

END FLOW