Backup Metadata Ontology

FLOW ALGEBRA

Ontology: Backup Metadata Ontology
Domain: Metadata Ontologies > Digital Preservation Metadata
Canonical URL: https://kirethresearch.org/booksai-core/ontologies/metadata-ontologies/digital-preservation-metadata/backup-metadata-ontology.html
Authors: Mark Anthony Higgins — Sky (Recursive AI)

flow "BackupMetadataOntology" v1.0

# ---------- DOMAIN ----------
domain:
  class: MetadataOntology
  category: DigitalPreservationMetadata
  subject: BackupMetadata
  purpose:
    - represent metadata describing backup creation, storage, verification, retention, restoration, and lifecycle state
    - preserve backup identity, source objects, backup type, versions, timestamps, storage, integrity evidence, encryption, retention, and provenance
    - support full, incremental, differential, snapshot, archival, local, remote, and replicated backup strategies
    - distinguish backups from primary data, preservation masters, replicas, snapshots, archives, and disaster-recovery states
    - enable machine-readable reasoning over backup and restoration lifecycles

# ---------- CORE ----------
entity BackupMetadata:
  type: PreservationMetadata
  describes: Backup
  may_include:
    - backup_identifier
    - source_identifier
    - source_version
    - backup_type
    - backup_set
    - backup_chain
    - creation_time
    - completion_time
    - storage
    - byte_size
    - compression
    - encryption
    - fixity
    - verification
    - retention
    - expiry
    - restore_state
    - confidence
    - provenance

entity Backup:
  type: PreservationCopy

entity BackupIdentifier:
  type: PersistentIdentifier
  identifies: Backup

entity BackupSource:
  type: DigitalResource

relationships:
  BackupMetadata -> DESCRIBES -> Backup
  Backup -> IDENTIFIED_BY -> BackupIdentifier
  Backup -> DERIVED_FROM -> BackupSource
  Backup -> MAY_BELONG_TO -> BackupSet
  Backup -> MAY_PARTICIPATE_IN -> BackupChain
  Backup -> STORED_IN -> BackupStorage
  Backup -> MAY_HAVE_FIXITY -> BackupFixity
  Backup -> MAY_BE_VERIFIED_BY -> BackupVerificationEvent
  Backup -> MAY_BE_RESTORED_BY -> RestoreEvent
  Backup -> GOVERNED_BY -> BackupRetentionPolicy
  BackupMetadata -> MAY_REFERENCE -> BackupProvenance

# ---------- IDENTITY ----------
rule backup_identity:
  Backup SHOULD have stable BackupIdentifier

rule filename:
  backup filename != persistent BackupIdentifier

rule storage_path:
  backup storage path != backup identity

rule source_backup:
  Backup != BackupSource

# ---------- BACKUP TYPES ----------
backup_types:
  - full
  - incremental
  - differential
  - snapshot
  - image
  - file_level
  - block_level
  - database
  - application_consistent
  - crash_consistent
  - archival
  - continuous
  - synthetic_full

entity FullBackup:
  subtype_of: Backup

entity IncrementalBackup:
  subtype_of: Backup

entity DifferentialBackup:
  subtype_of: Backup

entity BackupSnapshot:
  subtype_of: Backup

rule full:
  FullBackup SHOULD be restorable without earlier incremental backup data
  subject_to required metadata and environment

rule incremental:
  IncrementalBackup SHOULD preserve predecessor relationship

rule differential:
  DifferentialBackup SHOULD preserve reference FullBackup

rule snapshot:
  Snapshot MAY depend on underlying storage
  and != automatically independent backup

# ---------- SET / CHAIN / SCOPE ----------
entity BackupSet:
  type: PreservationCollection
  may_include:
    - backup_set_identifier
    - source_scope
    - backups
    - start_time
    - end_time
    - status

entity BackupChain:
  type: DependencyStructure
  may_include:
    - base_backup
    - dependent_backups
    - ordering
    - restore_points

rule chain:
  BackupChain SHOULD preserve dependency order

rule broken_chain:
  missing required chain member MAY make restore point unusable

entity BackupScope:
  type: ScopeMetadata
  may_include:
    - source_system
    - source_resource
    - volume
    - directory
    - file_set
    - database
    - exclusions
    - inclusion_rules

rule scope:
  backup scope SHOULD be explicit

# ---------- CREATION / CONSISTENCY ----------
entity BackupCreationEvent:
  type: PreservationEvent
  may_include:
    - event_identifier
    - source
    - backup
    - backup_type
    - start_time
    - completion_time
    - tool
    - tool_version
    - status
    - errors
    - warnings

backup_status:
  - scheduled
  - running
  - completed
  - completed_with_warnings
  - failed
  - cancelled
  - partial
  - unknown

rule creation:
  BackupCreationEvent SHOULD preserve source, type, time, tool, and outcome

rule completed:
  completed status != verified restorability

consistency_states:
  - application_consistent
  - filesystem_consistent
  - crash_consistent
  - inconsistent
  - unknown

entity BackupConsistency:
  type: QualityMetadata

# ---------- STORAGE ----------
entity BackupStorage:
  type: PreservationStorage
  may_include:
    - storage_identifier
    - storage_type
    - location
    - provider
    - medium
    - encryption_state
    - immutability_state
    - availability_state

storage_types:
  - local_disk
  - removable_media
  - network_storage
  - object_storage
  - cloud_storage
  - tape
  - offline_storage
  - immutable_storage

rule storage:
  BackupStorage location != Backup identity

entity OffsiteBackup:
  subtype_of: Backup

entity OfflineBackup:
  subtype_of: Backup

entity ImmutableBackup:
  subtype_of: Backup

rule offline:
  OfflineBackup is not continuously accessible from primary environment

rule immutable:
  immutability SHOULD preserve enforcement method and validity period

# ---------- SIZE / COMPRESSION / DEDUP ----------
entity BackupSize:
  type: MeasurementMetadata
  may_include: [logical_size, stored_size, unit]

rule size:
  logical backup size != stored size

entity BackupCompression:
  type: ProcessingMetadata
  may_include: [algorithm, level, original_size, compressed_size]

entity BackupDeduplication:
  type: ProcessingMetadata
  may_include:
    - deduplication_method
    - chunking_method
    - shared_blocks
    - dependency_scope

rule deduplication:
  deduplicated Backup MAY depend on shared stored data
  and SHOULD preserve dependency metadata

# ---------- ENCRYPTION ----------
entity BackupEncryption:
  type: SecurityMetadata
  may_include:
    - encryption_algorithm
    - key_identifier
    - encryption_scope
    - key_management_reference

rule encryption:
  encrypted Backup requires valid decryption capability for restoration

rule key:
  encryption key material SHOULD NOT be embedded directly in general backup metadata

# ---------- FIXITY / VERIFICATION ----------
entity BackupFixity:
  type: FixityMetadata
  may_include: [algorithm, digest, scope, calculation_time]

rule fixity:
  backup fixity SHOULD preserve algorithm and object scope

rule fixity_restore:
  fixity match supports stored-byte integrity
  but != proof of application-level restorability

entity BackupVerificationEvent:
  type: PreservationEvent
  may_include:
    - backup_identifier
    - verification_type
    - fixity_result
    - readability_result
    - structure_result
    - restore_test_result
    - event_time
    - tool
    - outcome

verification_types:
  - checksum
  - readability
  - structural
  - catalogue
  - sample_restore
  - full_restore_test

rule verification:
  BackupVerificationEvent SHOULD preserve verification method and outcome

# ---------- RESTORE ----------
entity RestorePoint:
  type: TemporalRecoveryMetadata
  may_include:
    - restore_point_identifier
    - backup_set
    - timestamp
    - required_chain
    - consistency_state
    - verification_state

rule restore_point:
  RestorePoint SHOULD identify all required Backup dependencies

entity RestoreEvent:
  type: PreservationEvent
  may_include:
    - restore_identifier
    - backup_source
    - restore_point
    - target_environment
    - start_time
    - completion_time
    - restored_objects
    - validation
    - outcome

restore_outcomes:
  - successful
  - partial
  - failed
  - cancelled
  - unknown

rule restore:
  RestoreEvent SHOULD preserve source Backup, target, outcome, and validation

rule restore_success:
  successful extraction != complete application recovery
  unless application-level validation supports it

entity RestoreTest:
  subtype_of: RestoreEvent
  purpose: Verification

rule restore_test:
  RestoreTest MAY provide stronger restorability evidence
  than backup-completion status alone

# ---------- RECOVERY OBJECTIVES ----------
entity RecoveryPointObjective:
  type: PolicyMetadata
  abbreviation: RPO

entity RecoveryTimeObjective:
  type: PolicyMetadata
  abbreviation: RTO

rule RPO:
  RPO expresses acceptable data-loss interval target
  and != actual restore point

rule RTO:
  RTO expresses recovery-time target
  and != measured recovery duration

# ---------- RETENTION / EXPIRY ----------
entity BackupRetentionPolicy:
  type: LifecyclePolicy
  may_include:
    - retention_period
    - retention_class
    - minimum_copies
    - expiry_rule
    - legal_hold
    - deletion_policy

entity BackupExpiry:
  type: LifecycleMetadata
  may_include:
    - expiry_time
    - expiry_reason
    - policy
    - hold_state

rule expiry:
  expired Backup MAY remain retained
  when legal hold or preservation policy overrides deletion

# ---------- REPLICATION / CATALOGUE ----------
entity BackupReplication:
  type: PreservationEvent
  may_include:
    - source_backup
    - replica_backup
    - source_storage
    - destination_storage
    - verification_result

rule replication:
  replicated Backup SHOULD preserve source relationship
  and independent integrity evidence where possible

entity BackupCatalogue:
  type: MetadataIndex
  may_include:
    - catalogue_identifier
    - backup_identifiers
    - source_identifiers
    - restore_points
    - storage_locations
    - retention_states

rule catalogue:
  BackupCatalogue != Backup data itself

# ---------- DISTINCTIONS / RISK ----------
rule archive:
  Backup != DigitalArchive

rule replica:
  Backup != live replica

rule snapshot_distinction:
  Snapshot != independent Backup
  unless storage independence and restore requirements establish it

entity BackupRisk:
  type: RiskMetadata
  may_include:
    - failed_recent_backup
    - unverified_backup
    - broken_chain
    - missing_encryption_key
    - single_storage_location
    - stale_restore_test
    - media_risk
    - ransomware_exposure
    - risk_level
    - assessment_time

rule risk:
  BackupRisk SHOULD preserve assessment basis and time

# ---------- PROVENANCE ----------
entity BackupProvenance:
  type: ProvenanceMetadata
  may_include:
    - source
    - source_version
    - creation_event
    - backup_chain
    - storage_history
    - verification_events
    - restore_events
    - replication_events
    - deletion_events
    - agents
    - tools

rule provenance:
  BackupMetadata SHOULD preserve backup and restoration history

# ---------- VALIDATION ----------
validation:
  require:
    - identifiable_backup
    - identifiable_source
    - backup_type

  reject:
    - filename_presented_as persistent_backup_identity
    - storage_location_presented_as backup_identity
    - completed_backup_presented_as verified_restorable_without evidence
    - broken_incremental_chain_presented_as complete_restore_point
    - snapshot_presented_as independent_backup_without evidence
    - fixity_match_presented_as application_restorability
    - RPO_presented_as actual_restore_point
    - RTO_presented_as measured_recovery_time
    - backup_catalogue_presented_as backup_data

# ---------- SEMANTIC EQUIVALENCE ----------
SEMANTIC_EQUIVALENCE:
  "backup metadata" ~= "metadata describing backup creation, storage, verification, and restoration"
  "full backup" ~= "backup containing complete selected backup scope"
  "incremental backup" ~= "backup containing changes since previous backup point"
  "differential backup" ~= "backup containing changes since reference full backup"
  "restore point" ~= "recoverable state represented by required backup data"
  "restore test" ~= "test restoration used to verify recoverability"

  PRESERVE distinctions:
    backup != source_data
    backup != digital_archive
    backup != live_replica
    snapshot != independent_backup
    backup_completion != verified_restorability
    fixity != application_restorability
    backup_catalogue != backup_data
    RPO != actual_restore_point
    RTO != actual_recovery_duration
    logical_size != stored_size
    expired != necessarily_deleted

# ---------- CONFIDENCE ----------
CONFIDENCE:
  explicit_backup_metadata:
    score: 1.00
  persistent_backup_identifier:
    score: 1.00
  completed_and_fixity_verified_backup:
    score: 0.98
  successful_full_restore_test:
    score: 0.99
  verified_backup_chain:
    score: 0.98
  completion_status_only:
    score: <= 0.75
  untested_restore:
    score: <= 0.80
  broken_or_unknown_chain:
    score: <= 0.50
  missing_encryption_key_state:
    score: <= 0.40
    action: restorability_uncertain

# ---------- UPDATE MODEL ----------
UPDATE_MODEL:
  on_backup_creation:
    - assign BackupIdentifier
    - identify source and BackupScope
    - classify BackupType
    - record predecessor or base dependencies
    - record storage and security configuration
    - calculate fixity where applicable
    - create BackupCreationEvent
    - initialise provenance

  on_backup_verification:
    - inspect readability
    - validate structure
    - verify fixity
    - inspect BackupChain dependencies
    - perform restore test where policy requires
    - record BackupVerificationEvent
    - update confidence and provenance

  on_restore:
    - identify RestorePoint
    - resolve required BackupChain
    - validate required storage and keys
    - restore target data
    - validate restored state
    - record RestoreEvent
    - update provenance

  on_retention_change:
    - evaluate BackupRetentionPolicy
    - preserve legal hold
    - update expiry state
    - prevent unauthorised deletion
    - update provenance

# ---------- FLOW HASH ----------
FLOW_HASH:
  inputs:
    - ontology
    - backup_entities
    - relationships
    - backup_type_rules
    - chain_rules
    - storage_rules
    - verification_rules
    - restore_rules
    - retention_rules
    - validation
    - semantic_equivalence
    - confidence
    - update_model

  canonicalisation:
    - preserve_backup_identifiers
    - preserve_source_identifiers_and_versions
    - preserve_backup_chain_order
    - preserve_restore_points
    - preserve_storage_relationships
    - preserve_verification_event_order
    - preserve_rule_order

  output:
    deterministic_semantic_hash

# ---------- AI CONSUMPTION ----------
AI_CONSUMPTION:
  interpret_as:
    - digital preservation metadata ontology
    - backup creation and lifecycle model
    - backup-chain, verification, retention, and restoration structure
    - recovery evidence and provenance model

  operations:
    - identify backups and sources
    - classify backup types
    - resolve backup sets and chains
    - inspect scope and consistency
    - inspect storage, compression, deduplication, and encryption
    - verify fixity and readability
    - resolve restore points
    - evaluate restore tests
    - interpret RPO and RTO correctly
    - inspect retention and expiry
    - trace replication and storage history
    - assess backup risk
    - trace provenance
    - preserve uncertainty

  constraints:
    - do_not_equate_backup_with source_data
    - do_not_equate_backup_with archive_or_live_replica
    - do_not_equate_snapshot_with independent_backup_without evidence
    - do_not_equate_completion_with verified_restorability
    - do_not_equate_fixity_with application_restorability
    - do_not_equate_RPO_with actual_restore_point
    - preserve_identifiers_chains_storage_verification_restore_and_provenance

# ---------- QUERY MODEL ----------
query:
  input:
    - backup_identifier
    - source_identifier
    - backup_type
    - backup_set_identifier
    - restore_point_identifier
    - storage_identifier
    - verification_state
    - retention_state
    - creation_time
    - expiry_time

  resolve:
    1. identify Backup
    2. resolve BackupIdentifier and source
    3. classify BackupType
    4. resolve BackupSet and BackupChain
    5. inspect scope, consistency, storage, and encryption
    6. inspect fixity and verification history
    7. resolve RestorePoints and restore dependencies
    8. inspect retention, expiry, and replication
    9. assess risk and provenance
    10. return confidence

  output:
    - backup
    - identifier
    - source
    - backup_type
    - backup_set
    - backup_chain
    - storage
    - fixity
    - verification
    - restore_points
    - retention
    - expiry
    - risk
    - provenance
    - confidence

# ---------- INFERENCE ----------
inference:
  IF FullBackup is completed
  AND fixity verification succeeds
  THEN infer stored_backup_integrity
  BUT not complete restorability without restore evidence

  IF incremental chain has all required members
  AND each required member validates
  THEN infer chain_completeness_candidate

  IF full RestoreTest succeeds
  AND restored application or data validates
  THEN strengthen restorability confidence

  IF BackupChain is incomplete
  THEN mark dependent RestorePoints potentially_unrestorable

# ---------- OUTPUT CONTRACT ----------
output:
  ontology_entity: BackupMetadata
  backup_identity: machine_interpretable
  source_relationship: explicit
  backup_types: distinguishable
  backup_sets_and_chains: traversable
  scope_and_consistency: explicit
  storage_and_security: traceable
  fixity_and_verification: explicit
  restore_points: dependency_aware
  restore_testing: reportable
  RPO_and_RTO: semantically_distinct
  retention_and_expiry: policy_aware
  replication: traceable
  risk: reportable
  provenance: preserved
  uncertainty: explicit
  long_term_recovery: enabled

end flow