Validity Period Ontology

FLOW ALGEBRA
Validity Period Ontology
Kireth Semantic Research Archive

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

AUTHORS:
Mark Anthony Higgins — Sky (Recursive AI)

FLOW "ValidityPeriodOntology" v4.0

DOMAIN := MetadataOntologies
SUBDOMAIN := TemporalMetadata
ONTOLOGY := ValidityPeriodOntology

ENTITY ValidityPeriod {
 definition: "A temporal interval representing the period during which a resource, assertion, permission, licence, credential, policy, version, classification, record or other entity is considered valid, effective, applicable, authorised or current according to defined rules.";
 objectives: [ValidityRepresentation, EffectivePeriodTracking, TemporalEligibility, LifecycleReasoning, VersionContext, PolicyEnforcement, MachineInterpretability];
}

ValidityEntity := {ValidityPeriod, ValidityIdentifier, ValidityInterval, ValidFrom, ValidTo, EffectiveAt, ExpiryDate, ValidityStatus};
TemporalEntity := {TemporalInstant, TemporalInterval, Date, Timestamp, Duration, Calendar, TimeZone, Precision};
LifecycleEntity := {Activation, Expiry, Suspension, Renewal, Revocation, Supersession, Extension, Review};
MetadataEntity := {Entity, Version, Policy, Authority, Evidence, Provenance, Confidence, ValidationStatus};

ValidityPeriod APPLIES_TO Entity;
ValidityPeriod HAS_START ValidFrom;
ValidityPeriod MAY_HAVE_END ValidTo;
EffectiveAt MAY_DEFINE ValidFrom;
ExpiryDate MAY_DEFINE ValidTo;
Policy GOVERNS ValidityPeriod;
Provenance SUPPORTS ValidityAssertion;

ValidityPeriodFlow :=
 Entity
 -> IdentifyValidityRequirement
 -> ResolveEntityIdentityAndVersion
 -> IdentifyValidityStart
 -> IdentifyValidityEndOrOpenEndedState
 -> ResolveCalendarTimeZoneAndPrecision
 -> DetermineBoundaryInclusivity
 -> IdentifySuspensionRenewalRevocationAndExceptions
 -> DetermineValidityStatusAtEvaluationTime
 -> AttachPolicyAuthorityEvidenceAndProvenance
 -> ValidateValidityInterval
 -> StoreValidityRecord
 -> EnableTemporalEligibilityAndHistoricalReasoning
 -> MaintainAcrossLifecycle;

ValidityPeriod := TemporalIntervalDuringWhichEntityIsValidEffectiveApplicableOrAuthorised;

Entity MAY_BE {
 Permission,
 Licence,
 Credential,
 Certificate,
 Policy,
 Contract,
 SecurityClassification,
 Resource,
 Dataset,
 Publication,
 Version,
 MetadataRecord,
 Assertion
};

ValidityIdentifier := StableReferenceToValidityPeriodOrAssertion;
ValidityIdentifier MAY_BE {URI, IRI, UUID, InternalIdentifier};

ValidityInterval := IntervalRepresentingTemporalExtentOfValidity;
ValidFrom := TemporalBoundaryAtWhichValidityBegins;
ValidTo := TemporalBoundaryAtWhichValidityEnds;
EffectiveAt := TimeEntityBecomesEffective;
ExpiryDate := ScheduledOrEffectiveEndOfValidity;

ValidFrom MAY_EQUAL EffectiveAt;
ValidTo MAY_EQUAL ExpiryDate according_to policy_semantics;

OpenEndedValidity := ValidityPeriodWithoutDefinedEndBoundary;
OpenEndedValidity != PermanentValidityByDefinition;

PermanentValidity := ValidityIntendedToContinueWithoutNormalExpiry
BUT MAY_STILL_BE SubjectToRevocationSupersessionOrPolicyChange;

FutureValidity := ValidityPeriodWhoseStartBoundaryIsInFuture;
CurrentValidity := ValidityPeriodContainingEvaluationTime;
HistoricalValidity := ValidityPeriodEndingBeforeEvaluationTime;

ValidityStatus MAY_BE {
 NotYetValid,
 Valid,
 ExpiringSoon,
 Expired,
 Suspended,
 Revoked,
 Superseded,
 Unknown
};

EvaluationTime := TemporalInstantAtWhichValidityIsAssessed;

IF EvaluationTime < ValidFrom
THEN ValidityStatus := NotYetValid;

IF ValidFrom <= EvaluationTime
AND ValidToIsOpen
THEN ValidityStatus MAY_BE Valid
subject_to suspension_revocation_and_policy;

IF ValidFrom <= EvaluationTime
AND EvaluationTime < ValidTo
THEN ValidityStatus MAY_BE Valid
according_to boundary_semantics;

IF EvaluationTime >= ValidTo
THEN ValidityStatus MAY_BE Expired
according_to boundary_semantics;

BoundaryInclusivity := RulesDefiningWhetherStartAndEndInstantsBelongToValidityInterval;

StartBoundary MAY_BE {Inclusive, Exclusive};
EndBoundary MAY_BE {Inclusive, Exclusive};
ValidityInterval MAY_BE {Closed, Open, HalfOpen};

BoundarySemantics MUST_BE ExplicitWhereExactEligibilityDependsOnBoundary;

DateOnlyValidityBoundary := ValidityBoundaryRepresentedWithoutTimeOfDay;
DateOnlyBoundary MAY_REQUIRE {StartOfDayRule, EndOfDayRule, JurisdictionalRule, PolicyRule};

ExactTime MUST_NOT_BE InventedWithoutDefinedBoundaryPolicy;

ValidityDuration := DurationBetweenValidityStartAndEnd;
ValidityDuration MAY_BE {FixedDuration, CalendarDuration, IndefiniteDuration};

DurationBasedValidity :=
 ValidFrom
 + ValidityDuration
 -> ValidTo;

CalendarDuration MUST_BE EvaluatedUsingApplicableCalendarSemantics;

EventBasedValidity := ValidityBoundariesDerivedFromLifecycleEvents;

ValidityStartTrigger MAY_BE {
 Creation,
 Activation,
 Issue,
 Publication,
 Approval,
 Signature,
 Purchase,
 CustomEvent
};

ValidityEndTrigger MAY_BE {
 Expiry,
 ContractEnd,
 Revocation,
 Supersession,
 Completion,
 CustomEvent
};

ConditionalValidity := ValidityDependentOnTemporalAndNonTemporalConditions;

ValidityCondition MAY_INCLUDE {
 DateRange,
 Role,
 Jurisdiction,
 ResourceState,
 Approval,
 ComplianceState
};

TemporalValidity != GeneralLogicalValidityByDefinition;

Suspension := TemporaryInterruptionOfOtherwiseExistingValidity;
SuspensionPeriod := IntervalDuringWhichEntityIsTemporarilyNotUsableOrEffective;

SuspendedEntity MAY_RETURN_TO ValidStatusAfterSuspensionEnds according_to policy;

Suspension MAY_OR_MAY_NOT ExtendOriginalValidityEnd according_to policy;

Revocation := AuthorisedTerminationOfValidityBeforeScheduledEnd;
RevocationDate := TimeRevocationBecomesEffective;

IF RevocationDate < ScheduledValidTo
THEN EffectiveValidityEnd MAY_BE RevocationDate;

Revocation != ExpiryByDefinition;

Supersession := ReplacementOfEntityOrVersionBySuccessor;
SupersededAt := TimeSuccessorBecomesControllingOrCurrent;

Supersession MAY_END ValidityOfEarlierVersion according_to policy;

Renewal := ExtensionOrReplacementOfValidityPeriod;
Renewal MAY_CREATE {ExtendedValidityPeriod, NewValidityPeriod, NewEntityVersion};

RenewalDate := DateRenewalOccursOrBecomesEffective;

IF RenewalCreatesNewPeriod
THEN PreviousValidityPeriod SHOULD_BE Preserved;

Extension := AuthorisedMovementOfValidityEndToLaterTime;
Reduction := AuthorisedMovementOfValidityEndToEarlierTime;

ValidityChange SHOULD_PRESERVE {
 PreviousBoundary,
 NewBoundary,
 Reason,
 Authority,
 Timestamp,
 Provenance
};

GracePeriod := IntervalAfterNominalEndDuringWhichLimitedActionsMayRemainPermitted;
NominalValidityEnd := ScheduledEndBeforeGracePeriod;
EffectiveValidityEnd := BoundaryAfterApplyingGracePeriodAndPolicy;

NominalValidityEnd MAY_DIFFER_FROM EffectiveValidityEnd;

ReviewPeriod := IntervalOrDateAtWhichValidityMustBeReassessed;
ReviewDate != ValidToByDefinition;

ValidityPolicy := RulesDefiningStartEndSuspensionRenewalRevocationAndBoundarySemantics;
PolicyVersion SHOULD_BE PreservedForValidityDecision;

Authority := AgentOrBodyAuthorisedToCreateModifySuspendRenewOrRevokeValidity;

ValiditySource MAY_BE {
 Contract,
 Licence,
 PermissionRecord,
 Policy,
 Certificate,
 CredentialRecord,
 VersionRecord,
 PublicationRecord,
 SystemRecord
};

ValidityEvidence MAY_BE {
 Agreement,
 Approval,
 PolicyRule,
 Certificate,
 SystemLog,
 AuditRecord,
 VersionHistory
};

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

ValidityConfidence := EstimatedSupportForValidityPeriodOrStatus;

Confidence MAY_DEPEND_ON {
 SourceReliability,
 BoundaryResolution,
 RuleClarity,
 VersionResolution,
 TemporalConsistency,
 ProvenanceQuality
};

ExplicitValidityPeriod := ValidityPeriodDirectlySpecifiedByAuthoritativeSource;
CalculatedValidityPeriod := ValidityPeriodDerivedFromStartDurationOrRule;
InferredValidityPeriod := ValidityPeriodEstimatedFromIndirectEvidence;

InferredValidityPeriod SHOULD_HAVE {
 InferenceMethod,
 Confidence,
 Provenance
};

ApproximateValidityPeriod := ValidityPeriodWithUncertainOrApproximateBoundaries;
ApproximateBoundary MAY_HAVE {EarliestPossible, LatestPossible, Precision};

UnknownValidityBoundary := BoundaryCannotBeReliablyDetermined;
UnknownBoundary MUST_NOT_BE ReplacedByArbitraryDate;

Calendar MAY_BE {Gregorian, Julian, DomainSpecificCalendar};
TimeZone := ZoneOrOffsetUsedToInterpretExactValidityBoundaries;

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

Precision MUST_NOT BeArtificiallyIncreased;

ValidityNormalisation :=
 OriginalValidityExpression
 -> ParseBoundariesOrDuration
 -> ResolveCalendarTimeZoneAndPolicy
 -> CanonicalValidityInterval;

OriginalExpression SHOULD_BE PreservedWhereUseful;

OverlappingValidityPeriods := MultipleValidityPeriodsForSameEntityOrRoleWithIntersectingTemporalExtent;
Overlap MAY_BE {Valid, Redundant, Conflicting} according_to domain_and_policy;

ValidityConflict := IncompatibleValidityPeriodsStatusesOrRules;

ConflictHandling MAY {
 PreserveAssertions,
 CompareAuthority,
 ComparePolicyVersion,
 CompareBoundaryPrecision,
 CompareEvidence,
 AssignConfidence,
 FlagReview
};

ValidityValidation MAY_CHECK {
 StartBoundary,
 EndBoundary,
 Calendar,
 TimeZone,
 Precision,
 Duration,
 Suspension,
 Revocation,
 Renewal,
 PolicyVersion
};

IF ValidFrom > ValidTo
THEN ValidationStatus := violation;

IF SuspensionStartsAfterSuspensionEnds
THEN SuspensionValidation := violation;

IF RevocationDatePredatesValidityStart
THEN ValidityHistory SHOULD_BE Reviewed;

ValidityCompleteness := DegreeToWhichRequiredBoundariesStatusPolicyAndSourceArePresent;
ValidityConsistency := DegreeToWhichValidityBoundariesEventsAndRulesAgree;
ValidityIntegrity := PreservationOfReliableOriginalNormalisedAndHistoricalValidityAssertions;
ValidityTraceability := AbilityToTraceValidityDecisionToRulesEvidenceAndAuthority;

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

ValidityVersion := VersionOfValidityPeriodAssertionOrRecord;

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

PermissionOntology MAY_USE ValidityPeriodForPermissionEligibility;
LicensingOntology MAY_USE ValidityPeriodForLicenceTerm;
AccessControlOntology MAY_USE ValidityPeriodForTemporaryAccess;
SecurityClassification MAY_USE ValidityPeriodsForClassificationState;
RetentionPolicyOntology MAY_USE RetentionIntervalsAndHolds;
ExpiryDateOntology SPECIALISES EndOfValidityBoundary;
CreationDateOntology MAY_DEFINE StartEventForCertainValidityRules;
PublicationDateOntology MAY_DEFINE PublicationBasedValidityStart;
TimestampOntology MAY_REPRESENT ExactValidityBoundaries;
VersionOntology MAY_DEFINE VersionEffectivePeriods;
RevisionHistoryOntology MAY_PRESERVE ValidityChanges;
ProvenanceOntology SHOULD_PRESERVE ValidityRulesEventsAndAuthorities;
TemporalMetadataOntology PROVIDES GeneralIntervalAndRelationSemantics;

MetadataRepository MAY_STORE OriginalCalculatedAndHistoricalValidityPeriods;
MetadataRegistry MAY_REGISTER ValidityPropertiesStatusesBoundaryTypesAndPolicies;

KnowledgeGraph MAY_REPRESENT:
 Entity -> VALID_DURING -> ValidityPeriod;
 ValidityPeriod -> STARTS_AT -> ValidFrom;
 ValidityPeriod -> ENDS_AT -> ValidTo;

ValidityGraph SHOULD_PRESERVE {
 EntityVersion,
 BoundarySemantics,
 Status,
 PolicyVersion,
 Authority,
 Provenance,
 Confidence
};

RDF MAY_REPRESENT ValidityRelationshipsAsTypedStatements;
JSONLD MAY_SERIALISE LinkedValidityMetadata;

Search MAY_USE ValidityPeriodFor {
 CurrentValidityFiltering,
 HistoricalValiditySearch,
 FutureValiditySearch,
 ExpiredFiltering,
 VersionFiltering
};

SemanticSearch MAY_USE ValidityPeriodFor {
 CurrentStateSelection,
 PolicyContext,
 TemporalEligibility,
 HistoricalReasoning
};

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

ValidityAwareRAG SHOULD_PRESERVE {
 EntityIdentifier,
 EntityVersion,
 ValidFrom,
 ValidTo,
 ValidityStatus,
 EvaluationTime,
 BoundarySemantics,
 Provenance
};

EntityOutsideValidityPeriod SHOULD_NOT BeTreatedAsCurrentlyValid
UNLESS ApplicablePolicyOrGraceRuleAllowsUse;

AI MAY_SUPPORT {
 ValidityPeriodExtraction,
 BoundaryParsing,
 DurationCalculation,
 StatusDetermination,
 ValidityConflictDetection
};

AI SHOULD_NOT InventMissingValidityBoundariesOrBoundarySemantics;

MachineReadableValidityPeriod SHOULD_PRESERVE {
 ValidityIdentifier,
 EntityIdentifier,
 EntityVersion,
 OriginalExpression,
 ValidFrom,
 ValidTo,
 ValidityDuration,
 ValidityStatus,
 SuspensionPeriods,
 RevocationDate,
 RenewalDate,
 GracePeriod,
 BoundaryInclusivity,
 Calendar,
 TimeZone,
 Precision,
 PolicyVersion,
 Authority,
 Evidence,
 Provenance,
 Confidence
};

# ---------- SEMANTIC REASONING ----------
IF TemporalIntervalRepresentsWhenEntityIsValidEffectiveApplicableOrAuthorised
THEN ValidityPeriodClassification := supported;

IF EvaluationTimeBeforeValidFrom
THEN Entity SHOULD_BE NotYetValid;

IF EvaluationTimeWithinValidityBoundaries
AND NoSuspensionRevocationOrSupersessionApplies
THEN Entity MAY_BE Valid;

IF EvaluationTimeAfterEffectiveValidityEnd
THEN Entity MAY_BE ExpiredOrInvalidAccordingToPolicy;

IF RevocationOccursBeforeScheduledValidTo
THEN EffectiveValidityEnd MAY_BE RevocationDate;

IF RenewalCreatesNewValidityPeriod
THEN PreviousPeriod MUST_BE PreservedForHistoricalReasoning;

IF DateOnlyBoundaryLacksInclusivitySemantics
THEN ExactEligibilityAtBoundary MUST_NOT_BE Assumed;

IF ValidityPeriodCorrected
THEN PreviousAssertionAndCorrectionProvenance SHOULD_BE Preserved;

# ---------- SEMANTIC EQUIVALENCE ----------
SEMANTIC_EQUIVALENCE {
 "validity period" ~= "validity interval";
 "valid from" ~= "validity start";
 "valid to" ~= "validity end";
 "effective period" ~= "validity period" WHEN policy_context;
 "valid during" ~= "effective during" WHEN applicability_context;
 "open-ended validity" ~= "validity without defined end";
 "current validity" ~= "currently valid period";
 "validity status" ~= "temporal validity state";
}

# ---------- QUERY FLOW ----------
QUERY(q) ->
 NORMALISE(q) ->
 IDENTIFY_VALIDITY_SUBJECT(q) ->
 RESOLVE_ENTITY_IDENTITY_AND_VERSION(q) ->
 IDENTIFY_VALIDITY_POLICY_AND_CONTEXT(q) ->
 IDENTIFY_VALID_FROM_AND_VALID_TO(q) ->
 RESOLVE_DURATION_CALENDAR_TIMEZONE_AND_PRECISION(q) ->
 IDENTIFY_BOUNDARY_INCLUSIVITY(q) ->
 IDENTIFY_SUSPENSIONS_RENEWALS_REVOCATIONS_AND_GRACE(q) ->
 DETERMINE_VALIDITY_STATUS_AT_EVALUATION_TIME(q) ->
 IDENTIFY_AUTHORITY_EVIDENCE_AND_PROVENANCE(q) ->
 VALIDATE_VALIDITY_INTERVAL(q) ->
 SCORE_CONFIDENCE(q) ->
 RETURN_RELEVANT_VALIDITY_PERIOD_KNOWLEDGE;

# ---------- CONFIDENCE ----------
CONFIDENCE(assertion) :=
 weighted_mean(
  source_reliability,
  authority_strength,
  boundary_resolution,
  rule_clarity,
  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: ValidityPeriod;
 ontology: ValidityPeriodOntology;
 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_boundary_semantics: true;
 evaluate_validity_at_query_time: true;
}

# ---------- UPDATE MODEL ----------
UPDATE_MODEL {
 new_validity_period:
  identify_entity_and_version
  -> identify_policy_and_context
  -> preserve_original_expression
  -> resolve_valid_from_and_valid_to
  -> resolve_duration_calendar_timezone_and_precision
  -> define_boundary_inclusivity
  -> attach_authority_evidence_and_provenance
  -> validate
  -> assign_confidence
  -> integrate;

 renewal:
  preserve_previous_validity_period
  -> verify_renewal_authority
  -> extend_or_create_new_period
  -> assign_new_boundaries
  -> update_status
  -> preserve_history
  -> integrate;

 suspension_or_revocation:
  identify_affected_period
  -> verify_authority
  -> record_event_and_effective_time
  -> recalculate_effective_validity
  -> update_status
  -> audit
  -> integrate;

 validity_correction:
  preserve_previous_assertion
  -> record_corrected_boundaries_or_status
  -> revalidate_dependants
  -> recompute_confidence
  -> regenerate_flow_hash;

 conflict:
  preserve_all_validity_assertions_and_rules
  -> compare_authority_policy_versions_boundaries_and_evidence
  -> adjust_confidence
  -> flag_review;
}

# ---------- FLOW HASH ----------
FLOW_HASH_INPUT :=
 DOMAIN
 + SUBDOMAIN
 + ONTOLOGY
 + ValidityEntity
 + TemporalEntity
 + LifecycleEntity
 + MetadataEntity
 + ValidityPeriod
 + ValidityNormalisation
 + ValidityValidation
 + RELATIONSHIPS
 + SEMANTIC_REASONING
 + SEMANTIC_EQUIVALENCE
 + UPDATE_MODEL;

FLOW_HASH := HASH(FLOW_HASH_INPUT);

# ---------- TERMINAL ----------
ValidityPeriodOntology
 -> IdentifyEntityVersionPolicyAndValidityContext
 -> ResolveValidFromValidToDurationAndEffectiveBoundaries
 -> ResolveCalendarTimeZonePrecisionAndBoundaryInclusivity
 -> DistinguishOpenEndedPermanentFutureCurrentAndHistoricalValidity
 -> ApplySuspensionRenewalRevocationSupersessionAndGraceRules
 -> DetermineValidityStatusAtSpecifiedEvaluationTime
 -> PreserveApproximateUnknownAndConflictingBoundariesWithoutInventingPrecision
 -> AttachAuthorityEvidencePolicyVersionProvenanceAndConfidence
 -> ValidateTemporalOrderDurationAndLifecycleConsistency
 -> SupportValidityAwareSearchRAGPermissionsLicensingAndGovernance
 -> PreserveCorrectionsRenewalsAndHistoricalValidityPeriods
 -> ApplyPrivacySecurityAndAccessControls
 -> MaintainReliableValidityPeriodKnowledge;

END FLOW